diff -Nru acl2-6.2/GNUmakefile acl2-6.3/GNUmakefile
--- acl2-6.2/GNUmakefile 2013-06-06 16:31:01.000000000 +0000
+++ acl2-6.3/GNUmakefile 2013-09-29 21:31:26.000000000 +0000
@@ -1,6 +1,6 @@
# -*- Fundamental -*-
-# ACL2 Version 6.2 -- A Computational Logic for Applicative Common Lisp
+# ACL2 Version 6.3 -- A Computational Logic for Applicative Common Lisp
# Copyright (C) 2013, Regents of the University of Texas
# This version of ACL2 is a descendent of ACL2 Version 1.9, Copyright
@@ -72,33 +72,10 @@
# make regression-everything
# ; Same as make regression, except that target "everything"
# ; is used in community books file, Makefile.
-# make regression-legacy-fast [DEPRECATED as is books/regression-targets (legacy)]
-# ; NOTE: This target was not tested before the v6-2 release.
-# ; (WARNING: This target uses variable ACL2, with default value
-# ; "acl2", so it is probably a good idea to run after
-# ; explicitly setting ACL2=.
-# ; End of warning.)
-# ; Certify a substantial portion of the books that
-# ; would be certified by `make regression', but
-# ; with better parallelism. We have used this
-# ; with option "-j 24" to obtain over a 12x
-# ; speedup. This target assumes that
-# ; books/Makefile-fast is up-to-date; if you are
-# ; using an "alpha" version, just follow
-# ; instructions in books/regression-targets to
-# ; update that file first and then update
-# ; books/Makefile-fast as follows:
-# ; cd books/
-# ; ./cert.pl -s Makefile-fast --targets regression-targets -b .
# make clean-books ; Remove certificate files, object files, log files,
# ; debris, ..., created by `make certify-books',
# ; `make regression', etc.
-# Also included are various legacy versions of these targets, which
-# correspond to targets through ACL2 Version 6.1. For example, target
-# regression-legacy in this file corresponds to target regression in
-# older versions of htis file.
-
###############################################################################
# NOTE: Users need not read below this line. Neither should installers of
@@ -111,14 +88,7 @@
# Example invocations for CLI implementors:
# NOTE: Make large completely recompiles, initializes and
-# saves. Consider some of the "fast" and "very-fast" options below if only
-# part of the system needs to be rebuilt.
-
-# make very-fast init
-# ; Build the system, recompiling as little as possible
-# ; (perhaps don't even recompile TMP1.lisp).
-
-# make fast init ; Compile as needed, initialize, build saved_acl2
+# saves.
# make full ; A complete recompilation whether needed or not.
# make full init ; Completely recompile, initialize and save.
@@ -130,7 +100,6 @@
# ; Note: Allegro is not always named cl at CLI. See
# ; ~moore/allegro/runcl for some clues.
# make full LISP=lispworks PREFIX=lispworks- ; makes acl2 in lispworks
-# make copy DIR=targetdir ; copies all of acl2 to targetdir. Don't use ~ notation.
# make copy-distribution DIR=/stage/ftp/pub/moore/acl2/v2-9/acl2-sources
# ; copies all of acl2 plus books, doc, etc., to the named
# ; directory, as for compiling on another architecture or
@@ -148,15 +117,13 @@
# ; proofs during pass 2. Does not save an image. Uses same
# ; flags used to build full-size image.
-# Metering: If the currently compiled version is unmetered and you wish
-# it metered, the fastest thing to do is to (push :acl2-metering *features*)
-# and then yank in and recompile just those definitions that mention
-# acl2-metering. However, if you would like to install metering as part
-# of a system-wide recompilation, you must use the full-meter option below,
-# rather than the fast-meter option. If, while running a fully metered
-# system you wish to do what would otherwise be a make fast but you want
-# to preserve the metering, use the fast-meter option. If you want to
-# get rid of the metering in the compiled code, do make full.
+# Metering: If the currently compiled version is unmetered and you
+# wish it metered, the fastest thing to do is to (push :acl2-metering
+# *features*) and then yank in and recompile just those definitions
+# that mention acl2-metering. However, if you would like to install
+# metering as part of a system-wide recompilation, use the full-meter
+# option below. If you want to get rid of the metering in the
+# compiled code, do make full.
LISP = ccl
DIR = /tmp
@@ -188,15 +155,32 @@
ACL2_SUFFIX := $(ACL2_SUFFIX)r
endif
-# The user may legally edit the following variable, or set it on the command
-# line, only when :acl2-mv-as-values is pushed on to *features*. In that case,
-# this variable may be set to ":REUSE", as shown in the comment below. That
-# will cause the use of the existing acl2-proclaims.lisp, which will save one
-# compile and one initialization. BUT this should only be done if the
-# acl2-proclaims.lisp that would otherwise be generated would be identical to
-# the existing acl2-proclaims.lisp.
-USE_ACL2_PROCLAIMS =
-# USE_ACL2_PROCLAIMS = :REUSE
+# The following variable, ACL2_PROCLAIMS_ACTION, is intended to be
+# user-settable to one of three values, as shown below. By default,
+# it avoids consideration of file acl2-proclaims.lisp: that file is
+# neither consulted (i.e., reused) nor generated.
+
+ifndef ACL2_PROCLAIMS_ACTION
+
+# Default action: Do not reuse or build acl2-proclaims.lisp.
+ACL2_PROCLAIMS_ACTION := default
+
+# Use the existing acl2-proclaims.lisp for compilation.
+# ACL2_PROCLAIMS_ACTION ?= reuse
+
+# Do compile/initialize twice, in order to build acl2-proclaims.lisp
+# and then consult it before the second compile.
+# ACL2_PROCLAIMS_ACTION ?= generate_and_reuse
+
+endif
+
+# Variable ACL2_PROCLAIMS_ACTION is not to be set by the user. We use
+# override directives to ensure this.
+ifeq ($(ACL2_PROCLAIMS_ACTION), reuse)
+USE_ACL2_PROCLAIMS := t
+else
+USE_ACL2_PROCLAIMS :=
+endif
# The user may define PREFIX; otherwise it is implicitly the empty string.
PREFIX =
@@ -297,7 +281,7 @@
echo "(defparameter *acl2-safety* $(ACL2_SAFETY))" >> acl2r.lisp ;\
fi
if [ "$(ACL2_SIZE)" != "" ] ; then \
- echo '(or (find-package "ACL2") (#+gcl defpackage:defpackage #-gcl defpackage "ACL2" (:size $(ACL2_SIZE)) (:use)))' >> acl2r.lisp ;\
+ echo '(or (find-package "ACL2") (#+(and gcl (not ansi-cl)) defpackage:defpackage #-(and gcl (not ansi-cl)) defpackage "ACL2" (:size $(ACL2_SIZE)) (:use)))' >> acl2r.lisp ;\
fi
if [ "$(ACL2_COMPILER_DISABLED)" != "" ] ; then \
echo '(DEFPARAMETER *ACL2-COMPILER-ENABLED* NIL)' >> acl2r.lisp ;\
@@ -347,17 +331,6 @@
fi
@echo "Initialization SUCCEEDED."
-.PHONY: fast
-fast:
- date
- rm -f workxxx
- echo '(load "init.lisp")' > workxxx
- echo '(acl2::quick-compile-acl2 nil)' >> workxxx
- echo '(acl2::exit-lisp)' >> workxxx
- ${LISP} < workxxx
- @$(MAKE) check_compile_ok
- rm -f workxxx
-
.PHONY: compile-ok
compile-ok:
date
@@ -368,28 +341,6 @@
${LISP} < workxxx
rm -f workxxx
-.PHONY: very-fast
-very-fast:
- date
- rm -f workxxx
- echo '(load "init.lisp")' > workxxx
- echo '(acl2::quick-compile-acl2 t)' >> workxxx
- echo '(acl2::exit-lisp)' >> workxxx
- ${LISP} < workxxx
- @$(MAKE) check_compile_ok
- rm -f workxxx
-
-.PHONY: fast-meter
-fast-meter:
- date
- rm -f workxxx
- echo '(load "init.lisp") (push :acl2-metering *features*)' > workxxx
- echo '(acl2::quick-compile-acl2 nil)' >> workxxx
- echo '(acl2::exit-lisp)' >> workxxx
- ${LISP} < workxxx
- @$(MAKE) check_compile_ok
- rm -f workxxx
-
.PHONY: check-sum
check-sum:
date
@@ -423,15 +374,6 @@
@$(MAKE) check_compile_ok
rm -f workxxx
-.PHONY: copy
-copy:
- rm -f workxxx
- echo '(load "init.lisp")' > workxxx
- echo '(acl2::copy-acl2 "${DIR}")' >> workxxx
- echo '(acl2::exit-lisp)' >> workxxx
- ${LISP} < workxxx
- rm -f workxxx
-
.PHONY: copy-distribution
copy-distribution:
# WARNING: Execute this from an ACL2 source directory.
@@ -472,7 +414,9 @@
# useful when building a hons or parallel version after a normal version, or
# vice-versa.
.PHONY: TAGS!
-TAGS!: acl2r TAGS
+TAGS!: acl2r
+ rm -f TAGS
+ $(MAKE) TAGS
.PHONY: move-to-old
move-to-old:
@@ -488,6 +432,7 @@
if [ -f nsaved_acl2.${LISPEXT} ]; then \
mv -f nsaved_acl2.${LISPEXT} ${PREFIXsaved_acl2}.${LISPEXT} ; fi
+# See Section "PROCLAIMING" in acl2-fns.lisp.
acl2-proclaims.lisp: ${sources}
rm -f acl2-proclaims.lisp
rm -f workxxx
@@ -499,12 +444,17 @@
${LISP} < workxxx
[ -f acl2-proclaims.lisp ]
+# If ACL2_PROCLAIMS_ACTION has value generate_and_reuse, then the
+# following target remakes acl2-proclaims.lisp and recompiles, as
+# follows. The first subsidiary call of $(MAKE) initializes, i.e.,
+# gets ACL2 to LD its own sources. Then, a second $(MAKE) uses that
+# file of proclaim forms to recompile.
+# See also the Section "PROCLAIMING" in acl2-fns.lisp.
.PHONY: make-acl2-proclaims
make-acl2-proclaims:
- if [ "$(USE_ACL2_PROCLAIMS)" != ":REUSE" ]; then \
- rm -f acl2-proclaims.lisp; \
+ if [ "$(ACL2_PROCLAIMS_ACTION)" = "generate_and_reuse" ]; then \
$(MAKE) acl2-proclaims.lisp; \
- $(MAKE) full USE_ACL2_PROCLAIMS=t; \
+ $(MAKE) full ACL2_PROCLAIMS_ACTION=reuse; \
fi
.PHONY: init
@@ -843,10 +793,10 @@
clean-books-nonstd:
ifndef ACL2
cd books/nonstd ; \
- $(MAKE) $(ACL2_IGNORE) ACL2=$(shell pwd)/saved_acl2 clean
+ $(MAKE) $(ACL2_IGNORE) ACL2=$(shell pwd)/saved_acl2 clean clean-links
else
cd books/nonstd ; \
- $(MAKE) $(ACL2_IGNORE) ACL2=$(ACL2) clean
+ $(MAKE) $(ACL2_IGNORE) ACL2=$(ACL2) clean clean-links
endif
# This following should be executed inside the acl2-sources directory.
@@ -948,98 +898,3 @@
else
cd books ; $(MAKE) $(ACL2_IGNORE) chk-include-book-worlds ACL2=$(ACL2)
endif
-
-##########
-### Legacy targets
-### (renamed using "-legacy" and deprecated after ACL2 Version 6.1):
-##########
-
-# Here we provide support for a convenient way to pass -j down to the
-# community books Makefile, for both `make' and cert.pl. It seems
-# cleanest and perhaps critical that below, when we call in the books
-# directory we do so with an explicit -j, rather than leaving this to
-# the Makefile in the books/ directory.
-export ACL2_HONS_OPT
-ifdef ACL2_JOBS
-# Note: Because of recursive call of make, ACL2_HONS_OPT could
-# ultimately include many -j options. This anomaly seems harmless, so
-# we leave it for now but may revisit it later.
-ACL2_HONS_OPT += -j$(ACL2_JOBS)
-ACL2_JOBS_OPT := -j $(ACL2_JOBS)
-endif
-
-.PHONY: clean-books-legacy
-clean-books-legacy:
- cd books ; $(MAKE) -f Makefile.legacy $(ACL2_IGNORE) clean
-
-.PHONY: regression-legacy
-regression-legacy:
- uname -a
- cd books ; $(MAKE) -f Makefile.legacy $(ACL2_IGNORE) $(ACL2_JOBS_OPT) all-plus
-
-# For a HONS regression, we do regression-legacy-hons-only first to get the
-# extra parallelism provided by cert.pl. For regression-legacy-hons-only the
-# default for ACL2 is saved_acl2h in the development directory; for
-# regression-legacy, saved_acl2. So the user might be happiest simply
-# providing a value for ACL2.
-.PHONY: regression-legacy-hons-only
-regression-legacy-hons-only:
- uname -a
- cd books ; $(MAKE) -f Makefile.legacy $(ACL2_IGNORE) hons
-
-.PHONY: regression-legacy-hons
-# For a legacy HONS regression, we do regression-legacy-hons-only
-# first to get the extra parallelism provided by cert.pl. For
-# regression-legacy-hons-only the default for ACL2 is saved_acl2h in
-# the development directory; for regression-legacy, saved_acl2. So
-# the user might be happiest simply providing a value for ACL2.
-regression-legacy-hons:
- $(MAKE) regression-legacy-hons-only
- $(MAKE) regression-legacy ACL2_CENTAUR=skip ACL2_HONS_REGRESSION=t
-
-.PHONY: clean-books-nonstd-legacy
-clean-books-legacy-nonstd:
- cd books/nonstd ; $(MAKE) -f Makefile.legacy $(ACL2_IGNORE) clean-nonstd
-
-.PHONY: regression-legacy-nonstd
-regression-legacy-nonstd:
- uname -a
- cd books/nonstd ; $(MAKE) -f Makefile.legacy $(ACL2_IGNORE) $(ACL2_JOBS_OPT) all-nonstd
-
-# Warning: We are no longer actively maintaining books/Makefile-fast.
-.PHONY: regression-legacy-fast
-regression-legacy-fast:
- uname -a
- cd books ; pwd ; $(MAKE) $(ACL2_IGNORE) $(ACL2_JOBS_OPT) -f Makefile-fast
-
-.PHONY: regression-legacy-fresh regression-legacy-fast-fresh regression-legacy-nonstd-fresh
-regression-legacy-fresh: clean-books-legacy
- $(MAKE) $(ACL2_IGNORE) regression-legacy
-regression-legacy-hons-fresh: clean-books-legacy
- $(MAKE) $(ACL2_IGNORE) regression-legacy-hons
-regression-legacy-fast-fresh: clean-books-legacy
- $(MAKE) $(ACL2_IGNORE) regression-legacy-fast
-regression-legacy-nonstd-fresh: clean-books-legacy-nonstd
- $(MAKE) $(ACL2_IGNORE) regression-legacy-nonstd
-
-.PHONY: certify-books-legacy
-certify-books-legacy:
- cd books ; $(MAKE) -f Makefile.legacy $(ACL2_JOBS_OPT) $(ACL2_IGNORE)
-
-# Certify main books from scratch.
-.PHONY: certify-books-legacy-fresh
-certify-books-legacy-fresh: clean-books-legacy
- $(MAKE) $(ACL2_IGNORE) $(ACL2_JOBS_OPT) certify-books-legacy
-
-# The following allows for a relatively short test, in response to a request
-# from GCL maintainer Camm Maguire.
-.PHONY: certify-books-legacy-short
-certify-books-legacy-short:
- cd books ; $(MAKE) -f Makefile.legacy $(ACL2_JOBS_OPT) short-test
-
-# Next is a legacy version of a developer target.
-.PHONY: chk-include-book-worlds
-chk-include-book-worlds-legacy:
- uname -a
- cd books ; $(MAKE) -f Makefile.legacy $(ACL2_IGNORE) chk-include-book-worlds-top
-
diff -Nru acl2-6.2/TAGS acl2-6.3/TAGS
--- acl2-6.2/TAGS 2013-06-07 04:02:15.000000000 +0000
+++ acl2-6.3/TAGS 2013-09-30 17:38:32.000000000 +0000
@@ -1,8622 +1,8645 @@
-acl2.lisp,3673
-(defvar *acl2-compiler-enabled*)67,3198
-(defun acl2-set-character-encoding 305,15257
-(defun our-file-encoding 422,19679
-(defconstant acl2::*the-live-state* 695,30681
-(defvar acl2::*compiling-certified-file* 730,33041
-(defun acl2::defconst-redeclare-error 732,33088
-(defparameter acl2::*safe-mode-verified-p*753,34031
-(defmacro acl2::defconst 762,34324
-(defvar acl2::*copy-of-common-lisp-symbols-from-main-lisp-package*)836,37218
-(defvar acl2::*copy-of-common-lisp-specials-and-constants*)837,37286
-(defvar acl2::*copy-of-acl2-version*)838,37346
-(defconstant acl2::*acl2-files*840,37385
-(defparameter *compiled-file-extension*958,41354
-(defmacro initialize-state-globals 968,41764
-(defconstant *suppress-compile-build-time*1027,44413
-(defparameter *global-package-prefix* 1039,44801
-(defparameter *1*-package-prefix* 1041,44856
-(defun make-global-package 1043,44904
-(defun make-*1*-package 1051,45157
-(defconstant *main-lisp-package*1069,45716
-(defconstant *main-lisp-package-name-raw*1072,45782
-(defparameter acl2::*initial-lisp-symbol-mark*1095,46664
-(defconstant *acl2-package* 1106,47093
-(defmacro with-redefinition-suppressed 1136,48254
-(defmacro with-warnings-suppressed 1172,49605
-(defmacro with-more-warnings-suppressed 1219,51267
-(defmacro with-suppression 1254,52402
-(defconstant acl2::*acl2-status-file*1269,53032
-(defun acl2::check-suitability-for-acl2 1273,53139
-(defun note-compile-ok 1289,53661
-(defvar *lisp-extension* 1320,55199
-(defmacro our-with-compilation-unit 1356,56726
-(defconstant *acl2-read-character-terminators*1385,58048
-(defparameter *acl2-readtable*1420,59372
-(defparameter *host-readtable*1426,59583
-(defun set-new-dispatch-macro-character 1431,59756
-(defun define-sharp-dot 1469,61321
-(defun define-sharp-comma 1475,61417
-(defun define-sharp-atsign 1481,61517
-(defun define-sharp-bang 1487,61623
-(defun define-sharp-u 1493,61725
-(defvar *old-character-reader*1499,61821
-(defun modify-acl2-readtable 1502,61895
-(defvar *reckless-acl2-readtable*1591,64642
-(defvar *load-compiled-verbose* 1608,65168
-(defun load-compiled 1610,65206
-(defun compile-acl2 1861,75188
-(defun no-object-file-or-out-of-date-object-file 1962,79278
-(defun quick-compile-acl2 1970,79611
-(defvar user::*fast-acl2-gcl-build* 2030,81802
-(defun load-acl2 2032,81844
-(defparameter *acl2-panic-exit-status* 2117,85111
-(defun exit-lisp 2119,85156
-(defconstant *slashable-array*2224,89891
-(defconstant *suspiciously-first-numeric-array*2237,90338
-(defconstant *suspiciously-first-hex-array*2248,90674
-(defconstant *base-10-array*2262,91095
-(defconstant *hex-array*2273,91373
-(defconstant *letter-array*2286,91722
-(defmacro suspiciously-first-numeric-array 2300,92201
-(defmacro numeric-array 2305,92366
-(defconstant *char-code-backslash* 2310,92474
-(defconstant *char-code-slash* 2312,92527
-(defconstant *char-code-double-gritch* 2314,92576
-(defconstant *big-n-special-object* 2320,92832
-(defconstant *number-of-return-values*2322,92883
-(defconstant *boole-array*2328,92985
-(defconstant *mo-f* 2366,94352
-(defconstant *mo-h* 2367,94391
-(defconstant *mo-o* 2368,94430
-(defconstant *mf-old-caller* 2373,94523
-(defconstant *mf-start-hons* 2374,94580
-(defconstant *mf-start-pons* 2375,94637
-(defconstant *mf-start-bytes* 2376,94694
-(defconstant *mf-ans* 2377,94753
-(defconstant *mf-ans-p* 2378,94796
-(defconstant *mf-ma* 2379,94843
-(defconstant *mf-args* 2380,94884
-(defconstant *mf-2mmf* 2381,94929
-(defconstant *mf-2mmf-fnn* 2382,94977
-(defconstant *mf-count-loc* 2383,95033
-(defconstant *attached-fn-temp* 2385,95092
-(defvar *debug-prompt-suffix* 2412,96240
-(defun break-level-for-acl2 2414,96354
-
-acl2-fns.lisp,2682
-(defmacro qfuncall 23,881
-(defun acl2-realp 46,1863
-(defun gcl-version-> 62,2406
-(defun gcl-version->=87,3499
-(defvar *do-proclaims*143,6479
-(defmacro defun-one-output 147,6526
-(defun macroexpand-till 155,6769
-(defun get-type-from-dcls 172,7479
-(defun arg-declarations 180,7735
-(defun collect-types 185,7920
-(defun convert-type-to-integer-pair 196,8259
-(defvar *acl2-output-type-abort* 210,8693
-(defun min-integer-* 212,8732
-(defun max-integer-* 217,8838
-(defun max-output-type-for-declare-form 222,8944
-(defun max-output-type-for-declare-form-lst 302,11900
-(defun output-type-for-declare-form-rec 337,13314
-(defun output-type-for-declare-form-rec-list 479,19266
-(defun output-type-for-declare-form 490,19760
-(defun make-defun-declare-form 536,21509
-(defun make-defconst-declare-form 569,22927
-(defun make-defstobj-declare-form 587,23561
-(defmacro eval-or-print 618,24956
-(defun proclaim-form 626,25142
-(defun proclaim-file 660,26391
-(defparameter *comma* 712,28982
-(defparameter *comma-atsign* 716,29148
-(defparameter *backquote-counter* 720,29342
-(defun backquote 727,29674
-(defun backquote-lst 770,31852
-(defun rev1@ 795,32723
-(defun acl2-read-character-string 805,32930
-(defun acl2-character-reader 877,36013
-(defvar *inside-sharp-dot-read* 886,36331
-(defvar *inhibit-sharp-comma-warning* 888,36369
-(defvar *inside-sharp-u-read* 890,36413
-(defun sharp-comma-read 892,36449
-(defun sharp-dot-read 903,36980
-(defun sharp-bang-read 933,38316
-(defun sharp-u-read 956,39289
-(defmacro sharp-atsign-read-er 987,40680
-(defun sharp-atsign-read 993,40935
-(defvar *sharp-reader-array-size*1040,42909
-(defvar *sharp-reader-array*1047,43097
-(defvar *sharp-reader-array-size-multiplier*1050,43169
-(defconstant *sharp-reader-max-array-size*1057,43349
-(defvar *sharp-reader-max-index*1065,43601
-(defun update-sharp-reader-max-index 1078,44268
-(defun reckless-sharp-sharp-read 1107,45453
-(defun reckless-sharp-equal-read 1113,45613
-(defmacro with-reckless-read 1121,45945
-(defun symbol-package-name 1143,46827
-(defmacro gv 1175,48276
-(defun getenv$-raw 1198,49257
-(defun get-os 1221,50080
-(defmacro our-ignore-errors 1230,50294
-(defmacro safe-open 1234,50370
-(defun our-truename 1237,50442
-(defun our-pwd 1303,53317
-(defun cancel-dot-dots 1314,53664
-(defun unix-full-pathname 1322,53982
-(defun our-user-homedir-pathname 1350,54997
-(defun ser-cons-reader-macro 1402,57273
-(defun ser-hons-reader-macro 1408,57550
-(defmacro special-form-or-op-p 1425,58440
-(defvar *startup-package-name* 1432,58664
-(defmacro save-def 1434,58704
-(defun our-function-lambda-expression 1456,59561
-(defmacro defg 1476,60202
-(defmacro defv 1490,60696
-
-acl2-init.lisp,1877
-(defconstant *current-acl2-world-key*306,14371
-(defun system-call 360,16578
-(defun copy-acl2 433,19000
-(defun our-probe-file 450,19515
-(defun copy-distribution 471,20257
-(defun make-tags 639,27883
-(defvar *saved-build-date-lst*)680,30010
-(defvar *saved-mode*)681,30042
-(defconstant *acl2-svn-revision-string*683,30065
-(defun acl2-svn-revision-string 688,30297
-(defvar *saved-string*707,31023
-(defun maybe-load-acl2-init 732,31934
-(defun chmod-executable 738,32132
-(defun saved-build-dates 741,32220
-(defmacro our-with-standard-io-syntax 758,32822
-(defmacro write-exec-file 763,32953
-(defun save-acl2-in-akcl-aux 792,34099
-(defun save-acl2-in-akcl 834,35916
-(defun save-exec-raw 1054,44958
-(defvar *acl2-default-restart-complete* 1059,45168
-(defun fix-default-pathname-defaults 1061,45214
-(defun acl2-default-restart 1085,46046
-(defun cmulisp-restart 1133,47518
-(defun sbcl-restart 1139,47616
-(defun save-acl2-in-lucid 1145,47750
-(defun lispworks-save-exec-aux 1151,47946
-(defun save-acl2-in-lispworks 1245,52256
-(defun save-exec-raw 1254,52590
-(defun save-acl2-in-cmulisp-aux 1262,52782
-(defun save-acl2-in-cmulisp 1305,54522
-(defun save-exec-raw 1314,54839
-(defvar *sbcl-dynamic-space-size*1319,54981
-(defun save-acl2-in-sbcl-aux 1366,57533
-(defun save-acl2-in-sbcl 1445,60955
-(defun save-exec-raw 1461,61593
-(defun save-acl2-in-allegro-aux 1467,61766
-(defun save-acl2-in-allegro 1520,63994
-(defun save-exec-raw 1534,64466
-(defun rc-filename 1538,64601
-(defun write-acl2rc 1541,64666
-(defun save-acl2-in-clisp-aux 1560,65380
-(defun save-acl2-in-clisp 1604,67227
-(defun save-exec-raw 1613,67539
-(defun save-acl2-in-ccl-aux 1618,67678
-(defun save-acl2-in-ccl 1687,70685
-(defun save-exec-raw 1699,71152
-(defun save-acl2 1706,71436
-(defun proclaim-files 1768,73679
-(defun generate-acl2-proclaims 1791,74543
-(defun acl2 1811,75348
-
-akcl-acl2-trace.lisp,340
-(defmacro trace 36,1430
-(defmacro untrace 92,3486
-(defun trace-ppr-gcl 100,3630
-(defun trace-fix-entry-raw 132,4972
-(defun trace-fix-entry 148,5602
-(defun trace-values 163,6141
-(defun trace-values 173,6430
-(defun make-nths 178,6515
-(defun trace-fix-exit-raw 184,6637
-(defun trace-fix-exit 199,7204
-(defun trace-fix-cond 220,8176
-
-allegro-acl2-trace.lisp,341
-(defvar *trace-arglist*)52,2090
-(defvar *trace-values*)54,2116
-(defconst *trace-sublis* 56,2141
-(defun trace-pre-process 101,4371
-(defun trace-entry 129,5368
-(defun trace-values 158,6478
-(defun trace-values 168,6767
-(defun make-nths 173,6852
-(defun trace-exit 179,6974
-(defun traced-fns-lst 215,8449
-(defun trace-process 218,8514
-
-openmcl-acl2-trace.lisp,320
-(defvar *trace-arglist*)56,2188
-(defvar *trace-values*)58,2214
-(defparameter *trace-sublis* 60,2239
-(defun trace-pre-process 66,2516
-(defun trace-entry 101,3869
-(defun trace-values 126,5007
-(defun trace-exit 135,5321
-(defun traced-fns-lst 164,6651
-(defun trace-process 167,6716
-(defun acl2-traced-fns 187,7620
-
-serialize-raw.lisp,1886
-(defparameter *ser-verbose* 269,12198
-(defmacro ser-time? 271,12232
-(defmacro ser-print? 276,12314
-(defmacro ser-write-char 290,12862
-(defmacro ser-write-byte 293,12943
-(defmacro ser-read-char 296,13048
-(defmacro ser-read-byte 301,13275
-(defun ser-encode-magic 304,13373
-(defun ser-decode-magic 311,13607
-(defun ser-encode-nat-fixnum 371,16345
-(defun ser-encode-nat-large 387,16885
-(defmacro ser-encode-nat 405,17568
-(defun ser-decode-nat-large 417,17885
-(defmacro ser-decode-nat-body 435,18544
-(defun ser-decode-nat 469,19951
-(defun ser-encode-rat 498,20874
-(defun ser-decode-rat 504,21070
-(defun ser-encode-complex 533,22164
-(defun ser-decode-complex 538,22310
-(defun ser-encode-str 564,23389
-(defun ser-decode-str 573,23727
-(defstruct ser-decoder605,24863
-(defun ser-encode-nats 624,25485
-(defun ser-decode-and-load-nats 631,25686
-(defun ser-encode-rats 651,26435
-(defun ser-decode-and-load-rats 658,26637
-(defun ser-encode-complexes 677,27321
-(defun ser-decode-and-load-complexes 684,27532
-(defun ser-encode-chars 703,28217
-(defun ser-decode-and-load-chars 710,28421
-(defun ser-encode-strs 729,29094
-(defun ser-decode-and-load-strs 736,29294
-(defun ser-encode-package 780,31261
-(defun ser-decode-and-load-package 789,31570
-(defun ser-encode-packages 817,32914
-(defun ser-decode-and-load-packages 825,33238
-(defun ser-hashtable-init 841,33776
-(defstruct ser-encoder854,34211
-(defmacro ser-see-obj 924,37257
-(defun ser-gather-atoms 934,37510
-(defun ser-make-atom-map 1070,43758
-(defun ser-encode-conses1178,48408
-(defmacro ser-decode-loop 1230,50856
-(defun ser-decode-and-load-conses 1267,52419
-(defun ser-encode-fals 1355,56706
-(defun ser-decode-and-restore-fals 1383,57845
-(defun ser-encode-atoms 1410,59185
-(defun ser-encode-to-stream 1425,59808
-(defun ser-decode-and-load-atoms 1498,62752
-(defun ser-decode-from-stream 1508,63170
-
-axioms.lisp,68220
-(acl2::defconst acl2::*common-lisp-symbols-from-main-lisp-package*81,4294
-(defconst *common-lisp-specials-and-constants*593,26922
-(defconst *stobj-inline-declare*671,31242
-(defmacro make-package-entry 914,42484
-(defmacro find-package-entry 955,44431
-(defmacro package-entry-name 958,44533
-(defmacro package-entry-imports 961,44604
-(defmacro package-entry-hidden-p 964,44679
-(defmacro package-entry-book-path 967,44756
-(defmacro package-entry-defpkg-event-form 970,44835
-(defmacro package-entry-tterm 973,44928
-(defmacro find-non-hidden-package-entry 976,45009
-(defmacro remove-package-entry 981,45202
-(defmacro change-package-entry-hidden-p 984,45313
-(defmacro getprop 994,45683
-(defvar *user-stobj-alist* 1012,46394
-(defparameter *wormholep* 1041,48186
-(defun-one-output replace-bad-lisp-object 1048,48497
-(defun-one-output replace-bad-lisp-object-list 1060,48818
-(defun-one-output wormhole-er 1066,48991
-(defparameter *wormhole-cleanup-form* 1079,49517
-(defstruct (cloaking-device1120,52327
-(defun-one-output cloaked-set-w! 1127,52541
-(defun-one-output assoc-eq-butlast-2 1135,52817
-(defun-one-output assoc-eq-equal-butlast-2 1146,53239
-(defun-one-output push-wormhole-undo-formi 1159,53746
-(defconstant *open-input-channel-key*1283,60510
-(defconstant *open-input-channel-type-key*1289,60725
-(defconstant *open-output-channel-key*1292,60819
-(defconstant *open-output-channel-type-key*1295,60905
-(defconstant *non-existent-stream*1298,61001
-(defmacro live-state-p 1301,61081
-(defvar *acl2-error-p* 1307,61257
-(defun interface-er 1309,61286
-(defun-one-output acl2-numberp 1343,62601
-(defun-one-output binary-+ 1346,62652
-(defun-one-output binary-* 1348,62695
-(defun-one-output unary-- 1350,62738
-(defun-one-output unary-/ 1352,62776
-(defparameter *in-recover-world-flg* 1358,62991
-(defparameter *ever-known-package-alist*1363,63178
-(defparameter *package-alist* 1389,64394
-(defun-one-output find-package-fast 1391,64430
-(defvar **1*-symbol-key* 1397,64630
-(defvar *global-symbol-key* 1399,64690
-(defun global-symbol 1401,64756
-(defun *1*-symbol 1410,65095
-(defun *1*-symbol? 1420,65459
-(defmacro defun-*1* 1432,65940
-(defparameter *defun-overrides* 1435,66013
-(defmacro defun-overrides 1437,66051
-(defmacro defpkg 1452,66623
-(defmacro defuns 1465,67104
-(defmacro defun-std 1470,67234
-(defmacro defuns-std 1478,67460
-(defmacro defthm 1481,67515
-(defmacro defthmd 1485,67579
-(defmacro defthm-std 1490,67669
-(defmacro defaxiom 1494,67737
-(defmacro skip-proofs 1498,67803
-(defmacro deflabel 1501,67839
-(defmacro defdoc 1505,67905
-(defmacro deftheory 1509,67969
-(defun-one-output stobj-initial-statep-arr 1513,68036
-(defun-one-output stobj-initial-statep-entry 1518,68209
-(defun-one-output stobj-initial-statep1 1548,69129
-(defun-one-output stobj-initial-statep 1556,69520
-(defun remove-stobj-inline-declare 1570,70103
-(defun congruent-stobj-rep-raw 1577,70314
-(defmacro defstobj 1589,70699
-(defmacro value-triple 1715,76196
-(defmacro verify-termination-boot-strap 1719,76266
-(defmacro verify-guards 1723,76353
-(defmacro in-theory 1727,76424
-(defmacro in-arithmetic-theory 1731,76491
-(defmacro regenerate-tau-database 1735,76569
-(defmacro push-untouchable 1739,76650
-(defmacro remove-untouchable 1743,76724
-(defmacro set-body 1747,76800
-(defmacro table 1751,76866
-(defmacro encapsulate 1762,77243
-(defparameter *inside-include-book-fn*1805,79047
-(defmacro include-book 1816,79497
-(defmacro certify-book 1830,80064
-(defmacro local 1841,80565
-(defmacro defchoose 1845,80616
-(defmacro mutual-recursion 1855,81031
-(defmacro make-event 1858,81092
-(deflabel programming1876,82014
-(deflabel acl2-built-ins1893,82635
-(deflabel miscellaneous1909,83346
-(defconst *standard-co* 1923,83721
-(defconst *standard-oi* 1925,83797
-(defconst *standard-ci* 1927,83868
-(defconst nil 1949,84323
-(defconst t 1957,84491
-(defun insist 1963,84644
-(defun iff 1972,84871
-(defun xor 1987,85263
-(defun eq 2002,85631
-(defun booleanp 2029,86749
-(defthm iff-is-an-equivalence2051,87339
-(defun implies 2059,87554
-(defthm iff-implies-equal-implies-12074,87928
-(defthm iff-implies-equal-implies-22079,88077
-(defun not 2085,88243
-(defthm iff-implies-equal-not2102,88659
-(defun hide 2107,88790
-(defun rewrite-equiv 2213,93435
-(defmacro real/rationalp 2227,93921
-(defmacro complex/complex-rationalp 2245,94545
-(defun true-listp 2267,95355
-(defun list-macro 2283,95745
-(defmacro list 2292,95946
-(defun and-macro 2307,96350
-(defmacro and 2318,96582
-(defun or-macro 2334,97025
-(defmacro or 2346,97279
-(defmacro - 2389,98378
-(defthm booleanp-compound-recognizer2434,100239
-(defun integer-abs 2448,100734
-(defun xxxjoin 2454,100843
-(defmacro + 2473,101364
-(defun-one-output len2 2484,101623
-(defun len1 2489,101733
-(defun len 2518,103030
-(defun length 2547,103822
-(defun-one-output complex-rationalp 2571,104466
-(defun acl2-count 2574,104523
-(defun cond-clausesp 2629,106670
-(defun cond-macro 2638,106926
-(defmacro cond 2665,107923
-(defun eqlablep 2687,108648
-(defthm eqlablep-recog2711,109526
-(defun eqlable-listp 2720,109727
-(defun eql 2738,110210
-(defun atom 2761,110928
-(defun make-character-list 2780,111391
-(defun eqlable-alistp 2802,111974
-(defun alistp 2820,112524
-(defthm alistp-forward-to-true-listp2836,112917
-(defthm eqlable-alistp-forward-to-alistp2841,113039
-(defun acons 2847,113186
-(defun endp 2866,113759
-(defmacro caar 2890,114478
-(defmacro cadr 2899,114668
-(defmacro cdar 2908,114858
-(defmacro cddr 2917,115048
-(defmacro caaar 2926,115238
-(defmacro caadr 2935,115431
-(defmacro cadar 2944,115624
-(defmacro caddr 2953,115817
-(defmacro cdaar 2962,116010
-(defmacro cdadr 2971,116203
-(defmacro cddar 2980,116396
-(defmacro cdddr 2989,116589
-(defmacro caaaar 2998,116782
-(defmacro caaadr 3007,116978
-(defmacro caadar 3016,117174
-(defmacro caaddr 3025,117370
-(defmacro cadaar 3034,117566
-(defmacro cadadr 3043,117762
-(defmacro caddar 3052,117958
-(defmacro cadddr 3061,118154
-(defmacro cdaaar 3070,118350
-(defmacro cdaadr 3079,118546
-(defmacro cdadar 3088,118742
-(defmacro cdaddr 3097,118938
-(defmacro cddaar 3106,119134
-(defmacro cddadr 3115,119330
-(defmacro cdddar 3124,119526
-(defmacro cddddr 3133,119722
-(defun null 3142,119918
-(defun symbol-listp 3160,120430
-(defthm symbol-listp-forward-to-true-listp3176,120848
-(defun symbol-doublet-listp 3181,120982
-(defun reverse-strip-cars 3308,125508
-(defun strip-cars 3314,125697
-(defun reverse-strip-cdrs 3339,126447
-(defun strip-cdrs 3345,126636
-(defmacro let-mbe 3369,127377
-(defun return-last 3375,127507
-(defmacro return-last 3889,149626
-(defmacro mbe1-raw 3937,151760
-(defmacro mbe1 3945,151962
-(defmacro must-be-equal 3964,152530
-(defmacro mbe 3992,153792
-(defmacro mbt 4135,159815
-(defdoc equality-variants4238,163986
-(defdoc equality-variants-details4351,169641
-(defun member-eq-exec 4534,176537
-(defun member-eql-exec 4542,176803
-(defun member-equal 4550,177074
-(defmacro member-eq 4559,177376
-(defthm member-eq-exec-is-member-equal4562,177436
-(defthm member-eql-exec-is-member-equal4566,177536
-(defmacro member 4571,177655
-(defun subsetp-eq-exec 4626,179721
-(defun subsetp-eql-exec 4637,180080
-(defun subsetp-equal 4649,180430
-(defmacro subsetp-eq 4660,180785
-(defthm subsetp-eq-exec-is-subsetp-equal4663,180843
-(defthm subsetp-eql-exec-is-subsetp-equal4667,180947
-(defmacro subsetp 4672,181070
-(defun symbol-alistp 4723,183024
-(defthm symbol-alistp-forward-to-eqlable-alistp4740,183525
-(defun assoc-eq-exec 4747,183678
-(defun assoc-eql-exec 4755,183965
-(defun assoc-equal 4763,184257
-(defmacro assoc-eq 4772,184573
-(defthm assoc-eq-exec-is-assoc-equal4775,184631
-(defthm assoc-eql-exec-is-assoc-equal4779,184727
-(defmacro assoc 4784,184842
-(defun assoc-eq-equal-alistp 4837,186953
-(defun assoc-eq-equal 4845,187208
-(defmacro <=4865,187955
-(defun = =4880,188287
-(defun /=4905,188941
-(defmacro > 4929,189644
-(defmacro >=4944,189948
-(deflabel zero-test-idioms4958,190266
-(defmacro int=5127,198679
-(defun zp 5149,199424
-(defun-one-output zp 5189,200674
-(defthm zp-compound-recognizer5193,200743
-(defthm zp-open5208,201225
-(defun zip 5235,202087
-(defun-one-output zip 5275,203263
-(defthm zip-compound-recognizer5277,203299
-(defthm zip-open5286,203494
-(defun nth 5295,203702
-(defun char 5322,204455
-(defun proper-consp 5346,205187
-(defun improper-consp 5361,205580
-(defmacro * 5378,206039
-(defun conjugate 5407,206704
-(defmacro prog2$ 5428,207255
-(deflabel Other5505,210174
-(deflabel acl2-help5515,210476
-(defmacro ec-call1-raw 5528,210903
-(defmacro ec-call1 5562,212603
-(defmacro ec-call 5570,212878
-(defmacro non-exec 5717,218706
-(defmacro / 5815,221759
-(defaxiom closure5853,222656
-(defaxiom Associativity-of-+5860,222813
-(defaxiom Commutativity-of-+5863,222882
-(defun fix 5866,222939
-(defaxiom Unicity-of-05886,223441
-(defaxiom Inverse-of-+5890,223501
-(defaxiom Associativity-of-*5893,223550
-(defaxiom Commutativity-of-*5896,223619
-(defaxiom Unicity-of-15899,223676
-(defaxiom Inverse-of-*5903,223736
-(defaxiom Distributivity5908,223863
-(defaxiom <-on-others5912,223943
-(defaxiom Zero5917,224032
-(defaxiom Trichotomy5921,224085
-(defaxiom Positive5933,224355
-(defaxiom Rational-implies15943,224636
-(defaxiom Rational-implies25950,224835
-(defaxiom integer-implies-rational5958,225068
-(defaxiom rational-implies-real5963,225189
-(defaxiom complex-implies15969,225338
-(defaxiom complex-definition5976,225522
-(defaxiom nonzero-imagpart5987,225859
-(defaxiom realpart-imagpart-elim5992,225990
-(defaxiom realpart-complex6001,226277
-(defaxiom imagpart-complex6009,226507
-(defthm complex-equal6017,226731
-(defun force 6036,227439
-(defconst *force-xnume*6165,234578
-(defun immediate-force-modep 6172,234699
-(defconst *immediate-force-modep-xnume*6221,236604
-(defun case-split 6224,236668
-(defmacro disable-forcing 6278,238751
-(defmacro enable-forcing 6301,239498
-(defmacro disable-immediate-force-modep 6326,240296
-(defmacro enable-immediate-force-modep 6352,241234
-(defun synp 6378,242158
-(defmacro syntaxp 6414,243804
-(deflabel syntaxp-examples6638,254511
-(defmacro bind-free 6841,261023
-(deflabel bind-free-examples7063,270825
-(defun extra-info 7245,277567
-(defconst *extra-info-fn*7252,277729
-(deflabel rule-classes7267,278401
-(defun tau-system 7560,296049
-(defconst *tau-status-boot-strap-settings*8002,316069
-(defconst *tau-system-xnume*8021,317052
-(defconst *tau-acl2-numberp-pair* 8025,317177
-(defconst *tau-integerp-pair*8026,317232
-(defconst *tau-rationalp-pair*8031,317351
-(defconst *tau-natp-pair*8036,317473
-(defconst *tau-posp-pair*8041,317582
-(defconst *tau-minusp-pair*8046,317691
-(defconst *tau-booleanp-pair*8051,317806
-(defaxiom nonnegative-product8075,318775
-(defaxiom Integer-08105,319771
-(defaxiom Integer-18109,319828
-(defaxiom Integer-step8113,319885
-(defaxiom Lowest-Terms8119,320027
-(defthm basic-tau-rules8147,321073
-(defaxiom car-cdr-elim8200,322909
-(defaxiom car-cons 8205,323022
-(defaxiom cdr-cons 8207,323070
-(defaxiom cons-equal8209,323118
-(defaxiom booleanp-characterp8222,323523
-(defaxiom characterp-page8226,323603
-(defaxiom characterp-tab8230,323673
-(defaxiom characterp-rubout8234,323741
-(defun no-duplicatesp-eq-exec 8240,323833
-(defun no-duplicatesp-eql-exec 8246,324022
-(defun no-duplicatesp-equal 8252,324211
-(defmacro no-duplicatesp-eq 8258,324397
-(defthm no-duplicatesp-eq-exec-is-no-duplicatesp-equal8261,324464
-(defthm no-duplicatesp-eql-exec-is-no-duplicatesp-equal8265,324592
-(defmacro no-duplicatesp 8269,324722
-(defun chk-no-duplicatesp 8321,326621
-(defun r-eqlable-alistp 8329,326799
-(defun r-symbol-alistp 8349,327388
-(defun rassoc-eq-exec 8368,327932
-(defun rassoc-eql-exec 8376,328223
-(defun rassoc-equal 8384,328519
-(defmacro rassoc-eq 8393,328838
-(defthm rassoc-eq-exec-is-rassoc-equal8396,328902
-(defthm rassoc-eql-exec-is-rassoc-equal8400,329010
-(defmacro rassoc 8405,329137
-(defconst *standard-chars*8461,331479
-(defun standard-char-p 8471,331948
-(defun standard-char-listp 8497,332734
-(defun character-listp 8519,333336
-(defthm character-listp-forward-to-eqlable-listp8535,333757
-(defthm standard-char-listp-forward-to-character-listp8540,333903
-(defaxiom coerce-inverse-18545,334061
-(defaxiom coerce-inverse-28574,335093
-(defaxiom character-listp-coerce8584,335394
-(defun string 8616,336824
-(defun alpha-char-p 8654,338109
-(defun upper-case-p 8682,339069
-(defun lower-case-p 8711,340112
-(defun char-upcase 8740,341154
-(defun char-downcase 8796,343118
-(defthm lower-case-p-char-downcase8851,345133
-(defthm upper-case-p-char-upcase8856,345280
-(defthm lower-case-p-forward-to-alpha-char-p8861,345423
-(defthm upper-case-p-forward-to-alpha-char-p8867,345598
-(defthm alpha-char-p-forward-to-characterp8873,345773
-(defthm characterp-char-downcase8878,345907
-(defthm characterp-char-upcase8882,346010
-(defun string-downcase1 8891,346335
-(defthm character-listp-string-downcase-18900,346614
-(defun string-downcase 8904,346716
-(defun string-upcase1 8931,347696
-(defthm character-listp-string-upcase1-18940,347969
-(defun string-upcase 8944,348068
-(defun our-digit-char-p 8965,348783
-(defmacro digit-char-p 9038,351034
-(defun char-equal 9061,351934
-(defun atom-listp 9085,352726
-(defthm atom-listp-forward-to-true-listp9103,353186
-(defthm eqlable-listp-forward-to-atom-listp9108,353316
-(defun good-atom-listp 9113,353452
-(defthm good-atom-listp-forward-to-atom-listp9137,354167
-(defthm characterp-nth9142,354307
-(defun ifix 9148,354459
-(defun rfix 9167,354972
-(defun realfix 9196,356026
-(defun nfix 9215,356553
-(defun string-equal1 9236,357117
-(defun string-equal 9261,358040
-(defun standard-string-alistp 9288,359024
-(defthm standard-string-alistp-forward-to-alistp9309,359740
-(defun assoc-string-equal 9314,359886
-(defdoc e0-ordinalp9350,361212
-(defdoc e0-ord-<9367,362014
-(defun natp 9384,362830
-(defthm natp-compound-recognizer9403,363484
-(defun posp 9409,363626
-(defthm posp-compound-recognizer9426,364205
-(defun o-finp 9432,364346
-(defmacro o-infp 9447,364837
-(defun o-first-expt 9457,365056
-(defun o-first-coeff 9477,365743
-(defun o-rst 9497,366451
-(defun o 9601,371170
-(defmacro o<=9610,371366
-(defmacro o>=9619,371583
-(defun o-p 9628,371803
-(defthm o-p-implies-o 15251,580699
-(defun char<=15271,581278
-(defun char>=15291,581877
-(defun string<-l 15310,582465
-(defun string< 15324,582892
-(defun string> 15361,583932
-(defun string<=15382,584559
-(defun string>=15408,585424
-(defun symbol-< 15433,586272
-(defthm string<-l-irreflexive15459,587221
-(defthm string<-irreflexive15462,587279
-(defun substitute-ac 15465,587331
-(defun substitute 15479,587777
-(defun sublis 15515,589121
-(defun subst 15545,590161
-(defmacro pprogn 15570,590986
-(defmacro progn$ 15633,592941
-(defmacro pprogn@par 15659,593652
-(defparameter *acl2-unwind-protect-stack* 15788,601268
-(defvar *lp-ever-entered-p* 15791,601333
-(defmacro push-car 15794,601384
-(defmacro acl2-unwind-protect 15812,602204
-(defun-one-output acl2-unwind 15918,607111
-(defmacro when-logic 16094,616840
-(defmacro in-package 16118,617721
-(defmacro defpkg 16147,618570
-(defdoc managing-acl2-packages16269,624406
-(deflabel hidden-defpkg16278,624681
-(deflabel hidden-death-package16286,624813
-(defmacro defun 16348,627439
-(defmacro defun-std 16593,639401
-(defmacro defuns 16609,639764
-(defmacro defuns-std 16652,641027
-(defmacro verify-termination 16667,641401
-(defmacro verify-termination-boot-strap 16831,649469
-(defmacro verify-guards 16841,649750
-(defdoc defpun17160,664582
-(defmacro defmacro 17195,665937
-(defmacro defconst 17288,669947
-(defmacro defthm 17359,672977
-(defmacro defthmd 17440,676020
-(defmacro defthm-std 17486,677394
-(defmacro defaxiom 17514,678136
-(defmacro deflabel 17561,679832
-(deflabel theories17602,681357
-(defmacro deftheory 17761,689852
-(defmacro deftheory-static 17846,693164
-(defmacro defstobj 17925,696523
-(defmacro in-theory 18365,717775
-(defmacro in-arithmetic-theory 18430,720615
-(defmacro regenerate-tau-database 18489,723100
-(defmacro push-untouchable 18568,727185
-(defmacro remove-untouchable 18626,729606
-(defmacro set-body 18725,734222
-(defmacro table 18766,735834
-(defmacro encapsulate 18983,747295
-(defconst *load-compiled-file-values*19264,760967
-(defmacro include-book 19268,761056
-(defmacro make-event 19472,772007
-(defdoc make-event-details20040,797421
-(defdoc using-tables-efficiently20264,809315
-(defmacro record-expansion 20345,812514
-(defmacro skip-proofs 20548,823129
-(defmacro local 20656,828677
-(defmacro defchoose 20716,831143
-(deflabel conservativity-of-defchoose20877,837343
-(defmacro defattach 21287,857351
-(defun attachment-symbol 21804,881136
-(defun set-attachment-symbol-form 21811,881313
-(defmacro defattach 21814,881406
-(deflabel worldp)21895,885187
-(defun plist-worldp 21897,885244
-(defthm plist-worldp-forward-to-assoc-eq-equal-alistp21932,886702
-(defdoc getprop21937,886858
-(defun putprop 21953,887300
-(defparameter meter-maid-cnt 22017,889575
-(defun meter-maid 22020,889625
-(defconst *acl2-property-unbound* 22038,890441
-(defun getprop-default 22040,890500
-(defun-one-output sgetprop1 22056,891009
-(defun fgetprop 22163,895375
-(defun sgetprop 22221,897960
-(defun ordered-symbol-alistp 22259,899573
-(defthm ordered-symbol-alistp-forward-to-symbol-alistp22277,900124
-(defun add-pair 22282,900282
-(defun delete-assoc-eq-exec 22296,900697
-(defun delete-assoc-eql-exec 22304,901020
-(defun delete-assoc-equal 22312,901348
-(defmacro delete-assoc-eq 22318,901573
-(defthm delete-assoc-eq-exec-is-delete-assoc-equal22321,901649
-(defthm delete-assoc-eql-exec-is-delete-assoc-equal22325,901781
-(defmacro delete-assoc 22329,901915
-(defun getprops1 22382,904126
-(defun getprops 22397,904747
-(defthm equal-char-code22442,906536
-(defun has-propsp1 22456,906937
-(defun has-propsp 22477,907884
-(defun extend-world 22509,909250
-(defun retract-world 22529,909917
-(defun global-val 22549,910586
-(defun function-symbolp 22566,911255
-(defun translate-declaration-to-guard/integer 22587,912319
-(defun weak-satisfies-type-spec-p 22633,914217
-(defun translate-declaration-to-guard1 22647,914728
-(defun translate-declaration-to-guard 22833,922264
-(defun translate-declaration-to-guard-lst 22906,925690
-(deflabel declare22932,926568
-(deflabel type-spec22994,928985
-(defun the-check 23071,932341
-(defun the-fn 23081,932737
-(defmacro the 23131,935155
-(defconst *maximum-positive-32-bit-integer*23258,941331
-(defconst *our-array-total-size-limit*23262,941413
-(defun-one-output chk-make-array$ 23274,941845
-(defmacro make-array$ 23307,943317
-(defparameter *acl2-array-cache*23406,948182
-(defmacro set-acl2-array-property 23414,948450
-(defmacro get-acl2-array-property 23463,950251
-(defun bounded-integer-alistp 23491,951241
-(defthm bounded-integer-alistp-forward-to-eqlable-alistp23507,951814
-(defun keyword-value-listp 23512,951978
-(defthm keyword-value-listp-forward-to-true-listp23530,952521
-(defun assoc-keyword 23535,952669
-(defthm keyword-value-listp-assoc-keyword23557,953392
-(defthm consp-assoc-equal23563,953622
-(defmacro f-get-global 23582,954480
-(defun our-import 23643,956515
-(defvar *defpkg-virgins* 23662,957533
-(defun check-proposed-imports 23664,957564
-(defun-one-output defpkg-raw1 23723,960537
-(defun package-has-no-imports 23817,964552
-(defmacro maybe-make-package 23825,964793
-(defmacro maybe-introduce-empty-pkg-1 23909,967846
-(defmacro maybe-introduce-empty-pkg-2 23954,969828
-(defmacro defpkg-raw 23962,970149
-(defun-one-output slow-array-warning 23992,971408
-(deflabel arrays24009,972099
-(deflabel arrays-example24424,994547
-(deflabel slow-array-warning24504,997392
-(defun array1p 24608,1002822
-(defthm array1p-forward24659,1005134
-(defthm array1p-linear24679,1006295
-(defun bounded-integer-alistp2 24688,1006799
-(defun assoc2 24707,1007629
-(defun array2p 24719,1007934
-(defthm array2p-forward24762,1009664
-(defthm array2p-linear24787,1011229
-(defun header 24800,1011960
-(defun dimensions 24832,1012950
-(defun maximum-length 24859,1014040
-(defun default 24883,1014933
-(defun aref1 24931,1017202
-(defun compress11 24982,1018982
-(defconstant *invisible-array-mark* 24997,1019573
-(defun array-order 24999,1019654
-(defun compress1 25012,1020047
-(defthm array1p-cons25279,1032909
-(defun aset1 25289,1033267
-(defun aref2 25413,1039363
-(defun compress211 25460,1041057
-(defun compress21 25476,1041695
-(defun compress2 25489,1042181
-(defthm array2p-cons25667,1050142
-(defun aset2 25678,1050520
-(defun flush-compress 25791,1055394
-(defparameter *return-values*25952,1061729
-(defmacro declare-return-values 25959,1061918
-(defun declare-return-values1 25962,1061996
-(defun in-akcl-with-mv-set-and-ref 25973,1062218
-(defconstant *akcl-mv-ref-and-set-inclusive-upper-bound* 25976,1062293
-(defmacro special-location 25978,1062354
-(defmacro set-mv 25988,1062763
-(defmacro mv-ref 26001,1063229
-(defun mv-refs-fn 26013,1063661
-(defmacro mv-refs 26021,1063795
-(defun cdrn 26038,1064218
-(defun mv-nth 26044,1064384
-(defun make-mv-nths 26096,1066405
-(defun mv-bindings 26104,1066717
-(defun mv-set-mvs 26114,1067041
-(defmacro mv 26119,1067206
-(defmacro mv? 26267,1072761
-(defmacro mv-let 26338,1075125
-(defmacro mv?-let 26492,1081751
-(defun mv-list 26548,1083386
-(defmacro mv-list 26593,1085168
-(defmacro mv-list 26598,1085318
-(deflabel state26601,1085395
-(defdoc programming-with-state26776,1094559
-(defdoc error-triples27311,1117678
-(defun update-nth 27339,1118863
-(defun update-nth-array 27382,1120183
-(defmacro maximum-positive-32-bit-integer 27393,1120613
-(defmacro maximum-positive-32-bit-integer-minus-1 27396,1120696
-(defun 32-bit-integerp 27399,1120798
-(defthm 32-bit-integerp-forward-to-integerp27405,1120981
-(defun acl2-number-listp 27410,1121117
-(defthm acl2-number-listp-forward-to-true-listp27427,1121541
-(defun rational-listp 27432,1121685
-(defthm rational-listp-forward-to-acl2-number-listp27449,1122115
-(defun real-listp 27457,1122348
-(defdoc real-listp27464,1122512
-(defthm real-listp-forward-to-acl2-number-listp27476,1122861
-(defun integer-listp 27481,1123005
-(defthm integer-listp-forward-to-rational-listp27498,1123415
-(defun nat-listp 27503,1123559
-(defthm nat-listp-forward-to-integer-listp27520,1123968
-(defthm rational-listp-forward-to-real-listp27528,1124195
-(defun 32-bit-integer-listp 27533,1124333
-(defthm 32-bit-integer-listp-forward-to-integer-listp27539,1124521
-(defun open-input-channels 27548,1124872
-(defun update-open-input-channels 27552,1124962
-(defun open-output-channels 27556,1125070
-(defun update-open-output-channels 27560,1125161
-(defun global-table 27564,1125270
-(defun update-global-table 27568,1125353
-(defun t-stack 27572,1125454
-(defun update-t-stack 27576,1125532
-(defun 32-bit-integer-stack 27580,1125628
-(defun update-32-bit-integer-stack 27584,1125719
-(defun big-clock-entry 27588,1125828
-(defun update-big-clock-entry 27592,1125914
-(defun idates 27596,1126018
-(defun update-idates 27600,1126095
-(defun acl2-oracle 27604,1126190
-(defun update-acl2-oracle 27608,1126272
-(defun file-clock 27612,1126372
-(defun update-file-clock 27616,1126453
-(defun readable-files 27620,1126552
-(defun written-files 27624,1126637
-(defun update-written-files 27628,1126722
-(defun read-files 27632,1126825
-(defun update-read-files 27636,1126907
-(defun writeable-files 27640,1127007
-(defun list-all-package-names-lst 27644,1127094
-(defun update-list-all-package-names-lst 27648,1127192
-(defun user-stobj-alist1 27656,1127520
-(defun update-user-stobj-alist1 27660,1127609
-(defconst *initial-raw-arity-alist*27665,1127736
-(defconst *initial-checkpoint-processors*27691,1128463
-(defconst *primitive-program-fns-with-raw-code*27710,1129201
-(defconst *primitive-logic-fns-with-raw-code*27823,1133389
-(defconst *primitive-macros-with-raw-code*27983,1139779
-(defmacro with-live-state 28075,1143329
-(defun init-iprint-ar 28184,1147432
-(defconst *iprint-soft-bound-default* 28216,1148825
-(defconst *iprint-hard-bound-default* 28217,1148869
-(defdoc parallelism28219,1148915
-(defdoc parallel-programming28256,1150870
-(defdoc parallel-proof28294,1152765
-(defun default-total-parallelism-work-limit 28307,1153193
-(defconst *fmt-soft-right-margin-default* 28385,1157162
-(defconst *fmt-hard-right-margin-default* 28386,1157208
-(defconst *initial-global-table*28388,1157255
-(defun all-boundp 28678,1169861
-(defun known-package-alistp 28686,1170132
-(defthm known-package-alistp-forward-to-true-list-listp-and-alistp28697,1170513
-(defun timer-alistp 28703,1170717
-(defthm timer-alistp-forward-to-true-list-listp-and-symbol-alistp28715,1171029
-(defun typed-io-listp 28721,1171231
-(defthm typed-io-listp-forward-to-true-listp28733,1171682
-(defconst *file-types* 28738,1171824
-(defun open-channel1 28740,1171877
-(defthm open-channel1-forward-to-true-listp-and-consp28754,1172292
-(defun open-channel-listp 28760,1172470
-(defun open-channels-p 28773,1172827
-(defthm open-channels-p-forward28778,1172949
-(defun file-clock-p 28784,1173128
-(defthm file-clock-p-forward-to-integerp28788,1173194
-(defun readable-file 28793,1173320
-(defthm readable-file-forward-to-true-listp-and-consp28805,1173682
-(defun readable-files-listp 28811,1173860
-(defthm readable-files-listp-forward-to-true-list-listp-and-alistp28817,1174046
-(defun readable-files-p 28823,1174250
-(defthm readable-files-p-forward-to-readable-files-listp28827,1174336
-(defun written-file 28832,1174498
-(defthm written-file-forward-to-true-listp-and-consp28845,1174897
-(defun written-file-listp 28851,1175073
-(defthm written-file-listp-forward-to-true-list-listp-and-alistp28857,1175254
-(defun written-files-p 28863,1175454
-(defthm written-files-p-forward-to-written-file-listp28867,1175537
-(defun read-file-listp1 28872,1175693
-(defthm read-file-listp1-forward-to-true-listp-and-consp28881,1175923
-(defun read-file-listp 28887,1176107
-(defthm read-file-listp-forward-to-true-list-listp28893,1176286
-(defun read-files-p 28898,1176436
-(defthm read-files-p-forward-to-read-file-listp28902,1176513
-(defun writable-file-listp1 28907,1176657
-(defthm writable-file-listp1-forward-to-true-listp-and-consp28915,1176862
-(defun writable-file-listp 28921,1177054
-(defthm writable-file-listp-forward-to-true-list-listp28927,1177245
-(defun writeable-files-p 28932,1177403
-(defthm writeable-files-p-forward-to-writable-file-listp28936,1177489
-(defun state-p1 28941,1177651
-(defthm state-p1-forward28976,1179081
-(defun state-p 29019,1180977
-(defthm state-p-implies-and-forward-to-state-p129029,1181234
-(defmacro build-state29122,1186551
-(defconst *default-state*29146,1187484
-(defun build-state1 29151,1187618
-(defun coerce-state-to-object 29179,1188878
-(defun coerce-object-to-state 29183,1188947
-(defun-one-output strip-numeric-postfix 29193,1189120
-(defun global-table-cars1 29201,1189360
-(defun global-table-cars 29226,1190504
-(defun boundp-global1 29233,1190708
-(defun boundp-global 29242,1191034
-(defmacro f-boundp-global 29250,1191282
-(defun makunbound-global 29266,1191814
-(defun get-global 29294,1192856
-(defun put-global 29307,1193333
-(defmacro f-put-global 29328,1194153
-(defmacro f-put-global@par 29391,1196752
-(defconst *initial-ld-special-bindings*29409,1197354
-(defun always-boundp-global 29434,1198240
-(defun state-global-let*-bindings-p 29441,1198437
-(defun state-global-let*-get-globals 29458,1199068
-(defun state-global-let*-put-globals 29487,1200618
-(defun state-global-let*-cleanup 29520,1202345
-(defparameter *possible-parallelism-hazards*29571,1205234
-(defmacro with-parallelism-hazard-warnings 29612,1206597
-(defmacro warn-about-parallelism-hazard 29622,1206847
-(defmacro with-ensured-parallelism-finishing 29679,1209670
-(defmacro state-global-let* 29692,1210068
-(defmacro state-free-global-let* 29812,1215445
-(defun integer-range-p 29855,1217468
-(defun signed-byte-p 29881,1218503
-(defun unsigned-byte-p 29889,1218723
-(defthm integer-range-p-forward29900,1219028
-(defthm signed-byte-p-forward-to-integerp29908,1219278
-(defthm unsigned-byte-p-forward-to-nonnegative-integerp29913,1219412
-(defmacro the-fixnum 29921,1219675
-(defun-one-output zpf 29925,1219753
-(defun zpf 29929,1219862
-(defmacro logand 30178,1228056
-(defmacro logeqv 30201,1228788
-(defmacro logior 30224,1229532
-(defmacro logxor 30247,1230276
-(defun integer-length 30270,1231020
-(defun binary-logand 30299,1232000
-(defun lognand 30313,1232467
-(defun binary-logior 30332,1233043
-(defun logorc1 30338,1233220
-(defun logorc2 30359,1233904
-(defun logandc1 30380,1234589
-(defun logandc2 30401,1235263
-(defun binary-logeqv 30421,1235921
-(defun binary-logxor 30427,1236088
-(defun lognor 30433,1236247
-(defun logtest 30454,1236863
-(defconst *BOOLE-1* 30478,1237603
-(defconst *BOOLE-2* 30479,1237631
-(defconst *BOOLE-AND* 30480,1237659
-(defconst *BOOLE-ANDC1* 30481,1237687
-(defconst *BOOLE-ANDC2* 30482,1237715
-(defconst *BOOLE-C1* 30483,1237743
-(defconst *BOOLE-C2* 30484,1237771
-(defconst *BOOLE-CLR* 30485,1237799
-(defconst *BOOLE-EQV* 30486,1237827
-(defconst *BOOLE-IOR* 30487,1237855
-(defconst *BOOLE-NAND* 30488,1237883
-(defconst *BOOLE-NOR* 30489,1237911
-(defconst *BOOLE-ORC1* 30490,1237939
-(defconst *BOOLE-ORC2* 30491,1237967
-(defconst *BOOLE-SET* 30492,1237995
-(defconst *BOOLE-XOR* 30493,1238023
-(defun boole$ 30495,1238052
-(deflabel io30565,1240634
-(defdoc output-to-file30808,1251584
-(defdoc *standard-co*30863,1253807
-(defdoc *standard-oi*30902,1255880
-(defdoc *standard-ci*30916,1256460
-(defdoc print-control30932,1257068
-(defdoc character-encoding31031,1262352
-(defun set-forms-from-bindings 31078,1264539
-(defconst *print-control-defaults*31090,1264999
-(defun alist-difference-eq 31115,1266293
-(defmacro with-print-defaults 31131,1266837
-(defmacro reset-print-control 31140,1267308
-(defun digit-to-char 31144,1267419
-(defun print-base-p 31185,1268433
-(defun explode-nonnegative-integer 31192,1268586
-(defthm true-listp-explode-nonnegative-integer31240,1270206
-(defun explode-atom 31269,1271130
-(defun explode-atom+ 31313,1272781
-(defthm true-list-listp-forward-to-true-listp-assoc-equal31349,1274248
-(defthm true-listp-cadr-assoc-eq-for-open-channels-p31368,1275216
-(defun open-input-channel-p1 31383,1275730
-(defun open-output-channel-p1 31398,1276393
-(defun open-input-channel-p 31412,1277035
-(defun open-output-channel-p 31418,1277304
-(defun open-output-channel-any-p1 31424,1277575
-(defun open-output-channel-any-p 31431,1277916
-(defun open-input-channel-any-p1 31436,1278128
-(defun open-input-channel-any-p 31443,1278465
-(defmacro print-case 31448,1278675
-(defmacro acl2-print-case 31457,1278940
-(defun set-print-case 31460,1279012
-(defmacro set-acl2-print-case 31500,1280998
-(defmacro print-base 31506,1281195
-(defmacro acl2-print-base 31509,1281276
-(defmacro print-radix 31512,1281348
-(defmacro acl2-print-radix 31515,1281431
-(defun check-print-base 31518,1281505
-(defun set-print-base 31575,1284347
-(defmacro set-acl2-print-base 31615,1285652
-(defun set-print-circle 31621,1285849
-(defun set-print-escape 31625,1285967
-(defun set-print-pretty 31629,1286085
-(defun set-print-radix 31633,1286203
-(defun set-print-readably 31675,1287400
-(defun check-null-or-natp 31679,1287522
-(defun set-print-length 31690,1287870
-(defun set-print-level 31696,1288107
-(defun set-print-lines 31702,1288341
-(defun set-print-right-margin 31708,1288575
-(defmacro get-input-stream-from-channel 31715,1288847
-(defmacro get-output-stream-from-channel 31722,1289037
-(defmacro with-print-controls 31729,1289229
-(defun princ$ 31793,1292421
-(defun write-byte$ 31962,1299517
-(defvar *print-circle-stream* 31991,1300685
-(defmacro er 31993,1300721
-(defmacro er@par 32105,1306237
-(defun get-serialize-character 32128,1307162
-(defun w 32133,1307369
-(defun hons-enabledp 32145,1307896
-(defun set-serialize-character 32150,1308059
-(defun print-object$-ser 32177,1309245
-(defthm all-boundp-preserves-assoc-equal32231,1311525
-(defun print-object$ 32248,1312094
-(defparameter *file-clock* 32284,1313800
-(defun make-input-channel 32287,1313844
-(defun make-output-channel 32301,1314354
-(defun-one-output setup-standard-io 32323,1315368
-(defun-one-output lisp-book-syntaxp1 32363,1316860
-(defun-one-output lisp-book-syntaxp 32444,1319983
-(defparameter *parser* 32469,1321119
-(defun-one-output parse-infix-file 32482,1321589
-(defun open-input-channel 32512,1322831
-(defthm nth-update-nth32627,1328001
-(defthm true-listp-update-nth32634,1328187
-(defthm nth-update-nth-array32647,1328537
-(defun close-input-channel 32653,1328718
-(defun open-output-channel 32698,1330612
-(defun open-output-channel! 32798,1335707
-(defmacro assert$ 32929,1340446
-(defun fmt-to-comment-window 32953,1341250
-(defun fmt-to-comment-window! 33004,1343346
-(defun pairlis2 33018,1343708
-(defmacro cw 33026,1343992
-(defmacro cw! 33147,1348484
-(defun subseq-list 33166,1349135
-(defun subseq 33177,1349502
-(defun lock-symbol-name-p 33217,1351269
-(defun assign-lock 33226,1351561
-(defmacro with-lock 33247,1352239
-(defmacro deflock 33258,1352638
-(defun get-output-stream-string$-fn 33302,1354388
-(defmacro get-output-stream-string$ 33348,1356400
-(defun close-output-channel 33368,1357328
-(defun maybe-finish-output$ 33474,1362143
-(defmacro legal-acl2-character-p 33494,1362853
-(defun read-char$ 33510,1363401
-(defun peek-char$ 33545,1364876
-(defun read-byte$ 33571,1365926
-(defun-one-output parse-infix-from-terminal 33600,1367075
-(defparameter *acl2-read-suppress* 33625,1368130
-(defun read-object 33627,1368171
-(defun read-object-suppress 33723,1372478
-(defconst *suspiciously-first-numeric-chars*33740,1373236
-(defconst *suspiciously-first-hex-chars*33747,1373436
-(defconst *base-10-chars*33757,1373688
-(defconst *hex-chars*33764,1373830
-(defconst *letter-chars*33773,1374020
-(defconst *slashable-chars*33783,1374340
-(defun some-slashable 33791,1374625
-(defun prin1-with-slashes1 33799,1374830
-(defun prin1-with-slashes 33818,1375569
-(defmacro suspiciously-first-numeric-chars 33844,1376656
-(defmacro numeric-chars 33849,1376821
-(defun may-need-slashes1 33854,1376929
-(defmacro potential-numberp 33878,1377961
-(defun may-need-slashes-fn 33940,1380387
-(defmacro may-need-slashes 34189,1391328
-(defun needs-slashes 34198,1391722
-(defparameter *t-stack* 34214,1392250
-(defparameter *t-stack-length* 34216,1392292
-(defun t-stack-length1 34221,1392331
-(defun t-stack-length 34232,1392666
-(defun make-list-ac 34239,1392864
-(defmacro make-list 34246,1393072
-(defun extend-t-stack 34263,1393704
-(defconst *directory-separator*34338,1396370
-(defconst *directory-separator-string*34341,1396410
-(defmacro os-er 34344,1396484
-(defun os 34352,1396752
-(defun mswindows-drive1 34362,1396990
-(defun mswindows-drive 34387,1398195
-(defun pathname-os-to-unix 34402,1398817
-(defun ccl-at-least-1-3-p 34443,1400327
-(defun pathname-unix-to-os 34450,1400638
-(defun shrink-t-stack 34504,1403027
-(defun aref-t-stack 34529,1403884
-(defun aset-t-stack 34544,1404398
-(defparameter *32-bit-integer-stack*34572,1405189
-(defparameter *32-bit-integer-stack-length* 34575,1405278
-(defun 32-bit-integer-stack-length1 34579,1405329
-(defun 32-bit-integer-stack-length 34587,1405638
-(defun extend-32-bit-integer-stack 34594,1405862
-(defun shrink-32-bit-integer-stack 34642,1408180
-(defun aref-32-bit-integer-stack 34673,1409310
-(defun aset-32-bit-integer-stack 34696,1410080
-(defmacro f-big-clock-negative-p 34725,1411109
-(defmacro f-decrement-big-clock 34734,1411347
-(defun big-clock-negative-p 34753,1411931
-(defun decrement-big-clock 34773,1412813
-(defun list-all-package-names 34798,1413767
-(defun user-stobj-alist 34814,1414367
-(defun update-user-stobj-alist 34824,1414687
-(defun power-eval 34836,1415121
-(defun-one-output idate 34844,1415331
-(defun read-idate 34856,1415643
-(defun read-run-time 34875,1416300
-(defparameter *next-acl2-oracle-value* 34914,1417766
-(defun read-acl2-oracle 34916,1417811
-(defun read-acl2-oracle@par 34937,1418490
-(defun read-acl2-oracle@par 34962,1419519
-(defun getenv$ 34983,1420508
-(defun setenv$ 35012,1421534
-(defun random$ 35068,1423659
-(defthm natp-random$35107,1425117
-(defthm random$-linear35111,1425208
-(defvar *last-sys-call-status* 35128,1425658
-(defun sys-call 35130,1425693
-(defun sys-call-status 35216,1429086
-(defthm update-acl2-oracle-preserves-state-p135321,1434091
-(defthm read-run-time-preserves-state-p135334,1434454
-(defthm read-acl2-oracle-preserves-state-p135342,1434743
-(defthm nth-0-read-run-time-type-prescription35358,1435226
-(defun main-timer 35376,1435793
-(defun put-assoc-eq-exec 35389,1436296
-(defun put-assoc-eql-exec 35401,1436756
-(defun put-assoc-equal 35413,1437221
-(defmacro put-assoc-eq 35419,1437493
-(defmacro put-assoc-eql 35424,1437665
-(defthm put-assoc-eq-exec-is-put-assoc-equal35427,1437752
-(defthm put-assoc-eql-exec-is-put-assoc-equal35431,1437886
-(defmacro put-assoc 35435,1438022
-(defun set-timer 35502,1440684
-(defun get-timer 35511,1440968
-(defun push-timer 35522,1441345
-(defthm rationalp-+35531,1441729
-(defthm rationalp-*35627,1445995
-(defthm rationalp-unary--35632,1446110
-(defthm rationalp-unary-/35636,1446193
-(defthm realp-+35645,1446529
-(defthm realp-*35651,1446653
-(defthm realp-unary--35657,1446777
-(defthm realp-unary-/35662,1446873
-(defthm rationalp-implies-acl2-numberp35668,1447019
-(defun pop-timer 35671,1447103
-(defun add-timers 35689,1447728
-(defthm nth-0-cons35703,1448291
-(defthm nth-add135713,1448493
-(defthm main-timer-type-prescription35720,1448693
-(defthm ordered-symbol-alistp-add-pair-forward35726,1448888
-(defthm assoc-add-pair35735,1449157
-(defthm add-pair-preserves-all-boundp35743,1449437
-(defthm state-p1-update-main-timer35750,1449696
-(defun increment-timer 35781,1451087
-(defun print-rational-as-decimal 35804,1452082
-(defun print-timer 35825,1452852
-(defun known-package-alist 35833,1453195
-(defun prin1$ 35849,1453601
-(defun current-package 36030,1462391
-(defthm state-p1-update-nth-2-world36084,1465238
-(defconst *initial-untouchable-fns*36122,1466597
-(defconst *initial-untouchable-vars*36204,1469086
-(defun ld-skip-proofsp 36357,1473361
-(defun-one-output bad-lisp-objectp 36468,1479158
-(defun-one-output chk-bad-lisp-object 36702,1491028
-(defmacro assign 36744,1492262
-(defmacro @ 36784,1493788
-(defun make-var-lst1 36818,1495068
-(defun make-var-lst 36845,1495974
-(defun union-eq-exec 36853,1496204
-(defun union-eql-exec 36863,1496586
-(defun union-equal 36873,1496970
-(defmacro union-eq 36879,1497205
-(defthm union-eq-exec-is-union-equal36882,1497266
-(defthm union-eql-exec-is-union-equal36886,1497366
-(defun parse-args-and-test 36890,1497468
-(defmacro union$ 36939,1499712
-(defun subst-for-nth-arg 37011,1502847
-(defmacro the-mv 37021,1503149
-(defmacro the-mv 37075,1505083
-(defmacro the2s 37086,1505627
-(deflabel bibliography37089,1505676
-(defun non-free-var-runes 37110,1506478
-(defun free-var-runes 37125,1507196
-(defthm natp-position-ac 37133,1507415
-(defun absolute-pathname-string-p 37141,1507751
-(defun include-book-dir-alistp 37187,1509878
-(defun illegal-ruler-extenders-values 37196,1510193
-(defun intersection-eq-exec 37208,1510610
-(defun intersection-eql-exec 37220,1511026
-(defun intersection-equal 37231,1511447
-(defmacro intersection-eq 37241,1511769
-(defthm intersection-eq-exec-is-intersection-equal37244,1511844
-(defthm intersection-eql-exec-is-intersection-equal37248,1511972
-(defmacro intersection$ 37252,1512102
-(defun table-alist 37333,1515669
-(defun ruler-extenders-msg-aux 37341,1515899
-(defun ruler-extenders-msg 37358,1516667
-(defmacro chk-ruler-extenders 37391,1518196
-(defmacro fixnum-bound 37401,1518653
-(defconst *default-step-limit*37404,1518753
-(deflabel acl2-defaults-table37548,1523848
-(defmacro set-enforce-redundancy 37877,1538139
-(defmacro set-enforce-redundancy 37950,1541870
-(defmacro set-ignore-doc-string-error 37955,1541955
-(defmacro set-ignore-doc-string-error 38000,1543804
-(defmacro default-verify-guards-eagerness-from-table 38004,1543877
-(defun default-verify-guards-eagerness 38008,1544006
-(defmacro set-verify-guards-eagerness 38016,1544345
-(defmacro set-verify-guards-eagerness 38072,1547179
-(defun default-compile-fns 38076,1547252
-(defmacro set-compile-fns 38082,1547509
-(defmacro set-compile-fns 38140,1550035
-(defun set-compiler-enabled 38144,1550096
-(defun default-measure-function 38169,1551180
-(defmacro set-measure-function 38176,1551470
-(defmacro set-measure-function 38216,1553082
-(defun default-well-founded-relation 38220,1553154
-(defmacro set-well-founded-relation 38227,1553446
-(defmacro set-well-founded-relation 38266,1555184
-(defmacro default-defun-mode-from-table 38272,1555297
-(defun default-defun-mode 38282,1555596
-(defun default-defun-mode-from-state 38324,1557968
-(defmacro logic 38329,1558108
-(defmacro logic 38368,1559524
-(defmacro program 38371,1559566
-(defmacro program 38427,1561350
-(defun invisible-fns-table 38429,1561377
-(defmacro set-invisible-fns-table 38477,1563483
-(defun unary-function-symbol-listp 38550,1566254
-(defun invisible-fns-entryp 38568,1567053
-(defmacro add-invisible-fns 38580,1567372
-(defmacro remove-invisible-fns 38622,1569223
-(defmacro set-invisible-fns-alist 38667,1571117
-(defmacro invisible-fns-alist 38674,1571423
-(defmacro set-bogus-defun-hints-ok 38681,1571658
-(defmacro set-bogus-defun-hints-ok 38704,1572479
-(defmacro set-bogus-mutual-recursion-ok 38709,1572566
-(defmacro set-bogus-mutual-recursion-ok 38759,1574711
-(defdoc ruler-extenders38763,1574786
-(defmacro set-ruler-extenders 39166,1591069
-(defmacro set-ruler-extenders 39191,1591967
-(defmacro set-irrelevant-formals-ok 39196,1592049
-(defmacro set-irrelevant-formals-ok 39231,1593282
-(defmacro set-ignore-ok 39236,1593370
-(defmacro set-ignore-ok 39280,1595040
-(defmacro set-inhibit-warnings 39285,1595116
-(defmacro set-inhibit-warnings 39290,1595205
-(defmacro set-inhibit-output-lst 39332,1596800
-(defmacro set-inhibited-summary-types 39400,1600013
-(defmacro set-state-ok 39455,1602305
-(defmacro set-state-ok 39528,1605467
-(defmacro set-let*-abstractionp 39537,1605703
-(defmacro set-let*-abstractionp 39584,1607602
-(defmacro set-let*-abstraction 39588,1607669
-(defun let*-abstractionp 39596,1607903
-(defconst *initial-backchain-limit* 39610,1608399
-(defconst *initial-default-backchain-limit* 39612,1608448
-(defmacro set-backchain-limit 39615,1608522
-(defmacro set-backchain-limit 39668,1610886
-(defun backchain-limit 39672,1610959
-(defmacro set-default-backchain-limit 39831,1617810
-(defmacro set-default-backchain-limit 39897,1621160
-(defun default-backchain-limit 39901,1621241
-(defun step-limit-from-table 39977,1624555
-(defparameter *step-limit-error-p*39996,1625363
-(defmacro set-prover-step-limit 40005,1625641
-(defmacro set-prover-step-limit 40163,1632749
-(defparameter *rewrite-depth-max* 40182,1633486
-(defparameter *rewrite-depth-alist* 40183,1633557
-(defconst *default-rewrite-stack-limit*40231,1635395
-(defmacro set-rewrite-stack-limit 40245,1636024
-(defmacro set-rewrite-stack-limit 40285,1637659
-(defun rewrite-stack-limit 40289,1637736
-(defmacro set-nu-rewriter-mode 40335,1639580
-(defmacro set-nu-rewriter-mode 40389,1641921
-(defun nu-rewriter-mode 40393,1641987
-(defun case-split-limitations 40413,1642952
-(defmacro sr-limit 40442,1644195
-(defmacro case-limit 40445,1644263
-(defmacro set-case-split-limitations 40449,1644351
-(defmacro set-case-split-limitations 40591,1651808
-(defconst *initial-acl2-defaults-table*40602,1652280
-(defun untrans-table 40608,1652501
-(defmacro add-macro-fn 40647,1653581
-(defmacro add-binop 40690,1655764
-(defmacro remove-macro-fn 40701,1656075
-(defmacro remove-binop 40730,1657238
-(defun match-free-default 40744,1657704
-(defmacro set-match-free-default 40752,1658035
-(defmacro set-match-free-default 40813,1660921
-(defmacro set-match-free-error 40817,1660989
-(defun match-free-override 40862,1663140
-(defmacro add-match-free-override 40880,1663899
-(defmacro add-match-free-override 41067,1673162
-(defmacro add-include-book-dir 41071,1673253
-(defmacro delete-include-book-dir 41129,1676246
-(defconst *non-linear-rounds-value* 41170,1678012
-(defun non-linearp 41172,1678052
-(defmacro set-non-linearp 41183,1678388
-(defmacro set-non-linearp 41207,1679105
-(defmacro set-non-linear 41211,1679176
-(defun tau-auto-modep 41219,1679402
-(defmacro set-tau-auto-mode 41257,1681092
-(defmacro set-tau-auto-mode 41377,1687870
-(defmacro defttag 41382,1687960
-(defmacro defttag 41649,1701428
-(defun ttag 41653,1701493
-(defdoc complex-rationalp41665,1701877
-(deflabel let41679,1702325
-(defdoc flet41804,1707896
-(defun-one-output what-is-the-global-state 41934,1712948
-(deflabel macro-aliases-table42001,1716103
-(defun macro-aliases 42117,1720550
-(defmacro add-macro-alias 42121,1720669
-(defmacro remove-macro-alias 42186,1723423
-(deflabel nth-aliases-table42219,1724792
-(defun nth-aliases 42259,1726220
-(defmacro add-nth-alias 42263,1726335
-(defmacro remove-nth-alias 42284,1726985
-(deflabel default-hints-table42320,1728615
-(defun default-hints 42341,1729381
-(defmacro set-default-hints 42366,1730343
-(defmacro set-default-hints! 42425,1732753
-(defmacro set-default-hints! 42443,1733445
-(defmacro add-default-hints 42447,1733513
-(defmacro add-default-hints! 42496,1735654
-(defmacro add-default-hints! 42516,1736500
-(defmacro remove-default-hints 42520,1736568
-(defmacro remove-default-hints! 42560,1738111
-(defmacro remove-default-hints! 42578,1738885
-(defmacro set-override-hints-macro 42583,1738973
-(defmacro set-override-hints-macro 42589,1739195
-(defmacro add-override-hints! 42593,1739277
-(defmacro add-override-hints 42607,1739779
-(defmacro set-override-hints! 42637,1741051
-(defmacro set-override-hints 42650,1741492
-(defmacro remove-override-hints! 42674,1742349
-(defmacro remove-override-hints 42687,1742850
-(defmacro set-rw-cache-state 42713,1743913
-(defmacro set-rw-cache-state! 42991,1759363
-(defmacro set-rw-cache-state! 43006,1759886
-(defconst *legal-rw-cache-states*43010,1759955
-(defun fix-true-list 43019,1760160
-(defthm pairlis$-fix-true-list43037,1760620
-(defun boolean-listp 43041,1760718
-(defthm boolean-listp-cons43052,1761036
-(defthm boolean-listp-forward43061,1761289
-(defthm boolean-listp-forward-to-symbol-listp43071,1761552
-(defaxiom completion-of-+43089,1762330
-(defthm default-+-143100,1762569
-(defthm default-+-243105,1762702
-(defaxiom completion-of-*43110,1762835
-(defthm default-*-143119,1763022
-(defthm default-*-243123,1763108
-(defaxiom completion-of-unary-minus43127,1763194
-(defthm default-unary-minus43134,1763331
-(defaxiom completion-of-unary-/43138,1763423
-(defthm default-unary-/43146,1763598
-(defaxiom completion-of-<43153,1763778
-(defthm default-<-143165,1764202
-(defthm default-<-243174,1764435
-(defaxiom completion-of-car43183,1764668
-(defthm default-car43191,1764811
-(defaxiom completion-of-cdr43195,1764892
-(defthm default-cdr43203,1765035
-(defthm cons-car-cdr43207,1765116
-(defaxiom completion-of-char-code43213,1765237
-(defthm default-char-code43220,1765386
-(defaxiom completion-of-code-char43225,1765531
-(defaxiom completion-of-complex43246,1766126
-(defthm default-complex-143254,1766353
-(defthm default-complex-243262,1766586
-(defthm complex-043271,1766908
-(defthm add-def-complex43279,1767123
-(defthm realpart-+43294,1767798
-(defthm imagpart-+43299,1767928
-(defaxiom completion-of-coerce43304,1768058
-(defthm default-coerce-143315,1768321
-(defthm make-character-list-make-character-list43321,1768504
-(defthm default-coerce-243325,1768643
-(defthm default-coerce-343339,1769201
-(defaxiom completion-of-denominator43345,1769385
-(defthm default-denominator43352,1769539
-(defaxiom completion-of-floor143363,1769921
-(defthm default-floor143374,1770171
-(defaxiom floor1-integer-x43382,1770377
-(defaxiom floor1-x-<=43389,1770560
-(defaxiom x-<-add1-floor1-x43397,1770754
-(defthm floor1-value43407,1771073
-(defaxiom completion-of-imagpart43415,1771263
-(defthm default-imagpart43422,1771411
-(defaxiom completion-of-intern-in-package-of-symbol43427,1771525
-(defaxiom completion-of-numerator43446,1772185
-(defthm default-numerator43453,1772333
-(defaxiom completion-of-realpart43458,1772446
-(defthm default-realpart43465,1772594
-(defaxiom completion-of-symbol-name43470,1772708
-(defthm default-symbol-name43477,1772861
-(defaxiom completion-of-symbol-package-name43483,1773028
-(defthm default-symbol-package-name43490,1773205
-(defdoc i-small43499,1773485
-(defdoc i-close43508,1773734
-(defdoc i-large43516,1773989
-(defdoc i-limited43525,1774252
-(defdoc standardp43534,1774500
-(defdoc standard-part43555,1775525
-(defun i-small 43567,1775880
-(defun i-close 43572,1775990
-(defun i-large 43578,1776116
-(defmacro i-limited 43584,1776239
-(defaxiom i-large-integer-is-large43591,1776454
-(defaxiom standardp-plus43599,1776741
-(defaxiom standardp-uminus43604,1776861
-(defaxiom standardp-times43608,1776947
-(defaxiom standardp-udivide43613,1777068
-(defaxiom standardp-complex43617,1777155
-(defaxiom standardp-one43625,1777473
-(defaxiom standard-part-of-standardp43631,1777597
-(defaxiom standardp-standard-part43636,1777740
-(defaxiom standard-part-of-reals-is-idempotent43640,1777843
-(defaxiom standard-part-of-complex43645,1778003
-(defaxiom standard-part-of-plus43651,1778181
-(defaxiom standard-part-of-uminus43656,1778322
-(defaxiom standard-part-of-times43660,1778427
-(defaxiom standard-part-of-udivide43665,1778609
-(defaxiom standard-part-<=43671,1778793
-(defaxiom small-are-limited43677,1778953
-(defaxiom standards-are-limited43684,1779129
-(defthm standard-constants-are-limited43690,1779298
-(defaxiom limited-integers-are-standard43698,1779547
-(defaxiom standard+small->i-limited43705,1779783
-(defdoc acl2-numberp43713,1779967
-(defdoc +43721,1780173
-(defdoc binary-+43737,1780482
-(defdoc binary-*43763,1781092
-(defdoc -43787,1781656
-(defdoc unary--43816,1782147
-(defdoc unary-/43838,1782651
-(defdoc <43862,1783215
-(defdoc car43892,1784126
-(defdoc cdr43911,1784538
-(defdoc char-code43930,1784952
-(defdoc characterp43948,1785335
-(defdoc code-char43956,1785503
-(defdoc complex43979,1786058
-(defdoc cons44027,1787879
-(defdoc consp44036,1788162
-(defdoc coerce44043,1788323
-(defdoc denominator44092,1789974
-(defdoc equal44110,1790316
-(defdoc if44121,1790597
-(defdoc imagpart44137,1791009
-(defdoc integerp44155,1791342
-(defdoc intern-in-package-of-symbol44162,1791501
-(defdoc numerator44218,1793716
-(defdoc rationalp44236,1794049
-(defdoc realpart44244,1794245
-(defdoc stringp44262,1794573
-(defdoc symbol-name44269,1794722
-(defdoc symbol-package-name44287,1795060
-(defdoc symbolp44314,1796012
-(defdoc quote44321,1796161
-(defun double-rewrite 44329,1796326
-(defparameter *acl2-time-limit* 44562,1807291
-(defparameter *acl2-time-limit-boundp* 44564,1807329
-(defun chk-with-prover-time-limit-arg 44568,1807377
-(defmacro with-prover-time-limit1-raw 44585,1808050
-(defmacro with-prover-time-limit1 44605,1808929
-(defmacro with-prover-time-limit 44608,1809035
-(defparameter *time-limit-tags* 44702,1813830
-(defmacro catch-time-limit5 44704,1813868
-(defmacro catch-time-limit5@par 44728,1814852
-(defun time-limit5-reached-p 44764,1816486
-(defmacro catch-step-limit 44808,1818533
-(defconst *guard-checking-values*44837,1819728
-(defun chk-with-guard-checking-arg 44840,1819794
-(defmacro with-guard-checking1-raw 44852,1820313
-(defmacro with-guard-checking1 44863,1820709
-(defmacro with-guard-checking 44866,1820807
-(defun abort! 44892,1821746
-(defmacro a! 44906,1822049
-(defun p! 44930,1822917
-(defparameter *wormhole-status-alist* 44973,1824606
-(defparameter *inhibit-wormhole-activityp* 44976,1824667
-(defun wormhole1 44978,1824716
-(defun wormhole-p 45074,1828723
-(defun duplicates 45091,1829203
-(defun evens 45098,1829436
-(defun odds 45104,1829582
-(defun set-equalp-equal 45108,1829660
-(defparameter *metafunction-context* 45230,1836606
-(DEFMACRO |Access 45350,1841128
-(defun record-error 45367,1841699
-(defun record-accessor-function-name 45373,1841869
-(defmacro access 45385,1842254
-(defun mfc-clause 45394,1842594
-(defun mfc-rdepth 45428,1843992
-(defun type-alist-entryp 45438,1844287
-(defun type-alistp 45454,1844775
-(defun mfc-type-alist 45461,1844934
-(defun mfc-ancestors 45477,1845377
-(defun mfc-unify-subst 45493,1845814
-(defun mfc-world 45503,1846129
-(defthm pseudo-term-listp-mfc-clause45516,1846500
-(defthm type-alistp-mfc-type-alist45519,1846578
-(defun bad-atom 45554,1848570
-(defthm bad-atom-compound-recognizer45565,1848788
-(defun-one-output bad-atom<=45577,1849082
-(defaxiom booleanp-bad-atom<=45586,1849436
-(defaxiom bad-atom<=45591,1849572
-(defaxiom bad-atom<=45599,1849778
-(defaxiom bad-atom<=45608,1850041
-(defun alphorder 45618,1850311
-(defun lexorder 45694,1852914
-(defthm alphorder-reflexive45759,1854966
-(defthm alphorder-transitive45776,1855483
-(defthm alphorder-anti-symmetric45787,1855817
-(defthm alphorder-total45811,1856832
-(defthm lexorder-reflexive45826,1857369
-(defthm lexorder-anti-symmetric45829,1857415
-(defthm lexorder-transitive45834,1857554
-(defthm lexorder-total45839,1857704
-(defun merge-lexorder 45855,1858235
-(defthm true-listp-merge-sort-lexorder45881,1858983
-(defun merge-sort-lexorder 45887,1859176
-(defdoc bdd45902,1859802
-(defun if* 45936,1861252
-(defun resize-list 46120,1868402
-(deflabel theory-functions46136,1868922
-(defun e/d-fn 46171,1870545
-(defmacro e/d 46182,1871066
-(defun mod-expt 46261,1874049
-(defmacro fcons-term* 46305,1875822
-(defun conjoin2 46322,1876500
-(defun conjoin 46336,1876998
-(defun conjoin2-untranslated-terms 46342,1877167
-(defun conjoin-untranslated-terms 46358,1877609
-(defun disjoin2 46370,1877948
-(defun disjoin 46382,1878306
-(defun disjoin-lst 46388,1878491
-(defun conjoin-clauses 46394,1878713
-(defconst *true-clause* 46398,1878847
-(defconst *false-clause* 46400,1878884
-(defun clauses-result 46402,1878915
-(defdoc sharp-dot-reader46407,1879063
-(defdoc sharp-comma-reader46446,1880352
-(defdoc sharp-bang-reader46454,1880557
-(defdoc sharp-u-reader46486,1881355
-(defdoc evisc-table46538,1882889
-(defconst *top-hint-keywords*46782,1891422
-(defconst *hint-keywords*46792,1891830
-(defmacro add-custom-keyword-hint 46837,1893233
-(defmacro add-custom-keyword-hint 46925,1897017
-(defmacro remove-custom-keyword-hint 46929,1897098
-(defmacro show-custom-keyword-hint-expansion 46962,1898235
-(defun splice-keyword-alist 46989,1899066
-(deflabel custom-keyword-hints47002,1899608
-(defun search-fn-guard 47014,1899955
-(defun search-from-start 47062,1902103
-(defun search-from-end 47085,1902963
-(defmacro search 47266,1908619
-(defthm eqlablep-nth47330,1911662
-(defun count-stringp 47335,1911791
-(defun count-listp 47350,1912324
-(defmacro count 47385,1913456
-(defun make-sharp-atsign 47425,1915048
-(defun sharp-atsign-alist 47432,1915264
-(defmacro time$1-raw 47539,1920224
-(defmacro time$1 47559,1920907
-(defmacro time$ 47562,1920977
-(defmacro our-multiple-value-prog1 47744,1927694
-(defconst *mv-vars*47760,1928182
-(defconst *mv-var-values*47767,1928327
-(defconst *mv-extra-var* 47771,1928421
-(defun protect-mv 47773,1928457
-(defmacro our-time 47821,1930221
-(defun-one-output gc$-fn 47956,1936162
-(defun gc$-fn 47980,1937006
-(defmacro gc$ 47985,1937089
-(defun-one-output gc-verbose-fn 48014,1938074
-(defun gc-verbose-fn 48029,1938542
-(defmacro gc-verbose 48034,1938630
-(defun get-wormhole-status 48059,1939525
-(defun file-write-date$ 48088,1940619
-(defun debugger-enable 48106,1941131
-(defun break$ 48111,1941322
-(defun print-call-history 48146,1942490
-(defun debugger-enabledp 48196,1944336
-(defun maybe-print-call-history 48203,1944612
-(defmacro with-reckless-readtable 48210,1944903
-(defmacro set-debugger-enable 48228,1945510
-(defun set-debugger-enable-fn 48362,1951401
-(defun add-@par-suffix 48387,1952490
-(defun generate-@par-mappings 48393,1952665
-(defconst *@par-mappings*48410,1953510
-(defun make-identity-for-@par-mappings 48604,1960360
-(defmacro define-@par-macros 48618,1960925
-(defun replace-defun@par-with-defun 48635,1961521
-(defmacro mutual-recursion@par 48646,1961888
-(defun defun@par-fn 48650,1962007
-(defun mutual-recursion@par-guardp 48670,1962749
-(defun mutual-recursion@par-fn 48682,1963231
-(defmacro mutual-recursion@par 48704,1964192
-(defmacro defun@par 48708,1964360
-(defmacro serial-first-form-parallel-second-form 48722,1964858
-(defmacro serial-first-form-parallel-second-form@par 48730,1965019
-(defmacro serial-only 48737,1965169
-(defmacro serial-only@par 48744,1965251
-(defmacro parallel-only 48751,1965347
-(defmacro parallel-only@par 48759,1965458
-(defmacro mv@par 48766,1965544
-(defmacro value@par 48772,1965704
-(defmacro state-mac 48778,1965778
-(defmacro state-mac@par 48785,1965860
-(defmacro mv-let@par 48792,1965939
-(defmacro warning$@par 48798,1966130
-(defmacro error-in-parallelism-mode 48807,1966379
-(defmacro error-in-parallelism-mode@par 48812,1966499
-(defun increment-timer@par 48834,1967412
-(defconst *waterfall-printing-values*48842,1967638
-(defconst *waterfall-parallelism-values*48845,1967712
-(defun symbol-constant-fn 48852,1967940
-(defun stobjs-in 48863,1968293
-(defmacro oracle-funcall 48878,1968697
-(defun all-nils 48912,1969805
-(defun oracle-apply-guard 48918,1969971
-(defun oracle-apply 48931,1970465
-(defun oracle-apply-raw 49057,1976100
-(defun time-tracker-fn 49092,1977556
-(defmacro time-tracker 49161,1979867
-(defmacro time-tracker 49166,1980065
-(defdoc time-tracker49170,1980135
-(defdoc time-tracker-tau49411,1992959
-(defg *inside-absstobj-update* 49478,1995556
-(defun set-absstobj-debug-fn 49480,1995594
-(defmacro set-absstobj-debug 49511,1997026
-(defun 49749,2007176
-(defun tau-interval-domainp 49783,2008342
-(defun tau-interval-dom 49791,2008598
-(defun tau-interval-lo-rel 49812,2009166
-(defun tau-interval-lo 49834,2009914
-(defun tau-interval-hi-rel 49856,2010613
-(defun tau-interval-hi 49877,2011360
-(defun make-tau-interval 49899,2012059
-(defun tau-intervalp 49959,2014802
-(defun in-tau-intervalp 50071,2018961
-
-memoize.lisp,831
-(defmacro defn 31,1268
-(defmacro defnd 40,1466
-(defdoc hons-and-memoization49,1682
-(defn clear-memoize-table 364,17583
-(defn clear-memoize-tables 379,18018
-(defn memoize-summary 395,18526
-(defn clear-memoize-statistics 410,19062
-(defmacro memsum 423,19510
-(defconst *hons-primitive-fns*444,20337
-(defconst *hons-primitives*473,20939
-(defconst *mht-default-size* 484,21211
-(defun memoize-form 486,21245
-(defmacro memoize 634,28081
-(defmacro unmemoize 921,43447
-(defmacro profile 972,45052
-(defmacro memoize-on-raw 1025,47519
-(defmacro memoize-on 1029,47587
-(defmacro memoize-off-raw 1040,47969
-(defmacro memoize-off 1044,48038
-(defmacro memoizedp-world 1054,48412
-(defmacro memoizedp 1065,48789
-(defparameter *never-profile-ht*1094,49641
-(defun never-memoize-fn 1098,49739
-(defmacro never-memoize 1103,49842
-
-hons.lisp,1363
-(defdoc normed35,1575
-(defn hons-copy 102,4467
-(defn hons-copy-persistent 141,6056
-(defn hons 164,6943
-(defn hons-equal 196,8130
-(defn hons-equal-lite 222,9274
-(defn hons-clear 248,10388
-(defn hons-wash 282,11784
-(defn hons-summary 316,13304
-(defmacro hons-resize 339,14200
-(defn hons-resize-fn 418,17291
-(defdoc hons-note427,17635
-(defdoc fast-alists491,20704
-(defn hons-assoc-equal 538,23041
-(defdoc slow-alist-warning563,24030
-(defmacro set-slow-alist-action 592,25244
-(defn get-slow-alist-action 598,25474
-(defn hons-get 606,25743
-(defn hons-acons 628,26672
-(defn hons-acons! 694,29637
-(defn make-fast-alist 758,32300
-(defn hons-shrink-alist 783,33378
-(defn hons-shrink-alist! 832,35378
-(defn fast-alist-len 853,36267
-(defn fast-alist-free 873,37101
-(defn fast-alist-summary 901,38211
-(defdoc with-fast-alist920,38911
-(defdoc with-stolen-alist989,41311
-(defdoc fast-alist-free-on-exit1010,42322
-(defined in 1032,43100
-(defmacro with-fast-alist-raw 1047,43528
-(defmacro with-fast-alist 1052,43649
-(defmacro with-stolen-alist-raw 1056,43774
-(defmacro with-stolen-alist 1061,43897
-(defmacro fast-alist-free-on-exit-raw 1065,44026
-(defmacro fast-alist-free-on-exit 1070,44155
-(defn cons-subtrees 1073,44263
-(defn number-subtrees 1093,44816
-(defn clear-hash-tables 1112,45486
-(defn flush-hons-get-hash-table-link 1126,45931
-
-serialize.lisp,287
-(defdoc serialize38,1448
-(defmacro serialize-write 55,2188
-(defun serialize-write-fn 84,3117
-(defmacro serialize-read 117,4200
-(defun serialize-read-fn 160,6021
-(defdoc serialize-alternatives196,7254
-(defdoc serialize-in-books212,7966
-(defmacro with-serialize-character 255,9650
-
-basis.lisp,17837
-(defun enforce-redundancy-er-args 39,1746
-(defmacro enforce-redundancy 48,2209
-(defdoc gcl71,3270
-(defun wormhole-statusp 307,14303
-(defun wormhole-entry-code 326,14818
-(defun wormhole-data 345,15378
-(defun set-wormhole-entry-code 361,15809
-(defun set-wormhole-data 388,16833
-(defun make-wormhole-status 412,17694
-(defun tree-occur-eq 471,20320
-(defun wormhole-eval 482,20570
-(deflock *wormhole-lock*)585,25641
-(defmacro wormhole-eval 588,25685
-(defmacro wormhole 644,28280
-(deflabel wormhole-implementation1159,52912
-(defun global-set 1242,57403
-(defun defabbrev1 1247,57574
-(defun legal-variable-or-constant-namep 1253,57776
-(defun legal-constantp1 1319,60693
-(defun tilde-@-illegal-variable-or-constant-name-phrase 1334,61190
-(defun legal-constantp 1365,62869
-(defun defined-constant 1375,63183
-(defun legal-variablep 1392,63922
-(defun genvar1 1400,64207
-(defun genvar 1436,65983
-(defun packn1 1478,68167
-(defun packn 1484,68351
-(defun packn-pos 1492,68596
-(defun pack2 1498,68833
-(defun gen-formals-from-pretty-flags1 1501,68879
-(defun gen-formals-from-pretty-flags 1526,69902
-(defun defstub-body 1538,70496
-(defun collect-non-x 1561,71330
-(defmacro defproxy 1573,71709
-(defmacro defproxy 1910,83557
-(defun defstub-ignores 1926,84341
-(defun partition-rest-and-keyword-args1 1950,85218
-(defun partition-rest-and-keyword-args2 1959,85519
-(defun partition-rest-and-keyword-args 1976,86215
-(defmacro defstub 1995,87005
-(defun lambda-keywordp 2099,91713
-(defun arglistp1 2103,91808
-(defun arglistp 2111,91997
-(defun find-first-bad-arg 2115,92073
-(defun process-defabbrev-declares 2143,93442
-(defmacro defabbrev 2166,94524
-(defconst *primitive-formals-and-guards*2303,100788
-(defconst *primitive-monadic-booleans*2382,103814
-(defun equal-x-constant 2405,104415
-(defun match-tests-and-bindings 2421,104882
-(defun match-clause 2495,108206
-(defun match-clause-list 2503,108454
-(defmacro case-match 2511,108765
-(defconst *non-standard-primitives*2594,112166
-(defun cons-term1-cases 2599,112257
-(defconst *cons-term1-alist*2647,114445
-(defmacro cons-term1-body 2650,114528
-(defun quote-listp 2659,114795
-(defun cons-term1 2665,114957
-(defun cons-term 2670,115114
-(defmacro cons-term* 2676,115282
-(defmacro mcons-term 2679,115354
-(defmacro mcons-term* 2686,115531
-(defmacro fcons-term 2693,115722
-(defun fargn1 2710,116383
-(defmacro fargn 2716,116567
-(defun cdr-nest 2719,116618
-(defun all-but-last 2723,116692
-(defconst *evisceration-mark* 2759,118501
-(defconst *evisceration-hash-mark* 2769,119002
-(defconst *evisceration-ellipsis-mark* 2770,119069
-(defconst *evisceration-world-mark*2771,119142
-(defconst *evisceration-state-mark*2773,119218
-(defconst *evisceration-error-triple-marks*2775,119294
-(defconst *evisceration-hiding-mark*2777,119382
-(defconst *anti-evisceration-mark*2780,119461
-(defmacro evisceratedp 2783,119548
-(defconst *sharp-atsign-ar* 2869,124621
-(defun get-sharp-atsign 2878,124996
-(defun update-iprint-alist 2888,125334
-(defun eviscerate1 2908,126117
-(defun eviscerate1-lst 2940,127628
-(defun eviscerate1p 2974,129004
-(defun eviscerate1p-lst 2990,129677
-(defun eviscerate 3002,130155
-(defun eviscerate-simple 3062,132771
-(defun aset1-lst 3074,133259
-(defun iprint-hard-bound 3084,133574
-(defun iprint-soft-bound 3087,133651
-(defun iprint-last-index* 3090,133728
-(defun iprint-last-index 3097,133938
-(defun iprint-ar-illegal-index 3100,134028
-(defun iprint-enabledp 3109,134371
-(defun iprint-ar-aref1 3112,134466
-(defun collect-posp-indices-to-header 3135,135241
-(defun rollover-iprint-ar 3151,135834
-(defun update-iprint-ar 3224,139301
-(defun eviscerate-top 3247,140280
-(defun world-evisceration-alist 3264,141102
-(defun stobj-print-name 3271,141330
-(defun evisceration-stobj-mark 3278,141494
-(defun evisceration-stobj-marks1 3290,141806
-(defconst *error-triple-sig*3302,142214
-(defconst *cmp-sig*3305,142264
-(defun evisceration-stobj-marks 3308,142299
-(defun eviscerate-stobjs1 3316,142609
-(defun eviscerate-stobjs 3337,143673
-(defun eviscerate-stobjs-top 3386,145727
-(defmacro mv-letc 3458,149678
-(defmacro er-hard-val 3463,149805
-(defmacro the-fixnum! 3473,150149
-(defmacro the-half-fixnum! 3491,150723
-(defmacro the-unsigned-byte! 3509,151354
-(defmacro the-string! 3518,151659
-(defun xxxjoin-fixnum 3525,151823
-(defmacro +f 3540,152227
-(defmacro -f 3543,152284
-(defmacro 1-f 3549,152458
-(defmacro 1+f 3553,152539
-(defmacro charf 3557,152620
-(defmacro *f 3561,152694
-(defmacro ppr-flat-right-margin 3852,164733
-(defun set-ppr-flat-right-margin 3855,164817
-(defun keyword-param-valuep 3868,165383
-(defun cons-ppr1 3888,166340
-(defun flsz-integer 4030,172331
-(defun flsz-atom 4040,172709
-(defun flsz1 4116,175983
-(defun output-in-infixp 4149,177297
-(defun flatsize-infix 4153,177419
-(defun flsz 4169,178133
-(defun max-width 4175,178397
-(defun ppr1 4183,178608
-(defun ppr1-lst 4278,182915
-(defun newline 4324,184908
-(defun fmt-hard-right-margin 4327,184976
-(defun fmt-soft-right-margin 4331,185077
-(defun set-fmt-hard-right-margin 4335,185178
-(defun set-fmt-soft-right-margin 4371,186506
-(defun write-for-read 4393,187162
-(defun spaces1 4396,187233
-(defun make-spaces-array-rec 4413,187954
-(defun make-spaces-array 4423,188181
-(defconst *acl2-built-in-spaces-array*4432,188487
-(defun spaces 4438,188610
-(defun flpr1 4460,189365
-(defun flpr11 4473,189828
-(defun-one-output print-flat-infix 4490,190331
-(defun flpr 4504,190839
-(defun ppr2-flat 4516,191242
-(defun ppr2-column 4536,191894
-(defun ppr2 4553,192595
-(defconst *fmt-ppr-indentation* 4600,194554
-(defun ppr 4602,194590
-(defun scan-past-whitespace 4628,195638
-(defun zero-one-or-more 4638,195965
-(defun find-alternative-skip 4646,196134
-(defun find-alternative-start1 4684,197611
-(defun fmt-char 4727,199571
-(defun find-alternative-start 4749,200423
-(defun find-alternative-stop 4781,201893
-(defun punctp 4817,203408
-(defun fmt-tilde-s1 4822,203497
-(defun fmt-var 4877,205916
-(defun splat-atom 4889,206482
-(defun splat 4907,207213
-(defun splat1 4920,207782
-(defun number-of-digits 4954,209520
-(defun left-pad-with-blanks 4972,210192
-(defmacro maybe-newline 4992,210958
-(defun evisc-tuple 5019,212203
-(defun standard-evisc-tuplep 5083,215084
-(defun abbrev-evisc-tuple 5094,215391
-(defmacro gag-mode 5110,216087
-(defun default-evisc-tuple 5124,216391
-(defun term-evisc-tuple 5132,216806
-(defun gag-mode-evisc-tuple 5161,218057
-(defun ld-evisc-tuple 5169,218294
-(deflabel eviscerate-hide-terms5195,219578
-(defun-one-output print-infix 5213,220177
-(defun fmt-ppr 5253,222053
-(defun fmt0* 5270,222580
-(defun fmt0&v 5309,224372
-(defun spell-number 5355,226358
-(defun fmt-tilde-s 5425,229862
-(defun fmt0 5475,231779
-(defun tilde-*-&v-strings 5921,255562
-(defun fmt1 5966,257501
-(defun fmt 5990,258310
-(defun fms 6429,278201
-(defun fmt1! 6447,278679
-(defun fmt! 6470,279516
-(defun fms! 6493,280329
-(defmacro fmx 6515,281106
-(defun fmt-doc-example1 6522,281371
-(defun fmt-doc-example 6530,281681
-(defun fmt-abbrev1 6551,282772
-(defun fmt-abbrev 6569,283564
-(defconst *fmt-ctx-spacers*6575,283760
-(defun fmt-ctx 6604,284305
-(defun fmt-in-ctx 6647,285976
-(defun error-fms-channel 6663,286517
-(defun error-fms 6686,287472
-(defvar *accumulated-warnings* 6700,287874
-(defun push-warning-frame 6702,287911
-(defun absorb-frame 6708,288048
-(defun pop-warning-frame 6714,288170
-(defun push-warning 6749,289692
-(defun member-string-equal 6772,290595
-(defabbrev flambda-applicationp 6778,290750
-(defabbrev lambda-applicationp 6784,290850
-(defabbrev flambdap 6788,290946
-(defabbrev lambda-formals 6794,291036
-(defabbrev lambda-body 6796,291077
-(defabbrev make-lambda 6798,291116
-(defabbrev make-let 6801,291180
-(defun doubleton-list-p 6804,291246
-(defmacro er-let* 6810,291433
-(defmacro er-let*@par 6838,292455
-(defmacro match 6863,293398
-(defmacro match! 6866,293460
-(defun def-basic-type-sets1 6873,293688
-(defmacro def-basic-type-sets 6880,293981
-(defun list-of-the-type-set 6894,294449
-(defmacro ts=6900,294611
-(defmacro ts-complement0 6906,294819
-(defmacro ts-complementp 6909,294911
-(defun ts-union0-fn 6912,294961
-(defmacro ts-union0 6919,295174
-(defmacro ts-intersection0 6923,295267
-(defmacro ts-disjointp 6927,295377
-(defmacro ts-intersectp 6930,295464
-(defun ts-builder-case-listp 6937,295788
-(defun ts-builder-macro1 6970,297161
-(defun ts-builder-macro 6990,298136
-(defmacro ts-builder 6996,298345
-(defabbrev strip-not 7002,298576
-(defun record-maker-function-name 7223,307183
-(defun record-changer-function-name 7233,307482
-(defmacro make 7242,307719
-(defmacro change 7252,308076
-(defun make-record-car-cdrs1 7260,308409
-(defun make-record-car-cdrs 7264,308543
-(defun make-record-accessors 7273,309002
-(defun symbol-name-tree-occur 7297,310159
-(defun some-symbol-name-tree-occur 7313,310747
-(defun make-record-changer-cons 7318,310946
-(defun make-record-changer-let-bindings 7337,311692
-(defun make-record-changer-let 7359,312730
-(defun make-record-changer 7385,313926
-(defun make-record-maker-cons 7396,314240
-(defun make-record-maker-let 7423,315434
-(defun make-record-maker 7436,315910
-(defun make-record-field-lst 7446,316186
-(defun record-maker-recognizer-name 7453,316470
-(defun make-record-recognizer-body 7463,316772
-(defun make-record-recognizer 7487,317525
-(defun record-macros 7496,317912
-(defmacro defrec 7518,319068
-(defabbrev equalityp 7526,319363
-(defabbrev inequalityp 7537,319727
-(defabbrev consityp 7548,320089
-(defun power-rep 7557,320313
-(defun decode-idate 7563,320425
-(defun pcd2 7586,321191
-(defun print-idate 7593,321407
-(defun print-current-idate 7621,322343
-(defconst *window-descriptions*7676,325398
-(defun io?-nil-output 7694,325994
-(defmacro check-exact-free-vars 7701,326286
-(defun formal-bindings 7728,327415
-(defrec io-record7740,327762
-(defmacro io-record-forms 7751,328051
-(defun push-io-record 7758,328208
-(defun saved-output-token-p 7766,328511
-(defun io?-wormhole-bindings 7771,328741
-(defmacro io? 7779,329046
-(defmacro io?@par 7925,335828
-(defmacro io?-prove 7938,336267
-(defmacro io?-gag 7946,336446
-(defun output-ignored-p 7951,336587
-(defun error1 7956,336760
-(defun error1@par 7997,338214
-(defun error1-safe 8009,338534
-(defconst *uninhibited-warning-summaries*8020,338805
-(defun warning-off-p1 8034,339210
-(defun warning-off-p 8058,340204
-(defrec state-vars8061,340304
-(defmacro default-state-vars8071,340552
-(defun warning1-body 8125,342970
-(defmacro warning1-form 8141,343480
-(defun warning1 8175,344608
-(defmacro warning$ 8182,344811
-(defmacro warning-disabled-p 8210,345947
-(defmacro observation1-body 8222,346330
-(defun observation1 8247,347493
-(defun observation1-cw 8255,347698
-(defmacro observation 8258,347772
-(defmacro observation-cw 8346,351433
-(defun skip-when-logic 8376,352528
-(defun chk-inhibit-output-lst 8384,352777
-(defconst *ld-special-error*8417,354374
-(defun chk-ld-skip-proofsp 8421,354488
-(defun set-ld-skip-proofsp 8431,354819
-(defmacro set-ld-skip-proofs 8439,355038
-(defun set-write-acl2x 8448,355333
-(defconst *check-sum-exclusive-maximum* 8670,367576
-(defconst *check-length-exclusive-maximum* 8674,367727
-(defconst *-check-sum-exclusive-maximum* 8682,367999
-(defconst *1-check-length-exclusive-maximum*8684,368076
-(defun ascii-code! 8687,368163
-(defun check-sum1 8696,368309
-(defun check-sum 8722,369663
-(defun check-sum-inc 8788,373221
-(defun check-sum-natural 8819,374698
-(defun check-sum-string1 8826,374990
-(defun check-sum-string2 8844,375744
-(defun check-sum-string 8866,376633
-(defun check-sum-obj1 8872,376882
-(defun old-check-sum-obj 8913,378781
-(defun plus-mod-m31 8984,382626
-(defun double-mod-m31 9018,384147
-(defun times-expt-2-16-mod-m31 9033,384649
-(defun times-mod-m31 9079,386649
-(defun fchecksum-natural-aux 9149,389656
-(defun fchecksum-natural 9200,391631
-(defun fchecksum-string1 9205,391761
-(defun fchecksum-string2 9263,394180
-(defun fchecksum-string 9307,395940
-(defvar *fchecksum-symbol-memo*9332,396919
-(defun fchecksum-atom 9335,396959
-(defun fchecksum-obj 9407,400165
-(defun check-sum-obj 9442,401690
-(defun read-file-iterate 9577,406338
-(defun read-file 9584,406560
-(defun formals 9594,406926
-(defun arity 9607,407432
-(defun stobjs-out 9613,407656
-(deflabel user-defined-functions-table9630,408198
-(defconst *user-defined-functions-table-keys*9708,411516
-(defrec def-body9725,412165
-(defun latest-body 9739,412504
-(defun def-body 9745,412645
-(defun body 9748,412735
-(defun symbol-class 9776,414269
-(defmacro fdefun-mode 9829,417159
-(defmacro programp 9837,417325
-(defmacro logicalp 9840,417398
-(defun program-termp 9845,417496
-(defun program-term-listp 9854,417841
-(defdoc common-lisp9860,418007
-(deflabel defun-mode-caveat9897,419979
-(deflabel generalized-booleans9995,424605
-(defun defun-mode 10101,428444
-(defun get-stobj-recognizer 10251,435535
-(defun stobj-recognizer-terms 10262,435972
-(defun mcons-term-smart 10272,436398
-(defun optimize-stobj-recognizers1 10285,436726
-(defun optimize-stobj-recognizers1-lst 10329,438623
-(defun optimize-stobj-recognizers 10337,438975
-(defun guard 10362,440109
-(defdoc extra-info10425,442875
-(defdoc guard-debug10433,443119
-(deflabel guard-quick-reference10527,447640
-(deflabel guard-introduction10603,450506
-(deflabel guards-and-evaluation10651,452890
-(deflabel guards-for-specification11025,469778
-(deflabel guard-miscellany11082,472141
-(deflabel guard-evaluation-examples-script11160,476537
-(deflabel guard-evaluation-examples-log11323,482019
-(deflabel guard-evaluation-table12050,501811
-(defun guard-lst 12164,507839
-(defmacro equivalence-relationp 12169,508005
-(defun >=12194,509002
-(defun all->=12202,509170
-(defun strip-cadrs 12209,509359
-(defun strip-cddrs 12216,509559
-(defun global-set-lst 12221,509703
-(defmacro cons-term1-body-mv2 12228,509960
-(defun cons-term1-mv2 12238,510299
-(defun sublis-var1 12245,510488
-(defun sublis-var1-lst 12265,511354
-(defun sublis-var 12280,511961
-(defun sublis-var-lst 12306,512992
-(defun subcor-var1 12315,513316
-(defun subcor-var 12326,513717
-(defun subcor-var-lst 12342,514396
-(defun car-cdr-nest1 12356,514928
-(defun car-cdr-nest 12370,515436
-(defun collect-non-trivial-bindings 12393,516141
-(defun untranslate-and 12400,516435
-(defun untranslate-or 12416,516875
-(defun case-length 12426,517132
-(defun cond-length 12460,518477
-(defconst *untranslate-boolean-primitives*12468,518711
-(defun right-associated-args 12471,518767
-(defun dumb-negate-lit 12485,519279
-(defun dumb-negate-lit-lst 12502,519844
-(defun term-stobjs-out-alist 12509,520020
-(defun term-stobjs-out 12518,520317
-(defun accessor-root 12561,521925
-(defvar *load-compiled-stack* 12598,523769
-(defun observe-raw-mode-setting 12601,523822
-(defmacro progn! 12682,527933
-(defmacro progn! 12811,533991
-(defun ld-redefinition-action 12851,536011
-(deflabel redefining-programs13020,545641
-(defun chk-ld-redefinition-action 13149,552334
-(defun set-ld-redefinition-action 13157,552675
-(defmacro redef 13164,552887
-(defmacro redef! 13183,553470
-(defmacro redef+ 13202,554054
-(defmacro redef- 13250,555779
-(defun chk-current-package 13284,556798
-(defun set-current-package 13289,557005
-(defun standard-oi 13300,557280
-(defun read-standard-oi 13326,558499
-(defun chk-standard-oi 13339,558987
-(defun set-standard-oi 13352,559361
-(defun standard-co 13358,559553
-(defun chk-standard-co 13380,560499
-(defun set-standard-co 13387,560701
-(defun proofs-co 13394,560869
-(defun chk-proofs-co 13412,561496
-(defun set-proofs-co 13419,561694
-(deflabel prompt13426,561854
-(defun ld-prompt 13447,562743
-(defun chk-ld-prompt 13490,564821
-(defun set-ld-prompt 13501,565237
-(defun ld-keyword-aliases 13508,565397
-(defun ld-keyword-aliasesp 13557,567752
-(defun chk-ld-keyword-aliases 13584,568752
-(defun set-ld-keyword-aliases 13589,568937
-(defun ld-missing-input-ok 13596,569133
-(defun msgp 13618,570072
-(defun chk-ld-missing-input-ok 13624,570194
-(defun set-ld-missing-input-ok 13631,570446
-(defun ld-pre-eval-filter 13638,570646
-(defun new-namep 13668,572088
-(defun chk-ld-pre-eval-filter 13761,575884
-(defun set-ld-pre-eval-filter 13771,576298
-(defun ld-pre-eval-print 13778,576494
-(defun chk-ld-pre-eval-print 13814,578363
-(defun set-ld-pre-eval-print 13819,578542
-(defun ld-post-eval-print 13826,578734
-(defun chk-ld-post-eval-print 13888,582367
-(defun set-ld-post-eval-print 13893,582562
-(defun ld-error-triples 13900,582758
-(defun chk-ld-error-triples 13925,583920
-(defun set-ld-error-triples 13930,584090
-(defun ld-error-action 13937,584278
-(defun chk-ld-error-action 14052,590565
-(defun set-ld-error-action 14057,590761
-(defun ld-query-control-alist 14064,590945
-(defun ld-query-control-alistp 14122,594188
-(defun cdr-assoc-query-id 14136,594678
-(defun chk-ld-query-control-alist 14141,594839
-(defun set-ld-query-control-alist 14147,595019
-(defun ld-verbose 14154,595231
-(defun chk-ld-verbose 14185,596670
-(defun set-ld-verbose 14194,596947
-(defconst *nqthm-to-acl2-primitives*14201,597111
-(defconst *nqthm-to-acl2-commands*14269,599079
-(defun nqthm-to-acl2-fn 14361,602779
-(defmacro nqthm-to-acl2 14480,607314
-(defun allocate-fixnum-range 14688,615372
-(defmacro allegro-allocate-slowly 14747,618198
-(defun allegro-allocate-slowly-fn 14756,618757
-(defmacro clear-pstk 14793,620374
-(defconst *pstk-vars*14800,620554
-(defun pstk-bindings-and-args 14815,620777
-(defmacro pstk 14847,621858
-(defun pstack-fn 14895,623702
-(defmacro pstack 14918,624561
-(defun verbose-pstack 14987,627000
-(defun pop-inhibit-output-lst-stack 15020,628249
-(defun push-inhibit-output-lst-stack 15030,628680
-(defun set-gc-threshold$-fn 15036,628925
-(defmacro set-gc-threshold$ 15104,631883
-
-parallel.lisp,2398
-(defdoc deflock49,1910
-(defdoc compiling-acl2p133,5099
-(defdoc parallel172,6442
-(defdoc parallelism-build182,6596
-(defun set-parallel-execution-fn 190,6749
-(defmacro set-parallel-execution 231,8769
-(defdoc parallel-execution291,11345
-(defun waterfall-printing-value-for-parallelism-value 301,11627
-(defdoc unsupported-waterfall-parallelism-features335,13125
-(defdoc unsupported-parallelism-features492,21395
-(defdoc waterfall-printing534,23391
-(defdoc waterfall-parallelism542,23565
-(defun print-set-waterfall-parallelism-notice 550,23738
-(defun check-for-no-override-hints 586,25276
-(defun set-waterfall-parallelism-fn 616,26726
-(defmacro set-waterfall-parallelism1 706,31141
-(defmacro save-memo-table 735,32355
-(defun clear-memo-table-events 743,32539
-(defmacro clear-memo-table 751,32808
-(defmacro save-and-clear-memoization-settings 759,33029
-(defun set-memo-table-events 785,33703
-(defmacro restore-memoization-settings 793,33979
-(defmacro set-waterfall-parallelism 819,34577
-(defdoc waterfall-parallelism-for-book-certification970,41910
-(defun set-waterfall-printing-fn 1001,43191
-(defmacro set-waterfall-printing 1023,44114
-(defun set-waterfall-parallelism-hacks-enabled-guard 1099,47512
-(defmacro set-waterfall-parallelism-hacks-enabled 1110,47976
-(defmacro set-waterfall-parallelism-hacks-enabled! 1148,49563
-(defdoc parallelism-at-the-top-level1168,50190
-(defdoc parallelism-tutorial1223,52539
-(defdoc granularity1507,63922
-(defdoc parallelism-performance1615,68363
-(defdoc early-termination1652,70135
-(defdoc parallel-pushing-of-subgoals-for-induction1702,72336
-(defun caar-is-declarep 1744,74768
-(defun declare-granularity-p 1753,74979
-(defun check-and-parse-for-granularity-form 1766,75357
-(defmacro pargs 1803,77045
-(defmacro plet 1858,79471
-(defun binary-pand 1908,81361
-(defmacro pand 1916,81509
-(defun binary-por 2010,85305
-(defmacro por 2018,85461
-(defun or-list 2083,87981
-(defun and-list 2091,88136
-(defun cpu-core-count 2098,88283
-(defmacro spec-mv-let 2324,98021
-(defdoc error-triples-and-parallelism2448,103112
-(defdoc with-output-lock2498,105651
-(defdoc acl2p-key-checkpoints2600,108604
-(defun set-total-parallelism-work-limit-fn 2715,113681
-(defmacro set-total-parallelism-work-limit 2720,113889
-(defun set-total-parallelism-work-limit-error-fn 2776,116331
-(defmacro set-total-parallelism-work-limit-error 2781,116543
-
-hons-raw.lisp,5514
-(defconstant *hl-mht-default-rehash-size* 92,4372
-(defconstant *hl-mht-default-rehash-threshold* 93,4419
-(defun hl-mht 95,4472
-(defconstant hl-cache-table-size244,11754
-(defconstant hl-cache-table-cutoff249,11841
-(defstruct hl-cache253,11976
-(defabbrev hl-machine-hash 267,12345
-(defun hl-cache-set 291,13410
-(defun hl-cache-get 316,14347
-(defun hl-cache-clear 343,15102
-(defparameter *hl-hspace-str-ht-default-size* 567,25296
-(defparameter *hl-ctables-nil-ht-default-size* 568,25353
-(defparameter *hl-ctables-cdr-ht-default-size* 569,25410
-(defparameter *hl-ctables-cdr-ht-eql-default-size* 570,25469
-(defparameter *hl-hspace-addr-ht-default-size* 571,25526
-(defparameter *hl-hspace-sbits-default-size* 572,25585
-(defparameter *hl-hspace-other-ht-default-size* 573,25646
-(defparameter *hl-hspace-fal-ht-default-size* 574,25703
-(defparameter *hl-hspace-persist-ht-default-size* 575,25760
-(defstruct hl-ctables580,25833
-(defun hl-initialize-faltable-table 597,26399
-(defstruct hl-falslot638,28510
-(defstruct (hl-faltable 660,29241
-(defun hl-faltable-init 684,30179
-(defstruct (hl-hspace 689,30321
-(defun hl-hspace-init 740,31777
-(defabbrev hl-flex-alist-too-long 822,35611
-(defabbrev hl-flex-assoc 838,36213
-(defabbrev hl-flex-acons 848,36509
-(defun hl-hspace-truly-static-honsp 890,38014
-(defabbrev hl-hspace-find-alist-for-cdr 905,38557
-(defun hl-hspace-honsp 925,39283
-(defun hl-hspace-honsp-wrapper 943,39750
-(defun hl-hspace-faltable-wrapper 949,39944
-(defun hl-hspace-normedp 956,40142
-(defun hl-hspace-normedp-wrapper 977,40688
-(defun hl-hspace-hons-equal-lite 990,41087
-(defun hl-hspace-hons-equal 1010,41658
-(defconstant hl-minimum-static-int1086,44643
-(defconstant hl-maximum-static-int1091,44783
-(defconstant hl-num-static-ints1096,44919
-(defconstant hl-dynamic-base-addr1101,45102
-(defconstant hl-static-int-shift1110,45391
-(ccl::defstatic *hl-symbol-addr-lock*1118,45780
-(defabbrev hl-symbol-addr 1123,45945
-(defun hl-addr-of-unusual-atom 1171,48156
-(defmacro hl-addr-of 1214,49860
-(defun hl-nat-combine* 1237,50769
-(defabbrev hl-addr-combine* 1251,51327
-(defparameter *hl-addr-limit-minimum*1331,55267
-(defun hl-make-addr-limit-current 1339,55592
-(defun hl-make-addr-limit-next 1352,56022
-(defun hl-addr-ht-fullness 1370,56778
-(defparameter *hl-addr-limit-should-clear-memo-tables*1376,57001
-(defun hl-addr-limit-action 1381,57121
-(defun hl-hspace-grow-sbits 1441,59604
-(defun hl-hspace-norm-atom 1485,61857
-(defun hl-hspace-hons-normed 1523,63181
-(defun hl-hspace-norm-aux 1677,70918
-(defun hl-hspace-norm-expensive 1703,71858
-(defun hl-hspace-norm 1721,72493
-(defun hl-hspace-persistent-norm 1730,72714
-(defabbrev hl-hspace-hons 1755,73751
-(defun hl-slow-alist-warning 1858,78298
-(defun hl-faltable-maphash 1876,79063
-(defun hl-faltable-load-empty-slot 1903,79928
-(defun hl-faltable-eject 1926,80815
-(defun hl-faltable-get-free-slot 1944,81499
-(defun hl-faltable-slot-lookup 1959,82066
-(defun hl-faltable-general-lookup 1986,83098
-(defun hl-faltable-remove 2001,83753
-(defun hl-hspace-fast-alist-free 2024,84769
-(defun hl-hspace-hons-get 2032,84973
-(defun hl-hspace-hons-acons 2058,86006
-(defun hl-alist-stolen-warning 2118,88450
-(defun hl-hspace-hons-acons! 2136,89204
-(defun hl-alist-longest-normed-tail 2185,91151
-(defun hl-make-fast-norm-keys 2205,91948
-(defun hl-make-fast-alist-put-pairs 2231,92925
-(defun hl-hspace-make-fast-alist 2247,93582
-(defun hl-shrink-alist-aux-really-slow 2299,95969
-(defun hl-shrink-alist-aux-slow 2321,96967
-(defun hl-shrink-alist-aux-fast 2347,98152
-(defun hl-hspace-shrink-alist 2378,99529
-(defun hl-hspace-fast-alist-len 2452,102887
-(defun hl-check-alist-for-serialize-restore 2471,103611
-(defun hl-hspace-restore-fal-for-serialize 2490,104283
-(defun hl-restore-fal-for-serialize 2516,105527
-(defun hl-hspace-number-subtrees-aux 2527,105921
-(defun hl-hspace-number-subtrees 2539,106255
-(defun hl-system-gc 2566,107171
-(defun hl-hspace-classic-restore 2585,107715
-(defun hl-hspace-hons-clear 2641,110102
-(defun hl-hspace-static-restore 2721,113412
-(defun hl-hspace-hons-clear 2763,115246
-(defun hl-fix-sbits-after-gc 2859,119441
-(defun hl-rebuild-addr-ht 2880,120248
-(defparameter *hl-addr-ht-resize-cutoff*2917,122063
-(defun hl-hspace-hons-wash 2925,122436
-(defun hl-maybe-resize-ht 3073,129310
-(defun hl-hspace-resize 3101,130477
-(defun hl-get-final-cdr 3178,133299
-(defun hl-hspace-fast-alist-summary 3183,133400
-(defun hl-hspace-hons-summary 3226,135179
-(defparameter *default-hs*3310,138343
-(defun hl-maybe-initialize-default-hs 3340,139490
-(defun hl-maybe-initialize-default-hs-wrapper 3347,139630
-(defun hons 3351,139754
-(defun hons-copy 3356,139890
-(defun hons-copy-persistent 3361,140027
-(defun hons-equal 3367,140194
-(defun hons-equal-lite 3373,140399
-(defun hons-summary 3378,140584
-(defun hons-clear 3383,140707
-(defun hons-wash 3388,140831
-(defun hons-resize-fn 3393,140948
-(defun hons-acons 3405,141369
-(defun hons-acons! 3411,141586
-(defun hons-shrink-alist 3416,141774
-(defun hons-shrink-alist! 3421,141925
-(defun hons-get 3427,142103
-(defun fast-alist-free 3433,142310
-(defun fast-alist-len 3439,142529
-(defun number-subtrees 3445,142746
-(defun fast-alist-summary 3450,142927
-(defun make-fast-alist 3455,143062
-(defmacro with-fast-alist-raw 3460,143202
-(defmacro with-stolen-alist-raw 3489,144434
-(defmacro fast-alist-free-on-exit-raw 3518,145693
-(defun clear-hash-tables 3525,145882
-(defun wash-memory 3530,145996
-
-memoize-raw.lisp,7816
-(defconstant most-positive-mfixnum 69,2711
-(deftype mfixnum 71,2765
-(defmacro our-syntax 86,3276
-(defmacro our-syntax-nice 112,4228
-(defmacro our-syntax-brief 122,4588
-(defmacro ofn 131,4813
-(defun-one-output ofnum 134,4895
-(defmacro ofni 145,5220
-(defmacro ofnm 148,5343
-(defmacro oft 151,5451
-(defmacro oftr 155,5582
-(defv *number-of-arguments-and-values-ht*165,5858
-(defun-one-output input-output-number-error 208,7395
-(defun-one-output number-of-arguments 218,7889
-(defun-one-output number-of-return-values 242,8711
-(defg *float-ticks/second* 265,9496
-(defg *float-internal-time-units-per-second*267,9529
-(defabbrev internal-real-time 273,9712
-(defun-one-output float-ticks/second-init 281,10037
-(defun-one-output safe-incf-aux-error 303,10770
-(defmacro safe-incf-aux 307,10912
-(defmacro safe-incf 338,12083
-(defparameter *count-pons-calls* 384,13857
-(defg *pons-call-counter* 390,14101
-(defg *pons-misses-counter* 391,14130
-(defmacro maybe-count-pons-calls 395,14254
-(defmacro maybe-count-pons-misses 399,14384
-(defun-one-output assoc-no-error-at-end 403,14518
-(defun-one-output too-long 419,15062
-(defconstant atom-case-fudge 432,15669
-(defconstant most-positive-fudge 433,15719
-(defconstant most-negative-fudge 434,15770
-(defconstant -most-negative-fudge 435,15820
-(defun-one-output atom-case 438,15890
-(defmacro sqmpf 457,16642
-(defmacro hmnf 460,16694
-(defmacro static-hons-shift 466,16784
-(defun-one-output addr-for 470,16883
-(defun-one-output pons 529,19370
-(defmacro pist* 608,21885
-(defparameter *record-bytes*1008,33601
-(defparameter *record-calls* 1016,33921
-(defparameter *record-hits* 1020,34043
-(defparameter *record-hons-calls* 1025,34218
-(defparameter *record-mht-calls* 1029,34344
-(defparameter *record-pons-calls* 1034,34545
-(defparameter *record-time* 1038,34683
-(defv *report-bytes* 1045,34870
-(defv *report-calls* 1049,35026
-(defv *report-calls-from* 1053,35131
-(defv *report-calls-to* 1058,35303
-(defv *report-hits* 1063,35483
-(defv *report-hons-calls* 1067,35631
-(defv *report-mht-calls* 1071,35772
-(defv *report-pons-calls* 1079,36191
-(defv *report-time* 1083,36314
-(defv *report-on-memo-tables* 1087,36448
-(defv *report-on-pons-tables* 1091,36581
-(defg *memoize-info-ht*1095,36714
-(defrec memoize-info-ht-entry1106,37019
-(defg *memoize-call-array*1150,38966
-(defg *compute-array* 1182,40655
-(defv *initial-max-memoize-fns* 1199,41173
-(defg *2max-memoize-fns* 1201,41211
-(defconstant *ma-bytes-index* 1203,41270
-(defconstant *ma-hits-index* 1204,41309
-(defconstant *ma-mht-index* 1205,41348
-(defconstant *ma-hons-index* 1206,41387
-(defconstant *ma-pons-index* 1207,41426
-(defconstant *ma-initial-max-symbol-to-fixnum* 1209,41466
-(defg *max-symbol-to-fixnum* 1211,41517
-(defg *caller* 1219,41770
-(defn memoize-here-come 1226,42026
-(defun memoize-flush1 1269,43836
-(defmacro memoize-flush 1287,44714
-(defparameter *memo-max-sizes*1298,44881
-(defrec memo-max-sizes-entry1315,45672
-(defun make-initial-memoize-hash-table 1325,46120
-(defun make-initial-memoize-pons-table 1376,48761
-(defun update-memo-max-sizes 1409,50571
-(defun print-memo-max-sizes 1438,52109
-(defmacro heap-bytes-allocated 1470,53539
-(defn sync-memoize-call-array 1473,53621
-(defun memoize-call-array-grow1498,54541
-(defun-one-output symbol-to-fixnum-create 1527,55885
-(defun-one-output symbol-to-fixnum 1551,56849
-(defun-one-output fixnum-to-symbol 1557,57065
-(defun-one-output coerce-index 1562,57224
-(defun-one-output memoize-eval-compile 1575,57398
-(defun-one-output memoizedp-raw 1584,57666
-(defg *hons-gentemp-counter* 1588,57773
-(defun-one-output hons-gentemp 1590,57806
-(defun-one-output st-lst 1599,58136
-(defun-one-output dcls 1611,58512
-(defg *assoc-eq-hack-ht* 1624,58922
-(defn assoc-eq-hack 1627,59011
-(defun abbrev 1640,59570
-(defun prine 1664,60578
-(defun prine-alist 1669,60709
-(defun-one-output mf-trace-exit 1701,61754
-(defg *memoize-fn-signature-error*1711,62073
-(defg *sort-to-from-by-calls* 1720,62452
-(defvar *memoize-use-attachment-warning-p* 1722,62488
-(defun memoize-use-attachment-warning 1724,62535
-(defun-one-output memoize-fn-suffix 1751,63976
-(defun-one-output mis-ordered-commutative-args 1759,64201
-(defun our-function-lambda-expression 1790,65448
-(defun memoize-look-up-def 1808,66012
-(defg *memoize-init-done* 1852,67782
-(defun memoize-fn 1854,67814
-(defun-one-output unmemoize-fn 2524,98980
-(defun-one-output maybe-unmemoize 2574,101067
-(defun-one-output memoized-functions 2586,101589
-(defun-one-output length-memoized-functions 2596,101878
-(defun-one-output unmemoize-all 2605,102162
-(defun-one-output memoize-info 2620,102702
-(defun-one-output rememoize-all 2666,104712
-(defun-one-output uses-state 2688,105375
-(defun profile-fn 2697,105737
-(defun-one-output profiled-functions 2704,105935
-(defun-one-output unmemoize-profiled 2719,106376
-(defmacro memoize-on-raw 2730,106664
-(defmacro memoize-off-raw 2743,107177
-(defun-one-output memoize-condition 2756,107686
-(defn global-restore-memoize 2762,107847
-(defg *memoize-summary-order-list*2772,108125
-(defg *memoize-summary-limit* 2803,108981
-(defg *shorten-ht* 2809,109189
-(defn shorten 2811,109230
-(defg *memoize-summary-order-reversed* 2840,110538
-(defg *print-alist-width* 2846,110745
-(defun-one-output print-alist 2848,110776
-(defmacro very-unsafe-incf 2878,111848
-(defmacro very-very-unsafe-aref-incf 2892,112183
-(defun-one-output pons-summary 2898,112396
-(defun memoized-values 2939,113985
-(defn print-call-stack 2961,114820
-(defun-one-output hons-calls 2996,116049
-(defun-one-output pons-calls 3009,116418
-(defun-one-output bytes-allocated 3022,116785
-(defun-one-output number-of-hits 3034,117180
-(defun-one-output number-of-memoized-entries 3046,117572
-(defun-one-output number-of-mht-calls 3061,118066
-(defun-one-output time-for-non-hits/call 3073,118467
-(defun-one-output time/call 3078,118641
-(defun-one-output hits/calls 3083,118779
-(defun-one-output bytes-allocated/call 3089,118940
-(defn char-list-fraction 3096,119108
-(defn symbol-name-order 3102,119239
-(defun-one-output execution-order 3110,119464
-(defn compute-calls-and-times 3120,119758
-(defun-one-output number-of-calls 3163,121695
-(defun-one-output print-not-called 3172,121938
-(defun-one-output total-time 3189,122495
-(defn lex-> 3200,122765
-(defun-one-output memoize-summary-sort 3208,122957
-(defun-one-output memoize-summary 3227,123580
-(defg *short-symbol-name-width* 3303,126581
-(defn short-symbol-name 3305,126618
-(defun-one-output outside-p 3314,126942
-(defun-one-output memoize-summary-after-compute-calls-and-times 3318,127067
-(defun-one-output empty-ht-p 3633,141573
-(defn clear-one-memo-and-pons-hash 3637,141686
-(defun-one-output clear-memoize-table 3661,142829
-(defun-one-output clear-memoize-tables 3670,143016
-(defn clear-memoize-call-array 3685,143393
-(defn clear-memoize-statistics 3695,143722
-(defun-one-output memoize-init 3700,143794
-(defg *max-mem-usage* 3739,145080
-(defg *gc-min-threshold* 3747,145325
-(defun-one-output set-gc-threshold 3755,145457
-(defmacro globlet 3764,145666
-(defmacro globlet 3794,146902
-(defmacro with-lower-overhead 3805,147232
-(defun acl2h-init-memoizations 3831,148328
-(defun acl2h-init-unmemoizations 3868,149678
-(defun looking-at 3897,150746
-(defun meminfo 3925,151804
-(defvar *sol-gc-installed* 3960,153094
-(defun set-and-reset-gc-thresholds 3964,153138
-(defun start-sol-gc 3987,154042
-(defun-one-output acl2h-init 4082,157915
-(defun memstat 4181,161745
-(defmacro memo-on 4184,161802
-(defmacro memo-off 4187,161852
-(defun clear-memo-tables 4190,161904
-(defn lower-overhead 4197,162042
-(defun our-gctime 4214,162515
-(defun update-memo-entry-for-attachments 4217,162598
-(defun update-memo-entries-for-attachments 4239,163531
-
-translate.lisp,9824
-(deflabel syntax23,881
-(deflabel term41,1351
-(defun termp 228,11066
-(defun term-listp 254,11935
-(defun computed-hint-tuple-listp 261,12065
-(defun macro-args 281,12620
-(defconst *macro-expansion-ctx* 384,15627
-(defun remove-keyword 386,15679
-(defun error-trace-suggestion 392,15872
-(defun ignored-attachment-msg 403,16223
-(defun ev-fncall-null-body-er-msg 410,16566
-(defun ev-fncall-null-body-er 431,17336
-(defun ev-fncall-creator-er-msg 436,17490
-(defun unknown-pkg-error-msg 448,18091
-(defun illegal-msg 454,18278
-(defun program-only-er-msg 458,18369
-(defconst *safe-mode-guard-er-addendum*470,18976
-(defun find-first-non-nil 475,19220
-(defun latch-stobjs1 482,19418
-(defun latch-stobjs 535,21963
-(defvar *raw-guard-warningp*)560,23192
-(defun actual-stobjs-out1 562,23223
-(defun apply-symbol-alist 578,24030
-(defun apply-inverse-symbol-alist 592,24653
-(defun actual-stobjs-out 607,25190
-(defun raw-ev-fncall 618,25670
-(defun translated-acl2-unwind-protectp4 714,30252
-(defun translated-acl2-unwind-protectp 789,33851
-(defun stobjp 800,34255
-(defun acl2-system-namep 1146,49632
-(defparameter *ev-shortcut-okp*1219,51897
-(defun w-of-any-state 1234,52561
-(defun untranslate-preprocess-fn 1247,53124
-(defmacro untranslate* 1253,53389
-(defmacro raw-guard-warningp-binding 1269,54042
-(defun untouchable-fn-p 1297,55562
-(defun save-ev-fncall-guard-er 1301,55729
-(defrec attachment1310,56037
-(defrec attachment-component1317,56155
-(defun attachment-record-pairs 1324,56272
-(defun all-attachments 1332,56508
-(defun gc-off1 1336,56637
-(defun gc-off 1340,56732
-(defun return-last-lookup 1357,57227
-(defun make-let-or-let* 1372,57700
-(defmacro untranslate*-lst 1386,58176
-(defun apply-user-stobj-alist-or-kwote 1397,58470
-(defun ev-fncall-rec-logical 1436,60300
-(defun ev-fncall-rec 1761,73522
-(defun ev-rec-return-last 1808,75389
-(defun ev-rec 1908,80312
-(defun ev-rec-lst 2094,89636
-(defun ev-rec-acl2-unwind-protect 2127,91106
-(defun ev-fncall-w 2348,101188
-(defun ev-fncall-guard-er-msg 2416,103764
-(defun ev-fncall-guard-er 2472,106190
-(defun ev-fncall-msg 2483,106591
-(defun untranslate1 2534,108423
-(defun untranslate-cons1 2763,120575
-(defun untranslate-cons 2783,121577
-(defun untranslate-if 2794,122022
-(defun untranslate-into-case-clauses 2813,122985
-(defun untranslate-into-cond-clauses 2855,125306
-(defun untranslate1-lst 2870,126047
-(defun ev-fncall 2881,126480
-(defun ev 2894,127059
-(defun ev-lst 2928,128363
-(defun untranslate 2946,129103
-(defun untranslate-lst 2973,130182
-(defun ev-w 3011,131740
-(defun ev-w-lst 3072,134285
-(defun silent-error 3198,140470
-(defmacro cmp-to-error-triple 3201,140519
-(defmacro cmp-to-error-triple@par 3217,141077
-(defmacro cmp-to-error-double 3233,141660
-(defmacro cmp-and-value-to-error-quadruple 3249,142291
-(defmacro cmp-and-value-to-error-quadruple@par 3271,143205
-(defun er-cmp-fn 3291,144038
-(defmacro er-cmp 3299,144218
-(defmacro value-cmp 3306,144403
-(defun er-progn-fn-cmp 3309,144444
-(defmacro er-progn-cmp 3331,145402
-(defmacro er-let*-cmp 3336,145547
-(defun warning1-cw 3361,146504
-(defmacro warning$-cw1 3368,146708
-(defmacro warning$-cw 3393,147530
-(defun chk-length-and-keys 3406,148076
-(defun bind-macro-args-keys1 3426,148924
-(defun bind-macro-args-keys 3485,151782
-(defun bind-macro-args-after-rest 3503,152499
-(defun bind-macro-args-optional 3513,152896
-(defun bind-macro-args1 3548,154406
-(defun bind-macro-args 3574,155535
-(defun macroexpand1-cmp 3582,155885
-(defun macroexpand1 3641,158473
-(defun chk-declare 3645,158632
-(defun collect-dcls 3665,159587
-(defun acceptable-dcls-alist 3676,159968
-(defconst *documentation-strings-permitted*3705,161181
-(defconst *dcl-explanation-alist*3711,161332
-(defun tilde-*-conjunction-phrase1 3721,161854
-(defun tilde-*-conjunction-phrase 3732,162332
-(defun collect-non-legal-variableps 3749,162985
-(defun optimize-alistp 3755,163213
-(defun chk-dcl-lst 3768,163634
-(defun number-of-strings 3946,173109
-(defun remove-strings 3952,173272
-(defun get-string 3958,173438
-(defun collect-declarations-cmp 3963,173562
-(defun collect-declarations 4003,175554
-(defun listify 4008,175814
-(defun translate-declaration-to-guard-var-lst 4012,175912
-(defun translate-dcl-lst 4026,176575
-(defun dcl-guardian 4040,177171
-(defun ignore-vars 4073,178708
-(defun ignorable-vars 4079,178891
-(defun mv-nth-list 4085,179086
-(defabbrev translate-bind 4090,179263
-(defun translate-deref 4096,179398
-(defun translate-unbound 4112,179964
-(defun listlis 4120,180168
-(defun find-first-var 4130,180375
-(defun find-first-var-lst 4138,180613
-(defun find-first-fnsymb 4146,180784
-(defun find-first-fnsymb-lst 4154,181058
-(defun find-pkg-witness 4160,181219
-(defmacro trans-er 4179,181935
-(defmacro trans-er+ 4195,182670
-(defmacro trans-er+? 4214,183440
-(defmacro trans-value 4230,184094
-(defmacro trans-er-let* 4236,184241
-(defun hide-ignored-actuals 4259,185078
-(defun augment-ignore-vars 4285,186047
-(defun compute-stobj-flags 4393,191862
-(defun prettyify-stobj-flags 4406,192355
-(defun unprettyify-stobj-flags 4415,192641
-(defun prettyify-stobjs-out 4420,192815
-(defun defstobj-supporterp 4429,193111
-(defun stobj-creatorp 4445,193824
-(defun defstobj-fnname 4457,194242
-(defun parse-with-local-stobj 4516,196855
-(defun ffnnamep 4536,197362
-(defun ffnnamep-lst 4550,197815
-(defconst *synp-trans-err-string*4560,198036
-(defconst *ttag-fns-and-macros*4566,198384
-(defun unknown-binding-msg 4588,199063
-(defconst *oneify-primitives*4606,200205
-(defconst *macros-for-nonexpansion-in-raw-lisp*4652,201978
-(defun chk-no-duplicate-defuns-cmp 4712,204284
-(defun chk-no-duplicate-defuns 4722,204704
-(defun chk-state-ok-msg 4725,204815
-(defun chk-state-ok 4740,205441
-(defun chk-arglist-msg 4745,205587
-(defun msg-to-cmp 4762,206321
-(defun chk-arglist-cmp 4771,206562
-(defun@par chk-arglist 4774,206670
-(defun logical-name-type 4779,206856
-(defun chk-all-but-new-name-cmp 4804,207855
-(defun chk-all-but-new-name 4835,209112
-(defun chk-defuns-tuples-cmp 4838,209241
-(defun chk-defuns-tuples 4882,211119
-(defun non-trivial-encapsulate-ee-entries 4886,211313
-(defconst *ec-call-bad-ops*4895,211721
-(defmacro return-last-call 4905,212114
-(defmacro prog2$-call 4908,212201
-(defun name-dropper 4911,212275
-(defun first-assoc-eq 4927,212990
-(defun context-for-encapsulate-pass-2 4935,213255
-(defconst *brr-globals*4965,214670
-(defun unknown-binding-msg-er 4971,214764
-(defun congruent-stobj-rep 4991,215750
-(defun congruent-stobjsp 4997,215951
-(defun stobjs-in-out1 5001,216068
-(defun stobjs-in-matchp 5026,217228
-(defun stobjs-in-out 5034,217491
-(defun non-trivial-stobj-binding 5072,219281
-(defun formalized-varlistp 5084,219869
-(defun throw-nonexec-error-p1 5096,220350
-(defun throw-nonexec-error-p 5116,221134
-(defun chk-flet-declarations 5131,221849
-(defun chk-flet-declare-form 5157,223173
-(defun chk-flet-declare-form-list 5172,223774
-(defun translate-stobj-type-to-guard 5179,224073
-(defun get-stobj-creator 5214,225858
-(defun stobj-updater-guess-from-accessor 5238,226883
-(defun parse-stobj-let1 5259,227639
-(defun illegal-stobj-let-msg 5351,231761
-(defun parse-stobj-let 5355,231885
-(defun pairlis-x1 5449,235991
-(defun pairlis-x2 5457,236179
-(defun no-duplicatesp-checks-for-stobj-let-actuals/alist 5465,236371
-(defun no-duplicatesp-checks-for-stobj-let-actuals 5479,237068
-(defun stobj-let-fn 5503,238095
-(defun the-live-var 5537,239593
-(defun the-live-var-bindings 5556,240444
-(defun the-maybe-live-var-bindings 5562,240686
-(defun stobj-let-fn-raw 5572,241090
-(defun stobj-field-accessor-p 5658,244556
-(defun chk-stobj-let/bindings 5680,245143
-(defun chk-stobj-let/updaters1 5718,247042
-(defun chk-stobj-let/updaters 5748,248518
-(defun chk-stobj-let 5755,248778
-(defun all-nils-or-x 5777,249672
-(defun stobj-field-fn-of-stobj-type-p 5786,249934
-(defun stobj-recognizer-p 5798,250490
-(defmacro trans-or 5807,250765
-(defun translate11-flet-alist 5838,252099
-(defun translate11-flet-alist1 5852,252757
-(defun translate11-flet 6054,262340
-(defun translate-stobj-calls 6122,265280
-(defun translate11-let 6158,267101
-(defun translate11-let* 6364,277843
-(defun translate11-mv-let 6389,279068
-(defun translate11-wormhole-eval 6609,290173
-(defun translate11-call 6704,294507
-(defun translate11 6890,303899
-(defun translate11-lst 8074,363006
-(defun translate1-cmp 8196,369297
-(defun@par translate1 8261,372386
-(defun collect-programs 8266,372603
-(defun all-fnnames1 8298,373758
-(defmacro all-fnnames 8317,374450
-(defmacro all-fnnames-lst 8320,374513
-(defun translate-cmp 8323,374576
-(defun@par translate 8348,375733
-(defun translatable-p 8379,377201
-(defmacro chk-translatable 8386,377492
-(defun replaced-stobj 8412,378746
-(defun replace-stobjs1 8418,378915
-(defun replace-stobjs 8426,379211
-(defun non-stobjps 8467,381104
-(defun user-stobjsp 8474,381355
-(defun put-assoc-eq-alist 8481,381559
-(defun-one-output chk-user-stobj-alist 8515,383280
-(defun user-stobj-alist-safe 8540,384371
-(defun ev-for-trans-eval 8549,384645
-(defun ev-w-for-trans-eval 8601,386935
-(defun trans-eval 8637,388212
-(defun simple-translate-and-eval 8683,390082
-(defun error-fms-cw 8777,394706
-(defmacro error-fms@par 8794,395387
-(defun simple-translate-and-eval-cmp 8797,395451
-(defun simple-translate-and-eval-error-double 8859,398421
-(defun simple-translate-and-eval@par 8888,399705
-(defun tilde-*-alist-phrase1 8904,400537
-(defun tilde-*-alist-phrase 8910,400803
-(defun set-temp-touchable-fns 8922,401098
-(defun set-temp-touchable-vars 8939,401793
-(defun clear-temp-touchable-fns 8956,402491
-(defun clear-temp-touchable-vars 8959,402580
-(defun mapcar$ 8975,403345
-(defun mapdo 8997,404249
-(defun always 9010,404708
-(defun thereis 9024,405125
-
-type-set-a.lisp,1856
-(defconst *ts-non-negative-integer* 124,5901
-(defconst *ts-non-positive-integer* 127,6030
-(defconst *ts-integer* 130,6159
-(defconst *ts-rational* 134,6318
-(defconst *ts-real* 141,6570
-(defconst *ts-complex* 151,6940
-(defconst *ts-acl2-number*160,7355
-(defconst *ts-rational-acl2-number* 166,7525
-(defconst *ts-non-rational-acl2-number* 170,7683
-(defconst *ts-negative-rational* 174,7913
-(defconst *ts-positive-rational* 177,8046
-(defconst *ts-non-positive-rational* 180,8179
-(defconst *ts-non-negative-rational* 183,8311
-(defconst *ts-ratio* 186,8443
-(defconst *ts-non-ratio* 197,8772
-(defconst *ts-negative-real* 200,8895
-(defconst *ts-positive-real* 204,9084
-(defconst *ts-non-positive-real* 208,9273
-(defconst *ts-non-negative-real* 211,9393
-(defconst *ts-cons* 215,9515
-(defconst *ts-boolean* 218,9616
-(defconst *ts-true-list* 220,9669
-(defconst *ts-non-nil* 222,9734
-(defconst *ts-symbol* 224,9785
-(defconst *ts-true-list-or-string* 228,9929
-(defconst *ts-empty* 230,10005
-(defconst *ts-unknown* 232,10030
-(defun one-bit-type-setp 240,10392
-(defconst *code-type-set-alist*278,12045
-(defun logior-lst 362,15691
-(defun logand-lst 368,15821
-(defun ts-complement-fn 376,15970
-(defun ts-union-fn 382,16117
-(defun ts-intersection-fn 392,16425
-(defun eval-type-set 402,16744
-(defun eval-type-set-lst 423,17560
-(defmacro ts-complement 436,17878
-(defmacro ts-intersection 439,17952
-(defmacro ts-union 442,18036
-(defmacro ts-subsetp 445,18106
-(defun type-set-binary-+-alist-entry 460,18553
-(defun type-set-binary-+-alist1 592,25217
-(defun type-set-binary-+-alist 601,25623
-(defun type-set-binary-*-alist-entry 609,25887
-(defun type-set-binary-*-alist1 742,32974
-(defun type-set-binary-*-alist 752,33433
-(defun type-set-<-alist-entry 760,33697
-(defun type-set-<-alist1 844,37738
-(defun type-set-<-alist 854,38117
-
-linear-a.lisp,4999
-(defabbrev ts-acl2-numberp 35,1338
-(defabbrev ts-rationalp 38,1407
-(defabbrev ts-real/rationalp 41,1470
-(defabbrev ts-integerp 47,1618
-(defun all-quoteps 50,1679
-(defun dumb-occur 57,1826
-(defun dumb-occur-lst 68,2143
-(defrec history-entry84,2675
-(defun pt-occur 193,9106
-(defun pt-intersectp 201,9304
-(deflabel ttree293,13656
-(defun tag-tree-occur 320,14942
-(defun remove-tag-from-tag-tree 328,15118
-(defun remove-tag-from-tag-tree! 339,15416
-(defmacro extend-tag-tree 354,15866
-(defun add-to-tag-tree 362,16043
-(defun add-to-tag-tree! 381,16622
-(defconst *fake-rune-for-anonymous-enabled-rule*404,17454
-(defabbrev push-lemma 407,17552
-(defun delete-assoc-eq-assoc-eq-1 431,18808
-(defun delete-assoc-eq-assoc-eq 444,19349
-(defun cons-tag-trees1 450,19526
-(defun cons-tag-trees 471,20536
-(defmacro tagged-objects 493,21399
-(defmacro tagged-objectsp 501,21558
-(defun tagged-object 511,21865
-(deflock *ttree-lock*)537,23163
-(defun@par accumulate-ttree-and-step-limit-into-state 539,23187
-(defun pts-to-ttree-lst 582,25156
-(defun marry-parents 594,25695
-(defun collect-parents1 606,26088
-(defun collect-parents0 615,26319
-(defun collect-parents 622,26479
-(defun ignore-polyp 631,26844
-(defun to-be-ignoredp1 646,27492
-(defun to-be-ignoredp 651,27644
-(defrec assumnote 679,28813
-(defrec assumption694,29746
-(defrec fc-derivation755,33360
-(defun contains-assumptionp 767,33715
-(defun contains-assumptionp-fc-derivations 777,34074
-(defun remove-assumption-entries-from-type-alist 783,34296
-(defun force-assumption1802,35012
-(defun dumb-occur-in-type-alist 832,36345
-(defun all-dumb-occur-in-type-alist 841,36541
-(defun force-assumption848,36755
-(defun tag-tree-occur-assumption-nil-1 945,42074
-(defun tag-tree-occur-assumption-nil 952,42290
-(defun assumption-free-ttreep 959,42535
-(defconst *impossible-assumption*979,43381
-(deflabel linear-arithmetic1483,63384
-(defmacro fn-count-evg-max-val 1590,68216
-(defmacro fn-count-evg-max-val-neg 1598,68462
-(defmacro fn-count-evg-max-calls 1601,68532
-(defun min-fixnum 1612,68842
-(defun fn-count-evg-rec 1620,69075
-(defmacro fn-count-evg 1693,72318
-(defun var-fn-count-1 1696,72380
-(defmacro var-fn-count 1798,77743
-(defmacro var-or-fn-count-< 1804,77896
-(defun term-order1 1831,79223
-(defun arith-term-order 1902,83620
-(defrec poly1916,83960
-(defabbrev first-var 2046,90529
-(defabbrev first-coefficient 2048,90586
-(defun good-coefficient 2071,91644
-(defun good-pot-varp 2074,91694
-(defun good-polyp 2084,92074
-(defun logical-< 2094,92468
-(defun logical-<=2107,92880
-(defun evaluate-ground-poly 2117,93206
-(defun impossible-polyp 2126,93475
-(defun true-polyp 2130,93584
-(defun silly-polyp 2134,93678
-(defun impossible-poly 2141,93884
-(defun base-poly0 2151,94121
-(defun base-poly 2164,94486
-(defun poly-alist-equal 2177,94859
-(defun poly-equal 2191,95256
-(defun poly-weakerp 2202,95635
-(defun poly-member 2235,97018
-(defun new-and-ugly-linear-varsp 2251,97675
-(defun filter-polys 2277,98693
-(defun add-linear-variable1 2304,99663
-(defun zero-factor-p 2328,100653
-(defun get-coefficient 2349,101487
-(defun add-linear-variable 2363,102025
-(defun dumb-eval-yields-quotep 2385,102699
-(defun dumb-eval 2407,103504
-(defun add-linear-term 2436,104490
-(defun add-linear-terms-fn 2506,107054
-(defmacro add-linear-terms 2520,107505
-(defun normalize-poly1 2538,108056
-(defun normalize-poly 2545,108249
-(defun normalize-poly-lst 2561,108652
-(defrec linear-pot 2574,108927
-(defun modify-linear-pot 2583,109431
-(defconst *max-linear-pot-loop-stopper-value* 2657,112361
-(defun loop-stopper-value-of-var 2659,112411
-(defun set-loop-stopper-values 2670,112800
-(defun var-in-pot-lst-p 2702,114447
-(defun bounds-poly-with-var 2712,114712
-(defun bounds-polys-with-var 2738,115940
-(defun polys-with-var1 2763,116869
-(defun polys-with-var 2770,117172
-(defun polys-with-pots 2782,117608
-(defun new-vars-in-pot-lst 2795,118024
-(defun changed-pot-vars 2843,120598
-(defun infect-polys 2869,121822
-(defun infect-first-n-polys 2884,122406
-(defun infect-new-polys 2899,123017
-(defun fcomplementary-multiplep1 2970,126312
-(defun fcomplementary-multiplep 2983,126796
-(defun already-used-by-find-equational-polyp-lst 2998,127451
-(defun already-used-by-find-equational-polyp 3003,127667
-(defun cons-term-binary-+-constant 3032,129115
-(defun cons-term-unary-- 3041,129412
-(defun cons-term-binary-*-constant 3047,129646
-(defun find-equational-poly-rhs1 3058,130009
-(defun find-equational-poly-rhs 3072,130511
-(defun find-equational-poly3 3103,131546
-(defun find-equational-poly2 3131,132829
-(defun find-equational-poly1 3151,133529
-(defun find-equational-poly 3171,134277
-(defun get-coeff-for-cancel1 3208,135903
-(defun cancel2 3232,136711
-(defun cancel1 3240,136914
-(defun cancel 3266,137953
-(defun cancel-poly-against-all-polys 3336,141335
-(defun add-poly 3427,145440
-(defun prune-poly-lst 3554,150929
-(defun add-polys1 3562,151192
-(defun add-polys0 3607,153282
-
-type-set-b.lisp,11735
-(defconst *number-of-numeric-type-set-bits*26,995
-(defconst *type-set-binary-+-table-list*30,1099
-(defconst *type-set-binary-+-table*39,1468
-(defconst *type-set-binary-*-table-list*43,1589
-(defconst *type-set-binary-*-table*52,1958
-(defconst *type-set-<-table-list*60,2240
-(defconst *type-set-<-table*75,2691
-(defun assoc-equal-cdr 89,3292
-(defun runep 97,3517
-(defmacro base-symbol 228,10269
-(defmacro strip-base-symbols 242,10835
-(deflabel executable-counterpart245,10898
-(deflabel world324,14702
-(deflabel rune433,21437
-(deflabel rule-names580,28785
-(defun fnume 595,29023
-(defun frunic-mapping-pair 611,29800
-(defun fn-rune-nume 619,30054
-(defun definition-runes 635,30839
-(defun get-next-nume 640,31021
-(defun deref-macro-name 676,32855
-(defun deref-macro-name-lst 682,33014
-(defconst *abbrev-rune-alist*687,33260
-(defun translate-abbrev-rune 693,33403
-(defun rule-name-designatorp 703,33758
-(defun theoryp1 748,36001
-(defun theoryp 754,36205
-(defun theoryp!1 762,36478
-(defun theoryp! 784,37507
-(defun runic-theoryp1 789,37627
-(defun runic-theoryp 804,38175
-(defun find-mapping-pairs-tail1 880,42450
-(defun find-mapping-pairs-tail 895,43118
-(defun augment-runic-theory1 912,43941
-(defun augment-runic-theory 934,44999
-(defconst *bad-runic-designator-string*959,46319
-(defun convert-theory-to-unordered-mapping-pairs1 965,46679
-(defun convert-theory-to-unordered-mapping-pairs 1025,49030
-(defun duplicitous-cons-car 1043,49847
-(defun duplicitous-revappend-car 1052,50099
-(defun duplicitous-merge-car 1060,50362
-(defun duplicitous-sort-car 1094,52187
-(defun augment-theory 1115,53192
-(defmacro assert$-runic-theoryp 1143,54581
-(defun runic-theory 1157,54899
-(defrec enabled-structure1198,56839
-(defun enabled-numep 1282,61643
-(defun enabled-arith-numep 1297,62147
-(defun enabled-runep 1317,62997
-(defmacro active-runep 1325,63279
-(defun enabled-xfnp 1360,64465
-(defun sublis-var! 1381,65302
-(defun sublis-var!-lst 1490,69492
-(defun theory-warning-fns-aux 1507,70081
-(defun theory-warning-fns 1535,71298
-(defun@par maybe-warn-about-theory 1562,72904
-(defrec theory-invariant-record1617,75301
-(defun@par chk-theory-invariant1 1621,75370
-(defun@par chk-theory-invariant 1709,79790
-(defrec clause-id1735,80701
-(defun pos-listp 1748,81154
-(defun all-digits-p 1755,81315
-(defun d-pos-listp 1764,81658
-(defun clause-id-p 1776,82100
-(defconst *initial-clause-id*1791,82467
-(defun chars-for-tilde-@-clause-id-phrase/periods 1815,83611
-(defun chars-for-tilde-@-clause-id-phrase/primes 1825,83958
-(defun chars-for-tilde-@-clause-id-phrase 1833,84237
-(defun string-for-tilde-@-clause-id-phrase 1859,85552
-(defun@par load-theory-into-enabled-structure1867,85777
-(defun initial-global-enabled-structure 1955,90372
-(defun recompress-global-enabled-structure 1984,91590
-(defun recompress-stobj-accessor-arrays 2044,94494
-(defconst *fake-rune-for-type-set*2100,97530
-(defun puffert 2105,97667
-(defun immediate-forcep 2115,98079
-(defmacro numeric-type-set 2123,98288
-(defmacro rational-type-set 2146,99235
-(defmacro real-type-set 2167,100017
-(defun type-set-binary-+ 2188,100793
-(defun type-set-binary-* 2230,102850
-(defun type-set-not 2246,103418
-(defun type-set-<-1 2254,103618
-(defun type-set-< 2371,108055
-(defun type-set-unary-- 2533,115792
-(defun type-set-unary-/ 2556,116814
-(defun type-set-numerator 2575,117712
-(defun type-set-realpart 2590,118396
-(defun type-set-imagpart 2601,118789
-(defun type-set-complex 2622,119568
-(defun type-set-floor1 2665,121386
-(defun type-set-standard-part 2680,122063
-(defun type-set-standardp 2696,122731
-(defrec recognizer-tuple2712,123257
-(defconst *initial-recognizer-alist*2822,127951
-(defun most-recent-enabled-recog-tuple 2928,131698
-(defun type-set-recognizer 2940,132209
-(defun type-set-car 2973,133765
-(defun type-set-cdr 2977,133902
-(defun type-set-coerce 2988,134256
-(defun type-set-intern-in-package-of-symbol 3010,135128
-(defun type-set-length 3017,135414
-(defun type-set-cons 3028,135782
-(defconst *singleton-type-sets*3039,136135
-(defun type-set-equal 3042,136204
-(defun type-set-quote 3055,136737
-(defun type-set-char-code 3092,138039
-(defun fn-count-1 3102,138387
-(defmacro fn-count 3140,140215
-(defun term-order 3143,140273
-(defrec type-prescription3298,147920
-(defun find-runed-type-prescription 3341,149710
-(defconst *expandable-boot-strap-non-rec-fns*3352,150037
-(defun mv-atf 3410,152883
-(defun assume-true-false-error 3448,154460
-(defun non-cons-cdr 3457,154830
-(defconst *one-way-unify1-implicit-fns*3475,155630
-(defun one-way-unify1 3486,155794
-(defun one-way-unify1-lst 3719,167461
-(defun one-way-unify1-equal1 3736,168121
-(defun one-way-unify1-equal 3760,169273
-(defun one-way-unify 3768,169512
-(defun canonical-representative 3828,172431
-(defun subst-type-alist1-check 3874,174043
-(defun nil-fn 3885,174424
-(defconst *nil-fn-ts-entry*3893,174642
-(defun subst-type-alist1 3898,174772
-(defun subst-type-alist 3966,177969
-(defun infect-type-alist-entry 3981,178571
-(defun infect-new-type-alist-entries2 3989,178789
-(defun infect-new-type-alist-entries1 4008,179587
-(defun infect-new-type-alist-entries 4021,180131
-(defun extend-type-alist-simple 4040,181045
-(defun extend-type-alist1 4059,181825
-(defun extend-type-alist 4137,185090
-(defun zip-variable-type-alist 4188,187338
-(defun assoc-equiv 4202,187949
-(defun assoc-equiv+ 4221,188700
-(defun assoc-type-alist 4287,191679
-(defun look-in-type-alist 4304,192295
-(defun member-char-stringp 4309,192451
-(defun terminal-substringp1 4320,192836
-(defun terminal-substringp 4336,193472
-(defun evg-occur 4346,193898
-(defun occur 4415,196809
-(defun occur-lst 4427,197210
-(defun pseudo-variantp 4452,198053
-(defun pseudo-variantp-list 4487,199469
-(defun worse-than-builtin 4749,207467
-(defun worse-than-or-equal-builtin 4787,209210
-(defun basic-worse-than-lst1 4819,210512
-(defun basic-worse-than-lst2 4838,211361
-(defun basic-worse-than 4854,212033
-(defun some-subterm-worse-than-or-equal 4904,214302
-(defun some-subterm-worse-than-or-equal-lst 4924,215140
-(defun worse-than-lst 4935,215678
-(defattach (worse-than 4973,216897
-(defattach (worse-than-or-equal 4976,216959
-(defrec ancestor4981,217082
-(defmacro make-ancestor-binding-hyp 4995,217597
-(defmacro ancestor-binding-hyp-p 5002,217770
-(defmacro ancestor-binding-hyp/hyp 5006,217867
-(defmacro ancestor-binding-hyp/unify-subst 5009,217941
-(defun push-ancestor 5014,218081
-(defun ancestor-listp 5044,219448
-(defun earlier-ancestor-biggerp 5072,220535
-(defun equal-mod-commuting 5102,222021
-(defun ancestors-check1 5130,223016
-(defun ancestors-check-builtin 5271,230556
-(defproxy ancestors-check 5319,232590
-(defattach (ancestors-check 5321,232638
-(defun map-multiply-car 5386,235037
-(defun normalize-addend 5392,235284
-(defun insert-cdr-term-order 5416,236243
-(defun normalize-linear-sum-2 5425,236501
-(defun normalize-linear-sum-1 5437,236969
-(defun normalize-linear-sum 5487,239324
-(defun normalize-linear-sum-p1 5557,242134
-(defun normalize-linear-sum-p 5566,242526
-(defun type-set-finish-1 5594,243758
-(defun type-set-finish 5786,254215
-(defun search-type-alist-rec 5824,255889
-(defun free-varsp 5862,257639
-(defun free-varsp-lst 5867,257805
-(defun search-type-alist-with-rest 5874,257968
-(defun search-type-alist 5907,259517
-(defun term-and-typ-to-lookup 5956,261923
-(defun lookup-hyp 5977,262832
-(defun bind-free-vars-to-unbound-free-vars 5987,263222
-(defabbrev x-xrunep 6070,267627
-(defabbrev hyp-xrune 6074,267733
-(defabbrev hyp-xrune-rune 6078,267830
-(defabbrev conc-xrune 6083,267963
-(defabbrev conc-xrune-rune 6087,268058
-(defabbrev xrune-rune 6092,268192
-(defabbrev rune=6099,268355
-(defabbrev xrune=6103,268464
-(defun prettyify-xrune 6113,268825
-(defrec accp-info6123,269164
-(defrec accp-entry6156,270359
-(defun merge-accumulated-persistence-aux 6226,273765
-(defun merge-accumulated-persistence-rec 6249,274867
-(defun merge-accumulated-persistence 6258,275202
-(defun add-accumulated-persistence-s 6368,279607
-(defun add-accumulated-persistence-f 6395,280748
-(defun accumulated-persistence-make-failures 6425,282011
-(defun add-accumulated-persistence 6437,282560
-(defmacro accumulated-persistence 6461,283659
-(defmacro set-accumulated-persistence 6862,304577
-(defdoc accumulated-persistence-subtleties6865,304657
-(defun merge-car-> 6995,309798
-(defun merge-sort-car-> 7002,310023
-(defconst *accp-major-separator*7007,310188
-(defconst *accp-minor-separator*7010,310265
-(defun show-accumulated-persistence-phrase0 7013,310342
-(defun show-accumulated-persistence-phrase1 7041,311348
-(defun show-accumulated-persistence-remove-useless 7073,312710
-(defun show-accumulated-persistence-phrase-key 7083,313114
-(defun show-accumulated-persistence-phrase2-merge 7100,313827
-(defun show-accumulated-persistence-phrase2-not-merge 7130,315051
-(defun show-accumulated-persistence-phrase2 7139,315498
-(defun split-xrune-alist 7143,315711
-(defun sort-xrune-alist-by-rune1 7164,316730
-(defun sort-xrune-alist-by-rune 7197,318336
-(defun pop-accp-fn 7215,319172
-(defun pop-accp-fn-iterate 7272,321700
-(defun show-accumulated-persistence-phrase 7288,322374
-(defmacro show-accumulated-persistence 7360,325988
-(defun push-accp 7410,328392
-(defun pop-accp 7456,331054
-(defmacro with-accumulated-persistence 7473,331815
-(defun assume-true-false-<7523,334017
-(defun mv-atf-2 7729,342635
-(defun binding-hyp-p 7782,344760
-(defmacro adjust-ignore-for-atf 7830,347138
-(defun backchain-limit-reachedp1 7842,347537
-(defun backchain-limit-reachedp 7847,347704
-(defun new-backchain-limit 7858,348223
-(defproxy oncep-tp 7885,349162
-(defun oncep-tp-builtin 7887,349194
-(defattach (oncep-tp 7892,349310
-(defun type-set-rec 7897,349387
-(defun type-set-lst 8429,373922
-(defun type-set-relieve-hyps-free 8450,374947
-(defun type-set-relieve-hyps1 8493,377002
-(defun type-set-relieve-hyps 8649,382804
-(defun extend-type-alist-with-bindings 8920,395576
-(defun type-set-with-rule 8947,396757
-(defun type-set-with-rule1 9036,400812
-(defun type-set-with-rules 9073,402863
-(defun type-set-primitive 9126,405256
-(defun assume-true-false-if 9663,427822
-(defun assume-true-false-rec 9963,443098
-(defun assume-true-false1 11066,498228
-(defun proper/improper-cons-ts-tuple 11124,500807
-(defun extend-with-proper/improper-cons-ts-tuple11198,504314
-(defun type-set 11217,505133
-(defun assume-true-false 11372,512808
-(defun ok-to-force-ens 11379,513124
-(defun add-linear-assumption 11388,513481
-(defun return-type-alist11496,518354
-(defun type-alist-equality-loop1 11526,519511
-(defun clean-up-alist 11617,523567
-(defun duplicate-keysp 11630,524132
-(defun clean-type-alist 11643,524629
-(defun type-alist-equality-loop-exit 11660,525391
-(defconst *type-alist-equality-loop-max-depth* 11666,525613
-(defun type-alist-equality-loop 11668,525665
-(defun put-assoc-equal-ts 11699,527049
-(defun reconsider-type-alist 11711,527589
-(defun type-alist-clause-finish1 11773,530512
-(defun type-alist-clause-finish 11809,532253
-(defun type-alist-clause 11941,539350
-(defun known-whether-nil 12003,542946
-(defun ts-booleanp 12035,544632
-(defun weak-cons-occur 12046,545119
-(defun equal-x-cons-x-yp 12060,545577
-(defun not-ident 12135,548929
-(defun first-if 12170,550568
-(defun all-variablep 12184,551056
-(defun normalize-with-type-set 12189,551191
-(defun normalize 12221,552379
-(defun normalize-lst 12370,559473
-(defun normalize-or-distribute-first-if 12379,559937
-(defun distribute-first-if 12397,560743
-(defun decode-type-set1 12517,566224
-(defun decode-type-set 12527,566622
-(defmacro dts 12545,567342
-(defun ens 12562,567853
-(defmacro git 12565,567923
-
-linear-b.lisp,427
-(defun polys-from-type-set 36,1154
-(defun add-type-set-polys 133,5323
-(defun add-polynomial-inequalities 176,7396
-(defparameter *add-polys-counter*203,8547
-(defun add-polys 210,8702
-(defun eval-ground-subexpressions 231,9291
-(defun eval-ground-subexpressions-lst 326,12671
-(defun poly-set 341,13175
-(defun linearize1 423,17357
-(defun linearize 802,33926
-(defun linearize-lst1847,36093
-(defun linearize-lst877,37416
-
-non-linear.lisp,1066
-(defun cleanse-type-alist 29,1083
-(defun var-with-divisionp 56,1948
-(defun varify 87,3196
-(defun varify! 110,3790
-(defun varify!-lst1 119,4021
-(defun varify!-lst 124,4141
-(defun invert-var 131,4311
-(defun part-of1 172,6125
-(defun part-of 203,7114
-(defun product-already-triedp 220,7633
-(defun too-many-polysp 234,8146
-(defun expanded-new-vars-in-pot-lst2 252,8721
-(defun expanded-new-vars-in-pot-lst1 285,10134
-(defun expanded-new-vars-in-pot-lst 331,12494
-(defun extract-bounds 355,13495
-(defun good-bounds-in-pot 397,15667
-(defun inverse-polys 426,16721
-(defun add-inverse-polys 762,33525
-(defun add-polys-from-type-set 805,35285
-(defun length-of-shortest-polys-with-var 841,36731
-(defun shortest-polys-with-var1 861,37649
-(defun shortest-polys-with-var 873,38158
-(defun binary-*-leaves 905,39466
-(defun binary-*-tree 911,39624
-(defun merge-arith-term-order 929,40137
-(defun insert-arith-term-order 936,40398
-(defun sort-arith-term-order 945,40654
-(defun multiply-alist-and-const 952,40855
-(defun collect-rational-poly-p-lst 967,41543
-
-tau.lisp,11706
-(defun almost-lexorder-singletons 49,2456
-(defun member-nil-neg-evgs 57,2733
-(defun member-neg-evgs1 61,2844
-(defun member-neg-evgs 71,3173
-(defun insert-neg-evgs1 84,3633
-(defun insert-neg-evgs 96,4077
-(defun merge-car-< 106,4456
-(defun merge-sort-car-< 113,4681
-(defun merge-cadr-< 121,4921
-(defun merge-sort-cadr-< 128,5151
-(defun strip-caddrs 136,5398
-(defun unprettyify/add-hyps-to-pairs 148,5972
-(defun flatten-ands-in-lit 157,6311
-(defun unprettyify 170,6843
-(defun reprettyify 219,9041
-(defun remove-guard-holders1 274,11766
-(defun remove-guard-holders1-lst 319,13839
-(defun contains-guard-holdersp 329,14165
-(defun contains-guard-holdersp-lst 350,14873
-(defun remove-guard-holders 355,15051
-(defun remove-guard-holders-lst 364,15293
-(defun contains-guard-holdersp-lst-lst 372,15514
-(defun remove-guard-holders1-lst-lst 377,15703
-(defun remove-guard-holders-lst-lst 382,15890
-(defun convert-returned-vars-to-term-lst 397,16394
-(defun implicate 402,16601
-(defrec type-set-inverter-rule 414,16927
-(defconst *initial-type-set-inverter-rules*442,18350
-(defun convert-type-set-to-term-lst 665,28821
-(defun subst-var 705,30517
-(defun subst-var-lst 716,30916
-(defun convert-type-set-to-term 726,31224
-(defun convert-type-prescription-to-term 768,33175
-(defun all-runes-in-lmi 792,34361
-(defun all-runes-in-lmi-lst 807,34956
-(defun all-runes-in-var-to-runes-alist 812,35164
-(defun all-runes-in-var-to-runes-alist-lst 818,35363
-(defun all-runes-in-elim-sequence-lst 826,35595
-(defun all-runes-in-elim-sequence 832,35793
-(defun all-runes-in-ttree-fc-derivation-lst 847,36474
-(defun all-runes-in-ttree-find-equational-poly-lst 856,36823
-(defun all-runes-in-ttree 866,37240
-(defun all-runes-in-ttree-lst 993,41413
-(defdoc introduction-to-the-tau-system1000,41601
-(defdoc dealing-with-tau-problems1227,53081
-(defdoc future-work-related-to-the-tau-system1367,60209
-(defrec tau-interval 1836,83943
-(defconst *tau-empty-interval*2007,92105
-(defun tau-empty-intervalp 2020,92522
-(defun -number-v-rational 2171,98271
-(defun -rational-v-number 2197,99066
-(defun eval-tau-interval1 2223,99861
-(defun eval-tau-interval 2237,100443
-(defun decode-tau-interval 2252,101012
-(defrec tau2290,102854
-(defconst *tau-empty*2438,108644
-(defconst *nil-singleton-evg-list* 2457,109388
-(defconst *tau-t* 2459,109437
-(defconst *tau-nil* 2466,109665
-(defconst *tau-non-nil* 2473,109920
-(defconst *tau-contradiction* 2559,114571
-(defrec signature-rule 2594,116718
-(defrec big-switch-rule 2650,119886
-(defun tau-simple-implicants 2655,120108
-(defun tau-pair-member1 2667,120617
-(defun tau-pair-member 2674,120836
-(defun ev-fncall-w-tau-recog 2794,127433
-(defun bad-val-or-unknowns 2975,135309
-(defun exists-bad-valp 3002,136462
-(defun all-eval-valp 3028,137556
-(defun delete-bad-vals 3052,138461
-(defun delete-bad-vals1 3072,139199
-(defun tau-pairs-subsetp 3112,140793
-(defun tau-pairs-near-subsetp 3125,141267
-(defun tau-pairs-intersectionp 3152,142674
-(defun insert-tau-pair 3168,143248
-(defun interval-decider 3246,146126
-(defun signate 3270,147205
-(defun reduce-sign/recog 3355,150493
-(defun every-neg-evg-in-tau-p13816,169658
-(defun every-neg-evg-in-tau-p 3861,172167
-(defun lower-bound-<=4036,179664
-(defun upper-bound->=4051,180061
-(defun lower-bound-> 4063,180296
-(defun upper-bound-< 4075,180530
-(defun tau-subintervalp 4240,186639
-(defun tau-implies 4282,188810
-(defun empty-tau-intervalp 4328,190903
-(defun singleton-tau-intervalp 4337,191126
-(defun make-identity-interval 4354,191722
-(defun identity-intervalp 4385,193011
-(defun delete-consecutive-integers-upward 4466,196848
-(defun delete-consecutive-integers-downward 4498,198543
-(defun collect--x-k 4531,200113
-(defun collect--k-x 4567,202103
-(defun adjust-upper-bound-with-neg-evgs 4586,202830
-(defun adjust-lower-bound-with-neg-evgs 4617,204446
-(defun squeeze-k 4648,206058
-(defun set-tau-pos-evg 4696,207877
-(defun positive-lower-boundp 4730,209154
-(defun nonnegative-lower-boundp 4736,209269
-(defun negative-upper-boundp 4739,209329
-(defun tighten-bound 4745,209444
-(defun add-to-tau1 4906,217323
-(defun add-recogs-to-tau1 5303,234971
-(defun tau-interval-endpoint-to-sign-k-token 5327,236061
-(defun tau-union 5343,236682
-(defun all-integers-in-range-excludedp1 5419,240062
-(defun all-integers-in-range-excludedp 5444,241352
-(defun add-to-tau 5474,242665
-(defun pos-evg-near-subsetp 5686,252722
-(defun neg-evgs-near-subsetp5709,253656
-(defun tau-interval-endpoint-implication 6020,268358
-(defun tau-interval-near-subsetp 6148,272927
-(defun tau-near-subsetp 6329,282925
-(defun tau-put 6897,309166
-(defun tau-put* 7177,320239
-(defun tau-put*-tau 7250,323456
-(defun tau-put*-interval-endpoints 7312,325778
-(defun tau-put*-recogs 7356,327472
-(defconst *non-tau-monadic-boolean-functions*7445,332035
-(defun classicalp 7449,332135
-(defun classical-fn-list-p 7470,332919
-(defun monadic-boolean-fnp 7476,333097
-(defun putprop-if-different 7509,334203
-(defun tau-visit-function-introduction 7520,334568
-(defun tau-visit-function-introductions 7554,336129
-(defun putprop-tau-pair 7560,336339
-(defun initialize-tau-pred 7578,337131
-(defun initialize-tau-preds 7613,338904
-(defun tau-boolean-formp 7618,339087
-(defun tau-eval-formp 7633,339599
-(defun set-tau-runes 7644,340015
-(defun add-tau-boolean-rule 7665,340927
-(defun add-tau-eval-rule 7689,342069
-(defun tau-like-subject-criterion 7728,344017
-(defun tau-like-term 7744,344728
-(defun tau-like-term-listp 7842,348934
-(defun tau-conjunctive-formp 7867,350079
-(defun tau-simple-formp 7900,351389
-(defun add-tau-simple-rule 7909,351734
-(defun convert-tau-like-terms-to-tau 7938,353302
-(defun add-tau-conjunctive-rule 7960,354132
-(defun partition-signature-hyps-into-tau-alist-and-others8047,358025
-(defun tau-boolean-signature-formp 8090,360210
-(defun tau-signature-formp 8128,361646
-(defun replace-vars-by-bindings 8234,365936
-(defun add-tau-signature-rule 8244,366312
-(defun switch-varp 8345,370948
-(defun tau-big-switch-equationp 8360,371404
-(defun tau-big-switch-var 8397,372704
-(defun tau-big-switch-formp 8418,373515
-(defun add-tau-big-switch-rule 8422,373628
-(defun tau-mv-nth-synonym-formp 8444,374510
-(defun add-tau-mv-nth-synonym-rule 8459,374954
-(defrec bounder-correctness8475,375563
-(defun all-cars-nil 8522,377722
-(defun find-subject-bounder-link-term 8527,377864
-(defun tau-bounder-doms-extraction 8547,378864
-(defun tau-bounder-hyp-extraction8573,379916
-(defconst *all-interval-domains*8650,382871
-(defun acceptable-domains-for-bounder8653,382947
-(defun bounder-args 8668,383569
-(defun tau-bounder-formp 8674,383781
-(defun pairwise-subsetp-eq 8892,394674
-(defun bounder-subsumedp 8898,394889
-(defun bounder-subsumedp-by-some 8918,395933
-(defun delete-some-subsumed-bounders 8923,396121
-(defun add-bounder-to-bounders 8931,396420
-(defun add-tau-bounder-rule 8935,396593
-(defun strip-force-and-case-split 8979,398503
-(defun strip-force-and-case-split-in-hyps-of-pairs 8988,398834
-(defun acceptable-tau-rulep 9054,402236
-(defun acceptable-tau-rulesp 9070,402864
-(defun acceptable-tau-rules 9084,403392
-(defun cross-prod1 9094,403767
-(defun cross-prod 9099,403909
-(defun cnf-dnf 9104,404067
-(defun split-on-conjoined-disjunctions 9177,407086
-(defun split-on-conjoined-disjunctions-in-hyps-of-pairs 9193,407636
-(defun chk-acceptable-tau-rule 9210,408517
-(defun add-tau-rule1 9270,411486
-(defun add-tau-rule 9343,415095
-(defun discover-tau-pred 9406,418329
-(defun discover-tau-preds 9436,419792
-(defun tau-rules-from-type-prescriptions 9441,419979
-(defun original-def-body1 9509,423147
-(defun original-def-body 9515,423369
-(defun tau-like-propositionp 9522,423599
-(defun expand-tau-like-proposition 9559,425305
-(defun add-only-simple-and-conjunctive-tau-rules 9607,427634
-(defun convert-normalized-term-to-pairs 9631,428396
-(defun complementaryp 9708,431055
-(defun subsumes-but-for-one-negation 9736,432272
-(defun remove-ancestor-literals-from-pairs1 9982,444524
-(defun remove-ancestor-literals-from-pairs 10010,445658
-(defun convert-term-to-pairs 10025,446223
-(defun tau-subrs 10087,448799
-(defun tau-visit-defuns1 10130,450539
-(defun tau-visit-defuns 10181,452571
-(defun tau-visit-defun 10210,453885
-(defun corollaries-and-runes-of-enabled-rules10265,457148
-(defun tau-visit-defthm1 10297,458613
-(defun tau-visit-defthm 10321,459664
-(defun tau-visit-event 10339,460453
-(defun apply-conjunctive-tau-rule 10400,463257
-(defun apply-conjunctive-tau-rules2 10429,464572
-(defun apply-conjunctive-tau-rules1 10460,465782
-(defun apply-conjunctive-tau-rules 10511,468534
-(defun add-to-tau! 10529,469247
-(defun all-tau-emptyp 10562,470881
-(defun all-unrestricted-signature-rulesp 10567,471026
-(defun disjoin-intervals 10615,473570
-(defun conjoin-intervals 10715,478358
-(defun combine-pos/neg-pairs-from-tau1 10840,483426
-(defun augment-pos/neg-pairs-with-implicit-numeric-recogs10929,487352
-(defun combine-pos/neg-pairs-from-tau 10958,488544
-(defun combine-tau 10982,489523
-(defun push-mv-nth-down 11103,495781
-(defun tau-expand-big-switch 11124,496513
-(defun deconstruct-conjunction 11179,498945
-(defun ok-to-fire-signature-rulep1 11209,499912
-(defun smart-member-equal-+- 11237,501441
-(defmacro recursivep 11281,503511
-(defun find-first-acceptable-domain 11290,503742
-(defun tau-lst-with-acceptable-domainsp 11322,505725
-(defun collect-bounder-args 11358,507575
-(defun bounding-interval 11390,509344
-(defun conjoin-bounding-intervals 11416,510374
-(defun apply-tau-bounders 11429,510879
-(defun tau-interval-equal-decider 11478,512976
-(defun tau-interval-<-decider 11530,515104
-(defun tau-term 11572,516720
-(defun tau-term-lst 11966,535030
-(defun tau-rewrite 12000,536546
-(defun relieve-dependent-hyps 12057,538879
-(defun ok-to-fire-signature-rulep 12098,541033
-(defun apply-signature-tau-rule 12115,541776
-(defun apply-signature-tau-rules1 12136,542805
-(defun apply-signature-tau-rules 12171,544496
-(defun tau-assume-basic 12192,545688
-(defun tau-assume 12236,547647
-(defun annotate-clause-with-key-numbers 12569,565761
-(defun tau-clause1p 12593,566675
-(defun tau-get-all-preds 12642,568807
-(defun tau-get-stats-new-max-block 12648,569039
-(defun tau-size 12667,569648
-(defun tau-get-stats-on-implicant-sizes 12673,569838
-(defun decode-recog 12696,570832
-(defun decode-recog-lst 12710,571285
-(defun decode-tau1 12715,571454
-(defun decode-tau 12732,572154
-(defun decode-tau-conjunctive-rule 12796,574367
-(defun decode-tau-conjunctive-rules 12815,575169
-(defun decode-tau-lst 12820,575356
-(defun decode-tau-alist 12827,575644
-(defun decode-tau-signature-rule 12835,575985
-(defun decode-tau-signature-rules1 12873,577580
-(defun decode-tau-signature-rules2 12878,577811
-(defun decode-tau-signature-rules 12885,578144
-(defun tau-get-all-sig-fns 12903,578988
-(defun some-slot-has-multiple-tau-sigs 12911,579385
-(defun count-tau-sigs-by-slot 12916,579559
-(defun collect-rules-with-dependent-hyps 12921,579721
-(defun collect-rules-with-dependent-hyps-across-mv 12930,580084
-(defun tau-get-stats-on-signatures1 12936,580363
-(defun tau-get-stats-on-signatures 12979,582194
-(defun collect-tau-big-switches 13010,584006
-(defun tau-sum-lst 13017,584296
-(defun tau-get-stats 13023,584530
-(defmacro tau-status 13074,586737
-(defun tau-data-fn 13143,589253
-(defmacro tau-data 13184,590940
-(defun all-fnnames-world1 13223,592268
-(defun all-fnnames-world 13240,593012
-(defun tau-data-fns 13251,593350
-(defun tau-database 13260,593668
-(defun initialize-tau-globals 13317,596260
-(defun collect-tau-relevant-triples 13344,597031
-(deflabel bounders13359,597803
-
-rewrite.lisp,18562
-(defrec congruence-rule 268,13538
-(defconst *geneqv-iff*427,21586
-(defun refinementp 445,22361
-(defun geneqv-refinementp1 506,24900
-(defun geneqv-refinementp 518,25339
-(defun some-congruence-rule-disabledp 572,28274
-(defun filter-geneqv1 578,28503
-(defun filter-geneqv 584,28752
-(defun some-geneqv-disabledp 598,29232
-(defun filter-geneqv-lst1 603,29408
-(defun filter-geneqv-lst 608,29573
-(defun refinementp1 627,30350
-(defun pair-congruence-rules-with-coarsenings 640,30844
-(defun add-to-cr-and-coarsenings652,31324
-(defun union-geneqv1 702,33574
-(defun union-geneqv 729,35029
-(defun pairwise-union-geneqv 749,35845
-(defun geneqv-lst1 766,36572
-(defun geneqv-lst 872,41694
-(defun subst-expr1 983,46700
-(defun subst-expr1-lst 993,47082
-(defun subst-expr-error 1003,47414
-(defun subst-expr 1010,47661
-(defun scons-term 1088,51739
-(defun subst-equiv-expr1 1154,54301
-(defun subst-equiv-expr1-lst 1209,57055
-(defun subst-equiv-expr 1232,57980
-(defun ffnnamesp 1245,58415
-(defun ffnnamesp-lst 1260,58967
-(defun collect-ffnnames 1270,59115
-(defun collect-ffnnames-lst 1293,59983
-(defun comm-equal 1300,60168
-(defun member-term2 1314,60559
-(defun member-complement-term2 1328,61026
-(defun member-complement-term1 1337,61348
-(defun member-term 1352,61794
-(defun member-complement-term 1367,62342
-(defun instr-listp 1385,62982
-(defun spliced-instr-listp 1404,63805
-(defun next-tag 1422,64539
-(defun if-compile-formal 1430,64752
-(defun ffnnamep-hide 1445,65404
-(defun ffnnamep-hide-lst 1464,66144
-(defun if-compile 1476,66432
-(defun if-compile-lst 1575,71201
-(defun if-interp-assume-true 1630,74357
-(defun if-interp-switch 1650,75178
-(defun if-interp-assumed-value0 1663,75677
-(defun if-interp-assumed-value1 1674,76072
-(defun if-interp-assumed-value2-equal-constant 1686,76566
-(defun if-interp-assumed-value2 1736,79074
-(defun if-interp-assumed-value3 1774,80880
-(defun if-interp-assumed-value4 1791,81638
-(defun if-interp-assumed-value-x 1808,82429
-(defun if-interp-assumed-value 1841,83935
-(defun convert-assumptions-to-clause-segment 1859,84703
-(defun convert-clause-to-assumptions 1982,90789
-(defun simplifiable-mv-nth1 2004,91896
-(defun simplifiable-mv-nth 2033,93136
-(defun simplifiable-mv-nthp 2060,94315
-(defun call-stack 2069,94532
-(defun ret-stack 2192,99758
-(defun extra-info-lit-p 2196,99863
-(defun subsetp-equal-mod-extra-info-lits 2204,100096
-(defun quick-and-dirty-subsumption-replacement-step1 2213,100411
-(defun quick-and-dirty-subsumption-replacement-step 2234,101271
-(defstub quick-and-dirty-srs 2414,109310
-(defun quick-and-dirty-srs-builtin 2416,109352
-(defattach quick-and-dirty-srs 2421,109471
-(defun if-interp-add-clause 2423,109532
-(defun if-interp 2442,110294
-(defun splice-instrs1 2581,117884
-(defun splice-instrs 2611,118975
-(defun strip-branches 2615,119089
-(defun merge-length 2643,120206
-(defun merge-sort-length 2652,120546
-(defun member-equal-+- 2658,120763
-(defun arg1-almost-subsumes-arg2 2672,121364
-(defun find-subsumer-replacement 2721,123604
-(defun remove-one-complement 2740,124585
-(defun weak-disc-tree 2747,124869
-(defun sweep-clauses1 2757,125233
-(defun sweep-clauses 2763,125457
-(defun filter-with-and-without 2767,125564
-(defun disc-tree 2785,126359
-(defun find-clauses1 2809,127536
-(defun find-clauses 2829,128472
-(defun remove-one-+- 2832,128542
-(defun store-clause1 2838,128729
-(defun store-clause 2876,130226
-(defun substitute1-ac 2895,130816
-(defun substitute1 2910,131323
-(defun replace-clause1 2915,131496
-(defun replace-clause 2941,132516
-(defun extra-info-lits 2946,132722
-(defun rev-union-equal 2952,132918
-(defun merge-extra-info-lits 2961,133200
-(defun subsumption-replacement-loop 2969,133459
-(defun clausify 3022,135778
-(defun find-rewriting-equivalence 3063,137666
-(defun obj-table 3133,141473
-(defun rewrite-solidify-rec 3178,143230
-(defconst *rewrite-equiv-solidify-iteration-bound*3309,148635
-(defun rewrite-solidify 3316,148835
-(defun rewrite-if11 3366,150703
-(defun rewrite-if13377,151099
-(defun equal-mod-alist 3424,153029
-(defun equal-mod-alist-lst 3458,154399
-(defun member-equal-mod-alist 3465,154634
-(defun not-to-be-rewrittenp1 3471,154857
-(defun not-to-be-rewrittenp 3483,155202
-(defun rewrite-recognizer 3499,155917
-(defun remove-invisible-fncalls 3558,158476
-(defun term-order+ 3572,158902
-(defun invisible-fns 3709,164344
-(defun loop-stopperp-rec 3742,165544
-(defun loop-stopperp 3760,166133
-(defrec rewrite-rule 3764,166257
-(defun relevant-ground-lemmas 3820,169167
-(defun search-ground-units13830,169500
-(defun search-ground-units3891,172441
-(defun if-tautologyp 3905,173014
-(defun expand-some-non-rec-fns 3938,174537
-(defun expand-some-non-rec-fns-lst 3952,175126
-(defun tautologyp 3959,175337
-(defun make-true-list-cons-nest 4003,177350
-(defun being-openedp-rec 4014,177803
-(defmacro being-openedp 4036,178917
-(defun recursive-fn-on-fnstackp 4056,179899
-(defun fnstack-term-member 4069,180361
-(defun var-counts1 4318,192225
-(defun var-counts1-lst 4336,192731
-(defun var-counts 4345,193028
-(defun count-ifs 4399,196081
-(defun count-ifs-lst 4411,196458
-(defun too-many-ifs0 4441,197537
-(defproxy too-many-ifs-pre-rewrite 4471,198775
-(defun too-many-ifs-pre-rewrite-builtin 4473,198823
-(defattach (too-many-ifs-pre-rewrite 4489,199501
-(defun occur-cnt-bounded 4519,200323
-(defun occur-cnt-bounded-lst 4547,201432
-(defun too-many-ifs1 4566,202210
-(defproxy too-many-ifs-post-rewrite 4592,203191
-(defun too-many-ifs-post-rewrite-builtin 4594,203240
-(defattach (too-many-ifs-post-rewrite 4608,203808
-(defun all-args-occur-in-top-clausep 4611,203900
-(defun cons-count-bounded-ac 4616,204109
-(defun cons-count-bounded 4633,204793
-(defun max-form-count 4639,204901
-(defun max-form-count-lst 4715,208411
-(defun controller-complexity1 4726,208737
-(defun controller-complexity 4749,209681
-(defun controller-pocket-simplerp 4762,210257
-(defun constant-controller-pocketp1 4780,210981
-(defun constant-controller-pocketp 4789,211381
-(defun some-controller-pocket-constant-and-non-controller-simplerp4800,211840
-(defun rewrite-fncallp 4816,212551
-(defun rewrite-fncallp-listp 4882,215529
-(defun contains-rewriteable-callp4900,216199
-(defun contains-rewriteable-callp-lst4930,217518
-(defrec linear-lemma 4943,217969
-(defrec current-literal 4955,218265
-(defrec rewrite-constant4957,218309
-(defconst *default-rw-cache-state*5084,224277
-(defconst *empty-rewrite-constant*5087,224322
-(defrec metafunction-context5110,225020
-(defun ok-to-force 5125,225652
-(defun plist-to-alist 5214,229703
-(defmacro adjust-rdepth 5223,229985
-(defun add-rewrite-args 5232,230204
-(defrec step-limit-record5252,231026
-(defun step-limit-start 5267,231649
-(defun step-limit-strictp 5276,231943
-(defun initial-step-limit 5288,232362
-(defun step-limit-error1 5317,233795
-(defmacro step-limit-error 5329,234170
-(defmacro decrement-step-limit 5351,234913
-(defmacro rewrite-entry 5373,235632
-(deflabel free-variables5452,239288
-(deflabel free-variables-type-prescription5658,249881
-(deflabel free-variables-examples5753,253104
-(deflabel free-variables-examples-rewrite5767,253673
-(deflabel free-variables-examples-forward-chaining6320,272877
-(defconst *fake-rune-for-linear*6519,279921
-(defrec gframe 6526,280108
-(defparameter *deep-gstack* 6566,281840
-(defmacro push-gframe 6568,281874
-(defparameter *saved-deep-gstack* 6607,283469
-(defmacro initial-gstack 6609,283509
-(defun tilde-@-bkptr-phrase 6624,284076
-(defun cw-gframe 6672,286557
-(defun cw-gstack1 6744,289545
-(defun cw-gstack-fn 6751,289855
-(defmacro cw-gstack 6813,292711
-(defun restore-brr-globals1 6975,301974
-(defun restore-brr-globals 6984,302292
-(defun save-brr-globals 7012,303400
-(defun get-brr-global 7036,304348
-(defun exit-brr-wormhole 7073,306213
-(defmacro brr-wormhole 7082,306538
-(defun initialize-brr-stack 7134,308866
-(defun lookup-brr-stack 7153,309604
-(defun clean-brr-stack1 7165,310126
-(defun clean-brr-stack 7171,310298
-(defun get-brr-local 7219,312886
-(defun put-brr-local1 7232,313511
-(defun put-brr-local 7243,313993
-(defun put-brr-local-lst 7258,314669
-(defun some-cdr-equalp 7263,314867
-(defun push-brr-stack-frame 7271,315087
-(defun pop-brr-stack-frame 7302,316502
-(defun decode-type-alist 7313,316953
-(defun translate-break-condition 7324,317387
-(defun eval-break-condition 7340,318005
-(defconst *default-free-vars-display-limit* 7357,318631
-(defmacro set-free-vars-display-limit 7359,318680
-(defun free-vars-display-limit 7369,319112
-(defun limit-failure-reason 7379,319432
-(defun limit-failure-reason-alist 7401,320466
-(defun fix-free-failure-reason 7426,321692
-(defun fix-free-failure-reason-alist 7439,322044
-(defun tilde-@-failure-reason-free-phrase 7454,322446
-(defun tilde-@-failure-reason-phrase1 7491,324189
-(defun tilde-@-failure-reason-phrase 7616,330669
-(defun stuff-standard-oi 7630,331407
-(deflabel break-rewrite7655,332660
-(deflabel break-lemma7908,346174
-(deflabel brr-commands7989,349827
-(defdoc dmr8035,351925
-(defun raw-mode-p 8196,360225
-(defun defun-mode-prompt-string 8199,360293
-(defun brr-prompt 8220,360807
-(defun ts< 8234,361290
-(defun add-to-type-alist-segments 8260,361742
-(defun merge-term-order 8273,362080
-(defun merge-sort-term-order 8280,362317
-(defun sort-type-alist-segments 8285,362507
-(defun type-alist-segments 8297,362920
-(defun print-terms 8306,363244
-(defun print-type-alist-segments 8321,363702
-(defun print-type-alist 8339,364442
-(defun tilde-*-ancestors-stack-msg1 8344,364599
-(defun tilde-*-ancestors-stack-msg 8368,365808
-(defun brkpt1 8372,365973
-(defun brkpt2 8608,375117
-(defrec expand-hint8876,385941
-(defun binds-to-constants-p 8893,386315
-(defun expand-permission-result1 8900,386588
-(defun remove1-by-position 8975,390479
-(defun expand-permission-result 8985,390875
-(defun expand-permission-p 9062,393954
-(defun one-way-unify-restrictions1 9074,394491
-(defun one-way-unify-restrictions 9084,394854
-(defun ev-fncall! 9090,395036
-(defun ev-fncall-meta 9134,396945
-(defun get-evg 9168,398578
-(defun ev-synp 9180,398885
-(defun bad-synp-alist1 9212,400366
-(defun bad-synp-alist 9242,401653
-(defun evgs-or-t 9263,402523
-(deflabel nu-rewriter9625,420475
-(defparameter *nth-update-tracingp* 9736,425275
-(defparameter *lambda-abstractp* 9739,425354
-(defparameter *nu-memos* 9742,425428
-(defparameter *nu-memos-ens* 9745,425515
-(defparameter *nu-memos-wrld* 9748,425587
-(defparameter *ring-buffer-size* 9751,425660
-(defun-one-output initialize-nu-memos 9765,426299
-(defun-one-output clear-nu-memos1 9776,426662
-(defun-one-output clear-nu-memos 9795,427444
-(defmacro this-item 9814,428256
-(defmacro next-ptr 9815,428291
-(defmacro prev-ptr 9816,428326
-(defun-one-output link-em 9827,428632
-(defun-one-output destructive-get-memo1 9832,428751
-(defun-one-output destructive-get-memo 9880,430205
-(defun get-memo 9894,430753
-(defun-one-output destructive-retire-memo 9949,432683
-(defun-one-output destructive-insert-memo 9961,433120
-(defun-one-output nu-memo-stats1 9980,433751
-(defun-one-output nu-memo-stats 9997,434429
-(defun memo-key1 10011,434828
-(defun bounded-length 10042,436079
-(defun memo-key 10053,436304
-(defun mk 10077,437169
-(defun show-rbuff1 10085,437370
-(defun show-rbuff 10088,437467
-(defun memo-exit 10103,438237
-(defun nfix-quote 10149,439941
-(defun bound-in-framep 10170,440581
-(defun non-rec-defun1 10179,440864
-(defun non-rec-defun 10225,443165
-(defun deref-var 10286,445793
-(defun deref 10299,446260
-(defun equal-derefs 10368,448513
-(defun filter-args 10383,448952
-(defun foccurrences 10391,449222
-(defun foccurrences-lst 10420,450196
-(defun every-var-at-most-oncep 10427,450427
-(defun every-actual-simple 10437,450734
-(defun make-clean-lambda-application 10444,450925
-(defun lambda-stack 10497,453283
-(defun shorten-each-stack-to-len 10524,454422
-(defun all-equal-stacks 10535,454855
-(defun non-quoted-stack 10544,455239
-(defun cdr-all 10550,455418
-(defun len-common-tail 10554,455514
-(defun butlast-all-stacks 10559,455683
-(defun min-stack-len 10566,455936
-(defun reconcile-stacks 10576,456266
-(defun reconcile-terms 10625,458208
-(defun all-equal 10631,458382
-(defun recon 10636,458511
-(defun with-reconciliation-let-bindings 10659,459500
-(defmacro with-reconciliation 10665,459759
-(defun lambda-stack-one-way-unify1 10698,460737
-(defun lambda-stack-one-way-unify1-lst 10747,462586
-(defun lambda-stack-one-way-unify 10767,463410
-(defun apply-abbrevs-to-lambda-stack1 10796,464410
-(defun apply-abbrevs-to-lambda-stack 10839,466493
-(defconst *fake-rune-for-nu-rewriter*10936,470173
-(defun nth-update-rewriter1-continue10943,470320
-(defun nth-update-rewriter111001,472403
-(defun nth-update-rewriter1-lst 11548,495584
-(defun nth-update-rewriter-targetp 11571,496590
-(defun nth-update-rewriter-target-lstp 11585,497201
-(defun make-stack-from-alist 11594,497446
-(defun nth-update-rewriter 11617,498342
-(defun collect-by-position 11733,503151
-(defun make-lambda-application 11751,503854
-(defun lambda-nest-hidep 11786,505070
-(defun lambda-nest-unhide 11802,505525
-(defun search-type-alist+ 11813,505817
-(defun oncep 11833,506652
-(defabbrev memo-activep 11847,507274
-(defabbrev activate-memo 11850,507344
-(defmacro zero-depthp 11853,507409
-(defmacro rdepth-error 11870,508078
-(defun bad-synp-hyp-msg1 11902,509782
-(defun bad-synp-hyp-msg 12056,518557
-(defmacro sl-let 12083,519844
-(defmacro sl-let@par 12094,520097
-(defmacro rewrite-entry-extending-failure 12106,520465
-(defun set-difference-assoc-eq 12121,521324
-(defun relieve-hyp-synp 12131,521759
-(defun push-lemma? 12242,526724
-(defmacro push-lemma+ 12247,526810
-(defmacro push-splitter? 12262,527379
-(defmacro prepend-step-limit 12280,528101
-(defrec rw-cache-entry12291,528449
-(defmacro free-failure-p 12353,531106
-(defabbrev combine-free-failure-reasons 12356,531170
-(defun combine-free-failure-alists 12369,531611
-(defun combine-sorted-rw-cache-lists1 12410,533080
-(defun split-psorted-list1 12463,535443
-(defun split-psorted-list 12471,535704
-(defun merge-lexorder-fast 12484,536202
-(defun merge-sort-lexorder-fast 12501,536860
-(defun sort-rw-cache-list 12541,538509
-(defun combine-rw-cache-lists 12559,539113
-(defun merge-rw-caches 12583,540077
-(defmacro sorted-rw-cache-p 12615,541597
-(defun merge-symbol-alistp 12621,541728
-(defun merge-sort-symbol-alistp 12631,542013
-(defun cdr-sort-rw-cache 12643,542482
-(defun combine-rw-caches 12658,542953
-(defun unify-subst-subsetp 12676,543668
-(defun rw-cache-list-lookup 12688,544056
-(defstub relieve-hyp-failure-entry-skip-p12717,545360
-(defun relieve-hyp-failure-entry-skip-p-builtin 12721,545451
-(defattach (relieve-hyp-failure-entry-skip-p12727,545703
-(defmacro rw-cache-active-p 12730,545804
-(defun assoc-rw-cache 12734,545931
-(defun put-assoc-rw-cache1 12742,546159
-(defun put-assoc-rw-cache 12754,546653
-(defun relieve-hyp-failure-entry 12763,546931
-(defun maybe-extend-tag-tree 12788,547963
-(defun accumulate-rw-cache1 12795,548140
-(defun accumulate-rw-cache 12842,550104
-(defun accumulate-rw-cache? 12861,551024
-(defun dumb-occur-var 12877,551709
-(defun dumb-occur-var-lst 12887,552038
-(defun restrict-alist-to-all-vars1 12893,552202
-(defun all-vars-boundp 12911,552947
-(defun all-vars-lst-boundp 12919,553229
-(defun restrict-alist-to-all-vars 12928,553512
-(defun push-rw-cache-entry 12951,554509
-(defstub rw-cache-debug12973,555267
-(defstub rw-cache-debug-action12977,555363
-(defun rw-cache-debug-builtin 12981,555466
-(defun rw-cache-debug-action-builtin 12987,555691
-(defun rw-cacheable-failure-reason-builtin 13005,556322
-(defattach (rw-cacheable-failure-reason 13015,556760
-(defun rw-cacheable-nil-tag 13018,556856
-(defun note-relieve-hyp-failure 13039,557730
-(defun replace-free-rw-cache-entry1 13089,560185
-(defun replace-free-rw-cache-entry 13110,561189
-(defun rw-cache-alist-nil-tag-p 13129,561859
-(defabbrev merge-free-failure-reasons-nil-tag 13143,562474
-(defun merge-free-failure-alists-nil-tag 13156,563054
-(defun note-rw-cache-free-nil-tag 13202,564836
-(defun note-relieve-hyps-failure-free 13253,566964
-(defun rw-cache-enter-context 13290,568365
-(defun erase-rw-cache 13298,568640
-(defun rw-cache-exit-context 13307,568864
-(defun restore-rw-cache-any-tag 13335,570123
-(defun cons-tag-trees-rw-cache 13358,571311
-(defun normalize-rw-any-cache 13429,574131
-(defun cons-tag-trees-rw-cache-first 13441,574527
-(defun alist-keys-subsetp 13455,574959
-(defmacro tag-tree-tags-subsetp 13461,575113
-(defun rw-cache 13467,575226
-(defun rw-cached-failure-pair 13482,575685
-(defun extend-rw-cache-alist-free 13503,576655
-(defun rw-cache-add-failure-reason 13523,577672
-(defun rewrite 13548,578695
-(defun rewrite-solidify-plus 14220,609692
-(defun rewrite-if 14279,612457
-(defun rewrite-args 14430,620450
-(defun rewrite-primitive 14458,621507
-(defun rewrite-equal 14496,623022
-(defun relieve-hyp14799,637026
-(defun relieve-hyps1 15168,656190
-(defun relieve-hyps1-free-115310,663142
-(defun relieve-hyps1-free-215429,668677
-(defun relieve-hyps 15618,676778
-(defun rewrite-with-lemma 15753,683077
-(defun rewrite-with-lemmas1 16100,700519
-(defun rewrite-fncall 16144,702466
-(defun rewrite-with-lemmas 16530,722882
-(defun rewrite-linear-term 16671,729699
-(defun rewrite-linear-term-lst 16760,733714
-(defun add-linear-lemma 16813,736085
-(defun add-linear-lemmas 17051,747203
-(defun multiply-alists2 17104,749416
-(defun multiply-alists1 17163,752065
-(defun multiply-alists 17210,753790
-(defun multiply-polys1 17266,755777
-(defun multiply-polys 17438,763391
-(defun multiply-pots2 17500,765991
-(defun multiply-pots1 17561,768114
-(defun multiply-pots-super-filter 17610,769790
-(defun multiply-pots-filter 17666,771965
-(defun multiply-pots 17720,774194
-(defun add-multiplied-polys-filter 17773,776142
-(defun add-multiplied-polys 17853,779742
-(defun deal-with-product1 17937,783251
-(defun deal-with-product 18056,788937
-(defun deal-with-factor 18102,790831
-(defun deal-with-division 18190,794937
-(defun non-linear-arithmetic1 18307,800068
-(defun non-linear-arithmetic 18400,804414
-(defun add-polys-and-lemmas2-nl 18689,815996
-(defun add-polys-and-lemmas1-nl 18782,820206
-(defun add-polys-and-lemmas1 18906,825449
-(defun add-polys-and-lemmas 18972,828161
-(defun add-disjunct-polys-and-lemmas 19069,832235
-(defun add-disjuncts-polys-and-lemmas 19183,837367
-(defun add-terms-and-lemmas 19355,845467
-(defun rewrite-with-linear 19450,849823
-
-simplify.lisp,9746
-(defun negate-lit 65,2819
-(defun pegate-lit 86,3645
-(defun add-literal 107,4440
-(defun add-each-literal 144,5860
-(defun subsumes-rec 206,8828
-(defun subsumes1-equality-with-const 252,11316
-(defun subsumes1 301,14150
-(defun subsumes!-rec 336,15656
-(defun subsumes!1-equality-with-const 363,16943
-(defun subsumes!1 399,18696
-(defconst *init-subsumes-count*419,19397
-(defun subsumes 439,20215
-(defun some-member-subsumes 462,21200
-(defun conjoin-clause-to-clause-set 475,21722
-(defun add-each-literal-lst 494,22646
-(defun conjoin-clause-sets 500,22849
-(defun some-element-member-complement-term 506,23055
-(defun disjoin-clauses1 514,23376
-(defun disjoin-clauses 530,24029
-(defun disjoin-clause-segment-to-clause-set 548,24640
-(defun split-on-assumptions 567,25558
-(defun rewrite-clause-action 581,26033
-(defrec forward-chaining-rule717,33879
-(defrec fc-activation727,34373
-(defun suspend-fc-activation 840,40932
-(defun prettyify-fc-activation 901,43353
-(defun prettyify-fc-activations 976,46700
-(defun make-fc-activation 981,46897
-(defun make-fc-activations 1029,49411
-(defun collect-terms-and-activations 1039,49820
-(defun collect-terms-and-activations-lst1092,52378
-(defun collect-terms-and-activations-from-fcd-lst 1105,52966
-(defun sublis-varp 1137,54353
-(defun sublis-var-lstp 1146,54638
-(defun mult-search-type-alist 1155,54885
-(defun mult-lookup-hyp 1226,58673
-(defun ev-respecting-ens 1245,59482
-(defun ev-lst-respecting-ens 1302,62400
-(defun add-fc-derivations 1401,67961
-(defun prettyify-fc-derivation 1438,69596
-(defun prettyify-fc-derivations 1499,72210
-(defun expunge-fc-derivations-lst 1507,72441
-(defun expunge-fc-derivations 1517,72952
-(defun current-fc-call-number 1707,82792
-(defun current-fc-call-alist 1711,82911
-(defun put-current-fc-call-alist 1715,83029
-(defun initialize-fc-wormhole-sites 1733,83866
-(deflabel forward-chaining-reports1748,84317
-(defun show-fc-criteria 2034,97548
-(defun reset-fc-reporting 2057,98085
-(defun translate-fc-criterion 2088,98952
-(defun translate-fc-criteria 2119,100167
-(defun set-fc-criteria-fn 2136,100902
-(defmacro set-fc-criteria 2160,101707
-(defun set-fc-report-on-the-fly 2232,104949
-(defun new-fc-call 2290,107213
-(defun member-one-way-unify1 2336,109245
-(defun satisfying-fc-activation1p 2350,109693
-(defun satisfying-fc-activationp 2369,110392
-(defun collect-satisfying-fc-activations 2374,110600
-(defun satisfying-virtual-fc-activation1p 2392,111530
-(defun satisfying-virtual-fc-activationp 2418,112618
-(defun satisfying-fc-derivation1p 2430,113223
-(defun satisfying-fc-derivationp 2444,113701
-(defun collect-satisfying-fc-derivations 2449,113909
-(defun filter-satisfying-virtual-fc-activation 2464,114566
-(defun filter-all-satisfying-fc-derivations 2517,117086
-(defun filter-satisfying-fc-activations 2562,119083
-(defun filter-redundant-approved-fc-derivation 2596,120409
-(defun collect-rune-trigger-pairs-from-fc-activations 2696,124749
-(defun collect-rune-trigger-pairs-from-fc-derivations 2706,125248
-(defun prettyify-subst 2717,125751
-(defun collect-fc-status-site-1 2724,126024
-(defun collect-fc-status-sites-2-3-5 2750,127282
-(defun prettyify-blocked-fc-inst-hyp 2784,128971
-(defun collect-fc-status-site-4 2803,129775
-(defun collect-fc-status 2831,131067
-(defun make-fc-activity-report1 2843,131585
-(defun make-fc-activity-report 2855,132166
-(defun fc-report1 2881,133210
-(defun fc-report 2920,134589
-(defun fc-exit 2954,135612
-(defun advance-fc-activation13072,141659
-(defun advance-fc-activation23230,148410
-(defun advance-fc-activation33462,158532
-(defun advance-fc-activation 3486,159501
-(defun advance-fc-activations 3511,160540
-(defun fc-pair-lst 3532,161578
-(defun fc-pair-lst-type-alist 3554,162602
-(defmacro fcd-runep 3676,168253
-(defun fcd-runep-lst 3687,168794
-(defmacro fcd-worse-than-or-equal 3693,169041
-(defun fcd-worse-than-or-equal-lst 3705,169640
-(defun exists-fcd-worse-than-or-equal 3741,171456
-(defun all-dumb-occur-lst 3757,172181
-(defun all-args-occur-after-strip-not 3762,172344
-(defun approved-fc-derivationp 3778,173038
-(defun approve-fc-derivations 3864,176138
-(defun max-level-no 3892,177536
-(defun max-level-no-lst 3907,178175
-(defun get-level-no 3912,178338
-(defun sort-approved1-rating1 3926,178638
-(defun sort-approved1-rating1-lst 3944,179487
-(defun sort-approved1-rating 3951,179738
-(defun sort-approved1 3969,180665
-(defun sort-approved 3978,180968
-(defun strip-fcd-concls 3985,181225
-(defun type-alist-fcd-lst 3993,181502
-(defun every-concl-member-equalp 4043,183741
-(defun forward-chain1 4057,184252
-(defun forward-chain-top 4135,188551
-(defun forward-chain 4240,193567
-(defun select-forward-chained-concls-and-ttrees 4258,194442
-(defun rewrite-clause-type-alist 4532,207276
-(defun maximal-multiples1 4836,221859
-(defun maximal-multiples 4850,222355
-(defun lambda-abstract1 4863,222790
-(defun lambda-abstract 4872,223141
-(defun mutually-exclusive-tests 4889,223660
-(defun mutually-exclusive-subsumptionp 4920,224777
-(defun cleanup-if-expr 4940,225471
-(defun cleanup-if-expr-lst 4964,226383
-(defun all-type-reasoning-tags-p1 4970,226573
-(defun all-type-reasoning-tags-p 4977,226831
-(defun try-clause 4980,226935
-(defconst *trivial-non-nil-ttree*4995,227362
-(defun make-non-nil-ttree 4998,227414
-(defun try-type-set-and-clause 5002,227493
-(defun lambda-subtermp 5033,228923
-(defun lambda-subtermp-lst 5043,229177
-(defun rewrite-atm 5051,229335
-(defun every-occurrence-equiv-hittablep15432,246164
-(defun every-occurrence-equiv-hittablep1-listp5471,247512
-(defun every-occurrence-equiv-hittablep 5489,248007
-(defun every-occurrence-equiv-hittablep-in-clausep 5510,248867
-(defun some-occurrence-equiv-hittablep1 5532,249623
-(defun some-occurrence-equiv-hittablep1-listp5564,250702
-(defun some-occurrence-equiv-hittablep 5580,251133
-(defun equiv-hittable-in-some-other-lit 5597,251740
-(defun find-trivial-equivalence15610,252296
-(defun find-trivial-equivalence 5766,260335
-(defun add-literal-and-pt1 5817,262821
-(defun add-literal-and-pt 5835,263637
-(defun add-binding-to-tag-tree 5866,264771
-(defun subst-equiv-and-maybe-delete-lit5880,265299
-(defun remove-trivial-equivalences5935,268048
-(defrec built-in-clause 6006,271892
-(defconst *initial-built-in-clauses*6019,272604
-(defun built-in-clausep2 6247,281121
-(defun built-in-clausep1 6260,281711
-(defun possible-trivial-clause-p 6283,282851
-(defun trivial-clause-p 6307,283780
-(defun built-in-clausep 6312,283930
-(defun crunch-clause-segments1 6385,287747
-(defun crunch-clause-segments2 6425,289938
-(defun crunch-clause-segments 6439,290449
-(defun strip-non-rewrittenp-assumptions1 6506,294109
-(defun strip-non-rewrittenp-assumptions 6521,294816
-(defun assumnote-list-to-token-list 6538,295548
-(defun resume-suspended-assumption-rewriting16544,295761
-(defun resume-suspended-assumption-rewriting6702,303689
-(defun helpful-little-ecnt-msg 6797,308838
-(defun rewrite-clause 6811,309213
-(defun rewrite-clause-lst 7169,326436
-(defun setup-simplify-clause-pot-lst1 7237,329276
-(defun setup-simplify-clause-pot-lst 7270,330611
-(defun sequential-subst-var-term 7357,333898
-(defun process-equational-polys7369,334364
-(defun enumerate-elements 7548,342989
-(defun already-used-by-fertilize-clausep 7552,343110
-(defun unhidden-lit-info 7569,343969
-(defun tilde-@-hyp-phrase 7588,344821
-(defun simplify-clause1 7617,345931
-(defun some-element-dumb-occur-lst 7795,354551
-(defrec prove-spec-var7808,355121
-(defrec gag-info7835,356297
-(defrec gag-state7851,356859
-(defconst *initial-gag-state*7859,357255
-(defconst *empty-prove-spec-var*7867,357428
-(defun controller-unify-subst2 7882,357830
-(defun controller-unify-subst1 7889,358069
-(defun controller-unify-subst 7897,358402
-(defun filter-disabled-expand-terms 7904,358703
-(defun found-hit-rewrite-hist-entry 7985,362752
-(defabbrev append? 7999,363321
-(defun simplify-clause 8003,363395
-(defun settled-down-clause 8357,381955
-(defun member-class-name-runes 8380,382927
-(defun extract-and-classify-lemmas2 8388,383200
-(defun extract-and-classify-lemmas1 8413,384498
-(defun runes-to-class-alist1 8430,385265
-(defun strict-merge-symbol-< 8444,385897
-(defun strict-merge-sort-symbol-< 8465,386730
-(defun strict-symbol-<-sortedp 8482,387241
-(defun sort-symbol-listp 8489,387469
-(defun strict-merge-sort-symbol-<-cdrs 8495,387637
-(defun runes-to-class-alist 8501,387871
-(defun extract-and-classify-lemmas 8508,388063
-(deflabel Simple8540,389455
-(defun tilde-*-conjunction-of-possibly-forced-names-phrase1 8573,390850
-(defun tilde-*-conjunction-of-possibly-forced-names-phrase 8587,391398
-(defconst *fake-rune-alist*8602,392001
-(defun rune-< 8615,392464
-(defun merge-runes 8630,392822
-(defun merge-sort-runes 8637,393040
-(defun tilde-*-simp-phrase1 8642,393205
-(defun tilde-*-raw-simp-phrase1 8772,398347
-(defun recover-forced-runes1 8821,400637
-(defun recover-forced-runes 8833,401014
-(defun tilde-*-raw-simp-phrase 8845,401555
-(defun tilde-*-simp-phrase 8872,402507
-(defun tilde-@-pool-name-phrase 8904,403928
-(defun tilde-@-pool-name-phrase-lst 8942,405866
-(defun tilde-@-clause-id-phrase 8947,406092
-(defrec bddnote9036,409059
-(defun tilde-@-bddnote-phrase 9040,409160
-(defun parse-natural1 9054,409673
-(defun parse-natural 9080,410625
-(defun parse-dotted-naturals 9101,411431
-(defun parse-match 9137,413109
-(defun parse-primes 9151,413672
-(defun parse-clause-id2 9177,414655
-(defun parse-clause-id1 9207,415667
-(defun parse-clause-id 9272,417946
-(defun tilde-@-case-split-limitations-phrase 9310,419249
-(defun simplify-clause-msg1 9325,419791
-(deflabel specious-simplification9447,426022
-(defun settled-down-clause-msg1 9559,431610
-
-bdd.lisp,4141
-(defmacro mvf 45,1569
-(defmacro logandf 57,2133
-(defmacro logxorf 60,2201
-(defmacro logiorf 63,2268
-(defmacro ashf 66,2335
-(defmacro mx-id-bound 70,2441
-(defmacro 1+mx-id 78,2692
-(defmacro bdd-error 130,4826
-(defmacro unique-id 212,8206
-(defmacro tst 214,8255
-(defmacro cst-boolp 220,8545
-(defmacro tbr 222,8583
-(defmacro fbr 223,8615
-(defmacro leafp 225,8648
-(defmacro trm 228,8691
-(defun bdd-constructors 230,8722
-(defun make-leaf-cst 240,9074
-(defun evg-fn-symb 250,9376
-(defun bdd-constructor-trm-p 279,10363
-(defun evg-type 285,10576
-(defun make-if-cst 301,11116
-(defconst *cst-t* 360,14043
-(defconst *cst-nil* 361,14088
-(defmacro cst=363,14136
-(defmacro cst-tp 367,14214
-(defmacro cst-nilp 370,14265
-(defmacro cst-varp 373,14318
-(defun cst-nonnilp 376,14371
-(defun bool-mask1 400,15428
-(defun boolean-term-var 417,16248
-(defun boolean-hyps-vars 450,17432
-(defun first-boolean-type-prescription 465,17812
-(defun recognizer-rune 500,19423
-(defun bool-mask 510,19849
-(defun commutative-p1 554,21438
-(defun find-equivalence-rune 583,22834
-(defun equivalence-rune1 594,23187
-(defun equivalence-rune 621,24183
-(defun commutative-p 631,24554
-(defun op-alist 648,25192
-(defun op-alist-info 684,26727
-(defmacro if-op-code 707,27339
-(defmacro hash-size 709,27367
-(defmacro if-hash-index 736,28445
-(defun op-hash-index1 748,28866
-(defmacro op-hash-index 775,29913
-(defmacro op-hash-index-2 780,30048
-(defmacro op-hash-index-if 790,30319
-(defun if-search-bucket 800,30630
-(defun cst=811,30920
-(defmacro eq-op 817,31043
-(defun op-search-bucket 823,31150
-(defun op-search-bucket-2 836,31629
-(defun op-search-bucket-if 853,32363
-(defun chk-memo 869,32977
-(defun chk-memo-2 887,33646
-(defun chk-memo-if 903,34180
-(defmacro half-hash-size 923,34894
-(defmacro fourth-hash-size 926,34948
-(defun op-hash-index-string 929,35004
-(defun op-hash-index-evg 942,35400
-(defun op-search-bucket-quote 975,36439
-(defun chk-memo-quotep 983,36714
-(defun bdd-quotep 999,37198
-(defmacro bdd-quotep+ 1032,38309
-(defrec bdd-rule1049,39128
-(defun rewrite-rule-to-bdd-rule 1053,39170
-(defun bdd-rules-alist11059,39372
-(defun extra-rules-for-bdds 1137,43507
-(defun bdd-rules-alist 1204,46159
-(defmacro one-way-unify1-cst-2 1266,48779
-(defmacro one-way-unify1-cst-3 1280,49397
-(defun one-way-unify1-cst 1298,50127
-(defun one-way-unify1-cst-lst 1479,60972
-(defun one-way-unify1-cst-equal 1497,61625
-(defun some-one-way-unify-cst-lst 1511,62114
-(defun leaf-cst-list 1540,63265
-(defun decode-cst 1562,64118
-(defun decode-cst-lst 1600,65389
-(defun decode-cst-alist1 1612,65756
-(defun decode-cst-alist 1624,66204
-(defun leaf-cst-list-array 1630,66386
-(defconst *some-non-nil-value* 1637,66617
-(defun falsifying-assignment1 1639,66671
-(defun falsifying-assignment 1676,68058
-(defun make-if 1686,68419
-(defun make-if-no-memo 1765,72006
-(defmacro split-var 1799,73285
-(defun min-var 1812,73624
-(defun combine-op-csts1 1832,74212
-(defun bool-flg 1865,75735
-(defun some-bdd-constructorp 1887,76386
-(defun combine-op-csts-simple1894,76643
-(defmacro bdd-mv-let 1946,78574
-(defmacro combine-if-csts+ 2009,80999
-(defun combine-if-csts1 2018,81322
-(defun combine-if-csts2038,82047
-(defun cst-list-to-evg-list 2116,85211
-(defun cst-quote-listp 2122,85374
-(defrec bddspv2130,85558
-(defun bdd-ev-fncall2141,85961
-(defmacro combine-op-csts+ 2171,87181
-(defun make-if-for-op2189,88128
-(defun combine-op-csts 2239,89644
-(defun combine-op-csts-comm 2269,90778
-(defun combine-op-csts-guts2346,94005
-(defun bdd 2467,99178
-(defun bdd-alist 2588,103955
-(defun bdd-list 2607,104679
-(defun if-ht-max-length 2634,105613
-(defun op-ht-max-length 2639,105768
-(defun leaf-cst-list-to-alist 2644,105923
-(defvar *request-bigger-fixnum-table*2658,106351
-(defun bdd-top 2661,106441
-(defun get-bool-vars 2769,112114
-(defun bdd-clause1 2787,112719
-(defmacro expand-and-or-simple+2913,118147
-(defun expand-and-or-simple2925,118612
-(defun expand-clause3072,125108
-(defun bdd-clause 3097,126110
-(deflabel obdd3213,132073
-(deflabel bdd-algorithm3221,132227
-(deflabel bdd-introduction3731,157420
-
-other-processes.lisp,3301
-(defun strip-final-digits1 30,1253
-(defun strip-final-digits 51,2117
-(defconst *var-families-by-type*76,3315
-(defun assoc-ts-subsetp 97,4014
-(defun first-non-member-eq 107,4281
-(defun abbreviate-hyphenated-string1 120,4689
-(defun abbreviate-hyphenated-string 147,5788
-(defun generate-variable-root1 164,6375
-(defun generate-variable-root 225,8865
-(defun generate-variable 244,9569
-(defun generate-variable-lst 256,10121
-(defrec elim-rule290,11827
-(defun occurs-nowhere-else 296,11965
-(defun first-nomination 308,12364
-(defun second-nomination 315,12532
-(defun some-hyp-probably-nilp 328,12953
-(defun sublis-expr 354,13821
-(defun sublis-expr-lst 372,14513
-(defun nominate-destructor-candidate379,14679
-(defun nominate-destructor-candidates504,21176
-(defun nominate-destructor-candidates-lst527,22004
-(defun sum-level-nos 554,23112
-(defun pick-highest-sum-level-nos 570,23777
-(defun select-instantiated-elim-rule 589,24561
-(defun type-restriction-segment 640,27174
-(defun subterm-one-way-unify 736,31670
-(defun subterm-one-way-unify-lst 749,32208
-(defrec generalize-rule 759,32501
-(defun apply-generalize-rule 761,32553
-(defun generalize-rule-segment1 800,34317
-(defun generalize-rule-segment 822,35419
-(defun generalize1 846,36598
-(defun apply-instantiated-elim-rule 879,38225
-(defun eliminate-destructors-clause1 995,44107
-(defun owned-vars 1140,51274
-(defun eliminate-destructors-clause 1219,55508
-(defun prettyify-clause1 1253,57158
-(defun prettyify-clause2 1258,57344
-(defun prettyify-clause 1272,57954
-(defun prettyify-clause-lst 1285,58505
-(defun prettyify-clause-set 1291,58789
-(defun tilde-*-elim-phrase/alist1 1297,59054
-(defun tilde-*-elim-phrase/alist 1304,59325
-(defun tilde-*-elim-phrase3 1316,59769
-(defun tilde-*-elim-phrase2 1324,60172
-(defun tilde-*-elim-phrase1 1351,61496
-(defun tilde-*-elim-phrase 1384,63126
-(defun tilde-*-untranslate-lst-phrase 1404,63744
-(defun eliminate-destructors-clause-msg1 1409,63890
-(defun almost-quotep1 1462,66324
-(defun almost-quotep1-listp 1473,66697
-(defun almost-quotep 1480,66862
-(defun destructor-applied-to-varsp 1492,67217
-(defun dumb-occur-lst-except 1509,67900
-(defun fertilize-feasible 1527,68709
-(defun fertilize-complexity 1545,69499
-(defun maximize-fertilize-complexity 1555,69834
-(defun first-fertilize-lit 1562,70038
-(defun cross-fertilizep/c 1596,71602
-(defun cross-fertilizep/d 1610,72093
-(defun cross-fertilizep 1624,72584
-(defun delete-from-ttree 1649,73901
-(defun fertilize-clause1 1661,74427
-(defun fertilize-clause 1865,84067
-(defun fertilize-clause-msg1 1953,88534
-(defun collectable-fnp 1998,90495
-(defun smallest-common-subterms1 2016,91124
-(defun smallest-common-subterms1-lst 2077,93556
-(defun dumb-fn-count-1 2098,94237
-(defun dumb-fn-count 2112,94766
-(defun smallest-common-subterms 2135,95655
-(defun generalizing-relationp 2151,96368
-(defun generalizable-terms-across-relations 2182,97735
-(defun generalizable-terms-across-literals1 2197,98356
-(defun generalizable-terms-across-literals 2203,98602
-(defun generalizable-terms 2215,99081
-(defun generalize-clause 2226,99435
-(defun tilde-*-gen-phrase/alist1 2307,103268
-(defun tilde-*-gen-phrase/alist 2314,103537
-(defun tilde-*-gen-phrase 2322,103706
-(defun generalize-clause-msg1 2376,106558
-
-induct.lisp,5029
-(defun select-x-cl-set 23,881
-(defun unchangeables 35,1336
-(defun changeables 50,1930
-(defun sound-induction-principle-mask1 66,2516
-(defun sound-induction-principle-mask 104,4307
-(defrec candidate162,7269
-(defun count-non-nils 209,10209
-(defun controllers 214,10354
-(defun changed/unchanged-vars 221,10637
-(defrec tests-and-alists 228,10925
-(defun tests-and-alists/alist 230,10971
-(defun tests-and-alists/alists 257,12146
-(defrec tests-and-calls 279,13169
-(defrec justification294,14018
-(defun tests-and-alists 299,14132
-(defun tests-and-alists-lst 315,14877
-(defun flesh-out-induction-principle 327,15346
-(defun intrinsic-suggested-induction-cand364,16488
-(defrec induction-rule 404,18660
-(defun apply-induction-rule 408,18751
-(defun suggested-induction-cands1518,22845
-(defun suggested-induction-cands577,25248
-(defun get-induction-cands 601,26255
-(defun get-induction-cands-lst 617,26774
-(defun get-induction-cands-from-cl-set1 632,27150
-(defun get-induction-cands-from-cl-set 659,28281
-(defun pigeon-holep-apply 694,29800
-(defun pigeon-holep 736,31588
-(defun pigeon-holep1 755,32410
-(defun flush-cand1-down-cand2 776,33110
-(defun flush-candidates 812,34945
-(defun alists-agreep 837,36181
-(defun irreconcilable-alistsp 850,36682
-(defun affinity 868,37448
-(defun member-affinity 881,37921
-(defun occur-affinity 890,38209
-(defun some-occur-affinity 906,38779
-(defun all-occur-affinity 915,39113
-(defun contains-affinity 924,39446
-(defun antagonistic-tests-and-alists-lstp 937,39933
-(defun antagonistic-tests-and-alists-lstsp 963,40864
-(defun every-alist1-matedp 978,41349
-(defun merge-alist1-into-alist2 999,42274
-(defun merge-alist1-lst-into-alist2 1020,43207
-(defun merge-lst1-into-alist2 1034,43679
-(defun merge-lst1-into-alist2-lst 1050,44156
-(defun merge-lst1-into-lst2 1055,44392
-(defun merge-tests-and-alists-lsts 1065,44803
-(defun merge-cand1-into-cand2 1146,49374
-(defun merge-candidates 1244,54737
-(defun controller-variables1 1259,55207
-(defun controller-variables 1274,55837
-(defun induct-vars1 1288,56542
-(defun induct-vars 1302,56966
-(defun vetoedp 1321,57713
-(defun compute-vetoes1 1345,58716
-(defun compute-vetoes2 1367,59557
-(defun compute-vetoes 1383,60108
-(defun induction-complexity1 1447,63447
-(defun maximal-elements-apply 1465,64260
-(defun maximal-elements1 1478,64700
-(defun maximal-elements 1503,65735
-(defun intersectp-eq/union-equal 1527,66628
-(defun equal/union-equal 1533,66816
-(defun subsetp-equal/smaller 1539,66969
-(defun m&m-apply 1544,67087
-(defun count-off 1557,67604
-(defun m&m-search 1565,67810
-(defun m&m1 1583,68570
-(defun m&m 1634,70709
-(defun cons-subset-tree 1719,75214
-(defabbrev car-subset-tree 1736,75638
-(defabbrev cdr-subset-tree 1742,75723
-(defun or-subset-trees 1748,75808
-(defun m&m-over-powerset1 1760,76306
-(defun m&m-over-powerset 1786,77103
-(defun all-picks2 1895,82378
-(defun all-picks2r 1901,82558
-(defun all-picks1 1907,82747
-(defun all-picks 1916,83066
-(defun dumb-negate-lit-lst-lst 1957,85038
-(defun induction-hyp-clause-segments2 1969,85533
-(defun induction-hyp-clause-segments1 1975,85778
-(defun induction-hyp-clause-segments 1987,86196
-(defun induction-formula3 2023,87958
-(defun induction-formula2 2066,89723
-(defun induction-formula1 2095,90969
-(defun induction-formula 2111,91721
-(defun all-picks-size 2183,94929
-(defun induction-formula-size1 2190,95132
-(defun induction-formula-size 2206,95866
-(defconst *maximum-induct-size* 2221,96462
-(defun termify-clause-set 2226,96584
-(defun inform-simplify3 2243,97257
-(defun inform-simplify2 2252,97576
-(defun inform-simplify1 2262,97864
-(defun inform-simplify 2276,98433
-(defun all-vars1-lst-lst 2327,101319
-(defun gen-new-name1 2336,101620
-(defun gen-new-name 2346,101945
-(defun unmeasured-variables3 2354,102177
-(defun unmeasured-variables2 2362,102489
-(defun unmeasured-variables1 2368,102719
-(defun unmeasured-variables 2377,103131
-(defun tilde-@-well-founded-relation-phrase 2388,103620
-(defun measured-variables 2406,104367
-(defun induct-msg/continue 2416,104756
-(defun rec-fnnames 2597,113148
-(defun rec-fnnames-lst 2608,113630
-(defun induct-msg/lose 2615,113801
-(defun@par load-hint-settings-into-rcnst 2677,116943
-(defun update-hint-settings 2747,120320
-(defun@par load-hint-settings-into-pspv 2762,120885
-(defun restore-hint-settings-in-pspv 2795,122351
-(defun remove-trivial-clauses 2834,124475
-(defun non-standard-vector-check 2843,124755
-(defun merge-ns-check 2851,125019
-(defun trap-non-standard-vector-aux 2859,125302
-(defun remove-adjacent-duplicates 2873,125997
-(defun non-standard-induction-vars 2880,126272
-(defun trap-non-standard-vector 2892,126696
-(defun induct 2900,127058
-(defun pair-vars-with-lits 3091,135667
-(defun ffnnames-subsetp 3104,136009
-(defun ffnnames-subsetp-listp 3118,136513
-(defun probably-not-validp 3128,136793
-(defun irrelevant-lits 3161,138369
-(defun eliminate-irrelevance-clause 3173,138852
-(defun eliminate-irrelevance-clause-msg1 3203,140170
-
-history-management.lisp,28297
-(defrec goal-tree 37,1262
-(deflabel proof-tree95,4572
-(deflabel proof-tree-examples181,8507
-(defun start-proof-tree-fn 452,18636
-(defmacro start-proof-tree 465,19018
-(defmacro start-proof-tree 494,20059
-(defmacro checkpoint-forced-goals 504,20350
-(defun stop-proof-tree-fn 526,21134
-(defmacro stop-proof-tree 532,21345
-(deflabel proof-tree-details560,22404
-(defun insert-into-goal-tree-rec 605,24607
-(defun insert-into-goal-tree-lst 613,24929
-(defun insert-into-goal-tree 637,25726
-(defun set-difference-equal-changedp 660,26743
-(defun prune-goal-tree 678,27394
-(defun prune-goal-tree-lst 765,31055
-(defun prune-proof-tree 782,31722
-(defun print-string-repeat 796,32340
-(defconst *format-proc-alist*808,32743
-(defun format-forced-subgoals 821,33141
-(defun format-processor 850,34261
-(defun format-goal-tree-lst903,36276
-(defun format-goal-tree 935,37528
-(defun format-proof-tree 985,39680
-(defun print-proof-tree1 1009,40661
-(defconst *proof-failure-string*1022,41221
-(defun print-proof-tree-ctx 1025,41287
-(defconst *proof-tree-start-delimiter* 1050,42144
-(defconst *proof-tree-end-delimiter* 1052,42194
-(defun print-proof-tree-finish 1054,42241
-(defun print-proof-tree 1064,42669
-(defun decorate-forced-goals-1 1089,43517
-(defun decorate-forced-goals-1-lst1106,44227
-(defun decorate-forced-goals 1131,45124
-(defun decorate-forced-goals-in-proof-tree1149,45764
-(defun assumnote-list-to-clause-id-list 1167,46501
-(defun assumnote-list-list-to-clause-id-list-list 1173,46723
-(defun extend-proof-tree-for-forcing-round1179,46994
-(defun initialize-proof-tree1 1213,48216
-(defun initialize-proof-tree 1251,49760
-(defconst *star-1-clause-id*1276,50788
-(defun revert-goal-tree-rec 1285,50945
-(defun revert-goal-tree-lst 1310,52080
-(defun revert-goal-tree 1337,53296
-(defrec pool-element 1358,54210
-(defun pool-lst1 1360,54268
-(defun pool-lst 1367,54522
-(defun increment-proof-tree1388,55371
-(defun goal-tree-with-cl-id 1477,59673
-(defun goal-tree-choose-disjunct-rec 1486,59949
-(defun goal-tree-choose-disjunct-lst 1515,61177
-(defun goal-tree-choose-disjunct 1530,61982
-(defun install-disjunct-into-proof-tree 1541,62419
-(defun logical-namep 1599,65288
-(defun logical-name-type-string 1618,65979
-(defun signature-fns 1717,71018
-(defun make-event-tuple 1732,71630
-(defun access-event-tuple-number 1784,74129
-(defun access-event-tuple-depth 1792,74377
-(defun access-event-tuple-type 1795,74452
-(defun access-event-tuple-namex 1804,74688
-(defun access-event-tuple-form 1827,75490
-(defun access-event-tuple-symbol-class 1832,75580
-(defrec command-tuple1856,76809
-(defun make-command-tuple 1873,77469
-(defun access-command-tuple-number 1891,78183
-(defun access-command-tuple-defun-mode 1894,78259
-(defun access-command-tuple-form 1900,78425
-(defun safe-access-command-tuple-form 1910,78667
-(defun access-command-tuple-last-make-event-expansion 1923,79017
-(defun access-command-tuple-cbd 1926,79131
-(defun max-absolute-event-number 1931,79239
-(defun next-absolute-event-number 1941,79638
-(defun max-absolute-command-number 1944,79721
-(defun next-absolute-command-number 1952,80000
-(defun scan-to-event 1957,80117
-(defun scan-to-command 1968,80405
-(defun scan-to-landmark-number 1978,80667
-(defun add-to-zap-table 2115,88260
-(defun fetch-from-zap-table 2123,88502
-(defconst *event-index-interval* 2142,89183
-(defconst *command-index-interval* 2143,89220
-(defun update-world-index 2145,89260
-(defun lookup-world-index1 2219,92801
-(defun lookup-world-index 2241,93707
-(defun store-absolute-event-number 2270,94959
-(defun the-namex-symbol-class1 2303,96187
-(defun the-namex-symbol-class 2325,97459
-(defun add-event-landmark 2333,97710
-(defun scan-to-defpkg 2363,99108
-(defun scan-to-include-book 2378,99745
-(defun assoc-equal-cadr 2392,100348
-(defun multiple-assoc-terminal-substringp1 2397,100508
-(defun multiple-assoc-terminal-substringp 2403,100817
-(defun possibly-add-lisp-extension 2412,101207
-(defun decode-logical-name 2428,101683
-(defun er-decode-logical-name 2471,103230
-(defun renew-lemmas 2503,104500
-(defun renew-name/erase 2514,104942
-(defun renew-name/overwrite 2540,105980
-(defun renew-name 2693,112019
-(defun renew-names 2736,114109
-(defun collect-redefined 2742,114327
-(defun scrunch-eq 2762,115120
-(defun print-redefinition-warning 2767,115289
-(defun initialize-summary-accumulators 2805,116935
-(defun print-warnings-summary 2842,118485
-(defun print-time-summary 2866,119304
-(defun print-steps-summary 2929,121863
-(defun print-rules-summary 2954,123016
-(defun merge-cdr-> 2984,124239
-(defun merge-sort-cdr-> 2992,124485
-(defconst *gag-prefix* 2997,124650
-(defconst *gag-suffix* 2998,124680
-(defun gag-start-msg 3000,124718
-(defun print-gag-info 3008,124959
-(defun set-checkpoint-summary-limit-fn 3019,125398
-(defmacro set-checkpoint-summary-limit 3038,126049
-(defun print-gag-stack-rev 3102,128436
-(defun maybe-print-nil-goal-generated 3127,129618
-(defun print-gag-state1 3135,129940
-(defun erase-gag-state 3223,133715
-(defun print-gag-state 3233,134168
-(defun clause-id-is-top-level 3241,134399
-(defun clause-id-is-induction-round 3246,134557
-(defun clause-id-is-forcing-round 3251,134714
-(defun print-acl2p-checkpoints1 3259,134912
-(deflock *acl2p-checkpoint-saving-lock*)3303,137031
-(defun erase-acl2p-checkpoints-for-summary 3306,137084
-(defun print-acl2p-checkpoints 3311,137245
-(defun print-failure 3342,138726
-(defstub initialize-event-user 3355,139221
-(defstub finalize-event-user 3357,139278
-(defdoc initialize-event-user3359,139333
-(defdoc finalize-event-user3427,141882
-(defun lmi-seed 3553,146634
-(defun lmi-techs 3571,147329
-(defun lmi-seed-lst 3581,147633
-(defun lmi-techs-lst 3586,147803
-(defun filter-atoms 3591,147972
-(defun print-runes-summary 3601,148257
-(defun use-names-in-ttree 3614,148635
-(defun by-names-in-ttree 3621,148902
-(defrec clause-processor-hint3628,149154
-(defun clause-processor-fns 3632,149225
-(defun cl-proc-names-in-ttree 3639,149524
-(defun print-hint-events-summary 3645,149762
-(defun print-splitter-rules-summary 3668,150840
-(defun print-rules-and-hint-events-summary 3727,153446
-(defun print-summary 3755,154791
-(defun with-prover-step-limit-fn 3898,161066
-(defmacro with-prover-step-limit 3993,164851
-(defmacro with-prover-step-limit 4147,172021
-(defmacro with-prover-step-limit! 4154,172296
-(defrec proved-functional-instances-alist-entry4170,172948
-(defun supply-name-for-proved-functional-instances-alist-entry 4226,175851
-(defun proved-functional-instances-from-tagged-objects 4233,176161
-(defun add-command-landmark 4472,184580
-(defun find-longest-common-retraction1 4508,186340
-(defun find-longest-common-retraction1-event 4514,186562
-(defun find-longest-common-retraction 4520,186786
-(defun install-global-enabled-structure 4541,187635
-(defvar *defattach-fns*)4577,189346
-(defun set-w 4579,189372
-(defun set-w! 4656,192808
-(defmacro save-event-state-globals 4766,198290
-(defun attachment-alist 4784,198872
-(defun attachment-pair 4793,199256
-(defconst *protected-system-state-globals*4799,199480
-(defun state-global-bindings 4854,202997
-(defmacro protect-system-state-globals 4860,203196
-(defun formal-value-triple 4871,203545
-(defun formal-value-triple@par 4882,203841
-(defun@par translate-simple-or-error-triple 4889,203998
-(defun xtrans-eval 4978,208429
-(defun xtrans-eval-with-ev-w 5070,212266
-(defun xtrans-eval@par 5146,215166
-(defmacro xtrans-eval-state-fn-attachment 5149,215305
-(defmacro with-ctx-summarized 5183,216737
-(defmacro revert-world-on-error 5270,221042
-(defun@par chk-theory-expr-value1 5288,221823
-(defun@par chk-theory-expr-value 5316,223178
-(defun theory-fn-translated-callp 5324,223527
-(defun eval-theory-expr 5343,224127
-(defun eval-theory-expr@par 5378,225326
-(defun append-strip-cdrs 5420,226871
-(defun no-rune-based-on 5427,227028
-(defun revappend-delete-runes-based-on-symbols1 5433,227216
-(defun revappend-delete-runes-based-on-symbols 5445,227770
-(defun current-theory1 5466,228709
-(defun first-n-ac-rev 5504,230516
-(defun longest-common-tail-length-rec 5520,231073
-(defun longest-common-tail-length 5534,231640
-(defun extend-current-theory 5543,231988
-(defun update-current-theory 5578,233472
-(defun put-cltl-command 5602,234689
-(defun strip-non-nil-base-symbols 5619,235458
-(defun install-proof-supporters 5627,235722
-(defun install-event 5665,237557
-(deflabel redundant-events5881,249523
-(defun stop-redundant-event 6179,264485
-(defrec command-number-baseline-info6240,267190
-(defun absolute-to-relative-command-number 6244,267270
-(defun relative-to-absolute-command-number 6249,267457
-(defun normalize-absolute-command-number 6254,267644
-(defun tree-occur 6304,269574
-(defun cd-form-matchp 6313,269763
-(defun cd-some-event-matchp 6326,270139
-(defun cd-search 6345,270919
-(defun superior-command-world 6386,272723
-(defun er-decode-cd 6417,274211
-(defrec ldd-status6604,283424
-(defun make-ldd-flags 6608,283562
-(defun make-ldd 6621,284239
-(defun access-ldd-class 6638,284924
-(defun access-ldd-markp 6639,284968
-(defun access-ldd-status 6640,285012
-(defun access-ldd-fullp 6641,285056
-(defun access-ldd-n 6642,285100
-(defun access-ldd-form 6643,285143
-(defun big-d-little-d-name1 6645,285187
-(defun big-d-little-d-name 6659,285811
-(defun big-d-little-d-clique1 6673,286453
-(defun big-d-little-d-clique 6686,287003
-(defun big-d-little-d-event 6697,287462
-(defun big-d-little-d-command-block 6723,288678
-(defun big-m-little-m-name 6766,290688
-(defun big-m-little-m-clique1 6779,291123
-(defun big-m-little-m-clique 6792,291615
-(defun big-m-little-m-event 6802,291983
-(defun big-m-little-m-command-block 6816,292517
-(defun symbol-class-char 6844,293591
-(defun defun-mode-string 6855,293907
-(defun big-c-little-c-event 6863,294161
-(defun big-c-little-c-command-block 6890,295430
-(defun print-ldd-full-or-sketch/mutual-recursion 6928,297230
-(defun print-ldd-full-or-sketch/encapsulate 6937,297538
-(defun normalize-char 6950,298064
-(defun normalize-string1 6956,298220
-(defun normalize-string 6968,298754
-(defun string-matchp 6978,299159
-(defun string-search1 7004,300147
-(defun string-search 7011,300374
-(defun doc-stringp 7028,300965
-(defconst *zapped-doc-string*7045,301465
-(defun zap-doc-string-from-event-form/all-but-last 7048,301534
-(defun zap-doc-string-from-event-form/second-arg 7057,301893
-(defun zap-doc-string-from-event-form/third-arg 7067,302161
-(defun zap-doc-string-from-event-form/mutual-recursion 7078,302485
-(defun zap-doc-string-from-event-form/doc-keyword 7083,302726
-(defun zap-doc-string-from-event-form 7104,303692
-(defun print-ldd-full-or-sketch 7123,304473
-(defmacro with-base-10 7172,306263
-(defun print-ldd-formula-column 7202,307587
-(defun print-ldd 7207,307731
-(defun print-ldds 7264,309963
-(defun make-command-ldd 7295,311518
-(defun make-event-ldd 7314,312351
-(defun make-ldds-command-sequence 7329,312905
-(defun make-ldds-command-block1 7353,314032
-(defun make-ldds-command-block 7424,316448
-(defun pcb-pcb!-fn 7442,317233
-(defun pcb!-fn 7455,317696
-(defun pcb-fn 7458,317751
-(defmacro pcb! 7461,317807
-(defun pc-fn 7481,318438
-(defmacro pc 7493,318847
-(defun pcs-fn 7625,324979
-(defmacro pcs 7680,327553
-(defun get-command-sequence-fn1 7705,328496
-(defun get-command-sequence-fn 7718,328918
-(defmacro get-command-sequence 7743,329994
-(defmacro gcs 7767,330867
-(defmacro pbt 7770,330929
-(defmacro pcb 7794,331822
-(defun print-indented-list-msg 7825,333300
-(defun print-indented-list 7844,333949
-(defun print-book-path 7851,334235
-(defun pe-fn1 7866,334745
-(defun pe-fn2 7896,335792
-(defun pe-fn 7906,336330
-(defmacro pe 7964,338901
-(defmacro pe! 8012,340736
-(defun command-block-names1 8027,341139
-(defun command-block-names 8062,342834
-(defun symbol-name-lst 8071,343207
-(defun acl2-query-simulate-interaction 8076,343352
-(defun acl2-query1 8094,344064
-(defun acl2-query 8147,346180
-(defun collect-names-in-defun-modes 8197,348518
-(defun ubt-ubu-query 8208,348961
-(defmacro ubt 8331,355851
-(defmacro ubt! 8374,357812
-(defmacro ubu 8392,358352
-(defmacro ubu! 8423,359566
-(defmacro u 8442,360141
-(defun chk-virgin 8464,360822
-(deflabel name8476,361082
-(defun chk-boot-strap-redefineable-namep 8523,363309
-(defun maybe-coerce-overwrite-to-erase 8539,364020
-(defun redefinition-renewal-mode 8545,364198
-(defun redefined-names1 8882,380923
-(defun redefined-names 8892,381301
-(defun chk-redefineable-namep 8943,383178
-(defun chk-just-new-name 9002,385732
-(defun no-new-namesp 9054,388090
-(defun chk-just-new-names 9063,388310
-(defconst *return-character* 9089,389528
-(defun read-symbol-from-string1 9091,389574
-(defun read-symbol-from-string2 9106,390138
-(defun read-symbol-from-string 9115,390469
-(defun scan-past-newline 9166,393029
-(defun scan-past-newlines 9173,393245
-(defun scan-past-tilde-slash 9180,393458
-(defun scan-to-doc-string-part1 9192,394023
-(defun scan-to-doc-string-part 9203,394326
-(defun get-one-liner-as-string1 9222,395088
-(defun get-one-liner-as-string 9227,395262
-(defun read-doc-string-citations1 9235,395545
-(defun read-doc-string-citations 9249,396053
-(defun doc-topicp 9265,396822
-(defun ignore-doc-string-error 9268,396914
-(defmacro er-doc 9272,397055
-(defun chk-doc-string-citations 9286,397691
-(defun chk-well-formed-doc-string 9318,399256
-(defun translate-doc 9412,403843
-(defun translate-doc-lst 9434,404762
-(defun get-cites 9441,405040
-(defun alpha-< 9452,405377
-(defun merge-alpha-< 9472,406120
-(defun merge-sort-alpha-< 9479,406345
-(defun update-alpha-<-alist 9484,406520
-(defun put-cited-bys 9496,406970
-(defun update-doc-database 9521,407911
-(defun update-doc-database-lst 9546,408989
-(defun putprop-unless 9554,409258
-(defun redefined-warning 9562,409520
-(defun get-event 9575,409978
-(defun redundant-labelp 9588,410334
-(defun deflabel-fn 9598,410698
-(defun defdoc-fn 9647,412508
-(defmacro defdoc 9697,414307
-(defun access-doc-string-database 9769,417657
-(defun get-doc-string 9802,418806
-(defun get-doc-string-de-indent1 9809,418988
-(defun get-doc-string-de-indent 9813,419129
-(defun use-doc-string-de-indent 9825,419645
-(defun doc-prefix 9836,419965
-(defun princ-prefix 9841,420086
-(defun length-prefix 9847,420328
-(defun save-more-doc-state 9851,420453
-(defun doc-char-subst-table-p 9860,420842
-(defun set-doc-char-subst-table 9873,421137
-(defun doc-char-subst-table 9883,421558
-(defun doc-fmt-alist 9889,421683
-(defconst *terminal-markup-table*9892,421752
-(defun doc-markup-table 10021,428496
-(defun doc-scan-past-tilde-key 10026,428665
-(defun doc-scan-past-tilde-arg10054,429931
-(defun doc-scan-past-tilde10126,432767
-(defun assoc-char-alist-stringp 10164,434524
-(defun apply-char-subst-table1 10174,434837
-(defun apply-char-subst-table 10195,435730
-(defun read-pointer-and-text1 10222,436785
-(defun read-pointer-and-text2 10246,437871
-(defun read-pointer-and-text-raw 10255,438203
-(defun posn-char-stringp 10268,438614
-(defun replace-colons 10278,438838
-(defun read-pointer-and-text 10291,439257
-(defun lookup-fmt-alist 10299,439484
-(defun bar-sep-p 10389,443626
-(defun char-to-string-alistp 10393,443735
-(defun missing-fmt-alist-chars1 10404,444065
-(defun missing-fmt-alist-chars 10425,444950
-(defun complete-fmt-alist 10451,446169
-(defmacro mv-to-state 10478,447399
-(defun print-par-entry 10492,447827
-(defun print-doc-string-part1 10500,448081
-(defun print-doc-string-part-mv10815,464533
-(defun print-doc-string-part10912,469161
-(defun get-doc-section 10921,469502
-(defmacro pstate-global-let* 10929,469797
-(defun print-doc 10943,470225
-(defun print-doc-lst 11036,474233
-(defun degree-of-match2 11053,474912
-(defun degree-of-match1 11061,475211
-(defun degree-of-match 11067,475457
-(defun find-likely-near-misses 11081,475994
-(defun print-doc-dwim 11099,476809
-(defun end-doc 11116,477448
-(defun doc-fn 11130,477912
-(defun more-fn 11186,480475
-(defun doc!-fn 11210,481528
-(defmacro more 11236,482725
-(defmacro more! 11284,484800
-(defun print-doc-outline11309,485651
-(defun print-doc-outline-lst 11339,486776
-(deflabel apropos11353,487505
-(deflabel markup11366,487857
-(deflabel doc-string11649,499322
-(deflabel print-doc-start-column11881,512024
-(defmacro doc 11903,512912
-(defmacro doc! 11965,515804
-(defun more-doc-fn 11983,516222
-(defmacro more-doc 12002,516997
-(defun get-doc-section-symbols 12028,517975
-(defun get-docs-apropos1 12033,518168
-(defun get-docs-apropos 12039,518443
-(defun docs-fn 12042,518548
-(defmacro docs 12097,520714
-(defun print-top-doc-topics 12146,522730
-(defun help-fn 12158,523187
-(deflabel q12216,525750
-(defmacro help 12238,526549
-(deflabel logical-name12253,526792
-(deflabel command12328,530335
-(deflabel command-descriptor12354,531372
-(defun trans-fn 12442,535753
-(defun trans!-fn 12469,536957
-(defmacro trans 12490,537804
-(defmacro trans! 12536,539214
-(defun trans1-fn 12553,539683
-(defmacro trans1 12563,540070
-(defun tilde-*-props-fn-phrase1 12583,540588
-(defun tilde-*-props-fn-phrase 12590,540824
-(defun props-fn 12594,540940
-(defmacro props 12615,541714
-(deflabel enter-boot-strap-mode12630,542011
-(deflabel exit-boot-strap-mode12661,543460
-(defun walkabout-nth 12685,544424
-(defun walkabout-ip 12708,545247
-(defun walkabout-huh 12719,545567
-(defun walkabout1 12724,545720
-(defun walkabout 12823,549895
-(defun walkabout=12938,552938
-(defmacro walkabout=12943,553082
-(defun lookup-bddnote 12948,553213
-(defun update-bddnote-with-term 12955,553410
-(defmacro show-bdd 12968,553888
-(defun show-bdd-goal 13057,557742
-(defun merge-car-term-order 13108,559899
-(defun merge-sort-car-term-order 13115,560160
-(defun falsifying-pair-p 13120,560370
-(defun bogus-falsifying-assignment-var 13129,560667
-(defun show-falsifying-assignment 13140,560919
-(defun show-bdd-term 13216,564553
-(defun tilde-*-substitution-phrase1 13285,567490
-(defun tilde-*-substitution-phrase 13296,568022
-(defun show-bdd-backtrace 13302,568275
-(defun show-bdd-fn 13331,569339
-(defun get-docs 13393,572299
-(defun get-guards2 13406,572737
-(defun get-guards1 13490,576416
-(defun get-guards 13493,576497
-(defun get-guardsp 13538,578492
-(defconst *no-measure*13556,579360
-(defun get-measures1 13559,579393
-(defun get-measures2 13590,580924
-(defun get-measures 13598,581227
-(defconst *no-ruler-extenders*13614,581857
-(defconst *basic-ruler-extenders*13617,581898
-(defun get-ruler-extenders1 13620,581959
-(defun get-ruler-extenders2 13665,584054
-(defmacro default-ruler-extenders-from-table 13674,584483
-(defun default-ruler-extenders 13680,584679
-(defun get-ruler-extenders-lst 13699,585519
-(defun get-hints1 13717,586318
-(defun get-hints 13744,587235
-(defun get-guard-hints1 13754,587547
-(defun get-guard-hints 13782,588526
-(defun get-std-hints1 13793,588887
-(defun get-std-hints 13822,589849
-(defun get-normalizep 13832,590177
-(defun get-normalizeps 13871,591577
-(defconst *unspecified-xarg-value*13882,592074
-(defun get-unambiguous-xargs-flg1/edcls1 13889,592216
-(defun get-unambiguous-xargs-flg1/edcls 13922,593934
-(defun get-unambiguous-xargs-flg1 13933,594322
-(defun get-unambiguous-xargs-flg 13951,595263
-(defun get-unambiguous-xargs-flg-lst 13980,596795
-(defun chk-xargs-keywords1 14001,597820
-(defun chk-xargs-keywords 14018,598666
-(defun get-names 14039,599492
-(defun get-bodies 14044,599612
-(defun find-nontrivial-rulers 14051,599760
-(defun find-nontrivial-rulers-lst 14076,600802
-(defun tilde-@-free-vars-phrase 14085,601135
-(defun chk-free-vars 14112,602471
-(defun chk-declared-ignores 14131,603311
-(defun chk-free-and-ignored-vars 14143,603828
-(defun chk-free-and-ignored-vars-lsts 14200,606808
-(defun putprop-x-lst1 14237,608997
-(defun putprop-x-lst2 14247,609305
-(defun putprop-x-lst2-unless 14258,609651
-(defun@par translate-term-lst 14274,610358
-(defun find-named-lemma 14370,615015
-(defun find-runed-lemma 14387,615677
-(defun free-varsp-member 14400,616026
-(defun free-varsp-member-lst 14408,616276
-(defun@par translate-expand-term1 14415,616457
-(defun@par translate-expand-term 14540,622251
-(defun@par translate-expand-hint1 14568,623390
-(defun@par translate-expand-hint 14581,623945
-(defun cons-all-to-lst 14635,626080
-(defun@par translate-substitution 14640,626262
-(defun@par translate-substitution-lst 14689,628575
-(defun get-rewrite-and-defn-runes-from-runic-mapping-pairs 14699,628927
-(defun@par translate-restrict-hint 14708,629269
-(defconst *do-not-processes*14757,631359
-(defun coerce-to-process-name-lst 14761,631495
-(defun coerce-to-acl2-package-lst 14768,631734
-(defun@par chk-do-not-expr-value 14775,631947
-(defun@par translate-do-not-hint 14803,633232
-(defun@par translate-do-not-induct-hint 14844,634803
-(defun@par translate-hands-off-hint1 14870,636124
-(defun@par translate-hands-off-hint 14910,637662
-(defun truncated-class 14932,638430
-(defun tests-and-alists-lst-from-fn 14946,639125
-(defun corollary 14967,640144
-(defun formula 15048,643624
-(defun pf-fn 15069,644531
-(defmacro pf 15104,645969
-(defun merge-symbol-< 15125,646610
-(defun merge-sort-symbol-< 15132,646883
-(defconst *non-instantiable-primitives*15140,647146
-(defun instantiablep 15180,648795
-(defun all-ffn-symbs 15218,650471
-(defun all-ffn-symbs-lst 15228,650866
-(defconst *unknown-constraints*15235,651034
-(defun constraint-info 15243,651257
-(defdoc constraint15310,654231
-(defun@par chk-equal-arities 15761,674367
-(defun extend-sorted-symbol-alist 15781,674977
-(defun@par chk-equiv-classicalp 15795,675344
-(defun@par translate-functional-substitution 15814,676149
-(defun sublis-fn-rec 15936,681870
-(defun sublis-fn-rec-lst 16054,688073
-(defun sublis-fn 16069,688639
-(defun sublis-fn-simple 16076,688853
-(defun sublis-fn-lst-simple 16086,689176
-(defun instantiable-ffn-symbs 16097,689457
-(defun instantiable-ffn-symbs-lst 16124,690459
-(defun unknown-constraint-supporters 16135,690853
-(defun collect-instantiablep1 16155,691756
-(defun all-instantiablep 16166,692133
-(defun collect-instantiablep 16172,692296
-(defun immediate-instantiable-ancestors 16181,692558
-(defun instantiable-ancestors 16226,694819
-(defun hitp 16245,695481
-(defun hitp-lst 16258,695923
-(defun event-responsible-for-proved-constraint 16265,696072
-(defun getprop-x-lst 16310,698328
-(defun filter-hitps 16316,698561
-(defun relevant-constraints1 16323,698754
-(defun relevant-constraints1-axioms 16489,706915
-(defun relevant-constraints 16539,709424
-(defun bound-vars 16590,711677
-(defun bound-vars-lst 16601,712081
-(defun@par translate-lmi/instance 16609,712242
-(defun@par translate-lmi/functional-instance 16650,714333
-(defun@par translate-lmi 16747,719322
-(deflabel functional-instantiation-in-acl2r16854,723916
-(deflabel lemma-instance16877,724970
-(defun@par translate-use-hint1 16986,731048
-(defun@par translate-use-hint 17009,732187
-(defun convert-name-tree-to-new-name1 17121,737669
-(defun convert-name-tree-to-new-name 17148,739017
-(defun@par translate-by-hint 17170,740074
-(defun@par translate-cases-hint 17238,743159
-(defun@par translate-case-split-limitations-hint 17253,743647
-(defun@par translate-no-op-hint 17277,744595
-(defun character-alistp 17283,744743
-(defun tilde-@p 17298,745205
-(defun@par translate-error-hint 17305,745374
-(defun@par translate-induct-hint 17314,745667
-(defconst *built-in-executable-counterparts*17326,746144
-(defconst *s-prop-theory*17346,746810
-(defconst *definition-minimal-theory*17359,747308
-(defdoc theories-and-primitives17362,747407
-(defun translate-in-theory-hint17470,751199
-(defun translate-in-theory-hint@par17537,754263
-(defun all-function-symbolps 17616,758086
-(defun non-function-symbols 17622,758309
-(defun collect-non-logic-mode 17629,758551
-(defun@par translate-bdd-hint1 17637,758862
-(defun@par translate-bdd-hint 17723,762893
-(defun@par translate-nonlinearp-hint 17741,763527
-(defun@par translate-backchain-limit-rw-hint 17753,763868
-(defun@par translate-no-thanks-hint 17763,764193
-(defun@par translate-reorder-hint 17769,764343
-(defun arity-mismatch-msg 17781,764708
-(defun@par translate-clause-processor-hint 17812,766010
-(defun@par translate-custom-keyword-hint 17933,771865
-(defun custom-keyword-hint 17989,774529
-(defun remove-all-no-ops 18000,774863
-(defun remove-redundant-no-ops 18008,775168
-(defun find-first-custom-keyword-hint 18027,775765
-(defconst *custom-keyword-max-iterations*18047,776530
-(defun@par custom-keyword-hint-interpreter118050,776580
-(defun@par custom-keyword-hint-interpreter18224,784113
-(defun custom-keyword-hint-in-computed-hint-form 18255,785559
-(defun@par put-cl-id-of-custom-keyword-hint-in-computed-hint-form18294,787420
-(defun make-disjunctive-clause-id 18322,788594
-(defun make-disjunctive-goal-spec 18330,788885
-(defun minimally-well-formed-or-hintp 18335,789071
-(defun split-keyword-alist 18343,789341
-(defun distribute-other-hints-into-or1 18354,789779
-(defun distribute-other-hints-into-or 18359,789970
-(defconst *hint-expression-basic-vars*18380,790718
-(defconst *hint-expression-override-vars*18383,790829
-(defconst *hint-expression-backtrack-vars*18386,790926
-(defconst *hint-expression-all-vars*18391,791111
-(defun@par translate-hint-expression 18396,791317
-(defun@par translate-backtrack-hint 18583,798706
-(defun@par translate-rw-cache-state-hint 18586,798849
-(defun@par translate-or-hint 18597,799191
-(defun@par translate-hint-settings 18649,801457
-(defun@par translate-x-hint-value 18683,802794
-(defun replace-goal-spec-in-name-tree1 18757,805419
-(defun replace-goal-spec-in-name-tree 18777,806160
-(defun@par translate-hint 18799,807157
-(defun@par translate-hint-expressions 19138,824228
-(defun@par check-translated-override-hint 19158,825098
-(defun@par translate-hints1 19169,825546
-(defun@par warn-on-duplicate-hint-goal-specs 19256,830557
-(defun@par translate-hints2 19277,831759
-(defun override-hints 19289,832408
-(defun@par translate-hints 19433,840130
-(defun@par translate-hints+1 19437,840294
-(defun translate-hints+ 19448,840668
-(defun translate-override-hints 19457,841052
-(defun@par apply-override-hint119472,841663
-(defun@par apply-override-hint19585,846223
-(defun@par apply-override-hints19608,847453
-(defun@par eval-and-translate-hint-expression19631,848236
-(deflabel goal-spec19881,860167
-(deflabel hints-and-the-waterfall19988,864494
-(deflabel hints20191,876406
-(deflabel clause-identifier20933,912292
-(deflabel computed-hints20986,914342
-(deflabel using-computed-hints-121139,922643
-(deflabel using-computed-hints-221190,923864
-(deflabel using-computed-hints-321295,928102
-(deflabel using-computed-hints-421415,933077
-(deflabel using-computed-hints-521560,939191
-(deflabel using-computed-hints-621624,941552
-(deflabel using-computed-hints-721880,951731
-(deflabel using-computed-hints-822111,960962
-(deflabel using-computed-hints22153,962858
-(defmacro ttags-seen 22259,967421
-(defrec certify-book-info22317,969953
-(defun active-book-name 22321,970048
-(defrec deferred-ttag-note22332,970530
-(defun fms-to-standard-co 22336,970604
-(defun print-ttag-note 22343,970839
-(defun show-ttag-notes1 22398,973492
-(defun show-ttag-notes-fn 22410,973993
-(defmacro show-ttag-notes 22427,974792
-(defun set-deferred-ttag-notes 22431,974892
-(defun ttags-from-deferred-ttag-notes1 22518,978546
-(defun ttags-from-deferred-ttag-notes 22528,978923
-(defun print-deferred-ttag-notes-summary 22531,979023
-(defun notify-on-defttag 22548,979797
-(defun ttag-allowed-p 22585,981324
-(defun chk-acceptable-ttag1 22609,982312
-(defun chk-acceptable-ttag 22675,985631
-(defun chk-acceptable-ttags2 22690,986115
-(defun chk-acceptable-ttags1 22706,987056
-(defun chk-acceptable-ttags 22735,988748
-(defun chk-table-nil-args 22751,989493
-(defun chk-table-guard 22763,989898
-(defun chk-table-guards-rec 22805,991698
-(defun chk-table-guards 22819,992390
-(defun put-assoc-equal-fast 22832,993014
-(defun global-set? 22844,993435
-(defun cltl-def-from-name2 22849,993547
-(defrec absstobj-info22872,994468
-(defun cltl-def-from-name1 22876,994524
-(defun cltl-def-from-name 22901,995638
-(defun table-cltl-cmd 22913,996100
-(defun table-fn1 23000,1000548
-(defun table-fn 23189,1009578
-(defun set-override-hints-fn 23291,1013995
-
-prove.lisp,10740
-(defun abbreviationp1 37,1383
-(defun abbreviationp1-lst 55,2103
-(defun abbreviationp 63,2362
-(defun all-vars-bag 76,2858
-(defun all-vars-bag-lst 81,3012
-(defun find-abbreviation-lemma 87,3175
-(defun expand-abbreviations-with-lemma 122,4780
-(defun expand-abbreviations 150,5859
-(defun expand-abbreviations-lst 453,20221
-(defun and-orp 473,21210
-(defun find-and-or-lemma 484,21540
-(defun expand-and-or 516,23118
-(defun clausify-input1 601,26844
-(defun clausify-input1-lst 674,30392
-(defun clausify-input 694,31378
-(defun expand-some-non-rec-fns-in-clauses 720,32749
-(defun no-op-histp 739,33542
-(defun expand-any-final-implies1 775,35128
-(defun expand-any-final-implies1-lst 807,36375
-(defun expand-any-final-implies 816,36617
-(defun rw-cache-state 839,37471
-(defmacro make-rcnst 844,37641
-(defun cheap-type-alist-and-pot-lst 875,39023
-(defconst *tau-ttree*911,40835
-(defun tau-clausep 916,40966
-(defun tau-clausep-lst-rec 946,41994
-(defun tau-clausep-lst 973,42990
-(defun preprocess-clause 985,43401
-(defun tilde-*-preprocess-phrase 1186,54018
-(defun tilde-*-raw-preprocess-phrase 1212,54921
-(defun preprocess-clause-msg1 1237,55747
-(defun more-than-simplifiedp 1295,58274
-(defun delete-assoc-eq-lst 1315,59135
-(defun delete-assumptions-1 1323,59406
-(defun delete-assumptions 1347,60511
-(defun save-and-print-acl2p-checkpoint 1367,61215
-(defun find-the-first-checkpoint 1431,64304
-(defun acl2p-push-clause-printing 1457,65375
-(defun@par push-clause 1498,67094
-(defun push-clause-msg1-abort 1848,82575
-(defun push-clause-msg1 1888,84245
-(deflabel otf-flg1912,85169
-(defun clause-set-subsumes-1 1956,87012
-(defun clause-set-subsumes 1970,87755
-(defun apply-use-hint-clauses 1983,88224
-(defun apply-cases-hint-clause 2096,93373
-(defun term-list-listp 2132,94644
-(defun non-term-listp-msg 2139,94810
-(defun non-term-list-listp-msg 2156,95256
-(defun eval-clause-processor 2174,95729
-(defun eval-clause-processor@par 2235,98343
-(defun apply-top-hints-clause1 2310,101617
-(defun@par apply-top-hints-clause 2590,114249
-(defun tilde-@-lmi-phrase 2683,118997
-(defun or-hit-msg 2760,122391
-(defun apply-top-hints-clause-msg12783,123571
-(defun previous-process-was-speciousp 2990,133626
-(defconst *preprocess-clause-ledge*3088,138636
-(defmacro initialize-pspv-for-gag-mode 3119,139882
-(defun waterfall-update-gag-state 3194,143096
-(defun waterfall-update-gag-state@par 3374,152263
-(defun@par record-gag-state 3383,152597
-(defun@par gag-state-exiting-cl-id 3389,152784
-(defun remove-pool-lst-from-gag-state 3464,156744
-(defun pop-clause-update-gag-state-pop 3518,159159
-(defun gag-mode-jppl-flg 3539,159836
-(defmacro splitter-output 3560,160672
-(defdoc splitter3576,161362
-(defmacro set-splitter-output 3732,168692
-(defun waterfall-msg13766,170325
-(defmacro io?-prove-cw 3827,172538
-(defmacro io?-prove@par 3839,172819
-(defun waterfall-print-clause-body 3846,172978
-(defmacro waterfall-print-clause-id-fmt1-call 3860,173446
-(defmacro waterfall-print-clause-id-fmt1-call@par 3873,173822
-(defmacro waterfall-print-clause-id 3886,174220
-(defmacro waterfall-print-clause-id@par 3893,174418
-(defproxy print-clause-id-okp 3934,176469
-(defun print-clause-id-okp-builtin 3936,176510
-(defattach (print-clause-id-okp 3941,176632
-(defun@par waterfall-print-clause 3944,176712
-(defun some-parent-is-checkpointp 3965,177591
-(defun@par waterfall-msg3973,177870
-(defun put-ttree-into-pspv 4061,181890
-(defun set-cl-ids-of-assumptions1 4066,182080
-(defun set-cl-ids-of-assumptions 4076,182549
-(defun collect-assumptions1 4095,183436
-(defun collect-assumptions 4113,184157
-(defun sublis-var-lst-lst 4137,185296
-(defun add-segments-to-clause 4142,185484
-(defun split-initial-extra-info-lits 4148,185719
-(defun conjoin-clause-to-clause-set-extra-info1 4155,185992
-(defun conjoin-clause-to-clause-set-extra-info 4201,188101
-(defun conjoin-clause-sets-extra-info 4221,189172
-(defun maybe-add-extra-info-lit 4238,189975
-(defun conjoin-clause-sets+ 4247,190332
-(defconst *equality-aliases*4251,190512
-(defun term-equated-to-constant 4258,190716
-(defun simplify-clause-for-term-equal-const-1 4269,191044
-(defun simplify-clause-for-term-equal-const 4289,191954
-(defun add-literal-smart 4298,192209
-(defun guard-clauses 4317,192860
-(defun guard-clauses-lst 4567,204254
-(defun linked-variables1 4582,204757
-(defun linked-variables 4599,205477
-(defun contains-constrained-constantp 4660,208847
-(defun contains-constrained-constantp-lst 4674,209491
-(defun disvar-type-alist1 4682,209772
-(defun collect-all-vars 4690,210146
-(defun disvar-type-alist 4694,210273
-(defun unencumber-type-alist 4714,211137
-(defun unencumber-assumption 4757,213143
-(defun unencumber-assumptions 4827,215371
-(defun dumb-type-alist-implicationp1 4864,216958
-(defun dumb-type-alist-implicationp2 4876,217589
-(defun dumb-type-alist-implicationp 4882,217869
-(defun partition-according-to-assumption-term 4946,221247
-(defun exists-assumption-with-weaker-type-alist 4968,222138
-(defun add-assumption-with-weak-type-alist 4986,222925
-(defun dumb-keep-assumptions-with-weakest-type-alists 5011,224050
-(defun dumb-assumption-subsumption1 5046,225566
-(defun dumb-assumption-subsumption 5062,226092
-(defun clausify-type-alist 5079,226898
-(defun clausify-assumption 5106,228137
-(defun clausify-assumptions 5121,228538
-(defun strip-assumption-terms 5139,229259
-(defun add-splitters-to-ttree1 5147,229518
-(defun add-splitters-to-ttree 5156,229832
-(defun maybe-add-splitters-to-ttree 5170,230312
-(defun extract-and-clausify-assumptions 5176,230566
-(defun@par waterfall-step1 5301,237060
-(defun@par process-backtrack-hint 5336,238195
-(defun set-rw-cache-state-in-pspv 5377,240109
-(defun maybe-set-rw-cache-state-disabled 5385,240421
-(defun maybe-set-rw-cache-state-enabled 5393,240703
-(defun accumulate-rw-cache-into-pspv 5401,240984
-(defun erase-rw-cache-from-pspv 5431,242460
-(defconst *simplify-clause-ledge*5452,243354
-(defconst *simplify-clause-ledge-complement*5455,243447
-(defun@par waterfall-step-cleanup 5459,243587
-(defun@par waterfall-step 5619,250549
-(defun@par find-applicable-hint-settings15791,259193
-(defun@par find-applicable-hint-settings 5974,268448
-(defun@par thanks-for-the-hint 5988,269137
-(defun lmi-name-or-rune 6056,272161
-(defun enabled-lmi-names1 6069,272561
-(defun enabled-lmi-names 6084,273103
-(defdoc using-enabled-rules6105,273811
-(defun@par maybe-warn-for-use-hint 6180,276827
-(defun@par maybe-warn-about-theory-simple 6203,277676
-(defun@par maybe-warn-about-theory-from-rcnsts 6214,278189
-(defun waterfall-or-hit-msg-a 6260,280279
-(defun waterfall-or-hit-msg-b 6296,281611
-(defun tilde-*-or-hit-summary-phrase1 6316,282497
-(defun tilde-*-or-hit-summary-phrase 6329,282970
-(defun waterfall-or-hit-msg-c 6342,283403
-(defun term-difficulty1 6411,286527
-(defun term-difficulty1-lst 6425,287130
-(defun term-difficulty 6431,287318
-(defun clause-difficulty 6439,287663
-(defun clause-set-difficulty 6444,287781
-(defun pool-difficulty 6453,288141
-(defun how-many-to-be-proved 6464,288544
-(defun pick-best-pspv-for-waterfall0-or-hit16476,288938
-(defun pick-best-pspv-for-waterfall0-or-hit 6529,291542
-(defun change-or-hit-history-entry 6563,292954
-(defun@par pair-cl-id-with-hint-setting 6615,295070
-(defun apply-reorder-hint-front 6648,296753
-(defun apply-reorder-hint-back 6655,296997
-(defun filter-> 6662,297354
-(defun@par apply-reorder-hint 6669,297539
-(defun pspv-equal-except-for-tag-tree-and-pool 6700,298891
-(defun list-extensionp-aux 6732,300368
-(defun list-extensionp 6743,300696
-(defun find-list-extensions 6752,300919
-(defun combine-pspv-pools 6759,301138
-(defun combine-pspv-tag-trees 6770,301449
-(defun print-pspvs 6779,301750
-(defun combine-prove-spec-vars 6788,301941
-(defun speculative-execution-valid 6844,303915
-(defun abort-will-occur-in-pool 6859,304455
-(defrec maybe-to-be-proved-by-induction6901,306617
-(defun convert-maybes-to-tobe-subgoals 6911,306894
-(defun convert-maybes-to-tobes 6926,307503
-(defun convert-maybes-to-tobes-in-pspv 6994,310499
-(defun erase-rw-cache-any-tag-from-pspv 7003,310844
-(defun restore-rw-cache-state-in-pspv 7014,311210
-(defvar *waterfall-parallelism-timings-ht-alist* 7028,311964
-(defvar *waterfall-parallelism-timings-ht* 7034,312258
-(defun setup-waterfall-parallelism-ht-for-name 7042,312644
-(defun clear-current-waterfall-parallelism-ht 7066,313808
-(defun flush-waterfall-parallelism-hashtables 7072,313941
-(defun save-waterfall-timings-for-cl-id 7080,314169
-(defun lookup-waterfall-timings-for-cl-id 7087,314389
-(defmacro waterfall1-wrapper 7095,314671
-(defparameter *acl2p-starting-proof-time* 7106,315126
-(defun waterfall1-wrapper@par-before 7109,315187
-(defun waterfall1-wrapper@par-after 7146,316727
-(defmacro waterfall1-wrapper@par 7171,317721
-(defun increment-waterfall-parallelism-counter 7184,318174
-(defun halves-with-length 7209,318945
-(defun@par waterfall17224,319460
-(defun@par waterfall0-with-hint-settings7305,323045
-(defun@par waterfall0 7348,324866
-(defun@par waterfall0-or-hit 7653,337532
-(defun waterfall1-lst 7866,347131
-(defun waterfall1-lst@par-serial 7941,349998
-(defun waterfall1-tree@par-pseudo-parallel 8005,352736
-(defun waterfall1-tree@par-parallel 8170,360732
-(defun waterfall1-lst@par 8385,371483
-(defun waterfall 8524,377337
-(defun some-pool-member-subsumes 8624,382186
-(defun add-to-pop-history8640,382891
-(defun pop-clause1 8686,385035
-(defun make-defthm-forms-for-byes 8762,388521
-(defun pop-clause-msg1 8773,388923
-(defun pop-clause-msg 8939,397008
-(defun subsumed-clause-ids-from-pop-history 8964,397895
-(defun increment-proof-tree-pop-clause 8978,398473
-(defun pop-clause 8991,399056
-(defun tilde-@-assumnotes-phrase-lst 9027,400689
-(defun tilde-*-assumnotes-column-phrase 9079,403519
-(defun tilde-@-assumnotes-phrase-lst-gag-mode 9086,403736
-(defun tilde-*-assumnotes-column-phrase-gag-mode 9126,405615
-(defun process-assumptions-msg1 9133,405844
-(defun process-assumptions-msg 9170,407325
-(deflabel forcing-round9217,409557
-(deflabel failure9352,416908
-(deflabel failed-forcing9398,419551
-(defun count-assumptions 9545,426574
-(defun add-type-alist-runes-to-ttree1 9552,426760
-(defun add-type-alist-runes-to-ttree 9560,427032
-(defun process-assumptions-ttree 9569,427453
-(defun process-assumptions 9581,427872
-(defun do-not-induct-msg 9661,431226
-(defun prove-loop2 9688,432158
-(defun prove-loop1 9795,436943
-(defun print-pstack-and-gag-state 9806,437349
-(defun prove-loop0 9837,438680
-(defmacro bind-acl2-time-limit 9862,439736
-(defun prove-loop 9885,440741
-(defmacro make-pspv 9917,442104
-(defun chk-assumption-free-ttree 9941,443113
-(defun prove 9993,445551
-
-defuns.lisp,11502
-(defconst *mutual-recursion-ctx-string*31,1307
-(defun translate-bodies1 34,1394
-(defun chk-non-executable-bodies 112,4978
-(defun translate-bodies 148,6709
-(defun chk-mutual-recursion-bad-names 179,8164
-(defconst *chk-mutual-recursion-string*187,8476
-(defun chk-mutual-recursion1 196,8863
-(defun chk-mutual-recursion 216,9530
-(defun ffnnamep-mod-mbe 245,10735
-(defun ffnnamep-mod-mbe-lst 264,11537
-(defun putprop-recursivep-lst 279,11955
-(defrec tests-and-call 307,13291
-(defun all-calls 316,13658
-(defun all-calls-lst 345,14963
-(defun all-calls-alist 354,15203
-(defun termination-machine1 363,15528
-(defun ffnnamesp-eq 383,16304
-(defun ffnnamesp-eq-lst 393,16685
-(defun member-eq-all 401,16823
-(defun termination-machine 407,16918
-(defun termination-machine-for-list 514,21848
-(defun termination-machines 522,22236
-(defun proper-dumb-occur-as-output 537,22839
-(defun always-tested-and-changedp 562,23997
-(defun guess-measure 588,25059
-(defun guess-measure-alist 644,28120
-(defun remove-built-in-clauses 679,29922
-(defun length-exceedsp 714,31407
-(defun clean-up-clause-set 719,31533
-(defun measure-clause-for-branch 801,35292
-(defun measure-clauses-for-fn1 832,36427
-(defun measure-clauses-for-fn 846,37045
-(defun measure-clauses-for-clique 877,38160
-(defun tilde-*-measure-phrase1 894,38868
-(defun tilde-*-measure-phrase 902,39209
-(defun find-?-measure 930,40209
-(defun prove-termination 939,40512
-(defun putprop-justification-lst 1140,50681
-(defun union-equal-to-end 1168,51805
-(defun cross-tests-and-calls3 1177,52062
-(defun cross-tests-and-calls2 1193,52931
-(defun cross-tests-and-calls1 1201,53190
-(defun sublis-tests-rev 1210,53505
-(defun all-calls-test-alist 1228,54252
-(defun cross-tests-and-calls 1240,54658
-(defun induction-machine-for-fn1 1307,58160
-(defun induction-machine-for-fn1-lst 1667,76386
-(defun term-equated-to-constant-in-termlist 1691,77460
-(defun simplify-tests 1700,77761
-(defun simplify-tests-and-calls 1721,78696
-(defun simplify-tests-and-calls-lst 1745,79651
-(defun induction-machine-for-fn 1767,80368
-(defun induction-machines 1789,81289
-(defun putprop-induction-machine-lst 1809,82178
-(defun quick-block-initial-settings 1823,82732
-(defun quick-block-info1 1828,82907
-(defun quick-block-info2 1833,83056
-(defun quick-block-settings 1841,83282
-(defun quick-block-down-t-machine 1850,83715
-(defun quick-block-info 1866,84344
-(defun putprop-quick-block-info-lst 1884,85111
-(deflabel subversive-recursions1900,85741
-(deflabel subversive-inductions2054,93730
-(defmacro big-mutrec 2064,93898
-(defmacro update-w 2074,94303
-(defun get-sig-fns1 2098,95151
-(defun get-sig-fns 2109,95574
-(defun selected-all-fnnames-lst 2112,95657
-(defun subversivep 2120,95957
-(defun subversive-cliquep 2153,97299
-(defun prove-termination-non-recursive 2188,99102
-(defun prove-termination-recursive 2233,100922
-(defun put-induction-info-recursive 2276,102577
-(defun put-induction-info 2328,104652
-(defun destructure-definition 2411,108643
-(defun member-rewrite-rule-rune 2468,110654
-(defun replace-rewrite-rule-rune 2477,110947
-(defun preprocess-hyp 2489,111365
-(defun preprocess-hyps 2508,112180
-(defun add-definition-rule-with-ttree 2513,112336
-(defun add-definition-rule 2594,116022
-(defun listof-standardp-macro 2603,116396
-(defun putprop-body-lst 2618,116806
-(defun type-set-implied-by-term1 2907,132454
-(defun type-set-implied-by-term 2932,133474
-(defun putprop-initial-type-prescriptions 2952,134369
-(defun map-returned-formals-via-formals 3001,136559
-(defun map-type-sets-via-formals 3032,138197
-(defun vector-ts-union 3048,138906
-(defun map-cons-tag-trees 3057,139218
-(defun type-set-and-returned-formals-with-rule13066,139437
-(defun type-set-and-returned-formals-with-rule 3122,141717
-(defun type-set-and-returned-formals-with-rules3203,144933
-(defun type-set-and-returned-formals 3274,147897
-(defun type-set-and-returned-formals-lst3562,161931
-(defun guess-type-prescription-for-fn-step 3580,162698
-(defconst *clique-step-install-interval*3625,164760
-(defun guess-and-putprop-type-prescription-lst-for-clique-step3633,165039
-(defun cleanse-type-prescriptions3697,167679
-(defun guess-and-putprop-type-prescription-lst-for-clique3765,170925
-(defun get-normalized-bodies 3816,173301
-(defun putprop-type-prescription-lst 3832,173921
-(defun putprop-level-no-lst 3977,179451
-(defun primitive-recursive-argp 4003,180791
-(defun primitive-recursive-callp 4067,184392
-(defun primitive-recursive-callsp 4072,184624
-(defun primitive-recursive-machinep 4077,184856
-(defun putprop-primitive-recursive-defunp-lst 4094,185612
-(defun make-controller-pocket 4128,187157
-(defun make-controller-alist1 4141,187630
-(defun make-controller-alist 4165,188779
-(defun max-nume-exceeded-error 4182,189635
-(defun putprop-defun-runic-mapping-pairs1 4191,190055
-(defun putprop-defun-runic-mapping-pairs 4228,191820
-(defun eval-ground-subexpressions-lst-lst 4310,196034
-(defun guard-clauses+ 4325,196617
-(defun guard-clauses-for-body 4334,197065
-(defun guard-clauses-for-fn 4358,198081
-(defun guard-clauses-for-clique 4428,201030
-(defun print-verify-guards-msg 4449,201891
-(defun collect-ideals 4475,202795
-(defun collect-non-ideals 4481,203034
-(defun collect-non-common-lisp-compliants 4487,203273
-(defun all-fnnames1-exec 4494,203593
-(defmacro all-fnnames-exec 4522,204785
-(defun chk-common-lisp-compliant-subfunctions4525,204858
-(defun chk-acceptable-verify-guards-formula 4554,206300
-(defun chk-acceptable-verify-guards 4601,208443
-(defun guard-obligation-clauses 4687,212141
-(defun guard-obligation 4760,215204
-(defun prove-guard-clauses-msg 4840,218771
-(defmacro verify-guards-formula 4877,220360
-(defun prove-guard-clauses 4925,222524
-(defun verify-guards-fn1 5013,226510
-(defun verify-guards-fn 5249,236636
-(defconst *super-defun-wart-table*5340,240289
-(defun project-out-columns-i-and-j 5389,242971
-(defconst *super-defun-wart-binding-alist*5395,243170
-(defconst *super-defun-wart-stobjs-in-alist*5398,243276
-(defun super-defun-wart-bindings 5401,243384
-(defun store-stobjs-ins 5408,243672
-(defun store-super-defun-warts-stobjs-in 5414,243924
-(defun collect-old-nameps 5428,244408
-(defun defuns-fn-short-cut 5434,244632
-(defun print-defun-msg/collect-type-prescriptions 5471,246434
-(defun print-defun-msg/type-prescriptions1 5495,247428
-(defun print-defun-msg/type-prescriptions 5537,249307
-(defun simple-signaturep 5580,250824
-(defun all-simple-signaturesp 5593,251304
-(defun print-defun-msg/signatures1 5598,251488
-(defun print-defun-msg/signatures 5622,252383
-(defun print-defun-msg 5635,252844
-(defun get-ignores 5663,253998
-(defun get-ignorables 5669,254162
-(defun chk-all-stobj-names 5675,254335
-(defun get-declared-stobj-names 5691,255036
-(defun get-stobjs-in-lst 5732,256888
-(defun chk-stobjs-out-bound 5784,259501
-(defun store-stobjs-out 5792,259836
-(defun unparse-signature 5801,260129
-(defun chk-defun-mode 5813,260556
-(defun scan-to-cltl-command 5827,261040
-(defconst *xargs-keywords*5841,261526
-(defun plausible-dclsp1 5851,261850
-(defun plausible-dclsp 5870,262671
-(defun dcl-fields1 5899,264032
-(defun dcl-fields 5906,264319
-(defun strip-keyword-list 5920,264837
-(defun strip-dcls1 5934,265340
-(defun strip-dcls 5947,265954
-(defun fetch-dcl-fields2 5965,266789
-(defun fetch-dcl-fields1 5975,267202
-(defun fetch-dcl-fields 5986,267745
-(defun fetch-dcl-field 5997,268251
-(defun set-equalp-eq 6015,269137
-(defun non-identical-defp-chk-measures 6023,269441
-(defun non-identical-defp 6077,271911
-(defun identical-defp 6260,281283
-(defun redundant-or-reclassifying-defunp0 6267,281524
-(defun redundant-or-reclassifying-defunp 6504,291700
-(defun redundant-or-reclassifying-defunsp10 6527,293081
-(defun redundant-or-reclassifying-defunsp1 6547,293961
-(defun recover-defs-lst 6552,294250
-(defun get-clique 6617,297517
-(defun redundant-or-reclassifying-defunsp0 6631,298113
-(defun get-unnormalized-bodies 6679,300930
-(defun strip-last-elements 6685,301179
-(defun redundant-or-reclassifying-defunsp 6691,301380
-(defun collect-when-cadr-eq 6842,309519
-(defun all-programp 6848,309733
-(defun formal-position 6925,313564
-(defun make-posns 6930,313723
-(defun relevant-posns-term 6937,313911
-(defun relevant-posns-term-lst 6958,314801
-(defun relevant-posns-call 6965,315073
-(defun relevant-posns-clique1 6995,316464
-(defun relevant-posns-clique-recur 7023,317690
-(defun relevant-posns-clique-init 7030,318078
-(defun relevant-posns-lambdas 7077,319869
-(defun relevant-posns-lambdas-lst 7089,320273
-(defun relevant-posns-merge 7096,320481
-(defun relevant-posns-lambdas-top 7108,321013
-(defun relevant-posns-clique 7112,321175
-(defun irrelevant-non-lambda-slots-clique2 7129,322125
-(defun irrelevant-non-lambda-slots-clique1 7137,322446
-(defun irrelevant-non-lambda-slots-clique 7149,322998
-(defun tilde-*-irrelevant-formals-msg1 7167,324016
-(defun tilde-*-irrelevant-formals-msg 7175,324382
-(defun chk-irrelevant-formals 7178,324514
-(deflabel irrelevant-formals7209,325859
-(defun chk-logic-subfunctions 7282,329270
-(defun get-non-classical-fns-from-list 7309,330527
-(defmacro get-non-classical-fns 7321,331048
-(defun get-non-classical-fns-aux 7325,331164
-(defun strip-missing-measures 7340,331779
-(defun chk-classical-measures 7348,332036
-(defun chk-no-recursive-non-classical 7368,332918
-(defun union-collect-non-x 7405,334697
-(defun translate-measures 7410,334872
-(defun redundant-predefined-error-msg 7442,336381
-(defun chk-acceptable-defuns-redundancy 7456,337055
-(defun chk-acceptable-defuns-verify-guards-er 7543,340687
-(defun chk-non-executablep 7604,343440
-(defun chk-acceptable-defuns0 7626,344330
-(defun get-boolean-unambiguous-xargs-flg-lst 7682,346821
-(defun chk-acceptable-defuns1 7690,347232
-(defun conditionally-memoized-fns 7988,360865
-(defun chk-acceptable-defuns 8006,361638
-(deflabel XARGS8131,367709
-(defmacro link-doc-to-keyword 8279,374766
-(defmacro link-doc-to 8295,375091
-(defun build-valid-std-usage-clause 8456,381772
-(defun verify-valid-std-usage 8464,382096
-(defun union-eq1-rev 8543,385702
-(defun collect-hereditarily-constrained-fnnames 8553,385973
-(defun putprop-hereditarily-constrained-fnnames-lst 8567,386553
-(defun defuns-fn1 8608,388565
-(defun defuns-fn0 8771,395990
-(defun strip-non-hidden-package-names 8822,397638
-(defun in-package-fn 8831,398062
-(defun defstobj-functionsp 8853,398905
-(defun index-of-non-number 8917,402541
-(defun non-std-error 8926,402747
-(defun non-std-body 8935,403153
-(defun non-std-def-lst 8949,403646
-(defun make-udf-insigs 8964,404212
-(defun intro-udf 8973,404501
-(defun intro-udf-lst1 9012,405896
-(defun intro-udf-lst2 9018,406101
-(defun intro-udf-lst 9056,407940
-(defun defun-ctx 9074,408758
-(defun install-event-defuns 9092,409382
-(defun defuns-fn 9143,411529
-(defun defun-fn 9286,417334
-(defun args-fn 9301,417877
-(defmacro args 9388,422087
-(defun make-verify-termination-def 9409,422720
-(defun make-verify-termination-defs-lst 9438,423972
-(defun chk-acceptable-verify-termination1 9454,424762
-(defun uniform-defun-modes 9492,426907
-(defun chk-acceptable-verify-termination 9506,427511
-(defun verify-termination1 9577,430722
-(defun verify-termination-boot-strap-fn 9610,432163
-(defmacro when-logic3 9641,433249
-(defun verify-termination-fn 9650,433515
-(defun fns-used-in-axioms 9677,434708
-(defun check-out-instantiablep1 9703,435681
-(defun check-out-instantiablep 9712,435969
-
-proof-checker-pkg.lisp,26
-(defpkg "ACL2-PC" 23,881
-
-proof-checker-a.lisp,4256
-(defmacro pc-value 29,1271
-(defmacro pc-assign 35,1467
-(defun initialize-pc-acl2 44,1747
-(defmacro state-stack 55,2076
-(defmacro old-ss 58,2129
-(defmacro ss-alist 63,2244
-(defun define-global-name 66,2291
-(defmacro define-global 71,2407
-(define-global pc-prompt)78,2623
-(define-global pc-prompt-depth-prefix)79,2649
-(define-global pc-print-macroexpansion-flg)80,2688
-(define-global pc-print-prompt-and-instr-flg)82,2786
-(defrec pc-state93,3346
-(defconst *pc-state-fields-for-primitives*102,3459
-(defmacro instruction 105,3572
-(defmacro goals 112,3790
-(defmacro abbreviations 119,3996
-(defmacro local-tag-tree 126,4218
-(defmacro pc-ens 133,4442
-(defmacro tag-tree 140,4650
-(defrec goal153,5192
-(defconst *goal-fields*159,5279
-(defmacro conc 162,5354
-(defmacro hyps 165,5449
-(defmacro current-addr 168,5544
-(defmacro goal-name 171,5655
-(defmacro depends-on 174,5760
-(defmacro make-official-pc-command 177,5867
-(defun intern-in-keyword-package 181,6021
-(defun make-pretty-pc-command 185,6142
-(defun make-pretty-pc-instr 190,6308
-(defmacro change-pc-state 201,6703
-(defun make-official-pc-instr 204,6787
-(defun check-formals-length 221,7430
-(defun check-&optional-and-&rest 250,8843
-(defun make-let-pairs-from-formals 276,9986
-(defun all-symbols 292,10609
-(defun all-symbols-list 306,10959
-(defun make-access-bindings 314,11099
-(defun let-form-for-pc-state-vars 320,11356
-(defun check-field-names 332,11875
-(defmacro print-no-change 342,12293
-(defmacro print-no-change2 345,12399
-(defun print-no-change-fn 349,12509
-(defmacro maybe-update-instruction 369,13303
-(defun add-pc-doc-header 378,13703
-(defun remove-doc 389,13990
-(defun pc-primitive-defun-form 396,14302
-(defun pc-command-table-guard 419,15194
-(defmacro add-pc-command 452,16071
-(defmacro pc-command-type 455,16167
-(defmacro print-no-change3 458,16273
-(defun add-pc-command-1 462,16412
-(defun toggle-pc-macro-fn 469,16616
-(defun pc-meta-or-macro-defun 494,18233
-(defun goal-names 513,19018
-(defun instructions-of-state-stack 519,19162
-(defmacro fms0 528,19442
-(defmacro with-output-forced 542,19986
-(defun print-pc-prompt 566,20775
-(defun pc-macroexpand 577,21128
-(defun find-goal 605,22419
-(defun print-all-goals-proved-message 612,22600
-(defmacro when-goals 621,22874
-(defmacro when-goals-trip 626,22979
-(defun current-immediate-deps 632,23125
-(defun goal-dependent-p 642,23550
-(defun current-all-deps 650,23766
-(defun maybe-print-proved-goal-message 660,24179
-(defun accumulate-ttree-in-pc-state 703,26335
-(defun pc-process-assumptions 710,26628
-(defun make-implication 737,27407
-(defun cl-set-to-implications 743,27557
-(defun known-assumptions 750,27792
-(defun add-assumptions-to-top-goal767,28524
-(defun unproved-goals 794,29767
-(defun make-pc-ens 802,29986
-(defun initial-rcnst-from-ens 807,30072
-(defun make-new-goals-fixed-hyps 817,30496
-(defun pc-single-step-primitive 830,30977
-(defun maybe-print-macroexpansion 1014,40452
-(defun pc-single-step-1 1033,41476
-(defun union-lastn-pc-tag-trees 1105,45355
-(defun pc-single-step 1118,45751
-(defconst *pc-complete-signal* 1149,47365
-(defmacro catch-throw-to-local-top-level 1151,47416
-(defun pc-main-loop 1179,48411
-(defun make-initial-goal 1264,51976
-(defun initial-state-stack 1272,52134
-(defun event-name-and-types-and-raw-term 1282,52526
-(defmacro install-initial-state-stack 1285,52648
-(defun pc-main1 1295,53051
-(defun pc-main 1302,53300
-(defun pc-top 1308,53624
-(defun illegal-fnp 1329,54338
-(defun illegal-fnp-list 1343,54725
-(defun verify-fn 1349,54868
-(defun print-unproved-goals-message 1403,56789
-(defun state-stack-from-instructions1412,57176
-(defun state-from-instructions1423,57657
-(defun print-pc-defthm 1431,57947
-(defmacro print-pc-goal 1442,58320
-(defmacro print-pc-state 1467,59442
-(defun proof-checker1486,60241
-(deflabel proof-checker-commands1571,64102
-(deflabel macro-command1581,64405
-(defmacro verify 1608,65634
-(deflabel instructions1660,67491
-(defun sublis-expr-non-quoteps 2246,89480
-(defun sublis-expr-non-quoteps-lst 2264,90244
-(defun invert-abbreviations-alist 2271,90446
-(defun abbreviate 2278,90677
-(defmacro untrans0 2283,90835
-(defun untrans0-lst-fn 2289,91030
-(defmacro untrans0-lst 2295,91260
-
-defthm.lisp,15168
-(defun remove-lambdas 51,2105
-(defun remove-lambdas-lst 61,2420
-(defun interpret-term-as-rewrite-rule2 72,2676
-(defun interpret-term-as-rewrite-rule1 107,3973
-(defun interpret-term-as-rewrite-rule 144,5842
-(defun non-recursive-fnnames 191,7520
-(defun non-recursive-fnnames-lst 206,8212
-(defun hide-lambdas1 217,8637
-(defun hide-lambdas 227,8991
-(defun variantp 237,9369
-(defun surrounding-fns1 255,9841
-(defun surrounding-fns-lst 283,10936
-(defun surrounding-fns 291,11154
-(defun loop-stopper1 317,12154
-(defun loop-stopper 327,12573
-(defun remove-irrelevant-loop-stopper-pairs 502,22921
-(defun put-match-free-value 520,23572
-(defun free-vars-in-hyps 538,24207
-(defun free-vars-in-hyps-simple 578,26063
-(defun free-vars-in-fc-hyps 590,26581
-(defun free-vars-in-hyps-considering-bind-free 602,26998
-(defun all-vars-in-hyps 669,30005
-(defun match-free-value 700,31295
-(defun match-free-fc-value 710,31608
-(defun rule-backchain-limit-lst 723,32205
-(defun create-rewrite-rule 731,32546
-(defun hyps-that-instantiate-free-vars 773,34336
-(defun maybe-one-way-unify 790,35023
-(defun maybe-one-way-unify-lst 808,35722
-(defun maybe-one-way-unify-with-some 815,36003
-(defun maybe-subsumes 824,36378
-(defun subsumes-rewrite-rule 849,37587
-(defun find-subsumed-rule-names 901,39816
-(defun find-subsuming-rule-names 918,40669
-(defun forced-hyps 934,41477
-(defun strip-top-level-nots-and-forces 943,41803
-(defun free-variable-error? 957,42386
-(defun extend-geneqv-alist 976,43434
-(defun covered-geneqv-alist 988,43848
-(defun covered-geneqv-alist-lst 1009,44746
-(defun uncovered-equivs 1019,45169
-(defun uncovered-equivs-alist 1029,45553
-(defun uncovered-equivs-alist-lst 1123,49818
-(defun double-rewrite-opportunities 1143,50828
-(defun show-double-rewrite-opportunities1 1244,56794
-(defun show-double-rewrite-opportunities 1279,58722
-(defun irrelevant-loop-stopper-pairs 1301,59814
-(defun chk-rewrite-rule-warnings 1313,60194
-(defun chk-acceptable-rewrite-rule2 1496,69429
-(defun chk-acceptable-rewrite-rule1 1527,70890
-(defun chk-acceptable-rewrite-rule 1546,71748
-(defun add-rewrite-rule2 1565,72732
-(defun add-rewrite-rule1 1638,76388
-(defun add-rewrite-rule 1659,77355
-(deflabel linear1675,78020
-(defun expand-inequality-fncall1 1813,85802
-(defun expand-inequality-fncall 1836,86777
-(defun all-vars-in-poly-lst 1881,89011
-(defun subbagp-eq 1892,89362
-(defun always-biggerp-data 1899,89561
-(defun always-biggerp-data-lst 1907,89752
-(defun always-biggerp 1915,89945
-(defun no-element-always-biggerp 1939,90998
-(defun maximal-terms1 1949,91355
-(defun maximal-terms 1964,91978
-(defun collect-when-ffnnamesp 1999,93714
-(defun make-free-max-terms-msg1 2009,94019
-(defun make-free-max-terms-msg 2036,95386
-(defun external-linearize 2052,95990
-(defun bad-synp-hyp-msg-for-linear 2062,96233
-(defun show-double-rewrite-opportunities-linear 2071,96613
-(defun chk-acceptable-linear-rule22092,97514
-(defun chk-acceptable-linear-rule1 2231,105251
-(defun chk-acceptable-linear-rule 2247,105930
-(defun add-linear-rule3 2265,106785
-(defun add-linear-rule2 2307,108738
-(defun add-linear-rule1 2322,109441
-(defun add-linear-rule 2338,110244
-(deflabel well-founded-relation2380,111640
-(defun destructure-well-founded-relation-rule 2557,119472
-(defun chk-acceptable-well-founded-relation-rule 2596,120789
-(defun add-well-founded-relation-rule 2633,122418
-(deflabel built-in-clause2645,122904
-(defun chk-acceptable-built-in-clause-rule2 2782,128255
-(defun chk-acceptable-built-in-clause-rule1 2807,129354
-(defun chk-acceptable-built-in-clause-rule 2821,129881
-(defun fn-and-maximal-level-no 2837,130613
-(defun fn-and-maximal-level-no-lst 2863,131870
-(defun built-in-clause-discriminator-fn 2872,132118
-(defun all-fnnames-subsumer 2878,132291
-(defun make-built-in-clause-rules1 2902,133724
-(defun chk-initial-built-in-clauses 2926,134901
-(defun make-built-in-clause-rules 2955,136141
-(defun classify-and-store-built-in-clause-rules 2971,136807
-(defun add-built-in-clause-rule 3017,139276
-(deflabel compound-recognizer3049,140776
-(defun destructure-compound-recognizer 3261,150903
-(defun make-recognizer-tuple 3319,153456
-(defun comment-on-new-recog-tuple1 3386,156444
-(defun comment-on-new-recog-tuple 3444,159543
-(defun chk-acceptable-compound-recognizer-rule 3507,162672
-(defun add-compound-recognizer-rule 3564,165075
-(deflabel forward-chaining3587,166134
-(defun chk-triggers 3739,174159
-(defun destructure-forward-chaining-term 3865,181363
-(defun chk-acceptable-forward-chaining-rule 3906,183285
-(defun putprop-forward-chaining-rules-lst3927,184031
-(defun add-forward-chaining-rule 3949,184996
-(deflabel meta3965,185733
-(deflabel evaluator-restrictions4350,205289
-(deflabel extended-metafunctions4823,222608
-(deflabel meta-extract5182,238726
-(defun evaluator-clause/arglist 5509,254946
-(defun evaluator-clause 5523,255536
-(defun evaluator-clauses1 5551,256533
-(defun evaluator-clauses 5556,256736
-(defun cdrp 5657,262216
-(defun expand-eq-and-atom-term-lst 5673,262765
-(defun normalize-alleged-evaluator-clause 5727,265166
-(defun normalize-alleged-evaluator-clause-set 5737,265511
-(defun shallow-clausify1 5742,265725
-(defun shallow-clausify 5755,266107
-(defun find-evfn-lst-in-clause 5775,266976
-(defun guess-evfn-lst-for-evfn 5806,268060
-(defun find-fn-in-clause 5818,268541
-(defun guess-fn-args-lst-for-evfn 5832,269057
-(defun normalized-evaluator-cl-set 5846,269742
-(defun chk-evaluator 5856,270066
-(defun defevaluator-form/defthms 5937,274080
-(defun defevaluator-form/fns-clauses 5952,274820
-(defconst *defevaluator-form-base-theory*5974,275590
-(defun defevaluator-form 5983,275933
-(defun pairs-to-macro-alias-msgs 6035,277998
-(defun defevaluator-check-msg 6042,278288
-(defun defevaluator-check 6078,280130
-(defun defevaluator-check-form 6104,281266
-(defmacro defevaluator 6118,281625
-(deflabel term-table6240,286660
-(defun remove-meta-extract-contextual-hyps 6276,288033
-(defun remove-meta-extract-global-hyps 6307,289428
-(defun meta-rule-hypothesis-functions 6327,290137
-(defun meta-fn-args 6369,291864
-(defun chk-meta-function 6395,292714
-(defun ev-lst-from-ev 6449,295121
-(defun attached-fns 6458,295327
-(defun siblings 6469,295778
-(defun canonical-sibling 6474,295937
-(defun canonical-ffn-symbs 6483,296238
-(defun canonical-ffn-symbs-lst 6510,297166
-(defun collect-canonical-siblings 6521,297442
-(defun immediate-canonical-ancestors 6533,297854
-(defun canonical-ancestors-rec 6560,299265
-(defun canonical-ancestors 6575,299810
-(defun canonical-ancestors-lst 6588,300347
-(defun chk-evaluator-use-in-rule 6596,300613
-(defun chk-rule-fn-guard 6748,308065
-(defun chk-acceptable-meta-rule 6792,310139
-(defun add-meta-rule1 6906,315584
-(defun maybe-putprop-lst 6920,316130
-(defun mark-attachment-disallowed2 6930,316483
-(defun mark-attachment-disallowed1 6956,317628
-(defun mark-attachment-disallowed 6965,317986
-(defun add-meta-rule 6978,318493
-(deflabel elim7033,320592
-(defun destructors 7174,327721
-(defun destructors-lst 7190,328355
-(defun strip-ffn-symbs 7197,328515
-(defun chk-acceptable-elim-rule1 7202,328657
-(defun chk-acceptable-elim-rule 7225,329668
-(defun add-elim-rule1 7280,331986
-(defun add-elim-rule 7305,333094
-(deflabel generalize7317,333537
-(defun chk-acceptable-generalize-rule 7346,334677
-(defun add-generalize-rule 7353,334869
-(deflabel type-prescription7365,335301
-(defun find-type-prescription-pat 7534,344405
-(defun type-prescription-disjunctp 7576,346152
-(defun type-prescription-conclp 7622,348359
-(defun subst-nil-into-type-prescription-disjunct 7647,349457
-(defun subst-nil-into-type-prescription-concl 7672,350410
-(defun unprettyify-tp 7704,351847
-(defun destructure-type-prescription 7721,352417
-(defun add-type-prescription-rule 7882,361549
-(defun strong-compound-recognizer-p 7959,364846
-(defun warned-non-rec-fns-for-tp 7969,365329
-(defun warned-non-rec-fns-tp-hyps1 7995,366406
-(defun warned-non-rec-fns-tp-hyps 8012,367243
-(defun chk-acceptable-type-prescription-rule 8017,367443
-(deflabel equivalence8140,374189
-(defun boolean-fn 8439,384067
-(defun reflexivity 8447,384265
-(defun symmetry 8453,384355
-(defun transitivity 8460,384469
-(defun equivalence-relation-condition 8468,384620
-(defun find-candidate-equivalence-relation 8486,385380
-(defun collect-problematic-pre-equivalence-rule-names 8500,385895
-(defun chk-acceptable-equivalence-rule 8519,386941
-(defun add-equivalence-rule 8642,393077
-(deflabel refinement8782,399185
-(defun chk-acceptable-refinement-rule 8833,401305
-(defun collect-coarsenings 8872,403240
-(defun putprop-coarsenings 8882,403569
-(defun union-values 8910,404870
-(defun extend-value-set 8918,405109
-(defun extend-each-value-set 8932,405774
-(defun close-value-sets 8942,406105
-(defun add-refinement-rule 8956,406733
-(deflabel congruence8977,407527
-(defun corresponding-args-eq-except 9121,414358
-(defun interpret-term-as-congruence-rule 9135,414951
-(defun some-congruence-rule-same 9216,418879
-(defun some-congruence-rule-has-refinement 9225,419175
-(defun chk-acceptable-congruence-rule 9235,419533
-(defun putnth 9313,423279
-(defun add-congruence-rule-to-congruence 9320,423541
-(defun add-congruence-rule 9330,423948
-(deflabel definition9376,426136
-(defun chk-destructure-definition 9536,435561
-(defun chk-acceptable-definition-install-body 9548,436124
-(defun chk-acceptable-definition-rule9619,439071
-(deflabel induction9669,441217
-(defun chk-acceptable-induction-rule 9837,449925
-(defun add-induction-rule 9844,450116
-(deflabel type-set-inverter9861,450786
-(defun chk-acceptable-type-set-inverter-rule 9918,453280
-(defun add-type-set-inverter-rule 9986,456170
-(deflabel clause-processor10015,457292
-(defun tilde-@-illegal-clause-processor-sig-msg 10290,470622
-(defun destructure-clause-processor-rule 10325,471833
-(defun chk-acceptable-clause-processor-rule 10350,472832
-(defun add-clause-processor-rule 10458,478452
-(defun trusted-clause-processor-table-guard 10503,480310
-(defmacro define-trusted-clause-processor10584,484159
-(defun primitive-instructionp 11014,503721
-(defun non-primitive-instructions 11022,504034
-(defun chk-primitive-instruction-listp 11032,504347
-(defun translate-instructions 11040,504586
-(defun controller-alistp 11047,504834
-(defun alist-to-keyword-alist 11067,505571
-(defun loop-stopper-alist-p 11079,506009
-(defun guess-controller-alist-for-definition-rule 11092,506363
-(defun chk-legal-linear-trigger-terms1 11107,507086
-(defun chk-legal-linear-trigger-terms 11128,508116
-(defun backchain-limit-listp 11156,509530
-(defun eliminate-macro-aliases 11169,509840
-(defun translate-rule-class-alist 11196,511212
-(defun translate-rule-class1 11909,549554
-(defun reason-for-non-keyword-value-listp 11970,552287
-(defun translate-rule-class 11989,552851
-(defun translate-rule-classes1 12040,555158
-(defun translate-rule-classes 12062,556016
-(defun chk-acceptable-x-rule 12093,557485
-(defun chk-acceptable-x-rules 12178,561277
-(defun collect-keys-eq 12193,561980
-(defun chk-acceptable-rules 12202,562336
-(defun add-x-rule 12292,565558
-(defun add-rules1 12403,570588
-(defun truncate-class-alist 12422,571428
-(defun truncate-classes 12440,572219
-(defun make-runes1 12458,573098
-(defun make-runes 12497,574743
-(defun make-runic-mapping-pairs 12505,574981
-(defun add-rules 12519,575520
-(defun redundant-theoremp 12542,576728
-(defun non-tautological-classes 12555,577306
-(defun prove-corollaries1 12573,578103
-(defun prove-corollaries 12633,581134
-(defun enabled-runep-string 12667,582557
-(defun untranslate-hyps 12672,582671
-(defun info-for-lemmas 12677,582848
-(defun world-to-next-event 12714,584831
-(defun assoc-eq-eq 12722,585082
-(defun actual-props 12733,585418
-(defun info-for-well-founded-relation-rules 12751,586040
-(defun info-for-built-in-clause-rules1 12766,586638
-(defun info-for-built-in-clause-rules 12783,587427
-(defun info-for-compound-recognizer-rules 12789,587667
-(defun info-for-generalize-rules 12813,588849
-(defun info-for-linear-lemmas 12830,589612
-(defun info-for-eliminate-destructors-rule 12860,591245
-(defun info-for-congruences 12888,592722
-(defun info-for-coarsenings 12896,592931
-(defun info-for-forward-chaining-rules 12904,593124
-(defun decode-type-set-lst 12932,594502
-(defun info-for-type-prescriptions 12938,594641
-(defun info-for-induction-rules 12968,596211
-(defun info-for-type-set-inverter-rules 12991,597320
-(defun info-for-x-rules 13011,598263
-(defun info-for-rules 13070,600376
-(defun print-info-for-rules-entry 13080,600767
-(defun print-info-for-rules 13105,601962
-(defun pr-body 13115,602342
-(defun pr-fn 13124,602584
-(defun print-clause-processor-rules1 13138,603249
-(defmacro print-clause-processor-rules 13151,603772
-(defun new-numes 13157,604006
-(defun world-to-next-command 13168,604359
-(defun pr!-fn 13175,604627
-(defmacro pr 13184,604918
-(defmacro pr! 13231,606511
-(defun disabledp-fn-lst 13258,607441
-(defun disabledp-fn 13265,607762
-(defmacro disabledp 13288,608758
-(defun access-x-rule-rune 13318,609992
-(defun collect-x-rules-of-rune 13362,612248
-(defun collect-congruence-rules-of-rune-in-geneqv-lst 13373,612653
-(defun collect-congruence-rules-of-rune 13385,613102
-(defun find-rules-of-rune2 13400,613748
-(defun find-rules-of-rune1 13494,617830
-(defun find-rules-of-rune 13510,618581
-(defun collect-non-backchain-subclass 13554,620591
-(defun chk-acceptable-monitor 13564,620967
-(defun chk-acceptable-monitors 13639,624593
-(defun monitor1 13660,625446
-(defun unmonitor1 13679,626212
-(defun monitor-fn 13698,626999
-(defun unmonitor-fn 13724,627823
-(defun monitored-runes-fn 13767,629398
-(defun brr-fn 13783,629857
-(defmacro brr 13798,630286
-(deflabel why-brr13870,634252
-(defmacro brr@ 13927,637323
-(defmacro monitor 14054,644088
-(defmacro unmonitor 14224,653168
-(defmacro monitored-runes 14251,654043
-(defun proceed-from-brkpt1 14267,654428
-(defun exit-brr 14299,655695
-(defun ok-if-fn 14310,656066
-(defmacro ok-if 14318,656311
-(defun print-rule-storage-dependencies 14365,658356
-(defun defaxiom-supporters 14382,658968
-(defun defaxiom-fn 14435,661809
-(defun warn-on-inappropriate-defun-mode 14528,666196
-(defun add-hyp-standardp-var-lst 14542,666716
-(defun strengthen-hyps-using-transfer-principle 14549,666904
-(defun weaken-using-transfer-principle 14561,667244
-(defun remove-standardp-hyp 14585,668114
-(defun remove-standardp-hyps 14593,668349
-(defun remove-standardp-hyps-and-standardp-conclusion 14605,668752
-(defun chk-classical-term-or-standardp-of-classical-term 14616,669109
-(defmacro with-waterfall-parallelism-timings 14634,669866
-(defmacro with-waterfall-parallelism-timings 14644,670274
-(defun defthm-fn1 14648,670366
-(defun defthm-fn 14794,677436
-(defmacro thm 14817,678038
-(defun thm-fn 14849,678863
-(defun chk-extensible-rule-classes 14882,680292
-(defun extend-rule-classes 14891,680640
-(defun gen-new-name-in-package-of-symbol1 14902,681000
-(defun gen-new-name-in-package-of-symbol 14922,681796
-(defmacro defequiv 14942,682518
-(defmacro defrefinement 15001,684610
-(defmacro defcong 15056,686545
-
-other-events.lisp,31305
-(defun legal-initp 46,2129
-(defun macro-arglist-keysp 58,2576
-(defun macro-arglist-after-restp 91,4156
-(defun macro-arglist-optionalp 98,4362
-(defun macro-arglist1p 125,5340
-(defun subsequencep 142,5953
-(defun collect-lambda-keywordps 155,6395
-(defun macro-args-structurep 162,6655
-(defun macro-vars-key 182,7611
-(defun macro-vars-after-rest 206,8490
-(defun macro-vars-optional 219,8841
-(defun macro-vars 240,9591
-(defun chk-legal-defconst-name 260,10312
-(defun defconst-fn1 274,10944
-(defvar *hcomp-fn-ht* 285,11207
-(defvar *hcomp-const-ht* 286,11234
-(defvar *hcomp-macro-ht* 287,11264
-(defvar *hcomp-fn-alist* 288,11294
-(defvar *hcomp-const-alist* 289,11324
-(defvar *hcomp-macro-alist* 290,11357
-(defconstant *hcomp-fake-value* 291,11390
-(defvar *hcomp-book-ht* 292,11457
-(defvar *hcomp-const-restore-ht* 293,11486
-(defvar *hcomp-fn-macro-restore-ht*294,11524
-(defvar *declaim-list* 327,12707
-(defrec hcomp-book-ht-entry331,12739
-(defun defconst-val-raw 341,13031
-(defun defconst-val 352,13520
-(defun defconst-fn 437,16794
-(defun chk-legal-init-msg 495,19265
-(defun chk-legal-init 520,20228
-(defun chk-macro-arglist-keys 525,20372
-(defun chk-macro-arglist-after-rest 598,24489
-(defun chk-macro-arglist-optional 605,24749
-(defun chk-macro-arglist1 640,26388
-(defun chk-macro-arglist-msg 660,27229
-(defun chk-macro-arglist 740,31252
-(defun defmacro-fn1 745,31438
-(defun chk-defmacro-width 761,31975
-(defun redundant-defmacrop 775,32477
-(defun defmacro-fn 793,33303
-(defconst *initial-event-defmacros*924,40005
-(defun boot-translate 1145,47975
-(defun primordial-event-macro-and-fn1 1188,49682
-(defun primordial-event-macro-and-fn 1217,51099
-(defun primordial-event-macros-and-fns 1352,57759
-(defconst *initial-type-prescriptions*1368,58354
-(defun collect-world-globals 1390,59173
-(defun primordial-world-globals 1397,59443
-(defun arglists-to-nils 1543,66376
-(defconst *unattachable-primitives*1549,66604
-(defun primordial-world 1567,67327
-(defun same-name-twice 1633,69758
-(defun conflicting-imports 1641,69990
-(defun chk-new-stringp-name 1648,70161
-(deflabel package-reincarnation-import-restrictions1687,71708
-(defun chk-package-reincarnation-import-restrictions 1750,75064
-(defun convert-book-name-to-cert-name 1762,75502
-(defun unrelativize-book-path 1785,76393
-(defun tilde-@-defpkg-error-phrase 1794,76769
-(defconst *1*-pkg-prefix*1843,79444
-(defun chk-acceptable-defpkg 1856,79870
-(defun defpkg-fn 2051,88540
-(defun theory-fn-callp 2227,97463
-(defun intersection-augmented-theories-fn1 2250,98324
-(defmacro check-theory 2270,99292
-(defun intersection-theories-fn 2278,99602
-(defmacro intersection-theories 2287,99949
-(defun union-augmented-theories-fn1 2319,100932
-(defun union-theories-fn1 2336,101784
-(defun union-theories-fn 2360,102881
-(defmacro union-theories 2399,104341
-(defun set-difference-augmented-theories-fn1 2445,105634
-(defun set-difference-theories-fn1 2460,106357
-(defun set-difference-theories-fn 2484,107437
-(defmacro set-difference-theories 2515,108629
-(defun universal-theory-fn1 2554,109927
-(defun universal-theory-fn 2606,112784
-(defmacro universal-theory 2637,114333
-(defun function-theory-fn1 2687,116381
-(defun function-theory-fn 2747,119291
-(defmacro function-theory 2763,119949
-(defun executable-counterpart-theory-fn 2802,121270
-(defmacro executable-counterpart-theory 2817,121907
-(defun standard-theories 2860,123458
-(defun current-theory-fn 2866,123708
-(defmacro current-theory 2886,124505
-(defconst *initial-return-last-table*3020,129504
-(defun end-prehistoric-world 3048,130808
-(defun theory-namep 3092,132859
-(defun theory-fn 3101,133116
-(defmacro theory 3113,133525
-(defun deftheory-fn 3143,134378
-(defun in-theory-fn 3265,139739
-(defun in-arithmetic-theory-fn 3331,142458
-(defmacro disable 3394,145088
-(defmacro enable 3434,146420
-(defmacro theory-invariant 3488,148320
-(defmacro theory-invariant 3689,158301
-(defmacro incompatible 3693,158375
-(deflabel signature3734,159849
-(defconst *generic-bad-signature-string*3883,167450
-(defconst *signature-keywords*3889,167737
-(defun duplicate-key-in-keyword-value-listp 3894,167844
-(defun chk-signature 3901,168089
-(defun chk-signatures 4167,180936
-(defun chk-acceptable-encapsulate1 4219,183551
-(defun primitive-event-macros 4270,186130
-(deflabel embedded-event-form4409,190800
-(defun name-introduced 4564,197104
-(defun chk-embedded-event-form-orig-form-msg 4641,200584
-(defun chk-embedded-event-form 4648,200833
-(defun destructure-expansion 5005,218572
-(defun rebuild-expansion 5020,219160
-(defun set-raw-mode-on 5025,219337
-(defun set-raw-mode-off 5030,219504
-(defmacro set-raw-mode-on! 5036,219691
-(defmacro set-raw-mode 5054,220339
-(defun-one-output stobj-out 5193,226900
-(defun mv-ref! 5204,227292
-(defmacro add-raw-arity 5243,228120
-(defmacro remove-raw-arity 5296,230136
-(defun raw-arity 5320,230967
-(defun alist-to-bindings 5383,233679
-(defun-one-output acl2-raw-eval-form-to-eval 5390,233861
-(defun acl2-raw-eval 5420,235084
-(defun acl2-raw-eval 5443,235969
-(defun acl2-raw-eval 5461,236665
-(defun get-and-chk-last-make-event-expansion 5464,236740
-(defconst *local-value-triple-elided*5491,237923
-(defun elide-locals-rec 5501,238181
-(defun elide-locals-lst 5556,240791
-(defun elide-locals 5567,241232
-(defun make-record-expansion 5591,242397
-(defun eval-event-lst 5598,242620
-(defun equal-insig 5803,252953
-(defun bad-signature-alist 5823,253870
-(defmacro if-ns 5888,256999
-(defun tilde-*-bad-insigs-phrase1 5907,257523
-(defun tilde-*-bad-insigs-phrase 5934,258822
-(defun union-eq-cars 5946,259318
-(defun chk-acceptable-encapsulate2 5950,259441
-(defun conjoin-into-alist 5993,261193
-(defun classes-theorems 6007,261722
-(defun constraints-introduced1 6019,262106
-(defun new-trips 6035,262733
-(defun constraints-introduced 6115,267054
-(defun putprop-constraints 6235,272283
-(deflabel local-incompatibility6269,273783
-(defun maybe-install-acl2-defaults-table 6371,278910
-(defun in-encapsulatep 6389,279602
-(defun update-for-redo-flat 6405,280163
-(defmacro redo-flat 6424,280906
-(defun cert-op 6574,287996
-(defun eval-event-lst-environment 6592,288728
-(defun process-embedded-events6611,289465
-(defun constrained-functions 6901,304925
-(defun collect-logicals 6927,306172
-(defun exported-function-names 6936,306456
-(defun get-subversives 6948,306874
-(defun ancestral-ffn-symbs-lst 6958,307299
-(defun constraints-list 6962,307454
-(defun encapsulate-constraint 6977,308166
-(defun new-dependent-clause-processors 7087,313388
-(defun bogus-exported-compliants 7104,314095
-(defun encapsulate-pass-2 7157,316678
-(defun tilde-@-abbreviate-object-phrase 7948,346964
-(defun encapsulate-ctx 7982,348021
-(defun print-encapsulate-msg1 8008,349088
-(defun print-encapsulate-msg2 8025,349794
-(defun print-encapsulate-msg3/exported-names 8037,350128
-(defun print-encapsulate-msg3/constraints 8056,350732
-(defun print-encapsulate-msg3 8104,352720
-(defun find-first-non-local-name 8181,356750
-(defun find-first-non-local-name-lst 8252,359586
-(defun corresponding-encap-events 8271,360415
-(defun corresponding-encaps 8298,361521
-(defun redundant-encapsulate-tuplep 8306,361765
-(defun redundant-encapsulatep 8345,363772
-(defun mark-missing-as-hidden-p 8427,367834
-(defun known-package-alist-included-p 8440,368359
-(defun encapsulate-fix-known-package-alist 8453,368913
-(defun subst-by-position1 8488,370868
-(defun subst-by-position 8508,371585
-(defun intro-udf-guards 8526,372404
-(defun intro-udf-non-classicalp 8567,374210
-(defun assoc-proof-supporters-alist 8582,374989
-(defun update-proof-supporters-alist-3 8590,375281
-(defun posn-first-non-event 8617,376481
-(defun update-proof-supporters-alist-2 8624,376732
-(defun update-proof-supporters-alist-1 8635,377231
-(defun update-proof-supporters-alist 8653,378114
-(defun install-proof-supporters-alist 8674,379006
-(defun encapsulate-fn 8687,379599
-(defun progn-fn1 9043,398591
-(defun progn-fn 9131,402618
-(defun progn!-fn 9134,402686
-(defun make-event-ctx 9140,403003
-(defun protected-eval 9145,403171
-(defun make-event-debug-pre 9206,405982
-(defun make-event-debug-post 9223,406705
-(defmacro do-proofs? 9232,407067
-(defun make-event-fn 9249,407582
-(deflabel books9552,422175
-(deflabel community-books9616,425444
-(defun chk-book-name 9634,426147
-(defun include-book-alist-subsetp 9679,428197
-(defun get-portcullis-cmds 9719,430150
-(defun remove-after-last-directory-separator 9752,431556
-(defun merge-using-dot-dot 9760,431880
-(defun our-merge-pathnames 9794,433187
-(defun expand-tilde-to-user-home-dir 9825,434336
-(defvar *canonical-unix-pathname-action*9862,435835
-(defun canonical-unix-pathname 9874,436366
-(defun unix-truename-pathname 9960,441338
-(defun chk-live-state-p 9980,442153
-(defun-overrides canonical-pathname 9992,442584
-(defun acl2-magic-canonical-pathname 9999,442813
-(defdoc canonical-pathname10030,443816
-(defun canonical-dirname! 10069,445706
-(defun directory-of-absolute-pathname 10080,446132
-(defun extend-pathname 10086,446342
-(defun maybe-add-separator 10130,448363
-(defun set-cbd-fn 10136,448563
-(defmacro set-cbd 10174,450117
-(defun set-cbd-state 10205,451176
-(defun parse-book-name 10221,451675
-(defun cbd-fn 10276,454056
-(defmacro cbd 10283,454363
-(defun make-include-books-absolute 10399,460059
-(defun make-include-books-absolute-lst 10607,469850
-(defun first-known-package-alist 10620,470378
-(defmacro string-prefixp 10640,471070
-(defun relativize-book-path 10649,471348
-(defun relativize-book-path-lst1 10674,472345
-(defun relativize-book-path-lst 10681,472631
-(defun defpkg-items-rec 10689,472932
-(defun defpkg-items 10762,476526
-(defun new-defpkg-list2 10775,477038
-(defun make-hidden-defpkg 10799,477873
-(defun new-defpkg-list110808,478183
-(defun new-defpkg-list 10842,479515
-(defun term-ignore-okp 10885,481908
-(defun term-list-ignore-okp 10896,482290
-(defun hidden-defpkg-events1 10904,482441
-(defun hidden-defpkg-events 10960,484643
-(defun fix-portcullis-cmds1 10968,484971
-(defun fix-portcullis-cmds 10979,485478
-(defun collect-uncertified-books 11031,488129
-(defun chk-in-package 11045,488706
-(defmacro ill-formed-certificate-er 11088,490605
-(defun include-book-er-warning-summary 11114,491553
-(defun include-book-er1 11162,493453
-(defun include-book-er 11177,494124
-(defun post-alist-from-channel 11202,495440
-(defun certificate-file-and-input-channel1 11229,496612
-(defmacro pcert-op-p 11237,496883
-(defun certificate-file-and-input-channel 11240,496994
-(defun cert-annotations-and-checksum-from-cert-file 11280,498896
-(defun tilde-@-cert-post-alist-phrase 11300,499726
-(defun tilde-*-book-check-sums-phrase1 11339,501808
-(defun tilde-*-book-check-sums-phrase 11398,504513
-(defun get-cmds-from-portcullis1 11414,505251
-(defun hidden-defpkg-events-simple 11445,506497
-(defun get-cmds-from-portcullis 11469,507187
-(defun convert-book-name-to-port-name 11501,508490
-(defun chk-raise-portcullis2 11510,508807
-(defun initial-acl2-defaults-table 11592,512966
-(defun chk-raise-portcullis1 11600,513293
-(defun mark-local-included-books 11631,514554
-(defun unmark-and-delete-local-included-books 11663,516234
-(defun decimal-string-to-number 11678,516956
-(defun parse-version 11709,518339
-(defun-one-output latest-release-note-string 11754,520387
-(defun earlier-acl2-versionp 11762,520689
-(defun acl2-version-r-p 11791,521781
-(defun ttag-alistp 11797,521954
-(defun cert-annotationsp 11809,522295
-(defun include-book-alist-entryp 11823,522688
-(defun include-book-alistp1 11835,523143
-(defun include-book-alistp 11850,523692
-(defrec cert-obj11860,524127
-(defun check-sum-cert-obj 11874,524705
-(defun chk-raise-portcullis 11885,525212
-(defun chk-certificate-file1 12106,535518
-(defun certificate-file 12219,540889
-(defun chk-certificate-file 12227,541233
-(defun equal-modulo-hidden-defpkgs 12321,546230
-(defun cert-obj-for-convert 12339,546933
-(defun symbol-name-equal 12386,549592
-(defun chk-acceptable-certify-book1 12391,549723
-(defun translate-book-names 12502,554912
-(defun fix-ttags 12516,555501
-(defun chk-well-formed-ttags 12556,557418
-(defun check-certificate-file-exists 12567,557827
-(defun chk-acceptable-certify-book 12601,559610
-(defun print-objects 12766,568451
-(defun replace-initial-substring 12771,568627
-(defun replace-string-prefix-in-tree 12784,569101
-(defmacro with-output-object-channel-sharing 12796,569682
-(defun elide-locals-and-split-expansion-alist 12833,571106
-(defun make-certificate-file1 12879,573610
-(defun make-certificate-file-relocated 12958,576967
-(defun make-certificate-file 12975,577648
-(defun make-certificate-files 13120,584990
-(defun open-input-object-file 13163,587055
-(defun read-object-file1 13185,587937
-(defun read-object-file 13197,588391
-(defun chk-cert-annotations13214,589223
-(defun chk-cert-annotations-post-alist13282,592526
-(defun chk-input-object-file 13369,596616
-(defun include-book-dir 13383,597252
-(defmacro include-book-dir-with-chk 13395,597813
-(defun newly-defined-top-level-fns-rec 13414,598762
-(defun newly-defined-top-level-fns 13448,600376
-(defun accumulate-post-alist 13479,601548
-(defun skipped-proofsp-in-post-alist 13498,602418
-(defun check-sum-cert 13517,603095
-(defmacro with-hcomp-bindings 13530,603632
-(defmacro with-hcomp-bindings 13535,603728
-(defmacro with-hcomp-ht-bindings 13552,604342
-(defmacro with-hcomp-ht-bindings 13556,604408
-(defun get-declaim-list 13589,605954
-(defun tilde-@-book-stack-msg 13595,606078
-(defun convert-book-name-to-acl2x-name 13627,607631
-(defun acl2x-alistp 13639,608030
-(defun read-acl2x-file 13649,608298
-(defun eval-port-file 13710,610908
-(defun getenv! 13783,614271
-(defun update-pcert-books 13792,614517
-(defun convert-non-nil-symbols-to-keywords 13800,614773
-(defun include-book-fn1 13808,615061
-(defun include-book-fn 14533,652155
-(defun spontaneous-decertificationp1 14635,656687
-(defun spontaneous-decertificationp 14681,658839
-(defun remove-duplicates-equal-from-end 14691,659260
-(defun include-book-alist-subsetp-failure-witnesses 14697,659523
-(defun expansion-filename 14807,665854
-(defun write-expansion-file 14824,666490
-(defun collect-ideal-user-defuns1 14999,674887
-(defun collect-ideal-user-defuns 15028,675947
-(defun set-difference-eq-sorted 15035,676186
-(defun expansion-alist-pkg-names0 15048,676719
-(defun hons-union-ordered-string-lists 15063,677240
-(defun expansion-alist-pkg-names-memoize 15080,677782
-(defun expansion-alist-pkg-names 15090,678093
-(defun delete-names-from-kpa 15121,679524
-(defun print-certify-book-step-2 15130,679806
-(defun print-certify-book-step-3 15160,681504
-(defun print-certify-book-guards-warning15170,681926
-(defun chk-certify-book-step-3 15198,683003
-(defun print-certify-book-step-4 15262,686709
-(defun print-certify-book-step-5 15278,687391
-(defun hcomp-build-from-portcullis 15285,687648
-(defstub acl2x-expansion-alist 15384,693165
-(defun hons-copy-with-state 15395,693640
-(defun identity-with-state 15400,693766
-(defattach (acl2x-expansion-alist15405,693879
-(defun write-acl2x-file 15415,694233
-(defun merge-into-expansion-alist1 15436,694992
-(defun acl2x-alistp-domains-subsetp 15463,696477
-(defun merge-into-expansion-alist 15476,696866
-(defun restrict-expansion-alist 15502,698110
-(defun elide-locals-from-expansion-alist 15514,698521
-(defun write-port-file 15530,699189
-(defmacro save-parallelism-settings 15559,700199
-(defun include-book-alist-equal-modulo-local 15572,700649
-(defun copy-object-channel-until-marker 15594,701841
-(defun copy-pcert0-to-pcert1 15604,702245
-(defun touch? 15635,703719
-(defun convert-book-name-to-compiled-name 15672,705430
-(defun certify-book-finish-convert 15682,705836
-(defun delete-cert-files 15715,707539
-(defun include-book-alist-uncertified-books 15725,707898
-(defun count-forms-in-channel 15762,709612
-(defun skip-forms-in-channel 15768,709821
-(defun post-alist-from-pcert1-1 15775,710101
-(defun post-alist-from-pcert1 15823,711809
-(defun certificate-post-alist 15840,712283
-(defun certify-book-finish-complete 15856,713028
-(defun expansion-alist-conflict 15910,715398
-(defun chk-absstobj-invariants 15942,717101
-(defun certify-book-fn 15997,719672
-(defmacro certify-book 16819,768510
-(defmacro certify-book! 17064,782409
-(defdoc provisional-certification17098,783820
-(deflabel pathname17421,802358
-(deflabel book-example17466,804708
-(deflabel full-book-name17637,813663
-(deflabel book-name17682,815510
-(deflabel book-contents17773,819761
-(deflabel certificate17851,823068
-(deflabel portcullis17934,827462
-(deflabel version18046,833569
-(deflabel keep18140,838572
-(deflabel uncertified-books18173,840142
-(deflabel books-certification-classic18236,843598
-(defdoc books-certification18481,855428
-(defun redundant-defchoosep 18747,867243
-(defun chk-arglist-for-defchoose 18761,867852
-(defun defchoose-constraint-basic 18779,868686
-(defun generate-variable-lst-simple 18820,870027
-(defun defchoose-constraint-extra 18837,870680
-(defun defchoose-constraint 18912,874553
-(defun defchoose-fn 18925,875128
-(defun non-acceptable-defun-sk-p 19095,883562
-(defmacro defun-sk 19175,887562
-(deflabel forall19548,904343
-(deflabel exists19562,904734
-(deflabel defun-sk-example19576,905129
-(defdoc quantifier-tutorial19672,908623
-(deflabel quantifiers20275,936125
-(deflabel quantifiers-using-recursion20312,937884
-(deflabel quantifiers-using-defun-sk20343,938717
-(deflabel quantifiers-using-defun-sk-extended20393,940343
-(defun doublet-style-symbol-to-symbol-alistp 20487,943473
-(defun chk-legal-defstobj-name 20500,943999
-(defun chk-unrestricted-guards-for-user-fns 20513,944479
-(defconst *expt2-28* 20526,945026
-(defun fix-stobj-array-type 20528,945061
-(defun chk-stobj-field-descriptor 20550,945915
-(defun chk-acceptable-defstobj-renaming20734,955082
-(defun defconst-name 20864,961324
-(defun chk-acceptable-defstobj120869,961446
-(defconst *defstobj-keywords*20962,966426
-(defun defstobj-redundancy-bundle 20965,966500
-(defun old-defstobj-redundancy-bundle 20999,967568
-(defun redundant-defstobjp 21012,968059
-(defun congruent-stobj-fields 21038,969418
-(defun chk-acceptable-defstobj 21049,969851
-(defun defstobj-fields-template 21217,977677
-(defun defstobj-template 21263,979678
-(defun defstobj-component-recognizer-calls 21309,981825
-(defun defstobj-component-recognizer-axiomatic-defs 21336,982969
-(defun defstobj-field-fns-axiomatic-defs 21408,986233
-(defun defstobj-axiomatic-init-fields 21522,992011
-(defun defstobj-creator-fn 21546,992953
-(defun defstobj-axiomatic-defs 21556,993245
-(defun simple-array-type 21595,995032
-(defun-one-output stobj-copy-array-aref 21607,995417
-(defun-one-output stobj-copy-array-svref 21625,996128
-(defun-one-output stobj-copy-array-fix-aref 21640,996585
-(defmacro live-stobjp 21657,997260
-(defun array-etype-is-fixnum-type 21667,997692
-(defun defstobj-field-fns-raw-defs 21703,999081
-(defun defstobj-raw-init-fields 21884,1007773
-(defun defstobj-raw-init 21941,1010272
-(defun defstobj-raw-defs 21949,1010517
-(defun put-stobjs-in-and-outs1 21996,1012527
-(defun put-stobjs-in-and-outs 22042,1014193
-(defun defconst-name-alist 22095,1016510
-(defun accessor-array 22101,1016670
-(defun strip-accessor-names 22111,1017089
-(defun defstobj-defconsts 22121,1017336
-(defun defstobj-fn 22127,1017521
-(defun absstobj-name 22575,1041832
-(defmacro defabsstobj 22604,1042988
-(defmacro defabsstobj 22715,1047678
-(defun concrete-stobj 23372,1080108
-(defmacro defabsstobj-missing-events 23380,1080387
-(defun redundant-defabsstobjp 23426,1082466
-(defun absstobj-correspondence-concl-lst 23430,1082628
-(defun absstobj-correspondence-formula 23441,1083156
-(defun absstobj-preserved-formula 23492,1085192
-(defrec absstobj-method23542,1087074
-(defun fn-stobj-updates-p 23561,1087787
-(defun stobj-updates-p 23585,1088477
-(defun stobj-updates-listp 23660,1091277
-(defun unprotected-export-p 23670,1091632
-(defun translate-absstobj-field 23674,1091777
-(defun simple-translate-absstobj-fields 24020,1111048
-(defun one-way-unify-p 24042,1112003
-(defun obviously-iff-equiv-terms 24052,1112266
-(defun chk-defabsstobj-method-lemmas 24097,1114285
-(defun chk-defabsstobj-method 24210,1119801
-(defun chk-acceptable-defabsstobj1 24234,1120858
-(defun first-keyword 24281,1122822
-(defun chk-acceptable-defabsstobj 24288,1123009
-(defun defabsstobj-axiomatic-defs 24373,1126942
-(defun defabsstobj-raw-def 24393,1127989
-(defun defabsstobj-raw-defs-rec 24443,1130121
-(defun defabsstobj-raw-defs 24451,1130338
-(defun expand-recognizer 24487,1131969
-(defun put-absstobjs-in-and-outs 24502,1132632
-(defun method-exec 24520,1133491
-(defun defabsstobj-raw-init 24529,1133826
-(defun defabsstobj-missing-msg 24532,1133920
-(defun update-guard-post 24556,1135021
-(defun defabsstobj-logic-subst 24576,1136127
-(defun chk-defabsstobj-guard 24582,1136387
-(defun chk-defabsstobj-guards1 24607,1137666
-(defun chk-defabsstobj-guards 24623,1138400
-(defun make-absstobj-logic-exec-pairs 24635,1138980
-(defun defabsstobj-fn1 24641,1139264
-(defun defabsstobj-fn 24858,1149879
-(deflabel stobj24878,1150944
-(deflabel stobj-example-124981,1156337
-(deflabel declare-stobjs25214,1165595
-(deflabel stobj-example-1-defuns25265,1167835
-(deflabel stobj-example-1-implementation25384,1172480
-(deflabel stobj-example-1-proofs25459,1175292
-(deflabel stobj-example-225609,1180852
-(deflabel stobj-example-325703,1183936
-(defdoc resize-list25941,1192963
-(defun-one-output mv-let-for-with-local-stobj 25955,1193483
-(defmacro with-local-stobj 26021,1196856
-(deflabel with-local-stobj26257,1203103
-(defun create-state 26337,1206209
-(defmacro with-local-state 26341,1206306
-(defmacro stobj-let 26630,1218057
-(defun push-untouchable-fn 27138,1240951
-(defun remove-untouchable-fn 27193,1243032
-(defun def-body-lemmas 27248,1245216
-(defmacro show-bodies 27256,1245526
-(defun set-body-fn1 27306,1247628
-(defun set-body-fn 27316,1247994
-(defdoc trace27362,1249653
-(defparameter *trace-evisc-tuple*27390,1250792
-(defparameter *trace-evisc-tuple-world*27393,1250834
-(defun trace-evisc-tuple 27396,1250882
-(defun trace-multiplicity 27405,1251151
-(defun first-trace-printing-column 27418,1251504
-(defun trace-ppr 27434,1251993
-(defvar *inside-trace$* 27445,1252293
-(defun custom-trace-ppr 27448,1252340
-(defun *1*defp 27509,1254938
-(defun trace$-er-msg 27514,1255084
-(defun decls-and-doc 27518,1255180
-(defun trace$-when-gcond 27528,1255456
-(defun stobj-evisceration-alist 27533,1255545
-(defun trace-evisceration-alist 27541,1255940
-(defun set-trace-evisc-tuple 27545,1256098
-(defun chk-trace-options-aux 27621,1259142
-(defun trace$-value-msgp 27648,1260324
-(defun chk-trace-options 27661,1260771
-(defun memoize-off-trace-error 27755,1264882
-(defun untrace$-fn1 27763,1265243
-(defun untrace$-rec 27814,1267209
-(defun untrace$-fn 27833,1267859
-(defun maybe-untrace$-fn 27844,1268250
-(defmacro maybe-untrace$ 27853,1268554
-(defmacro maybe-untrace 27857,1268637
-(defun maybe-untrace! 27867,1268903
-(defun increment-trace-level 27891,1269642
-(defun trace$-def 27897,1269823
-(defun trace$-install 28073,1278009
-(defun oneified-def 28105,1279331
-(defun trace$-fn-general 28121,1279950
-(defun trace$-fn-simple 28313,1289160
-(defconst *trace-keywords*28316,1289259
-(defconst *trace-keywords-needing-ttag*28325,1289507
-(defun all-keywords-p 28332,1289730
-(defun first-assoc-keyword 28338,1289890
-(defconst *illegal-trace-spec-fmt-string*28346,1290169
-(defun trace$-fn 28351,1290397
-(defun trace$-lst 28385,1292189
-(defmacro trace$ 28396,1292534
-(defmacro with-ubt! 28924,1316150
-(defmacro trace! 28944,1316966
-(defmacro untrace$ 29185,1324461
-(defun open-trace-file-fn 29209,1325179
-(defmacro open-trace-file 29235,1326279
-(defun close-trace-file-fn 29256,1326904
-(defmacro close-trace-file 29269,1327406
-(defmacro break-on-error 29285,1327875
-(defun defexec-extract-key 29386,1332788
-(defun parse-defexec-dcls-1 29408,1333832
-(defun fix-exec-xargs 29531,1339273
-(defun parse-defexec-dcls 29560,1340522
-(defmacro defexec 29632,1344122
-(defrec sar 29887,1355451
-(defun applicable-rewrite-rules1 29902,1356295
-(defun applicable-linear-rules1 29962,1358887
-(defun pc-relieve-hyp 30014,1360955
-(defun pc-relieve-hyps1 30096,1364453
-(defun pc-relieve-hyps 30136,1366425
-(defun remove-trivial-lits 30149,1367024
-(defun unrelieved-hyps 30172,1368073
-(defun untranslate-subst-abb 30196,1369089
-(defun show-rewrite-linear 30203,1369357
-(defun show-rewrites-linears 30296,1374078
-(defun expand-assumptions-1 30369,1377177
-(defun expand-assumptions 30384,1377821
-(defun hyps-type-alist 30394,1378052
-(defun show-rewrites-linears-fn 30408,1378713
-(defun show-meta-lemmas1 30508,1383459
-(defun show-meta-lemmas 30565,1386089
-(defun decoded-type-set-from-tp-rule 30575,1386504
-(defun show-type-prescription-rule 30595,1387268
-(defun show-type-prescription-rules1 30635,1389283
-(defun show-type-prescription-rules 30657,1390323
-(defun pl2-fn 30689,1391749
-(defun pl-fn 30747,1394666
-(defmacro pl 30784,1396179
-(defmacro pl2 30830,1398394
-(defun acl2-defaults-table-local-ctx-p 30916,1403189
-(defun add-include-book-dir-fn 30923,1403452
-(defun delete-include-book-dir-fn 31015,1407891
-(defun add-custom-keyword-hint-fn 31070,1410405
-(defmacro reset-prehistory 31158,1414320
-(defmacro reset-prehistory 31163,1414411
-(defun checkpoint-world 31219,1416780
-(defvar *checkpoint-world-len-and-alist-stack*31226,1416886
-(defmacro checkpoint-world-len-and-alist 31229,1416941
-(defun checkpoint-world1 31232,1417035
-(defun checkpoint-world 31258,1418142
-(defun reset-kill-ring 31270,1418421
-(defun reset-prehistory-fn 31309,1420061
-(defun memoize-table-chk-commutative 31371,1422888
-(defun memoize-table-chk 31422,1425339
-(defun remove-stobjs-in-by-position 31623,1435132
-(defun alist-to-doublets 31634,1435613
-(defun print-gv1 31640,1435819
-(defun print-gv-fn 31662,1436555
-(defmacro print-gv 31692,1437741
-(defun disable-iprint-ar 31854,1443171
-(defun enable-iprint-ar 31877,1444327
-(defconst *iprint-actions*31895,1445122
-(defun set-iprint-fn1 31898,1445189
-(defun set-iprint-fn 31927,1446207
-(defun set-iprint-hard-bound 31939,1446670
-(defun set-iprint-soft-bound 31952,1447141
-(defmacro set-iprint 31965,1447612
-(defconst *evisc-tuple-sites*32196,1457711
-(defun set-site-evisc-tuple 32199,1457783
-(defun chk-evisc-tuple 32229,1459271
-(defun set-evisc-tuple-lst 32238,1459596
-(defun set-evisc-tuple-fn1 32249,1460044
-(defun iprint-virginp 32292,1462001
-(defun set-evisc-tuple-fn 32299,1462266
-(defmacro set-evisc-tuple 32365,1465289
-(defmacro top-level 32479,1471022
-(defun translate-defattach-helpers 33149,1507869
-(defconst *defattach-keys*33207,1510313
-(defun defattach-unknown-constraints-error 33213,1510450
-(defun intersection-domains 33225,1510993
-(defun process-defattach-args1 33235,1511314
-(defun duplicate-keysp-eq 33536,1527007
-(defun split-at-first-keyword 33546,1527309
-(defun filter-for-attachment 33561,1527809
-(defconst *defattach-keys-plus-skip-checks*33583,1528944
-(defun process-defattach-args 33586,1529029
-(defun prove-defattach-guards1 33715,1535063
-(defun prove-defattach-guards 33781,1538210
-(defun defattach-constraint-rec 33810,1539481
-(defun defattach-constraint 33879,1542629
-(defun prove-defattach-constraint 33889,1543097
-(defun attachment-component-owner 34140,1556287
-(defun intersection1-eq 34169,1557761
-(defun defattach-component-has-owner 34178,1558094
-(defun defattach-merge-into-component 34194,1558886
-(defun defattach-merge-components 34310,1562852
-(defun defattach-merge 34352,1564768
-(defun defattach-merge-lst 34376,1565735
-(defun defattach-merge-lst-lst 34394,1566498
-(defun defattach-loop-error-msg 34420,1567788
-(defun defattach-loop-error 34429,1568104
-(defun defattach-close 34436,1568387
-(defun defattach-erase-components 34445,1568721
-(defun defattach-erase-p 34476,1570342
-(defun defattach-erase1 34494,1571174
-(defun defattach-erase 34529,1572674
-(defun collect-ext-anc 34549,1573691
-(defun extend-attachment-components 34560,1574076
-(defun component-path-extension 34600,1576125
-(defun extend-attachment-record 34617,1576957
-(defun update-attachment-records1 34654,1578632
-(defun update-attachment-records 34685,1580172
-(defun attachment-records 34722,1582088
-(defun chk-defattach-loop 34738,1582699
-(defun defaxiom-supporter-msg-list 34773,1584288
-(defun chk-acceptable-defattach 34783,1584792
-(defun attachment-cltl-cmd 34894,1590273
-(defun defattach-fn 34908,1590837
-(defun chk-return-last-entry 34991,1595180
-(defdoc return-last-table35053,1598070
-(defmacro defmacro-last 35079,1599372
-(defdoc printing-to-strings35102,1600269
-(defconst *fmt-control-defaults*35160,1603112
-(defconst *fixed-fmt-controls*35184,1604224
-(defun fmt-control-bindings1 35193,1604484
-(defun fmt-control-bindings 35217,1605605
-(defun set-iprint-ar 35222,1605772
-(defmacro channel-to-string 35230,1606036
-(defun fms-to-string-fn 35337,1610579
-(defmacro fms-to-string 35342,1610811
-(defun fms!-to-string-fn 35346,1611020
-(defmacro fms!-to-string 35351,1611254
-(defun fmt-to-string-fn 35355,1611465
-(defmacro fmt-to-string 35360,1611697
-(defun fmt!-to-string-fn 35364,1611906
-(defmacro fmt!-to-string 35370,1612170
-(defun fmt1-to-string-fn 35374,1612381
-(defmacro fmt1-to-string 35380,1612653
-(defun fmt1!-to-string-fn 35385,1612903
-(defmacro fmt1!-to-string 35391,1613175
-(defdoc dead-events35403,1613812
-(defun attachment-pairs 35544,1621578
-(defun sibling-attachments 35556,1621914
-(defun extended-ancestors4 35562,1622077
-(defun extended-ancestors3 35573,1622441
-(defun extended-ancestors2 35588,1622981
-(defun canonical-cdrs 35610,1624081
-(defun extended-ancestors1 35617,1624332
-(defun attachment-records-fal 35640,1625500
-(defun extended-ancestors 35648,1625822
-(defun ext-anc-attachment-missing 35662,1626358
-(defun ext-anc-attachments-valid-p-1 35672,1626635
-(defun ext-anc-attachments-valid-p 35683,1627009
-(defconst *inline-suffix* 35710,1628210
-(defconst *inline-suffix-len-minus-1* 35711,1628247
-(defconst *notinline-suffix* 35712,1628316
-(defconst *notinline-suffix-len-minus-1* 35713,1628359
-(defconst *non-stobj-var-root* 35714,1628434
-(defun defun-inline-form 35716,1628511
-(defmacro defun-inline 35746,1629762
-(defmacro defund-inline 35864,1635257
-(defmacro defun-notinline 35878,1635704
-(defmacro defund-notinline 35900,1636752
-(defun regenerate-tau-database-fn0 35914,1637215
-(defun regenerate-tau-database-fn135958,1639348
-(defun regenerate-tau-database-fn 36029,1642852
-(defun rational-to-decimal-string 36075,1644574
-(defvar *time-tracker-alist* 36090,1645134
-(defvar *time-tracker-disabled-p* 36092,1645169
-(defstruct time-tracker36094,1645209
-(defun tt-print-msg 36123,1646499
-(defun tt-init 36138,1647072
-(defun tt-end 36181,1648764
-(defun tt-print? 36191,1649104
-(defun tt-stop 36243,1651532
-(defun tt-start 36265,1652399
-(defun program-declared-p1 36288,1653282
-(defun program-declared-p 36298,1653619
-(defmacro defund 36310,1654038
-(defmacro defund 36366,1656222
-(defun magic-ev-fncall-cl-proc 36375,1656632
-(defun-overrides magic-ev-fncall 36400,1657321
-
-ld.lisp,13208
-(defun default-print-prompt 27,1032
-(defun print-prompt 133,5763
-(defun initialize-timers 164,6996
-(defun maybe-add-command-landmark 171,7199
-(defun replace-last-cdr 230,9917
-(defun ld-standard-oi-missing 235,10077
-(defun chk-acceptable-ld-fn1-pair 248,10704
-(defun close-channels 400,17494
-(defun chk-acceptable-ld-fn1 435,19081
-(defun chk-acceptable-ld-fn 555,25471
-(defun f-put-ld-specials 596,27392
-(defun f-get-ld-specials 656,29897
-(defun ld-read-keyword-command1 698,31607
-(defun exit-ld 717,32331
-(defun macro-minimal-arity1 726,32646
-(defun macro-minimal-arity 733,32849
-(defun ld-read-keyword-command 739,33104
-(defun ld-read-command 811,36066
-(deflabel acl2-customization847,37907
-(deflabel keyword-commands924,42058
-(defun ld-print-command 979,44529
-(defun ld-filter-command 1001,45110
-(defun-one-output ppr? 1025,46360
-(defun ld-print-results 1038,46733
-(defun ld-print-prompt 1147,51370
-(defun good-bye-fn 1163,51957
-(defmacro good-bye 1169,52085
-(defun ld-return-error 1206,53303
-(defun initialize-accumulated-warnings 1214,53559
-(defun ld-read-eval-print 1219,53664
-(defun ld-loop 1353,59853
-(defvar *first-entry-to-ld-fn-body-flg*)1379,60994
-(defun update-cbd 1381,61036
-(defun ld-fn-body 1416,62650
-(defun ld-fn1 1511,67073
-(defun ld-fn-alist 1551,68997
-(defmacro with-interrupts 1583,70499
-(defun ld-fn0 1600,70999
-(defun ld-fn 1785,81011
-(defmacro ld 1845,83353
-(defdoc calling-ld-in-bad-contexts2166,101206
-(defmacro quick-test 2205,103084
-(defun wormhole-prompt 2229,103968
-(defun reset-ld-specials-fn 2241,104470
-(defmacro reset-ld-specials 2254,105010
-(defun maybe-reset-defaults-table12283,106333
-(defun maybe-reset-defaults-table22322,108008
-(defun maybe-reset-defaults-table 2331,108354
-(defun delete-something 2336,108656
-(defun store-in-kill-ring 2346,108983
-(defun rotate-kill-ring1 2366,109999
-(defun rotate-kill-ring 2371,110166
-(defun ubt-ubu-fn1 2383,110712
-(defun ubt-ubu-fn 2439,112864
-(defun ubt!-ubu!-fn 2491,115262
-(defmacro ubt-prehistory 2508,115719
-(defun ubt-prehistory-fn 2521,116168
-(defun oops-warning 2557,117763
-(defun oops-fn 2571,118333
-(defmacro oops 2598,119644
-(defmacro i-am-here 2695,124074
-(defun rebuild-fn-read-filter 2729,125188
-(defun rebuild-fn 2761,126658
-(defmacro rebuild 2787,127486
-(defconst *basic-sweep-error-str*2993,138098
-(defun sweep-symbol-binding-for-bad-symbol 3000,138472
-(defun sweep-global-lst 3022,139489
-(defun sweep-stack-entry-for-bad-symbol 3031,139809
-(defun sweep-t-stack 3054,140866
-(defun sweep-acl2-oracle 3062,141180
-(defun sweep-global-state-for-lisp-objects 3077,141714
-(deflabel compilation3123,143408
-(defdoc book-compiled-file3170,145569
-(deflabel escape-to-common-lisp3262,151245
-(deflabel copyright3277,151677
-(deflabel acknowledgments3305,152680
-(deflabel breaks3451,159931
-(deflabel saving-and-restoring3496,162084
-(deflabel ordinals3509,162646
-(defmacro wet 3651,169663
-(defmacro disassemble$ 3833,178187
-(deflabel release-notes3891,180878
-(deflabel note13903,181198
-(deflabel note23924,181827
-(deflabel note33958,183454
-(deflabel note44060,189292
-(deflabel note54221,196332
-(deflabel note64468,208647
-(deflabel note74593,214020
-(deflabel note84792,222755
-(deflabel note8-update5139,238551
-(deflabel note95199,240770
-(deflabel note-2-05280,243827
-(deflabel note-2-15313,245050
-(deflabel note-2-25331,245430
-(deflabel note-2-35393,248316
-(deflabel note-2-45453,250613
-(deflabel note-2-55499,252166
-(deflabel |NOTE-2-5(5829,268570
-(deflabel note-2-65845,268867
-(deflabel note-2-6-new-functionality5864,269523
-(deflabel note-2-6-proofs6047,278564
-(deflabel note-2-6-rules6159,284274
-(deflabel note-2-6-guards6230,287636
-(deflabel note-2-6-proof-checker6298,290672
-(deflabel note-2-6-system6324,291581
-(deflabel note-2-6-other6371,293749
-(deflabel |NOTE-2-6(6491,299306
-(deflabel note-2-76507,299633
-(deflabel note-2-7-bug-fixes6594,303172
-(deflabel note-2-7-new-functionality6881,317633
-(deflabel note-2-7-proofs7037,325587
-(deflabel note-2-7-rules7139,331062
-(deflabel note-2-7-guards7160,331982
-(deflabel note-2-7-proof-checker7190,332802
-(deflabel note-2-7-system7201,333085
-(deflabel note-2-7-other7271,336162
-(deflabel |NOTE-2-7(7444,344462
-(deflabel note-2-87469,345226
-(deflabel note-2-8-bug-fixes7632,352221
-(deflabel note-2-8-new-functionality8082,373272
-(deflabel note-2-8-proofs8228,381421
-(deflabel note-2-8-rules8305,385670
-(deflabel note-2-8-guards8346,387430
-(deflabel note-2-8-proof-checker8357,387652
-(deflabel note-2-8-system8390,389318
-(deflabel note-2-8-ordinals8419,390602
-(deflabel note-2-8-other8427,390750
-(deflabel |NOTE-2-8(8503,393902
-(deflabel note-2-98520,394375
-(deflabel |NOTE-2-9(9108,419946
-(deflabel note-2-9-19123,420273
-(deflabel note-2-9-29337,429618
-(deflabel note-2-9-39559,439366
-(deflabel note-2-9-3-ppr-change9791,449938
-(deflabel note-2-9-410069,458469
-(deflabel note-2-9-510452,477788
-(deflabel note-3-010807,494560
-(deflabel |NOTE-3-0(10834,495578
-(deflabel note-3-0-110849,495881
-(deflabel |NOTE-3-0-1(11176,512595
-(deflabel note-3-0-211191,512908
-(deflabel note-3-111706,535340
-(deflabel |NOTE-3-1(11721,535745
-(deflabel note-3-211737,536053
-(deflabel |NOTE-3-2(12404,565231
-(deflabel note-3-2-112431,566128
-(deflabel |NOTE-3-2-1(12707,579611
-(deflabel note-3-312720,579809
-(deflabel |NOTE-3-3(13223,602978
-(deflabel note-3-413236,603172
-(deflabel |NOTE-3-4(13987,639221
-(deflabel note-3-514007,639794
-(deflabel |NOTE-3-5(14975,685537
-(deflabel note-3-615053,688506
-(deflabel |NOTE-3-6(15509,707928
-(deflabel note-3-6-115522,708120
-(deflabel note-4-015571,710035
-(deflabel |NOTE-4-0(16612,757914
-(deflabel note-4-0-wormhole-changes16625,758099
-(deflabel note-4-116692,760630
-(deflabel |NOTE-4-1(16852,767799
-(deflabel note-4-216865,767989
-(deflabel |NOTE-4-2(17424,795911
-(deflabel note-4-317437,796099
-(deflabel |NOTE-4-3(18260,830975
-(deflabel note-5-018273,831160
-(deflabel note-6-019502,888018
-(deflabel note-6-120049,914356
-(deflabel note-6-220462,933184
-(deflabel the-method20959,957358
-(deflabel lp21054,962643
-(defun-one-output compiled-function-p! 21122,966233
-(defun compile-function 21134,966689
-(defun getpid$ 21196,968946
-(defun-one-output tmp-filename 21220,969772
-(defun keep-tmp-files 21246,970805
-(defun comp-fn 21249,970876
-(defmacro comp 21364,975166
-(defmacro comp 21369,975237
-(defmacro comp-gcl 21476,980693
-(defun scan-past-deeper-event-landmarks 21495,981421
-(defun puffable-encapsulate-p 21515,982177
-(defun puffable-command-blockp 21526,982591
-(defun puffable-command-numberp 21560,984025
-(defun puff-command-block 21575,984565
-(defun commands-back-to 21713,991268
-(defun puffed-command-sequence 21728,991819
-(defun puff-fn1 21751,992701
-(defun puff-report 21843,997335
-(defun puff-fn 21856,997927
-(defun puff*-fn11 21860,998058
-(defun puff*-fn1 21881,998808
-(defun puff*-fn 21909,1000136
-(defmacro puff 21977,1003194
-(defmacro puff* 22110,1010951
-(defmacro mini-proveall 22188,1014016
-(defmacro exit 22426,1021227
-(defmacro quit 22437,1021421
-(defmacro set-guard-checking 22448,1021615
-(defun dmr-stop-fn 22724,1033679
-(defmacro dmr-stop 22730,1033823
-(defun dmr-start-fn 22734,1033937
-(defmacro dmr-start 22743,1034200
-(defconst *home-page*22747,1034317
-(defconst *home-page-references*23197,1049464
-(deflabel |Pages 23210,1050021
-(deflabel |Undocumented 23233,1051171
-(deflabel |Common 23239,1051343
-(deflabel |An 23289,1053377
-(deflabel |The 23327,1054745
-(deflabel |A 23370,1056760
-(deflabel |About 23413,1058731
-(deflabel |A 23443,1059903
-(deflabel |What 23470,1060949
-(deflabel |About 23497,1061822
-(deflabel |Models 23524,1062606
-(deflabel |The 23549,1063207
-(deflabel |Corroborating 23571,1063921
-(deflabel |Models 23616,1065954
-(deflabel |A 23654,1066952
-(deflabel |Functions 23681,1067836
-(deflabel |Common 23714,1068951
-(deflabel |Analyzing 23751,1070480
-(deflabel |What 23791,1071894
-(deflabel |A 23816,1072711
-(deflabel |What 23825,1072925
-(deflabel |What 23847,1073733
-(deflabel |ACL2 23861,1074163
-(deflabel |ACL2 23874,1074633
-(deflabel |ACL2 23905,1075986
-(deflabel |Modeling 23930,1077107
-(deflabel |Running 23956,1077903
-(deflabel |Symbolic 23988,1078993
-(deflabel |Proving 24013,1079611
-(deflabel |What 24050,1080912
-(deflabel |How 24081,1081852
-(deflabel |Other 24103,1082780
-(deflabel |The 24132,1083531
-(deflabel |An 24149,1083877
-(deflabel |How 24200,1086096
-(deflabel |How 24230,1087260
-(deflabel |The 24263,1088565
-(deflabel |A 24308,1089988
-(deflabel |Revisiting 24327,1090653
-(deflabel |Evaluating 24368,1092080
-(deflabel |Conversion|24410,1093056
-(deflabel |The 24441,1094516
-(deflabel |The 24483,1095910
-(deflabel |Free 24515,1097196
-(deflabel |The 24559,1098912
-(deflabel |Name 24616,1101816
-(deflabel |Perhaps|24625,1102081
-(deflabel |Suggested 24634,1102316
-(deflabel |Subsumption 24657,1102987
-(deflabel |Flawed 24680,1103701
-(deflabel |The 24703,1104359
-(deflabel |The 24724,1105099
-(deflabel |The 24753,1105915
-(deflabel |The 24774,1106445
-(deflabel |The 24785,1106795
-(deflabel |Nontautological 24798,1107257
-(deflabel |Overview 24809,1107703
-(deflabel |On 24840,1108848
-(deflabel |Overview 24852,1109310
-(deflabel |The 24865,1109912
-(deflabel |The 24884,1110532
-(deflabel |The 24904,1111182
-(deflabel |Overview 24925,1111786
-(deflabel |The 24936,1112323
-(deflabel |The 24954,1112908
-(deflabel |The 24980,1113972
-(deflabel |The 25001,1114663
-(deflabel |The 25020,1115294
-(deflabel |The 25042,1116124
-(deflabel |The 25064,1116899
-(deflabel |The 25086,1117645
-(deflabel |The 25108,1118364
-(deflabel |The 25130,1119177
-(deflabel |The 25154,1120050
-(deflabel |The 25174,1120752
-(deflabel |The 25193,1121385
-(deflabel |Overview 25213,1121925
-(deflabel |Overview 25241,1122766
-(deflabel |Overview 25250,1123159
-(deflabel |The 25260,1123524
-(deflabel |The 25278,1124128
-(deflabel |The 25295,1124667
-(deflabel |The 25311,1125123
-(deflabel |The 25330,1125664
-(deflabel |Popping 25360,1126548
-(deflabel |The 25370,1126928
-(deflabel |The 25379,1127211
-(deflabel |The 25394,1127954
-(deflabel |Guiding 25410,1128645
-(deflabel |Rewrite 25437,1129628
-(deflabel |You 25471,1130587
-(deflabel |Using 25501,1131595
-(deflabel |Overview 25521,1132231
-(deflabel |The 25572,1133906
-(deflabel |The 25593,1134791
-(deflabel |A 25612,1135495
-(deflabel |The 25646,1136734
-(deflabel |The 25658,1137110
-(deflabel |ACL2 25691,1138199
-(deflabel |Hey 25718,1139325
-(deflabel |Guards|25743,1140275
-(deflabel |About 25780,1142010
-(deflabel |The 25848,1145733
-(deflabel |About 25895,1148035
-(deflabel |About 25926,1149681
-(deflabel |Numbers 25971,1152049
-(deflabel |ACL2 26026,1154350
-(deflabel |ACL2 26045,1155175
-(deflabel |ACL2 26063,1156023
-(deflabel |ACL2 26108,1158697
-(deflabel |Guessing 26141,1160208
-(defconst *meta-level-function-problem-1*26186,1162177
-(defconst *meta-level-function-problem-1a*26190,1162376
-(defconst *meta-level-function-problem-1b*26194,1162586
-(defconst *meta-level-function-problem-1c*26199,1162813
-(defconst *meta-level-function-problem-1d*26205,1163142
-(defconst *meta-level-function-problem-1e*26212,1163503
-(defconst *meta-level-function-problem-2*26218,1163821
-(defconst *meta-level-function-problem-3*26225,1164175
-(defun acl2-magic-mfc 26245,1165368
-(defun mfc-ts-raw 26299,1167262
-(defun mfc-rw-raw 26381,1170900
-(defun mfc-relieve-hyp-raw 26463,1175116
-(defun-one-output mfc-ap-raw 26571,1180656
-(defmacro mfc-ts 26677,1186852
-(defmacro mfc-rw 26686,1187173
-(defmacro mfc-rw+ 26704,1188015
-(defmacro mfc-relieve-hyp 26713,1188410
-(defmacro mfc-ap 26724,1188906
-(defun congruence-rule-listp 26729,1189082
-(defun term-alistp-failure-msg 26742,1189546
-(defun find-runed-linear-lemma 26759,1190248
-(defun mfc-force-flg 26770,1190592
-(defun update-rncst-for-forcep 26775,1190740
-(defun trans-eval-lst 26825,1192887
-(defun print-saved-output 26831,1193103
-(defmacro pso 26874,1194977
-(defmacro psog 26889,1195452
-(defmacro pso! 26903,1195837
-(defdoc nil-goal26918,1196322
-(defmacro set-saved-output 26957,1198599
-(defmacro set-raw-proof-format 27062,1204362
-(defmacro set-print-clause-ids 27089,1205429
-(defun set-standard-co-state 27137,1207456
-(defun set-proofs-co-state 27146,1207791
-(defmacro with-standard-co-and-proofs-co-to-file 27155,1208120
-(defmacro wof 27179,1208967
-(defmacro psof 27205,1209829
-(defun set-gag-mode-fn 27240,1211534
-(defmacro set-gag-mode 27271,1212666
-(defparameter *initial-cbd* 27381,1218065
-(defun save-exec 27383,1218099
-(deflabel about-acl227474,1221737
-(defun defun-for-state-name 27501,1222556
-(defmacro defun-for-state 27506,1222686
-(defun set-ld-evisc-tuple 27516,1223012
-(defun-for-state set-ld-evisc-tuple 27521,1223139
-(defun set-abbrev-evisc-tuple 27523,1223189
-(defun-for-state set-abbrev-evisc-tuple 27528,1223324
-(defun set-gag-mode-evisc-tuple 27530,1223378
-(defun-for-state set-gag-mode-evisc-tuple 27535,1223517
-(defun set-term-evisc-tuple 27537,1223573
-(defun-for-state set-term-evisc-tuple 27542,1223704
-(defun without-evisc-fn 27544,1223756
-(defmacro without-evisc 27555,1224159
-
-proof-checker-b.lisp,10417
-(defmacro install-new-pc-meta-or-macro 23,881
-(defun define-pc-meta-or-macro-fn 27,1084
-(defmacro define-pc-meta 41,1553
-(defmacro define-pc-macro 56,2123
-(defmacro define-pc-atomic-macro 95,3725
-(defmacro toggle-pc-macro 98,3857
-(defmacro define-pc-primitive 126,4867
-(define-pc-primitive comment 150,5925
-(defun non-bounded-nums 169,6340
-(defun delete-by-position 182,6807
-(define-pc-primitive drop 192,7191
-(define-pc-meta lisp 232,8583
-(define-pc-primitive fail-primitive 296,11125
-(define-pc-macro fail 300,11213
-(define-pc-macro illegal 322,11807
-(defun chk-assumption-free-ttree-1 344,12485
-(defun put-cdr-assoc-query-id 358,12997
-(defun set-query-val 364,13251
-(defmacro query-on-exit 377,13662
-(defun replay-query 380,13760
-(define-pc-meta exit 393,14482
-(define-pc-meta undo 557,23037
-(define-pc-meta restore 611,25007
-(defun print-commands 642,26110
-(defun make-pretty-start-instr 657,26708
-(defun raw-indexed-instrs 667,27066
-(define-pc-macro sequence-no-restore 684,28051
-(define-pc-macro skip 687,28155
-(defmacro define-pc-help 700,28401
-(defun evisc-indexed-instrs-1 735,29742
-(defun evisc-indexed-instrs-rec 747,30285
-(defun mark-unfinished-instrs 767,31258
-(defun evisc-indexed-instrs 783,32054
-(define-pc-help commands 789,32322
-(define-pc-macro comm 831,33959
-(defun promote-guts 887,36275
-(define-pc-primitive promote 899,36651
-(defun remove-by-indices 938,38349
-(define-pc-macro print 950,38915
-(defun bounded-integer-listp 982,40156
-(defun fetch-term-and-cl 995,40571
-(defun fetch-term 1037,42711
-(defun governors 1047,43038
-(defun term-id-iff 1055,43330
-(defmacro ? 1103,45606
-(defstub ?-fn 1106,45638
-(defun abbreviations-alist 1113,45848
-(defun chk-?s 1122,46111
-(defun chk-?s-lst 1143,46989
-(defun remove-?s 1151,47178
-(defun translate-abb 1156,47365
-(defmacro trans0 1169,47696
-(defun p-body 1172,47809
-(define-pc-help p 1180,48161
-(define-pc-help pp 1203,48857
-(defun take-by-indices 1222,49379
-(defun print-hyps 1231,49748
-(defun some-> 1244,50375
-(defun print-hyps-top 1253,50622
-(defun print-governors-top 1262,50987
-(defun pair-indices 1271,51346
-(define-pc-macro hyps 1287,52014
-(define-pc-primitive demote 1405,57392
-(defun pair-keywords 1461,59695
-(defun null-pool 1476,60332
-(defun initial-pspv 1483,60499
-(defun pc-prove 1491,60816
-(defun sublis-equal 1514,61855
-(defun abbreviations-alist-? 1524,62138
-(defun find-?-fn 1534,62541
-(defun unproved-pc-prove-clauses 1544,62849
-(defun prover-call 1547,62947
-(defun make-new-goals 1620,67251
-(defun same-goal 1632,67763
-(defun remove-byes-from-tag-tree 1638,67959
-(define-pc-primitive prove 1641,68042
-(defun add-string-val-pair-to-string-val-alist 1723,71420
-(defconst *bash-skip-forcing-round-hints*1741,72221
-(define-pc-atomic-macro bash 1759,72731
-(define-pc-primitive dive 1811,74781
-(define-pc-atomic-macro split 1872,77210
-(define-pc-primitive add-abbreviation 1914,78936
-(defun not-in-domain-eq 1980,81959
-(define-pc-primitive remove-abbreviations 1991,82325
-(defun print-abbreviations 2033,84056
-(define-pc-help show-abbreviations 2077,85740
-(defun drop-from-end 2112,87093
-(define-pc-primitive up 2119,87333
-(define-pc-atomic-macro top 2159,89092
-(defmacro expand-address-recurse2179,89808
-(defmacro dive-once-more-error 2194,90359
-(defun abbreviation-raw-term-p 2201,90632
-(defmacro addr-recur 2205,90710
-(defun or-addr 2220,91231
-(defun and-addr 2270,93105
-(defmacro add-dive-into-macro 2328,95558
-(defmacro remove-dive-into-macro 2343,96029
-(defun dive-into-macros-table 2359,96593
-(defun rassoc-eq-as-car 2403,98411
-(defun expand-address 2409,98588
-(defmacro dv-error 2771,116530
-(define-pc-atomic-macro dv 2781,116874
-(defun deposit-term 2878,120115
-(defun deposit-term-lst 2888,120468
-(defun geneqv-at-subterm 2906,121183
-(defun geneqv-at-subterm-top 2925,121954
-(defun maybe-truncate-current-address 2968,123766
-(defun deposit-term-in-goal 2996,124995
-(defun split-implies 3015,125758
-(defun equiv-refinementp 3028,126221
-(defun find-equivalence-hyp-term 3032,126362
-(defun flatten-ands-in-lit-lst 3053,127250
-(define-pc-primitive equiv 3059,127402
-(define-pc-primitive casesplit3171,132803
-(define-pc-macro top? 3268,137268
-(define-pc-macro contrapose-last 3274,137379
-(define-pc-macro drop-last 3282,137652
-(define-pc-macro drop-conc 3290,137907
-(define-pc-atomic-macro claim 3293,137993
-(define-pc-atomic-macro induct 3360,140977
-(defun print-on-separate-lines 3399,142440
-(define-pc-help goals 3409,142853
-(defun modified-error-triple-for-sequence 3428,143406
-(define-pc-meta sequence3465,145266
-(define-pc-macro negate 3591,151912
-(define-pc-macro succeed 3613,152577
-(define-pc-macro do-all 3635,153199
-(define-pc-macro do-strict 3662,154146
-(define-pc-macro do-all-no-prompt 3680,154683
-(define-pc-macro th 3698,155256
-(define-pc-macro protect 3730,156491
-(defun extract-goal 3749,157093
-(define-pc-primitive change-goal 3759,157472
-(define-pc-macro cg 3812,159721
-(defun change-by-position 3828,160130
-(define-pc-primitive contrapose 3838,160494
-(define-pc-macro contradict 3878,162288
-(define-pc-atomic-macro pro 3887,162463
-(define-pc-atomic-macro nx 3902,162838
-(define-pc-atomic-macro bk 3927,163691
-(define-pc-help p-top 3958,164782
-(define-pc-macro repeat 3996,166349
-(define-pc-macro repeat-rec 4014,166823
-(defmacro define-pc-bind 4022,166983
-(define-pc-bind quiet4039,167689
-(define-pc-bind noise 4057,168097
-(defun find-equivalence-hyp-term-no-target 4076,168741
-(define-pc-atomic-macro if-not-proved 4102,170005
-(define-pc-atomic-macro = =4121,170694
-(define-pc-macro set-success 4323,180728
-(define-pc-macro orelse 4326,180817
-(defun applicable-rewrite-rules 4346,181412
-(define-pc-help show-rewrites 4365,182377
-(define-pc-macro sr 4409,184480
-(define-pc-help show-linears 4424,184771
-(define-pc-macro sls 4455,186002
-(define-pc-macro pl 4472,186494
-(define-pc-macro pr 4506,187749
-(define-pc-help show-type-prescriptions 4540,189004
-(define-pc-macro st 4567,190093
-(defun translate-subst-abb1 4582,190407
-(defun single-valued-symbolp-alistp 4605,191541
-(defun check-cars-are-variables 4612,191763
-(defun translate-subst-abb 4631,192541
-(defun make-rewrite-instr 4662,193825
-(define-pc-primitive rewrite 4669,194089
-(defun applicable-linear-rules 4920,207264
-(defun make-linear-instr 4934,207839
-(define-pc-primitive apply-linear 4941,208101
-(define-pc-macro al 5186,220726
-(defun pc-help-fn 5199,220959
-(defmacro state-only 5245,223157
-(define-pc-help help 5251,223291
-(defun pc-help!-fn 5316,225968
-(define-pc-help help! 5358,227886
-(define-pc-macro help-long 5372,228388
-(define-pc-help more 5383,228656
-(define-pc-help more! 5395,228913
-(defun pc-rewrite*-15406,229225
-(defun pc-rewrite*5450,231305
-(defun make-goals-from-assumptions 5464,231852
-(defun make-new-goals-from-assumptions 5477,232428
-(defconst *default-s-repeat-limit* 5487,232749
-(define-pc-primitive s 5489,232789
-(defun build-pc-enabled-structure-from-ens 5746,244997
-(define-pc-primitive in-theory 5773,246256
-(define-pc-atomic-macro s-prop 5865,250401
-(define-pc-atomic-macro x 5888,251160
-(define-pc-primitive expand 5947,253483
-(define-pc-atomic-macro x-dumb 6044,257175
-(define-pc-macro bookmark 6059,257587
-(defun change-last 6080,258313
-(defun assign-event-name-and-rule-classes 6088,258490
-(defun save-fn 6104,259290
-(define-pc-macro save 6113,259522
-(defmacro retrieve 6161,261595
-(define-pc-macro retrieve 6179,261999
-(defun unsave-fn 6205,263024
-(defmacro unsave 6209,263126
-(define-pc-help unsave 6227,263498
-(defun show-retrieved-goal 6261,264888
-(defun retrieve-fn 6271,265285
-(defun print-all-goals 6316,267270
-(define-pc-help print-all-goals 6322,267430
-(defmacro print-conc 6334,267729
-(defun print-all-concs 6346,268210
-(define-pc-help print-all-concs 6353,268416
-(defun gen-var-marker 6366,268753
-(defun translate-generalize-alist-1 6371,268842
-(defun non-gen-var-markers 6426,270927
-(defun find-duplicate-generalize-entries 6435,271215
-(defun translate-generalize-alist-2 6444,271528
-(defun translate-generalize-alist 6455,271995
-(defun all-vars-goals 6473,272918
-(defun pc-state-vars 6480,273173
-(define-pc-primitive generalize 6484,273358
-(define-pc-atomic-macro use 6551,276209
-(define-pc-atomic-macro clause-processor 6579,277160
-(define-pc-macro cl-proc 6609,278121
-(defun fromto 6618,278374
-(define-pc-atomic-macro retain 6624,278513
-(define-pc-atomic-macro reduce 6658,279643
-(define-pc-macro run-instr-on-goal 6702,281291
-(defun run-instr-on-goals-guts 6713,281547
-(define-pc-macro run-instr-on-new-goals 6720,281796
-(define-pc-macro then 6733,282263
-(defun print-help-separator 6758,283109
-(defun print-pc-help-rec 6763,283241
-(defun print-all-pc-help-fn 6775,283546
-(defmacro print-all-pc-help 6791,284229
-(define-pc-macro nil 6794,284341
-(define-pc-atomic-macro free 6822,285376
-(define-pc-macro replay 6845,286044
-(defun instr-name 6889,287969
-(defun pc-free-instr-p 6895,288105
-(defun find-possible-put 6900,288274
-(define-pc-macro put 6912,288760
-(define-pc-macro reduce-by-induction 6954,290574
-(define-pc-macro r 6996,292170
-(define-pc-atomic-macro sl 7008,292378
-(define-pc-atomic-macro elim 7040,293649
-(define-pc-macro ex 7059,294293
-(defun save-fc-report-settings 7074,294612
-(defun restore-fc-report-settings 7089,295098
-(define-pc-help type-alist 7104,295611
-(define-pc-help print-main 7207,300349
-(define-pc-macro pso 7219,300587
-(define-pc-macro psog 7239,301296
-(define-pc-macro pso! 7260,302033
-(define-pc-macro acl2-wrap 7281,302782
-(defmacro acl2-wrap 7297,303145
-(define-pc-macro check-proved-goal 7304,303295
-(define-pc-macro check-proved 7312,303544
-(define-pc-atomic-macro forwardchain 7320,303725
-(define-pc-atomic-macro bdd 7404,306924
-(define-pc-macro runes 7428,307750
-(define-pc-macro lemmas-used 7449,308560
-(defun goal-terms 7457,308731
-(defun wrap1-aux1 7468,309032
-(defun wrap1-aux2 7489,309930
-(define-pc-primitive wrap1 7504,310531
-(define-pc-atomic-macro wrap 7583,313845
-(define-pc-atomic-macro wrap-induct 7629,315802
-(define-pc-macro finish-error 7661,316719
-(define-pc-macro finish 7666,316871
-(defun show-geneqv 7687,317597
-(define-pc-macro geneqv 7695,317941
-(defun goals-to-clause-list 7729,319650
-(defun proof-checker-clause-list 7736,319894
-(defun proof-checker-cl-proc 7739,319970
-
-tutorial.lisp,4176
-(deflabel ACL2-Tutorial45,1562
-(deflabel alternative-introduction111,4534
-(deflabel annotated-acl2-scripts743,34484
-(deflabel Emacs811,37396
-(deflabel ACL2-As-Standalone-Program825,37884
-(deflabel acl2-sedan931,40895
-(deflabel solution-to-simple-example953,41995
-(deflabel Tutorial1-Towers-of-Hanoi1009,43994
-(deflabel Tutorial2-Eights-Problem1267,53213
-(deflabel Tutorial3-Phonebook-Example1396,57390
-(deflabel Tutorial4-Defun-Sk-Example2222,89653
-(deflabel Tutorial5-Miscellaneous-Examples2323,93583
-(deflabel file-reading-example2333,93863
-(deflabel guard-example2389,96296
-(deflabel mutual-recursion-proof-example2699,105463
-(deflabel functional-instantiation-example2847,111876
-(deflabel Startup2992,116769
-(deflabel Tidbits3077,119680
-(deflabel Tips3161,123247
-(deflabel introduction-to-the-theorem-prover3623,144893
-(deflabel dealing-with-key-combinations-of-function-symbols3956,161983
-(deflabel post-induction-key-checkpoints4138,169872
-(deflabel generalizing-key-checkpoints4187,172148
-(deflabel strong-rewrite-rules4282,176104
-(deflabel practice-formulating-strong-rules4376,180114
-(deflabel practice-formulating-strong-rules-14440,181925
-(deflabel practice-formulating-strong-rules-24537,186250
-(deflabel practice-formulating-strong-rules-34593,188285
-(deflabel practice-formulating-strong-rules-44720,193180
-(deflabel practice-formulating-strong-rules-54760,194437
-(deflabel practice-formulating-strong-rules-64822,196884
-(deflabel introduction-to-key-checkpoints4930,200843
-(deflabel programming-knowledge-taken-for-granted5090,210273
-(deflabel example-induction-scheme-nat-recursion5381,224315
-(deflabel example-induction-scheme-down-by-25434,225942
-(deflabel example-induction-scheme-on-lists5492,227621
-(deflabel example-induction-scheme-binary-trees5539,228978
-(deflabel example-induction-scheme-on-several-variables5581,230014
-(deflabel example-induction-scheme-upwards5627,231017
-(deflabel example-induction-scheme-with-accumulators5678,232543
-(deflabel example-induction-scheme-with-multiple-induction-steps5761,235398
-(deflabel example-inductions5825,237170
-(deflabel logic-knowledge-taken-for-granted-inductive-proof5884,240004
-(deflabel logic-knowledge-taken-for-granted-base-case6034,247690
-(deflabel logic-knowledge-taken-for-granted-q1-answer6061,248539
-(deflabel logic-knowledge-taken-for-granted-q2-answer6147,252564
-(deflabel logic-knowledge-taken-for-granted-q3-answer6291,257212
-(deflabel logic-knowledge-taken-for-granted-instance6332,258426
-(deflabel logic-knowledge-taken-for-granted-propositional-calculus6372,259774
-(deflabel logic-knowledge-taken-for-granted-rewriting6620,269107
-(deflabel logic-knowledge-taken-for-granted-rewriting-repeatedly6859,279161
-(deflabel logic-knowledge-taken-for-granted-equals-for-equals6953,282609
-(deflabel logic-knowledge-taken-for-granted-evaluation7004,284516
-(deflabel logic-knowledge-taken-for-granted7042,285900
-(deflabel special-cases-for-rewrite-rules7258,294500
-(deflabel equivalent-formulas-different-rewrite-rules7312,296860
-(deflabel introduction-to-rewrite-rules-part-27385,299808
-(deflabel specific-kinds-of-formulas-as-rewrite-rules7624,314123
-(deflabel further-information-on-rewriting7711,318452
-(deflabel introduction-to-rewrite-rules-part-17830,325226
-(deflabel introduction-to-the-database8009,334245
-(deflabel introduction-to-hints8241,346171
-(deflabel introduction-to-a-few-system-considerations8341,351342
-(deflabel architecture-of-the-prover8524,360136
-(deflabel frequently-asked-questions-by-newcomers8605,364193
-(deflabel introductory-challenges9182,396611
-(deflabel introductory-challenge-problem-19218,398163
-(deflabel introductory-challenge-problem-1-answer9251,398974
-(deflabel introductory-challenge-problem-29299,400314
-(deflabel introductory-challenge-problem-2-answer9322,400885
-(deflabel introductory-challenge-problem-39369,402201
-(deflabel introductory-challenge-problem-3-answer9405,403125
-(deflabel introductory-challenge-problem-49524,407130
-(deflabel introductory-challenge-problem-4-answer9581,409402
-(deflabel interesting-applications10163,432053
-(deflabel advanced-features10283,439549
-
-interface-raw.lisp,7813
-(defun-*1* mv-list 676,29373
-(defun-*1* return-last 680,29447
-(defun-*1* wormhole-eval 750,32381
-(defun-*1* acl2-numberp 757,32569
-(defun-*1* binary-* 760,32613
-(defun-*1* binary-+ 768,32797
-(defun-*1* unary-- 779,33071
-(defun-*1* unary-/ 785,33180
-(defun-*1* < 791,33309
-(defun-*1* apply 816,34292
-(defun-*1* bad-atom<=820,34414
-(defun-*1* car 830,34740
-(defun-*1* cdr 838,34843
-(defun-*1* char-code 846,34946
-(defun-*1* characterp 851,35040
-(defun-*1* code-char 854,35085
-(defun-*1* complex 861,35236
-(defun-*1* complex-rationalp 865,35400
-(defun-*1* complexp 871,35541
-(defun-*1* coerce 874,35582
-(defun-*1* cons 888,35912
-(defun-*1* consp 891,35949
-(defun-*1* denominator 894,35984
-(defun-*1* equal 899,36083
-(defun-*1* floor1 903,36147
-(defun-*1* if 912,36351
-(defun-*1* imagpart 917,36552
-(defun-*1* integerp 922,36640
-(defun-*1* intern-in-package-of-symbol 925,36681
-(defun-*1* pkg-imports 931,36863
-(defun-*1* pkg-witness 936,36970
-(defun-*1* numerator 946,37389
-(defun-*1* rationalp 951,37482
-(defun-*1* realp 957,37601
-(defun-*1* realpart 960,37636
-(defun-*1* stringp 965,37724
-(defun-*1* symbol-name 968,37763
-(defun-*1* symbol-package-name 973,37861
-(defun-*1* symbolp 979,38028
-(defun standardp 995,38669
-(defun-*1* standardp 999,38719
-(defun standard-part 1003,38773
-(defun-*1* standard-part 1006,38803
-(defun i-large-integer 1009,38838
-(defun-*1* i-large-integer 1012,38936
-(defun-one-output macroexpand1! 1017,39041
-(defvar *acl2-gentemp-counter* 1023,39211
-(defun-one-output acl2-gentemp 1024,39245
-(defun-one-output oneify-flet-bindings 1036,39685
-(defun-one-output oneify 1063,41009
-(defun-one-output oneify-lst 1266,48996
-(defun-one-output select-stobj 1274,49191
-(defun-one-output super-defstobj-wart-stobjs-in 1279,49375
-(defun-one-output oneify-fail-form 1287,49712
-(defun-one-output get-declared-stobjs 1308,50421
-(defun-one-output warn-for-guard-body 1322,50944
-(defun-one-output create-live-user-stobjp-test 1334,51529
-(defun oneify-cltl-code 1344,51843
-(defvar *saved-raw-prompt* 2088,89063
-(defvar *saved-raw-prompt-p* 2089,89095
-(defun-one-output install-new-raw-prompt 2094,89148
-(defun-one-output install-old-raw-prompt 2101,89418
-(defun-one-output install-new-raw-prompt 2111,89685
-(defun-one-output install-old-raw-prompt 2122,90173
-(defun-one-output install-new-raw-prompt 2132,90447
-(defun-one-output install-old-raw-prompt 2139,90678
-(defun-one-output install-new-raw-prompt 2146,90808
-(defun-one-output install-old-raw-prompt 2158,91360
-(defun-one-output install-new-raw-prompt 2172,91852
-(defun-one-output install-old-raw-prompt 2189,92694
-(defun-one-output install-new-raw-prompt 2207,93337
-(defun-one-output install-old-raw-prompt 2210,93389
-(defvar *dmr-interval* 2223,93743
-(defvar *dmr-interval-acl2-par-hack* 2224,93772
-(defvar *dmr-interval-used*)2225,93817
-(defvar *dmr-indent-max* 2232,94090
-(defvar *dmr-file-name*)2238,94374
-(defun dmr-file-name 2240,94400
-(defparameter *dmr-stream*2253,94998
-(defparameter *dmr-counter*2256,95033
-(defun dmr-acl2-par-hack-p 2265,95263
-(defun dmr-stop-fn-raw 2268,95352
-(defun initialize-dmr-interval-used 2274,95481
-(defun dmr-start-fn-raw 2282,95713
-(defvar *dmr-array*2296,96178
-(defun reverse-into-dmr-array 2299,96262
-(defparameter *dmr-reusable-string*2309,96564
-(defvar *dmr-indent*)2321,96916
-(defmacro dmr-increment-indent 2323,96939
-(defun tilde-@-bkptr-string 2327,97026
-(defvar *dmr-interp-state*2385,99861
-(defun dmr-interp-fresh-rewrite-p 2390,100003
-(defun dmr-prefix 2397,100216
-(defun dmr-interp 2410,100672
-(defvar *dmr-delete-string*2485,103412
-(defun dmr-string 2491,103528
-(defun dmr-flush1 2575,107292
-(defvar *dmr-lock* 2590,107724
-(defun dmr-flush 2592,107757
-(defun dmr-display 2604,108192
-(defun cw-gstack-short 2616,108569
-(defun-one-output fmakunbound! 2771,117320
-(defun-one-output maybe-push-undo-stack 2778,117589
-(defun-one-output maybe-pop-undo-stack 2951,125827
-(defun-one-output flush-undo-stack 2964,126168
-(defparameter *current-acl2-world-key-ordering*3275,142599
-(defun-one-output key-lesseqp 3299,143328
-(defun-one-output merge-into-alist 3308,143604
-(defun-one-output destructive-push-assoc 3320,144175
-(defun-one-output destructive-pop-assoc 3337,145045
-(defun-one-output remove-current-acl2-world-key 3343,145240
-(defun hcomp-init 4139,190426
-(defabbrev reclassifying-value-p 4199,193077
-(defmacro make-reclassifying-value 4206,193230
-(defmacro unmake-reclassifying-value 4212,193360
-(defun hcomp-transfer-to-hash-tables 4218,193472
-(defvar *saved-hcomp-restore-hts* 4262,195292
-(defun hcomp-restore-defs 4264,195332
-(defun missing-compiled-book 4316,197619
-(defun load-compiled-book 4378,200600
-(defun include-book-raw 4506,206320
-(defun include-book-raw-top 4763,219893
-(defmacro hcomp-ht-from-type 4795,221402
-(defmacro hcomp-build-p 4804,221690
-(defun install-for-add-trip-hcomp-build 4809,221877
-(defun install-for-add-trip-include-book 4866,224468
-(defun install-for-add-trip 4952,228499
-(defun install-defs-for-add-trip 4968,229138
-(defun hcomp-build-from-portcullis-raw 5088,234699
-(defun hcomp-alists-from-hts 5176,238569
-(defun-one-output add-trip 5221,240428
-(defun-one-output undo-trip 5789,268590
-(defun-one-output flush-trip 5831,270410
-(defvar *bad-wrld*)5861,271611
-(defun check-acl2-world-invariant 5863,271632
-(defparameter *known-worlds* 5881,272430
-(defun update-wrld-structures 5883,272465
-(defun-one-output extend-world1 5894,272802
-(defun-one-output retract-world1 6007,277962
-(defun-one-output recover-world1 6108,282353
-(defun-one-output recover-world 6123,283012
-(defun-one-output virginp 6251,289634
-(defun-one-output chk-virgin2 6262,290020
-(defun-one-output chk-package-reincarnation-import-restrictions26329,293242
-(defvar user::*acl2-keep-tmp-files* 6368,294478
-(defun-one-output enter-boot-strap-mode 6370,294520
-(defun-one-output move-current-acl2-world-key-to-front 6465,298799
-(defun-one-output exit-boot-strap-mode 6554,303406
-(defun-one-output ld-alist-raw 6577,304380
-(defun enter-boot-strap-pass-2 6601,305234
-(defconst *acl2-pass-2-files*6621,305948
-(defun our-update-ht 6638,306401
-(defun note-fns-in-form 6647,306698
-(defun note-fns-in-file 6736,309881
-(defun note-fns-in-files 6751,310324
-(defun raw-source-name-p 6764,310895
-(defvar *check-built-in-constants-debug* 6771,311176
-(defun fns-different-wrt-acl2-loop-only 6773,311223
-(defun collect-monadic-booleans 6841,314760
-(defun check-built-in-constants 6855,315357
-(defun-one-output check-none-ideal 7070,325362
-(defun check-state-globals-initialized 7110,326974
-(defun-one-output check-acl2-initialization 7127,327587
-(defun set-initial-cbd 7133,327796
-(defun initialize-acl2 7161,328937
-(defun our-abort 7452,342457
-(defun initial-customization-filename 7548,346774
-(defun spawn-extra-lispworks-listener 7631,350238
-(defun lp 7657,351441
-(defmacro lp! 7884,361933
-(defun acl2-compile-file 7890,362100
-(defun-one-output delete-auxiliary-book-files 7959,365139
-(defun delete-expansion-file 7992,366821
-(defun compile-uncompiled-defuns 8000,367114
-(defun compile-uncompiled-*1*-defuns 8173,375037
-(defun compile-certified-file 8404,385930
-(defun compile-for-include-book 8418,386536
-(defun-one-output enabled-structurep 8485,389980
-(defun-one-output rcnstp 8508,390967
-(defvar *trace-alist*8524,391381
-(defun-one-output assoc-eq-trace-alist 8527,391448
-(defun-one-output print-list-without-stobj-arrays 8535,391673
-(defun-one-output stobj-print-symbol 8542,391872
-(defun-one-output trace-hide-world-and-state 8559,392627
-(defun-one-output saved-build-date-string 8613,394876
-(defun-one-output get-stobjs-out-for-declare-form 8624,395172
-(defun fix-trace-untrace 8649,396145
-(defun fix-trace 8661,396585
-
-defpkgs.lisp,63
-(defconst *acl2-exports*34,1565
-(defpkg "ACL2-USER"638,27281
-
-boot-strap-pass-2.lisp,2141
-(defattach too-many-ifs-post-rewrite 487,19522
-(defattach (too-many-ifs-pre-rewrite 503,20156
-(defthm fn-count-evg-rec-type-prescription524,20788
-(defthm fn-count-evg-rec-bound529,20942
-(defthm fn-count-1-type546,21393
-(defthm symbol-listp-cdr-assoc-equal571,22588
-(defthm integerp-nth-0-var-fn-count-1579,22915
-(defthm integerp-nth-1-var-fn-count-1606,24205
-(defthm integerp-nth-2-var-fn-count-1629,25266
-(defun member-equal-mod-commuting 660,26527
-(defun strip-ancestor-literals 673,27135
-(defattach (ancestors-check 753,30277
-(defattach worse-than 756,30389
-(defattach worse-than-or-equal 758,30432
-(defattach (acl2x-expansion-alist768,30727
-(defattach rw-cache-debug 779,31047
-(defattach rw-cache-debug-action 783,31174
-(defattach rw-cacheable-failure-reason 787,31321
-(defthm d-pos-listp-forward-to-true-listp812,32089
-(defattach print-clause-id-okp 829,32654
-(defattach oncep-tp 863,33895
-(defthm pos-listp-forward-to-integer-listp885,34833
-(defthm true-listp-chars-for-tilde-@-clause-id-phrase/periods892,35035
-(defthm true-listp-explode-atom896,35198
-(deftheory definition-minimal-theory991,38048
-(deftheory executable-counterpart-minimal-theory997,38158
-(deftheory minimal-theory1003,38285
-(deftheory ground-zero 1053,40237
-(defund meta-extract-formula 1084,41170
-(defun typespec-check 1111,42319
-(defun meta-extract-rw+-term 1123,42693
-(defun meta-extract-contextual-fact 1154,43840
-(defun rewrite-rule-term 1199,45908
-(defmacro meta-extract-global-fact 1213,46340
-(defun fncall-term 1217,46473
-(defun logically-equivalent-states 1234,47115
-(defun meta-extract-global-fact+ 1238,47230
-(defun pair-fns-with-measured-subsets 1295,49630
-(defun new-verify-guards-fns1 1312,50422
-(defun new-verify-guards-fns 1334,51448
-(defconst *system-verify-guards-alist*1345,51890
-(defconst *len-system-verify-guards-alist*1398,53542
-(defmacro chk-new-verified-guards 1401,53627
-(defun system-verify-guards-fn-1 1435,55121
-(defun cons-absolute-event-numbers 1448,55730
-(defun sort->-absolute-event-number 1465,56475
-(defun system-verify-guards-fn 1470,56693
-(defmacro system-verify-guards 1480,57046
-
-multi-threading-raw.lisp,2050
-(defmacro without-interrupts 68,2994
-(defmacro unwind-protect-disable-interrupts-during-cleanup91,3890
-(defstruct (atomically-modifiable-counter130,5555
-(defun make-atomically-modifiable-counter 151,6759
-(defmacro define-atomically-modifiable-counter 161,6998
-(defmacro atomically-modifiable-counter-read 164,7138
-(defmacro atomic-incf 174,7342
-(defmacro atomic-incf-multiple 209,8732
-(defmacro atomic-decf 237,9909
-(defun lockp 261,10910
-(defun make-lock 273,11297
-(defmacro reset-lock 302,12540
-(defmacro with-lock 312,12897
-(defun run-thread 335,13668
-(defun interrupt-thread 370,15022
-(defun kill-thread 390,15718
-(defun all-threads 402,15977
-(defun current-thread 412,16209
-(defun thread-wait 422,16387
-(defmacro with-potential-timeout 437,16980
-(defun make-condition-variable 532,21197
-(defmacro signal-condition-variable 551,21762
-(defmacro broadcast-condition-variable 580,22863
-(defun wait-on-condition-variable 592,23152
-(defstruct acl2-semaphore627,24633
-(defstruct acl2-semaphore633,24772
-(defun make-semaphore 638,24893
-(defun semaphorep 695,27666
-(defun make-semaphore-notification 722,28667
-(defun semaphore-notification-status 737,29143
-(defun clear-semaphore-notification-status 754,29787
-(defun set-semaphore-notification-status 771,30525
-(defun signal-semaphore 780,30877
-(defun wait-on-semaphore 807,31791
-(defvar *throwable-worker-thread*929,37533
-(defun throw-all-threads-in-list 943,38210
-(defun kill-all-threads-in-list 991,40264
-(defun thread-name 1003,40635
-(defconstant *worker-thread-name* 1013,40876
-(defun worker-threads1 1015,40928
-(defun worker-threads 1023,41190
-(defun all-worker-threads-are-dead 1030,41351
-(defun all-given-threads-are-reset 1037,41473
-(defun all-worker-threads-are-dead-or-reset 1044,41682
-(defun send-die-to-worker-threads 1056,42093
-(defun kill-all-worker-threads 1088,43418
-(defun core-count-raw 1103,43915
-(defvar *core-count*1123,44653
-(defvar *unassigned-and-active-work-count-limit*1131,44892
-(defconstant *max-idle-thread-count*1149,45854
-
-futures-raw.lisp,3756
-(defstruct st-future49,1893
-(defmacro st-future 59,2101
-(defun st-future-read 69,2471
-(defun st-future-abort 83,3032
-(defstruct atomic-notification199,6821
-(defstruct barrier218,7691
-(defun broadcast-barrier 243,8941
-(defun wait-on-barrier 256,9451
-(defstruct mt-future266,9779
-(define-atomically-modifiable-counter *last-slot-saved* 277,10024
-(define-atomically-modifiable-counter *last-slot-taken* 278,10083
-(defvar *future-array*)295,11068
-(defvar *thread-array*)296,11092
-(defvar *future-dependencies*)297,11116
-(defparameter *future-queue-length-history*299,11148
-(defvar *current-thread-index*305,11241
-(defconstant *starting-core* 312,11416
-(defconstant *resumptive-core* 313,11453
-(defvar *allocated-core*315,11498
-(defvar *decremented-idle-future-thread-count* 338,12667
-(defvar *idle-future-core-count*340,12720
-(defvar *idle-future-resumptive-core-count*342,12806
-(defvar *idle-core* 344,12908
-(define-atomically-modifiable-counter *idle-future-thread-count*346,12947
-(defvar *future-added* 365,14032
-(defvar *idle-resumptive-core* 367,14074
-(defvar *threads-spawned* 370,14142
-(define-atomically-modifiable-counter *unassigned-and-active-future-count*372,14172
-(define-atomically-modifiable-counter *total-future-count*382,14524
-(defconstant *future-array-size* 394,14967
-(defmacro faref 396,15009
-(defvar *resource-and-timing-based-parallelizations*403,15243
-(defvar *resource-and-timing-based-serializations*408,15429
-(defvar *resource-based-parallelizations*413,15618
-(defvar *resource-based-serializations*418,15782
-(defun reset-future-queue-length-history 423,15949
-(defun reset-future-parallelism-variables 426,16038
-(defun reset-all-parallelism-variables 498,18678
-(defun futures-parallelism-buffer-has-space-available 505,18992
-(defun not-too-many-futures-already-in-existence 512,19257
-(defun futures-resources-available 556,21331
-(defmacro unwind-protect-disable-interrupts-during-cleanup574,22240
-(define-atomically-modifiable-counter *threads-waiting-for-starting-core*596,23131
-(defun claim-starting-core 607,23615
-(defun claim-resumptive-core 631,24705
-(defun free-allocated-core 669,26043
-(defun early-terminate-children 691,26850
-(defvar *aborted-futures-via-flag* 706,27452
-(defvar *aborted-futures-total* 707,27490
-(defvar *futures-resources-available-count* 710,27545
-(defvar *futures-resources-unavailable-count* 711,27592
-(defun set-thread-check-for-abort-and-funcall 713,27642
-(defvar *throwable-future-worker-thread*762,29825
-(defun wait-for-a-closure 778,30433
-(defvar *busy-wait-var* 860,35369
-(defvar *current-waiting-thread* 861,35396
-(defvar *fresh-waiting-threads* 862,35434
-(defun make-tclet-thrown-symbol1 867,35579
-(defun make-tclet-thrown-symbol 878,35896
-(defun make-tclet-bindings1 881,35990
-(defun make-tclet-bindings 888,36178
-(defun make-tclet-thrown-tags1 891,36264
-(defun make-tclet-thrown-tags 897,36433
-(defun make-tclet-catches 900,36525
-(defun make-tclet-cleanups 910,36891
-(defmacro throw-catch-let 918,37143
-(defun eval-a-closure 989,39646
-(defun eval-closures 1044,42000
-(defun number-of-idle-threads-and-threads-waiting-for-a-starting-core 1079,43152
-(defun spawn-closure-consumers 1088,43455
-(defun make-future-with-closure 1122,45285
-(defun add-future-to-queue 1162,47400
-(defmacro mt-future 1174,47732
-(defun mt-future-read 1265,51772
-(defvar *aborted-futures-via-throw* 1312,53815
-(defvar *almost-aborted-future-count* 1313,53854
-(defun mt-future-abort 1315,53896
-(defun abort-future-indices 1387,57344
-(defun print-non-nils-in-array 1401,57856
-(defun futures-still-in-flight 1410,58135
-(defmacro future 1421,58440
-(defun future-read 1424,58481
-(defun future-abort 1427,58527
-(defun abort-futures 1430,58575
-
-parallel-raw.lisp,2414
-(defstruct parallelism-piece 213,9963
-(defparameter *reset-parallelism-variables* 348,16353
-(defparameter *reset-core-count-too*350,16403
-(defun reset-parallelism-variables 360,16828
-(defun eval-and-save-result 422,18939
-(defun pop-work-and-set-thread 440,19673
-(defun consume-work-on-work-queue-when-there 471,21080
-(defun spawn-worker-threads-if-needed 617,28131
-(defun add-work-list-to-queue 661,30311
-(defun combine-array-results-into-list 685,31421
-(defun remove-thread-array-from-work-queue-rec695,31745
-(defun remove-thread-array-from-work-queue 729,33013
-(defun terminate-siblings 738,33336
-(defun generate-work-list-from-closure-list-rec751,33974
-(defun generate-work-list-from-closure-list771,34835
-(defun pargs-parallelism-buffer-has-space-available 799,35995
-(defun not-too-many-pieces-of-parallelism-work-already-in-existence 803,36176
-(defun parallelism-resources-available 814,36751
-(defun throw-threads-in-array 832,37681
-(defun decrement-children-left 861,39140
-(defun wait-for-children-to-finish869,39459
-(defun wait-for-resumptive-parallelism-resources 887,40210
-(defun early-terminate-children-and-rewait907,41150
-(defun prepare-to-wait-for-children 940,42428
-(defun parallelize-closure-list 959,43169
-(defun parallelize-fn 1069,48024
-(defmacro closure-for-expression 1085,48731
-(defmacro closure-list-for-expression-list 1088,48799
-(defun parallelism-condition 1097,49082
-(defmacro pargs 1107,49401
-(defun plet-doublets 1127,50104
-(defun make-closures 1134,50313
-(defun identity-list 1147,50810
-(defun make-list-until-non-declare 1149,50849
-(defun parse-additional-declare-forms-for-let 1155,51114
-(defmacro plet 1165,51510
-(defmacro pand 1189,52475
-(defmacro por 1210,53261
-(defun signal-semaphores 1232,54030
-(defmacro spec-mv-let 1238,54184
-(defun number-of-active-threads-aux 1277,55525
-(defun number-of-active-threads 1289,55865
-(defun number-of-threads-waiting-on-a-child-aux 1292,55951
-(defun number-of-threads-waiting-on-a-child 1304,56335
-(defun future-queue-length 1307,56445
-(defun total-number-of-threads 1325,57206
-(defvar *refresh-rate-indicator* 1328,57267
-(defmacro value-of-symbol 1330,57304
-(defun acl2p-sum-list1 1344,57930
-(defun acl2p-sum-list 1350,58086
-(defun average-future-queue-size 1357,58241
-(defun print-interesting-parallelism-variables-str 1361,58391
-(defun print-interesting-parallelism-variables 1420,60474
+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-check.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 (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 (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
diff -Nru acl2-6.2/acl2-check.lisp acl2-6.3/acl2-check.lisp
--- acl2-6.2/acl2-check.lisp 2013-06-06 16:30:52.000000000 +0000
+++ acl2-6.3/acl2-check.lisp 2013-09-29 21:27:51.000000000 +0000
@@ -1,4 +1,4 @@
-; ACL2 Version 6.2 -- A Computational Logic for Applicative Common Lisp
+; ACL2 Version 6.3 -- A Computational Logic for Applicative Common Lisp
; Copyright (C) 2013, Regents of the University of Texas
; This version of ACL2 is a descendent of ACL2 Version 1.9, Copyright
diff -Nru acl2-6.2/acl2-fns.lisp acl2-6.3/acl2-fns.lisp
--- acl2-6.2/acl2-fns.lisp 2013-06-06 16:30:53.000000000 +0000
+++ acl2-6.3/acl2-fns.lisp 2013-09-29 21:27:51.000000000 +0000
@@ -1,4 +1,4 @@
-; ACL2 Version 6.2 -- A Computational Logic for Applicative Common Lisp
+; ACL2 Version 6.3 -- A Computational Logic for Applicative Common Lisp
; Copyright (C) 2013, Regents of the University of Texas
; This version of ACL2 is a descendent of ACL2 Version 1.9, Copyright
@@ -20,6 +20,10 @@
(in-package "ACL2")
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; PRELIMINARIES
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
(defmacro qfuncall (fn &rest args)
; Avoid noise in CCL about undefined functions, not avoided by funcall alone.
@@ -33,6 +37,73 @@
#-(and cltl2 (not cmu) (not gcl))
`(funcall ',fn ,@args)))
+(defmacro defun-one-output (&rest args)
+
+; Use this for raw Lisp functions that are known to return a single value in
+; raw Lisp, since make-defun-declare-form uses that assumption to make an
+; appropriate declaration.
+
+ (cons 'defun args))
+
+; The following alist associates package names with Common Lisp packages, and
+; is used in function find-package-fast, which is used by princ$ in place of
+; find-package in order to save perhaps 15% of the print time.
+(defparameter *package-alist* nil)
+
+(defun-one-output find-package-fast (string)
+ (or (cdr (assoc string *package-alist* :test 'equal))
+ (let ((pkg (find-package string)))
+ (push (cons string pkg) *package-alist*)
+ pkg)))
+
+(defvar *global-symbol-key* (make-symbol "*GLOBAL-SYMBOL-KEY*"))
+
+(defun global-symbol (x)
+ (or (get x *global-symbol-key*)
+ (setf (get x *global-symbol-key*)
+ (intern (symbol-name x)
+ (find-package-fast
+ (concatenate 'string
+ *global-package-prefix*
+ (symbol-package-name x)))))))
+
+(defmacro live-state-p (x)
+ (list 'eq x '*the-live-state*))
+
+#-acl2-loop-only
+(defun get-global (x state-state)
+
+; Keep this in sync with the #+acl2-loop-only definition of get-global (which
+; doesn't use qfuncall).
+
+ (cond ((live-state-p state-state)
+ (return-from get-global
+ (symbol-value (the symbol (global-symbol x))))))
+ (cdr (assoc x (qfuncall global-table state-state))))
+
+(defmacro f-get-global (x st)
+ (cond ((and (consp x)
+ (eq 'quote (car x))
+ (symbolp (cadr x))
+ (null (cddr x)))
+
+; The cmulisp compiler complains about unreachable code every (perhaps) time
+; that f-get-global is called in which st is *the-live-state*. The following
+; optimization is included primarily in order to eliminate those warnings;
+; the extra efficiency is pretty minor, though a nice side effect.
+
+ (if (eq st '*the-live-state*)
+ `(let ()
+ (declare (special ,(global-symbol (cadr x))))
+ ,(global-symbol (cadr x)))
+ (let ((s (gensym)))
+ `(let ((,s ,st))
+ (declare (special ,(global-symbol (cadr x))))
+ (cond ((live-state-p ,s)
+ ,(global-symbol (cadr x)))
+ (t (get-global ,x ,s)))))))
+ (t `(get-global ,x ,st))))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; SUPPORT FOR NON-STANDARD ANALYSIS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -109,57 +180,79 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; The variable acl2::*do-proclaims* determines whether or not we proclaim ACL2
-; functions before compiling them. Normally this seems to improve performance,
-; though we believe that such proclaiming had the opposite effect for some
-; combination of ACL2 and Allegro CL; see comment in proclaim-file.
-
-; The constant acl2::*suppress-compile-build-time* determines whether or not we
-; avoid calling the compiler. If this variable is false, then in compile-acl2
-; we load each source file, then proclaim it, and finally compile it. But we
-; skip all that when acl2::*suppress-compile-build-time* is true; we can't
-; proclaim before loading because macros may not all have been defined, and it
-; seems dicey to do the sequence load,proclaim,load because the second load
-; redefines functions. So in this case, we instead do the build by first
-; optionally (though required in GCL) calling generate-acl2-proclaims to do the
-; entire load/initialization sequence and write out file acl2-proclaims.lisp.
-; At the makefile level (see GNUmakefile), this sequence is accomplished with
+; functions before compiling them. The intent of proclaiming is to improve
+; performance, though we once observed proclaiming to have had the opposite
+; effect for some combination of ACL2 and Allegro CL; see a comment in
+; proclaim-file.
+
+; In compile-acl2 we load each source file, then proclaim it, and finally
+; compile it, provided acl2::*suppress-compile-build-time* is false. in
+; compile-acl2 we load each source file, then proclaim it, and finally
+; Otherwise we skip all that: we can't proclaim before loading because macros
+; may not all have been defined, and it seems dicey to do the sequence
+; load,proclaim,load because the second load redefines functions. So in this
+; case, we could do the build as follow (though this isn't the default; see
+; variable ACL2_PROCLAIMS_ACTION in GNUmakefile): first call
+; generate-acl2-proclaims to do the entire load/initialization sequence, then
+; write out file acl2-proclaims.lisp, then compile again using that file. At
+; the makefile level (see GNUmakefile), this sequence is accomplished with
; target "large" as follows: target "full" does a compile (basically a no-op if
; *suppress-compile-build-time* is true), then target "init" first invokes
; target "make-acl2-proclaims" to do the load/initialization and writing out of
; file acl2-proclaims.lisp, and finally "init" does a new load/initialization
; but this time loading the existing acl2-proclaims.lisp to proclaim functions.
+; We considered using the above two-step process for GCL, expecting that better
+; proclaim forms would be generated after doing initialization of the
+; boot-strap world, since our code that generates proclaims tries to take
+; advantage of stobjs-out properties. However, we found (August 8, 2013) that
+; the generated proclaim forms were the same whether we did that, or we merely
+; generated them during the load/proclaim/compile of each source file. So, we
+; do the latter, which speeds up the build (see :DOC note-6-3).
+
; At one time we proclaimed for CCL, but one profiling run of a
; compute-intensive include-book form showed that this was costing us some 10%
; of the time. After checking with Gary Byers we decided that there was little
; if any benefit in CCL for proclaiming functions, so we no longer do it.
-; Perhaps we should reconsider some time.
+; Perhaps we should reconsider some time; in fact we have done so on 8/9/2013
+; (see comments below in *do-proclaims*).
; We considered adding &OPTIONAL to the end of every VALUES form (see comments
; below), based on output (since forgotten) from SBCL. But GCL issued several
; dozen warnings during the build when this happened, so for now, since we are
-; only proclaiming functions for GCL, we'll remove the &optional and be happy.
+; only proclaiming functions for GCL, we omit the &optional.
(defvar *do-proclaims*
- #+gcl t
- #-gcl nil)
-(defmacro defun-one-output (&rest args)
+; We may want to experiment for proclaiming with other Lisps besides GCL. But
+; this might not be a good idea, in particular for Allegro CL and CCL (see
+; above).
+
+; In fact we experimented with CCL and ACL2(h) on 8/9/2013, by temporarily
+; setting this variable to T. We got these results from "time" for make -j 8
+; with target regression-fresh on dunnottar.cs.utexas.edu. The results are
+; inconclusive, so we keep things simple (and avoid stepping on the possibility
+; of future CCL improvements) by the lskipping of function proclaiming in CCL.
+
+; Built as follows (not showing here the setting PREFIX=):
+; make ACL2_HONS=h LISP=ccl-trunk ACL2_SIZE=3000000
+; 27815.314u 1395.775s 1:09:03.35 705.0% 0+0k 2008+1736952io 34pf+0w
+
+; Built as follows (not showing here the setting PREFIX=):
+; make ACL2_HONS=h LISP=ccl-trunk ACL2_SIZE=3000000 \
+; ACL2_PROCLAIMS_ACTION=generate_and_reuse
+; 27272.420u 1401.555s 1:09:11.18 690.7% 0+0k 333088+1750384io 303pf+0w
-; Use this for raw Lisp functions that are known to return a single value in
-; raw Lisp, since make-defun-declare-form uses that assumption to make an
-; appropriate declaration.
-
- (cons 'defun args))
+ #+gcl t
+ #-gcl nil)
(defun macroexpand-till (form sym)
-; In order to find the THEs that we want to find to do automatic
-; proclaiming of the output types of functions, we need to do
-; macroexpansion at proclaim-time. It is possible that a given
-; implementation of Common Lisp will macroexpand THE forms further.
-; Hence we gently do the macroexpansion we need, one expansion at a
-; time, looking for the THE we want to find.
+; In order to find the THEs that we want to find to do automatic proclaiming of
+; the output types of functions, we need to do macroexpansion at proclaim-time.
+; It is possible that a given implementation of Common Lisp will macroexpand
+; THE forms further. Hence we gently do the macroexpansion we need, one
+; expansion at a time, looking for the THE we want to find.
(loop (cond ((and (consp form) (eq (car form) sym))
(return form))
@@ -624,10 +717,22 @@
(eval form)))))
(defun proclaim-form (form &optional stream)
+
+; We assume that this function is called under proclaim-file, which binds
+; *package*. See the comment below for the in-package case.
+
(when *do-proclaims*
(cond ((consp form)
(case (car form)
- ((in-package) (eval-or-print form stream) nil)
+ ((in-package)
+ (eval-or-print form stream)
+ (when stream
+
+; We make sure that when we're merely printing, nevertheless we are in the
+; correct package as we read the rest of the file.
+
+ (eval form))
+ nil)
((defmacro defvar defparameter) nil)
((defconst)
(eval-or-print (make-defconst-declare-form form) stream)
@@ -669,8 +774,8 @@
; Lisps other than GCL. However, our tests in Allegro suggested that this may
; not help. The comment below gives some details. Perhaps we will proclaim
; for MCL in the future. At any rate, CCL (OpenMCL) is supported starting with
-; Version_2.8, and we proclaim there since Warren Hunt thought that might be
-; useful.
+; Version_2.8. We tried proclaiming for that Lisp, but no longer do so; see
+; Section "PROCLAIMING" above.
; Here is a summary of three comparable user times from certifying all the ACL2
; books in June 2000, just before Release 2.5 is complete. The first column,
@@ -917,18 +1022,24 @@
(val (and (symbolp sym)
(qfuncall fgetprop sym 'const nil
(qfuncall w *the-live-state*)))))
- (if val
- (cond ((and (consp val)
- (eq (car val) 'quote)
- (consp (cdr val))
- (null (cddr val)))
- (cadr val))
- (t (error "(Implementation error) Found non-quotep 'const ~%~
- property for ~s."
- sym)))
+ (cond
+ (val
+ (cond ((and (consp val)
+ (eq (car val) 'quote)
+ (consp (cdr val))
+ (null (cddr val)))
+ (cadr val))
+ (t (error "(Implementation error) Found non-quotep 'const ~%~
+ property for ~s."
+ sym))))
+ (sym
+ (error "ACL2 supports #. syntax only for #.*a*, where *a* has been ~%~
+ defined by ~s. Thus the form #.~s is illegal."
+ 'defconst sym))
+ (t ; surprising case
(error "ACL2 supports #. syntax only for #.*a*, where *a* has been ~%~
defined by ~s."
- 'defconst))))
+ 'defconst)))))
(defun sharp-bang-read (stream char n)
@@ -1257,7 +1368,8 @@
; Finally, consider namestringp. If nil, then as above we either return nil or
; the truename (a pathname object). Otherwise, we return the namestring of
; such a truename, with the following treatment if that truename is nil: return
-; nil if namestringp is :safe, else cause an error.
+; nil if namestringp is :safe, else cause an error, where if namestringp is a
+; msgp then incorporate it into the error message.
(when (pathnamep filename)
(setq filename (namestring filename)))
@@ -1296,8 +1408,11 @@
(cond ((eq namestringp :safe) nil)
(t (qfuncall
interface-er
- "Unable to obtain the truename of file ~x0."
- filename))))
+ "Unable to obtain the truename of file ~x0.~@1"
+ filename
+ (if (qfuncall msgp namestringp)
+ (qfuncall msg " ~@0" namestringp)
+ "")))))
(t (namestring truename)))))
(defun our-pwd ()
@@ -1307,7 +1422,7 @@
; make invokes another make in a different directory.
(qfuncall pathname-os-to-unix
- (our-truename "" t)
+ (our-truename "" "Note: Calling OUR-TRUENAME from OUR-PWD.")
(get-os)
*the-live-state*))
@@ -1453,23 +1568,6 @@
#-hons
def-form)
-(defun our-function-lambda-expression (sym)
-
-; This is intended only for #+hons; otherwise it reduces to (mv
-; (function-lambda-expression (symbol-function sym)) nil).
-
- #-cltl2
- (declare (ignore sym))
- #-cltl2
- (mv nil nil)
- #+cltl2
- (let ((temp (get sym 'acl2-saved-def)))
- (cond (temp (values temp t))
- (t (let* ((fn (symbol-function sym))
- (lam (and fn (function-lambda-expression fn))))
- (cond (lam (values lam nil))
- (t (values nil nil))))))))
-
; [Comment from Jared]: We probably should work toward getting rid of
; defg/defv's in favor of regular parameters...
diff -Nru acl2-6.2/acl2-init.lisp acl2-6.3/acl2-init.lisp
--- acl2-6.2/acl2-init.lisp 2013-06-07 03:22:46.000000000 +0000
+++ acl2-6.3/acl2-init.lisp 2013-09-29 21:27:51.000000000 +0000
@@ -1,4 +1,4 @@
-; ACL2 Version 6.2 -- A Computational Logic for Applicative Common Lisp
+; ACL2 Version 6.3 -- A Computational Logic for Applicative Common Lisp
; Copyright (C) 2013, Regents of the University of Texas
; This version of ACL2 is a descendent of ACL2 Version 1.9, Copyright
@@ -358,14 +358,16 @@
(apply v rst)))))
(defun system-call (string arguments)
- #+akcl
+
+; Warning: Keep this in sync with system-call+.
+
+ #+gcl
(si::system
(let ((result string))
(dolist
(x arguments)
(setq result (concatenate 'string result " " x)))
result))
- #+lucid (user::run-program string :arguments arguments)
#+lispworks
(system::call-system
(let ((result string))
@@ -425,9 +427,9 @@
(integerp (cadr status))))
1 ; just some non-zero exit code here
(cadr status)))
- #-(or akcl lucid lispworks allegro cmu sbcl clisp ccl)
+ #-(or gcl lispworks allegro cmu sbcl clisp ccl)
(declare (ignore string arguments))
- #-(or akcl lucid lispworks allegro cmu sbcl clisp ccl)
+ #-(or gcl lispworks allegro cmu sbcl clisp ccl)
(error "SYSTEM-CALL is not yet defined in this Lisp."))
(defun copy-acl2 (dir)
@@ -502,7 +504,9 @@
(setq source-directory
(subseq source-directory 0 (1- (length source-directory))))))
(cond ((not (equal (our-truename (format nil "~a/" source-directory) :safe)
- (our-truename "" t)))
+ (our-truename
+ ""
+ "Note: Calling OUR-TRUENAME from COPY-DISTRIBUTION.")))
(error "We expected to be in the directory~%~s~%~
but instead are apparently in the directory~%~s .~%~
Either issue, in Unix, the command~%~
@@ -680,26 +684,41 @@
(defvar *saved-build-date-lst*)
(defvar *saved-mode*)
-(defconstant *acl2-svn-revision-string*
- "~% WARNING: Do not redistribute. This is NOT an ACL2 release; it is,~
- ~% rather, an svn distribution, ~a.~
- ~% The authors of ACL2 consider svn distributions to be experimental.~%")
-
-(defun acl2-svn-revision-string ()
-
-; Put symbol :release into file acl2-startup-info.txt before doing a release.
-; Otherwise, we expect that file to start with a string of the form
-; "$Revision: n $".
+(defun svn-revision-from-line (s)
+
+; S is a string such as "$Revision: 1053 $" (as in acl2-startup-info.txt) or
+; "Revision: 1998" (as printed by "svn info"). In general, it is a string for
+; which we want the object that is read immediately after the first #\: . If
+; there is none, then we return nil.
+
+ (let ((p (position #\: s)))
+ (and p
+ (read-from-string s nil nil :start (1+ p)))))
+(defconstant *acl2-svn-revision-string*
(let ((file "acl2-startup-info.txt"))
(cond ((probe-file file)
(let ((val (with-open-file
(str file :direction :input)
(read str))))
(cond ((eq val :release)
- "")
+ nil)
((stringp val)
- (format nil *acl2-svn-revision-string* val))
+ (let ((n (svn-revision-from-line val)))
+ (or n (error "Unexpected error in getting svn revision ~
+ from string:~%~s~%"
+ val))
+ (format nil
+ "
+ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ + WARNING: This is NOT an ACL2 release; it is svn revision ~a. +
+ + The authors of ACL2 consider svn distributions to be experimental; +
+ + they may be incomplete, fragile, and unable to pass our own +
+ + regression. Bug reports should include the following line: +
+ + ACL2 svn revision ~a; community books svn revision ~a +
+ ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+"
+ n n "~a")))
(t (error "Illegal value in file ~s: ~s"
file val)))))
(t (error "File ~s appears not to exist." file)))))
@@ -713,10 +732,13 @@
~% are welcome to redistribute it under certain conditions. For details,~
~% see the LICENSE file distributed with ACL2.~%"
-; The following is empty if acl2-startup-info.txt begins with the symbol
-; :release.
+ (or *acl2-svn-revision-string*
+
+; If acl2-startup-info.txt begins with the symbol :release, then
+; *acl2-svn-revision-string* is a string with ~a expecting to be bound to the
+; svn revision of the books. Otherwise we put "~a" here to be bound to "".
- (acl2-svn-revision-string)
+ "~a")
"~a"
#+hons
@@ -760,6 +782,22 @@
#+cltl2 'with-standard-io-syntax
args))
+(defun user-args-string (inert-args &optional (separator '"--"))
+
+; This function is used when saving executable scripts, which may specify that
+; certain command line arguments are not to be processed by Lisp (other than to
+; affect the value of a variable or function such as
+; ccl::*unprocessed-command-line-arguments*; see books/oslib/argv.lisp). Also
+; see :doc save-exec. A common convention is that arguments after `--' are not
+; processed by Lisp.
+
+ (cond ((null inert-args)
+ "\"$@\"")
+ ((eq inert-args t)
+ (concatenate 'string separator " \"$@\""))
+ (t
+ (concatenate 'string separator " " inert-args " \"$@\""))))
+
(defmacro write-exec-file (stream prefix string &rest args)
; Prefix is generally nil, but can be (string . fmt-args). String is the
@@ -788,10 +826,92 @@
,string
,@args)))
+(defun proclaim-files (&optional outfilename infilename infile-optional-p)
+
+; IMPORTANT: This function assumes that the defconst and defmacro forms in the
+; given files have already been evaluated. One way to achieve this state of
+; affairs, of course, is to load the files first.
+
+ (when (and outfilename infilename)
+ (error "It is illegal to supply non-nil values for both optional ~
+ arguments of proclaim-files."))
+ (when (not *do-proclaims*)
+ (return-from proclaim-files nil))
+ (cond
+ (outfilename
+ (format t
+ "Writing proclaim forms for ACL2 source files to file ~s.~%"
+ outfilename))
+ (t
+ (when infilename
+ (cond ((probe-file infilename)
+ (format t
+ "Loading nontrivial generated file of proclaim forms, ~
+ ~s...~%"
+ infilename)
+ (load infilename)
+ (format t
+ "Completed load of ~s.~%"
+ infilename)
+ (return-from proclaim-files nil))
+ (infile-optional-p) ; fall through as though infilename is nil
+ (t (error "File ~s is to be loaded by proclaim-files, but does ~
+ not exist."
+ infilename))))
+ (format t
+ "Generating and evaluating proclaim forms for ACL2 source ~
+ files.~%")))
+ (let (str)
+ (when outfilename
+ (if (probe-file outfilename)
+ (delete-file outfilename))
+ (or (setq str (safe-open outfilename :direction :output))
+ (error "Unable to open file ~s for output." outfilename)))
+
+; It is tempting to print an in-package form, but we leave that task to
+; proclaim-file, which presumably finds the first form to be an in-package
+; form.
+
+ (dolist (fl *acl2-files*)
+ (proclaim-file (format nil "~a.lisp" fl) str))
+ (when str ; equivalently, when outfilename is non-nil
+ (close str))))
+
+(defun insert-string (s)
+ (cond ((null s) "")
+ (t (concatenate 'string " " s))))
+
+#+gcl
+(defvar *saved-system-banner*
+
+; This variable is only used in GCL 2.6.9 and later, and the following comments
+; pertain only to that case.
+
+; Set this variable to nil before save-exec in order to save an image without a
+; GCL startup banner, as this will leave si::*system-banner* unbound; see
+; below.
+
+; ACL2 keeps this value at nil except when acl2-default-restart unbinds
+; si::*system-banner*, in which case *saved-system-banner* is set to the value
+; of si::*system-banner* just before that unbinding takes place. When
+; save-exec saves an image, it first checks whether si::*system-banner* is
+; unbound and *saved-system-banner* is non-nil, in which case it sets
+; si::*system-banner* to *saved-system-banner*. Even if si::*system-banner* is
+; bound, *saved-system-banner* is set to nil before saving an image.
+
+ nil)
+
#+akcl
(defun save-acl2-in-akcl-aux (sysout-name gcl-exec-name
write-worklispext
- set-optimize-maximum-pages)
+ set-optimize-maximum-pages
+ host-lisp-args
+ inert-args)
+ (when (and (gcl-version-> 2 6 9 t)
+ *saved-system-banner*)
+ (when (not (boundp 'si::*system-banner*)) ; true, unless user intervened
+ (setq si::*system-banner* *saved-system-banner*))
+ (setq *saved-system-banner* nil))
(if (and write-worklispext (probe-file "worklispext"))
(delete-file "worklispext"))
(let* ((ext "gcl")
@@ -812,7 +932,10 @@
(if (probe-file gcl-exec-file)
(delete-file gcl-exec-file))
(with-open-file (str sysout-name :direction :output)
- (write-exec-file str nil "~s $*~%" gcl-exec-file))
+ (write-exec-file str nil "~s~s ~a~%"
+ gcl-exec-file
+ (insert-string host-lisp-args)
+ (user-args-string inert-args)))
(cond ((and set-optimize-maximum-pages
(boundp 'si::*optimize-maximum-pages*))
@@ -961,14 +1084,6 @@
(lp)))
(load "akcl-acl2-trace.lisp")
-; The following is important so that ACL2 functions are efficient in certain
-; situations. For example, (aref1 'foo foo n) should avoid boxing a fixnum n.
-
- (cond (*suppress-compile-build-time*
- (load "acl2-proclaims.lisp")
- (load-acl2))
- (t (proclaim-files)))
-
; Return to normal allocation growth. Keep this in sync with load-acl2, which
; had presumably already set the allocation growth to be particularly slow.
@@ -979,7 +1094,10 @@
; In akcl, at least some versions of it, we cannot call allocate-growth on the
; following two types.
- #+gcl contiguous
+; Camm Maguire has told us on 9/22/2013 that certain allocations for contiguous
+; pages, as we now do in acl2.lisp for GCL 2.6.10 and later (which includes GCL
+; 2.6.10pre as of 9/22/2013).
+; #+gcl contiguous
#+gcl relocatable
)
do
@@ -991,7 +1109,10 @@
(t (si::allocate-growth type 0 0 0))))
; (print "Start (si::gbc nil)") ;debugging GC
- (si::set-hole-size 500) ; wfs suggestion
+
+; Camm Maguire suggests leaving the hole size alone for GCL 2.6.10pre as of
+; 9/22/2013:
+; (si::set-hole-size 500) ; wfs suggestion
; Camm Maguire says (7/04) that "the gc algorithm skips over any pages which
; have not been written to since sgc-on was invoked. So gc really needs to be
@@ -1032,7 +1153,10 @@
n))
do (setq new-hole-size (+ new-hole-size (- n space))))
; (print "Set hole size") ;debugging
- (si::set-hole-size new-hole-size))
+; Camm Maguire suggests leaving the hole size alone for GCL 2.6.10pre as of
+; 9/22/2013:
+; (si::set-hole-size new-hole-size)
+ )
; The calculation above is legacy. Now we increment the hole size to 20% of
; max-pages instead of the default 10%. Camm Maguire says that "Larger values
@@ -1040,21 +1164,24 @@
; part of the virtual (not resident) memory size, rather than being saved to
; disk.
- (let ((new-size (floor si:*lisp-maxpages* 5)))
- (if (< (si:get-hole-size) new-size)
- (si::set-hole-size new-size)))
+; Camm Maguire suggests leaving the hole size alone for GCL 2.6.10pre as of
+; 9/22/2013:
+; (let ((new-size (floor si:*lisp-maxpages* 5)))
+; (if (< (si:get-hole-size) new-size)
+; (si::set-hole-size new-size)))
; (print (true-listp (w *the-live-state*))) ;swap in the world's pages
; (print "Save the system") ;debugging
(when (not do-not-save-gcl)
- (save-acl2-in-akcl-aux sysout-name gcl-exec-name t t)))
+ (save-acl2-in-akcl-aux sysout-name gcl-exec-name t t nil nil)))
#+akcl
-(defun save-exec-raw (sysout-name)
+(defun save-exec-raw (sysout-name host-lisp-args inert-args)
(setq *acl2-allocation-alist* nil) ; Don't meddle with allocations.
(setq *acl2-default-restart-complete* nil)
- (save-acl2-in-akcl-aux sysout-name sysout-name nil nil))
+ (save-acl2-in-akcl-aux sysout-name sysout-name nil nil host-lisp-args
+ inert-args))
(defvar *acl2-default-restart-complete* nil)
@@ -1082,10 +1209,28 @@
(setq *default-pathname-defaults* p)))
nil)
+(defvar *print-startup-banner*
+
+; One might want to set this variable to nil in raw Lisp before calling
+; save-exec, in order to avoid seeing startup information. We do not comment
+; here on whether that is legally appropriate; for example, it suppresses
+; copyright information for ACL2 and, for CCL at least, information about the
+; host Lisp. We also do not guarantee that this behavior (suppressing printing
+; of startup information) is supported for every host Lisp.
+
+; Note that LD always prints some startup information, regardless of the value
+; of *print-startup-banner*. To suppress that information, evaluate
+; (set-ld-verbose nil state) in the ACL2 loop.
+
+ t)
+
+(defvar *lp-ever-entered-p* nil)
+
(defun acl2-default-restart ()
(if *acl2-default-restart-complete*
(return-from acl2-default-restart nil))
+ (setq *lp-ever-entered-p* nil)
(#+cltl2
common-lisp-user::acl2-set-character-encoding
#-cltl2
@@ -1099,19 +1244,44 @@
; In CCL, print greeting now, rather than upon first re-entry to ACL2 loop.
; Here we follow a suggestion from Gary Byers.
- (format t "~&Welcome to ~A ~A!~%"
- (lisp-implementation-type)
- (lisp-implementation-version))
+ (when *print-startup-banner*
+ (format t "~&Welcome to ~A ~A!~%"
+ (lisp-implementation-type)
+ (lisp-implementation-version)))
(setq ccl::*inhibit-greeting* t))
+
+ #+gcl
+ (progn
+
+; Some recent versions of GCL (specifically, 2.6.9 in Sept. 2013) do not print
+; the startup banner until we first exit the loop. So we handle that situation
+; much as we handle a similar issue for CCL above, following GCL source file
+; lsp/gcl_top.lsp.
+
+ (when (and *print-startup-banner*
+ (gcl-version-> 2 6 9 t)
+ (boundp 'si::*system-banner*))
+ (format t si::*system-banner*)
+ (setq *saved-system-banner* si::*system-banner*)
+ (makunbound 'si::*system-banner*)
+ (when (boundp 'si::*tmp-dir*)
+ (format t "Temporary directory for compiler files set to ~a~%"
+ si::*tmp-dir*))))
+
#+hons (qfuncall acl2h-init)
- (format t *saved-string*
- *copy-of-acl2-version*
- (saved-build-dates :terminal)
- (cond (*saved-mode*
- (format nil "~% Initialized with ~a." *saved-mode*))
- (t ""))
- (eval '(latest-release-note-string)) ; avoid possible warning
- )
+ (when *print-startup-banner*
+ (format t
+ *saved-string*
+ *copy-of-acl2-version*
+ (saved-build-dates :terminal)
+ (if (null *acl2-svn-revision-string*)
+ ""
+ (qfuncall acl2-books-revision))
+ (cond (*saved-mode*
+ (format nil "~% Initialized with ~a." *saved-mode*))
+ (t ""))
+ (eval '(latest-release-note-string)) ; avoid possible warning
+ ))
(maybe-load-acl2-init)
(eval `(in-package ,*startup-package-name*))
@@ -1131,7 +1301,8 @@
#+cmu
(defun cmulisp-restart ()
- (extensions::print-herald t)
+ (when *print-startup-banner*
+ (extensions::print-herald t))
(acl2-default-restart)
(lp))
@@ -1148,7 +1319,8 @@
:full-gc t))
#+lispworks
-(defun lispworks-save-exec-aux (sysout-name eventual-sysout-name)
+(defun lispworks-save-exec-aux (sysout-name eventual-sysout-name
+ host-lisp-args inert-args)
; LispWorks support (Dave Fox) pointed out, in the days of LispWorks 4, that we
; need to be sure to call (mp:initialize-multiprocessing) when starting up. Up
@@ -1215,8 +1387,10 @@
; changing the underlying Lisp implementation before building ACL2 (again,
; presumably based on knowledge of the host Lisp implementation).
- "~s -init - -siteinit - $*~%"
- eventual-lw-exec-file))
+ "~s -init - -siteinit -~a ~a~%"
+ eventual-lw-exec-file
+ (insert-string host-lisp-args)
+ (user-args-string inert-args)))
(chmod-executable sysout-name)
(cond ((and system::*init-file-loaded*
system::*complain-about-init-file-loaded*)
@@ -1248,18 +1422,21 @@
(delete-file "worklispext"))
(with-open-file (str "worklispext" :direction :output)
(format str "lw"))
- (lispworks-save-exec-aux sysout-name eventual-sysout-name))
+ (lispworks-save-exec-aux sysout-name eventual-sysout-name
+ nil nil))
#+lispworks
-(defun save-exec-raw (sysout-name)
+(defun save-exec-raw (sysout-name host-lisp-args inert-args)
; See the comment above about :multiprocessing t.
(setq *acl2-default-restart-complete* nil)
- (lispworks-save-exec-aux sysout-name sysout-name))
+ (lispworks-save-exec-aux sysout-name sysout-name
+ host-lisp-args inert-args))
#+cmu
-(defun save-acl2-in-cmulisp-aux (sysout-name core-name)
+(defun save-acl2-in-cmulisp-aux (sysout-name core-name
+ host-lisp-args inert-args)
(let ((eventual-sysout-core
(unix-full-pathname core-name "core"))
(sysout-core
@@ -1289,9 +1466,27 @@
(t prog1))))
(write-exec-file str
nil
- "~s -core ~s -eval '(acl2::cmulisp-restart)' $*~%"
+ "~s -core ~s -dynamic-space-size ~s -eval ~
+ '(acl2::cmulisp-restart)'~a ~a~%"
prog2
- eventual-sysout-core)))
+ eventual-sysout-core
+
+; In our testing for ACL2 Version_6.2 we found that certification failed for
+; ACL2(h) built on CMUCL for the book tau/bounders/elementary-bounders.lisp,
+; with the error: "CMUCL has run out of dynamic heap space (512 MB)." This
+; failure doesn't seem to be fully reproduceable, but it seems safest to
+; increase the stack size. Our CMUCL image, even though on 64-bit linux,
+; reported the following when we tried a value of 2000 here:
+
+; -dynamic-space-size must be no greater than 1632 MBytes.
+
+; Indeed, we have exceeded that in a version of community book
+; books/centaur/gl/solutions.lisp using ACL2(h) built on CMUCL. So we use the
+; maximum possible value just below.
+
+ 1632
+ (insert-string host-lisp-args)
+ (user-args-string inert-args))))
(chmod-executable sysout-name)
(system::gc)
(extensions::save-lisp sysout-core :load-init-file nil :site-init nil
@@ -1308,12 +1503,12 @@
(delete-file "worklispext"))
(with-open-file (str "worklispext" :direction :output)
(format str "core"))
- (save-acl2-in-cmulisp-aux sysout-name core-name))
+ (save-acl2-in-cmulisp-aux sysout-name core-name nil nil))
#+cmu
-(defun save-exec-raw (sysout-name)
+(defun save-exec-raw (sysout-name host-lisp-args inert-args)
(setq *acl2-default-restart-complete* nil)
- (save-acl2-in-cmulisp-aux sysout-name sysout-name))
+ (save-acl2-in-cmulisp-aux sysout-name sysout-name host-lisp-args inert-args))
#+sbcl
(defvar *sbcl-dynamic-space-size*
@@ -1363,7 +1558,17 @@
#-(and x86-64 hons) 2000)
#+sbcl
-(defun save-acl2-in-sbcl-aux (sysout-name core-name)
+(defvar *sbcl-contrib-dir* nil)
+
+#+sbcl
+(defun save-acl2-in-sbcl-aux (sysout-name core-name
+ host-lisp-args
+ toplevel-args
+ inert-args)
+
+; Note that host-lisp-args specifies what the SBCL manual calls "runtime
+; options", while toplevel-args is what it calls "toplevel options".
+
(declaim (optimize (sb-ext:inhibit-warnings 3)))
(let ((eventual-sysout-core
(unix-full-pathname core-name "core"))
@@ -1386,19 +1591,23 @@
("~a~%"
(let ((contrib-dir
- (and (boundp 'sb-ext::*core-pathname*)
- (ignore-errors
- (let* ((core-dir
- (pathname-directory sb-ext::*core-pathname*))
- (contrib-dir-pathname
- (and (equal (car (last core-dir))
- "output")
- (make-pathname
- :directory
- (append (butlast core-dir 1)
- (list "contrib"))))))
- (and (probe-file contrib-dir-pathname)
- (namestring contrib-dir-pathname)))))))
+ (or
+ *sbcl-contrib-dir*
+ (and (boundp 'sb-ext::*core-pathname*)
+ (ignore-errors
+ (let* ((core-dir
+ (pathname-directory
+ sb-ext::*core-pathname*))
+ (contrib-dir-pathname
+ (and (equal (car (last core-dir))
+ "output")
+ (make-pathname
+ :directory
+ (append (butlast core-dir 1)
+ (list "contrib"))))))
+ (and (probe-file contrib-dir-pathname)
+ (setq *sbcl-contrib-dir*
+ (namestring contrib-dir-pathname)))))))))
(if contrib-dir
(format nil
"export SBCL_HOME=~s"
@@ -1411,26 +1620,28 @@
; to be stack overflow from fmt0, which is not tail recursive. More recently,
; community book centaur/misc/defapply.lisp causes a stack overflow even with
; --control-stack-size 4 (though that might disappear after we added (comp t)
-; in a couple of places). So we use 8 instead of 4.
+; in a couple of places). Yet more recently, community books
+; books/centaur/regression/common.lisp and books/centaur/tutorial/intro.lisp
+; fail with --control-stack-size 8, due to calls of def-gl-clause-processor.
+; So we use --control-stack-size 16. We might increase 16 to 32 or greater in
+; the future.
; See *sbcl-dynamic-space-size* for an explanation of the --dynamic-space-size
; setting below.
- "~s --dynamic-space-size ~s --control-stack-size 8 --core ~s~a ~
- --eval '(acl2::sbcl-restart)'"
+; Note that --no-userinit was introduced into SBCL in Version 0.9.13, hence has
+; been part of SBCL since 2007 (perhaps earlier). So when Jared Davis pointed
+; out this option to us after ACL2 Version_6.2, we started using it in place of
+; " --userinit /dev/null", which had not worked on Windows.
+
+ "~s --dynamic-space-size ~s --control-stack-size 16 --core ~s~a ~
+ --end-runtime-options --no-userinit --eval '(acl2::sbcl-restart)'~a ~a~%"
prog
*sbcl-dynamic-space-size*
eventual-sysout-core
-
-; We have found (August 2008) that SBCL 1.0.13 on Windows does not like
-; "--userinit /dev/null". But we have been using this option for quite some
-; time on other platforms. So we conditionalize here, but we are open to
-; suggestions from SBCL users on a better way to handle this.
-
- #-mswindows
- " --userinit /dev/null"
- #+mswindows
- "")))
+ (insert-string host-lisp-args)
+ (insert-string toplevel-args)
+ (user-args-string inert-args "--end-toplevel-options"))))
(chmod-executable sysout-name)
;; In SBCL 0.9.3 the read-only space is too small for dumping ACL2 on x86,
;; so we have to specify :PURIFY NIL. This will unfortunately result in
@@ -1447,24 +1658,20 @@
(setq *saved-mode* mode)
(if (probe-file "worklispext")
(delete-file "worklispext"))
- (cond ((and *suppress-compile-build-time*
- (probe-file "acl2-proclaims.lisp"))
-; We do the following load when *suppress-compile-build-time* in save-acl2, but
-; it's harmless enough to do it again here.
- (load "acl2-proclaims.lisp"))
- (t (proclaim-files)))
(with-open-file (str "worklispext" :direction :output)
(format str "core"))
- (save-acl2-in-sbcl-aux sysout-name core-name)))
+ (save-acl2-in-sbcl-aux sysout-name core-name nil nil nil)))
#+sbcl
-(defun save-exec-raw (sysout-name)
+(defun save-exec-raw (sysout-name host-lisp-args toplevel-args inert-args)
(with-warnings-suppressed
(setq *acl2-default-restart-complete* nil)
- (save-acl2-in-sbcl-aux sysout-name sysout-name)))
+ (save-acl2-in-sbcl-aux sysout-name sysout-name host-lisp-args toplevel-args
+ inert-args)))
#+allegro
-(defun save-acl2-in-allegro-aux (sysout-name dxl-name)
+(defun save-acl2-in-allegro-aux (sysout-name dxl-name
+ host-lisp-args inert-args)
(excl:gc t) ; Suggestions are welcome for better gc call(s)!
#+(and allegro-version>= (version>= 4 3))
(progn
@@ -1502,11 +1709,13 @@
; Allegro 6.2 to avoid getting Allegro copyright information printed upon :q if
; we start up in the ACL2 read-eval-print loop.
-; "~s -I ~s -L ~s~%"
+; "~s -I ~s -L ~s ~s~%"
- "~s -I ~s $*~%"
+ "~s -I ~s~s ~a~%"
(system::command-line-argument 0)
- eventual-sysout-dxl))
+ eventual-sysout-dxl
+ (insert-string host-lisp-args)
+ (user-args-string inert-args)))
(chmod-executable sysout-name)
(excl:dumplisp :name sysout-dxl)))
#-(and allegro-version>= (version>= 5 0))
@@ -1528,12 +1737,12 @@
(with-open-file (str "worklispext" :direction :output)
(format str "dxl"))
(load "allegro-acl2-trace.lisp") ; Robert Krug's trace patch
- (save-acl2-in-allegro-aux sysout-name dxl-name))
+ (save-acl2-in-allegro-aux sysout-name dxl-name nil nil))
#+allegro
-(defun save-exec-raw (sysout-name)
+(defun save-exec-raw (sysout-name host-lisp-args inert-args)
(setq *acl2-default-restart-complete* nil)
- (save-acl2-in-allegro-aux sysout-name sysout-name))
+ (save-acl2-in-allegro-aux sysout-name sysout-name host-lisp-args inert-args))
(defun rc-filename (dir)
(concatenate 'string dir ".acl2rc"))
@@ -1557,7 +1766,7 @@
(ACL2::LP)~%")))))
#+clisp
-(defun save-acl2-in-clisp-aux (sysout-name mem-name)
+(defun save-acl2-in-clisp-aux (sysout-name mem-name host-lisp-args inert-args)
(let ((save-dir (our-pwd))
(eventual-sysout-mem
(unix-full-pathname mem-name "mem"))
@@ -1572,7 +1781,7 @@
(str sysout-name :direction :output)
(write-exec-file str
nil
- "~s -i ~s -p ACL2 -M ~s -m ~dMB -E ISO-8859-1 $*~%"
+ "~s -i ~s -p ACL2 -M ~s -m ~dMB -E ISO-8859-1~a ~a~%"
(or (ext:getenv "LISP") "clisp")
(rc-filename save-dir)
eventual-sysout-mem
@@ -1588,7 +1797,9 @@
; write-exec-file seems to put a decimal point after the number when using ~s,
; and CLISP complains about that when starting up.
- 10))
+ 10
+ (insert-string host-lisp-args)
+ (user-args-string inert-args)))
(chmod-executable sysout-name)
(ext:gc)
(ext:saveinitmem sysout-mem
@@ -1607,15 +1818,18 @@
(delete-file "worklispext"))
(with-open-file (str "worklispext" :direction :output)
(format str "mem"))
- (save-acl2-in-clisp-aux sysout-name mem-name))
+ (save-acl2-in-clisp-aux sysout-name mem-name nil nil))
#+clisp
-(defun save-exec-raw (sysout-name)
+(defun save-exec-raw (sysout-name host-lisp-args inert-args)
(setq *acl2-default-restart-complete* nil)
- (save-acl2-in-clisp-aux sysout-name sysout-name))
+ (save-acl2-in-clisp-aux sysout-name sysout-name host-lisp-args inert-args))
#+ccl
-(defun save-acl2-in-ccl-aux (sysout-name core-name)
+(defun save-acl2-in-ccl-aux (sysout-name core-name
+ &optional
+ (host-lisp-args nil save-exec-p)
+ inert-args)
(let* ((ccl-program0
(or (car ccl::*command-line-argument-list*) ; Gary Byers suggestion
(error "Unable to determine CCL program pathname!")))
@@ -1667,18 +1881,50 @@
default-dir)
"")))
+; See the section on "reading characters from files" in file acl2.lisp for an
+; explanation of the -K argument below.
+
; It is probably important to use -e just below instead of :toplevel-function,
; at least for #+hons. Jared Davis and Sol Swords have told us that it seems
; that with :toplevel-function one gets a new "toplevel" thread at start-up,
; which "plays badly with the thread-local hash tables that make up the hons
; space".
-; See the section on "reading characters from files" in file acl2.lisp for an
-; explanation of the -K argument below.
-
- "~s -I ~s -K ISO-8859-1 -e \"(acl2::acl2-default-restart)\" $*~%"
+ "~s -I ~s~a -K ISO-8859-1 -e ~
+ \"(acl2::acl2-default-restart)\"~a ~a~%"
ccl-program
- core-name))
+ core-name
+ (if save-exec-p
+
+; For an ACL2 built from sources, the saved script will include "-Z 64M"; see
+; comment below. But with save-exec, no -Z option will be written. The new
+; script can then be expected to invoke ACL2 with the same stack sizes as did
+; the original (which had -Z 64M explicitly), unless an explicit -Z option is
+; given to save-exec or globals such as
+; ccl::*initial-listener-default-control-stack-size* (see community book
+; books/centaur/ccl-config.lsp) are set before the save-exec call.
+
+; Turning now to the case of building from sources, as opposed to save-exec:
+
+; We use -Z 64M even though the default for -Z (as of mid-2013) is 2M, in order
+; to get larger stacks. We have ample evidence that a larger stack would be
+; useful: an ACL2 example from David Russinoff in August 2013 for which 8M was
+; insufficient (defining a constant function with body '(...), a quoted list of
+; length 65536; our own x86 model requiring 4M for an ACL2 proof using
+; def-gl-thm; and more generally, Centaur's routine use of large stacks,
+; equivalent to -Z 256M. Not surprisingly, we that performance was not hurt
+; using a larger stack size, for two pairs of ACL2(h) regressions as follows.
+; We ran one pair of runs on a Linux system with 32GB of RAM, and one pair of
+; runs on a MacBook Pro with 8GB of RAM, all in August 2013. For each pair we
+; ran with -Z 64M and also omitting -Z (equivalent to using -Z 2M). Our main
+; concern was potentially larger backtraces when using (set-debugger-enable
+; :bt), as during a regression. We solved that by restricting backtrace counts
+; using *ccl-print-call-history-count*.
+
+ ""
+ " -Z 64M")
+ (insert-string host-lisp-args)
+ (user-args-string inert-args)))
(chmod-executable sysout-name)
(ccl::gc)
(ccl:save-application core-name)))
@@ -1686,19 +1932,13 @@
#+ccl
(defun save-acl2-in-ccl (sysout-name &optional mode core-name)
(setq *saved-mode* mode)
- (cond ((and *suppress-compile-build-time*
- (probe-file "acl2-proclaims.lisp"))
-; We do the following load when *suppress-compile-build-time* in save-acl2, but
-; it's harmless enough to do it again here.
- (load "acl2-proclaims.lisp"))
- (t (proclaim-files)))
(load "openmcl-acl2-trace.lisp")
(save-acl2-in-ccl-aux sysout-name core-name))
#+ccl
-(defun save-exec-raw (sysout-name)
+(defun save-exec-raw (sysout-name host-lisp-args inert-args)
(setq *acl2-default-restart-complete* nil)
- (save-acl2-in-ccl-aux sysout-name sysout-name))
+ (save-acl2-in-ccl-aux sysout-name sysout-name host-lisp-args inert-args))
; Since saved-build-date-string is avoided for MCL, we avoid the following too
; (which is not applicable to MCL sessions anyhow).
@@ -1722,8 +1962,6 @@
; (ccl::save-application "acl2-image" :size (expt 2 24))
; for the Mac.
- (when (and *suppress-compile-build-time* (probe-file "acl2-proclaims.lisp"))
- (load "acl2-proclaims.lisp"))
(load-acl2)
(setq *saved-build-date-lst*
@@ -1765,33 +2003,12 @@
(error "We do not know how to save ACL2 in this Common Lisp.")
(format t "Saving of ACL2 is complete.~%"))
-(defun proclaim-files (&optional outfilename)
+(defun generate-acl2-proclaims ()
-; IMPORTANT: This function assumes that the defconst forms in the
-; given files have already been evaluated. One way to achieve this
-; state of affairs, of course, is to load the files first.
-
- (if outfilename
- (format t
- "Writing proclaim forms for ACL2 source files to file ~s.~%"
- outfilename)
- (format t
- "Generating and evaluating proclaim forms for ACL2 source ~
- files.~%"))
- (let (str)
- (when outfilename
- (if (probe-file outfilename)
- (delete-file outfilename))
- (or (setq str (safe-open outfilename :direction :output))
- (error "Unable to open file ~s for output." outfilename))
- (format str "(in-package \"ACL2\")~%"))
- (dolist (fl *acl2-files*)
- (proclaim-file (format nil "~a.lisp" fl) str))))
+; See the section "PROCLAIMING" in acl2-fns.lisp.
-(defun generate-acl2-proclaims ()
(let ((filename "acl2-proclaims.lisp"))
- (cond ((and *suppress-compile-build-time*
- *do-proclaims*)
+ (cond (*do-proclaims*
(format t "Beginning load-acl2 and initialize-acl2 on behalf of ~
generate-acl2-proclaims.~%")
(load-acl2 t)
@@ -1808,20 +2025,6 @@
"; No proclaims are generated here for this host Lisp.~%"))
nil))))
-(defun acl2 nil
- (let ((*readtable* *acl2-readtable*)
- (extension (if *suppress-compile-build-time*
- *lisp-extension*
- *compiled-file-extension*)))
- (dolist (name (remove "defpkgs" *acl2-files* :test #'equal))
- (if (equal name "proof-checker-pkg")
- (load "proof-checker-pkg.lisp")
- (load-compiled (make-pathname :name name
- :type extension))))
- (load "defpkgs.lisp")
- (in-package "ACL2")
- "ACL2"))
-
; The following avoids core being dumped in certain circumstances
; resulting from very hard errors.
diff -Nru acl2-6.2/acl2.lisp acl2-6.3/acl2.lisp
--- acl2-6.2/acl2.lisp 2013-06-06 16:30:52.000000000 +0000
+++ acl2-6.3/acl2.lisp 2013-09-29 21:27:51.000000000 +0000
@@ -1,4 +1,4 @@
-; ACL2 Version 6.2 -- A Computational Logic for Applicative Common Lisp
+; ACL2 Version 6.3 -- A Computational Logic for Applicative Common Lisp
; Copyright (C) 2013, Regents of the University of Texas
; This version of ACL2 is a descendent of ACL2 Version 1.9, Copyright
@@ -142,11 +142,14 @@
; SAFETY AND PROCLAIMING
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; The user is welcome to modify the following proclaim form.
-
(proclaim `(optimize #+cltl2 (compilation-speed 0)
+
+; The user is welcome to modify this proclaim form. Warning: Keep it in sync
+; with the settings in compile-acl2 under #+sbcl.
+
; The following may allow more tail recursion elimination (from "Lisp
; Knowledgebase" at lispworks.com); might consider for Allegro CL too.
+
#+(or lispworks ccl) (debug 0)
#+cmu (extensions:inhibit-warnings 3)
#+sbcl (sb-ext:inhibit-warnings 3)
@@ -481,6 +484,13 @@
#+ccl
(setq ccl::*record-source-file* nil)
+; Camm Maguire has suggested, on 9/22/2013, the following forms, which allowed
+; him to complete an ACL2 regresssion using 2.6.10pre.
+#+gcl
+(progn
+ (si::allocate 'contiguous 15000 t)
+ (si::allocate-sgc 'contiguous 15000 100000 10))
+
; The following avoids errors from extra right parentheses, but we leave it
; commented out since it doesn't seem important enough to merit messing around
; at this low level, and for just one Lisp.
@@ -491,7 +501,8 @@
; modifications, we made progress -- except there appears (as of Sept. 2011) to
; be no good way for us to save an executable image. Specifically, it appears
; that c:build-program not will suffice for saving state (properties etc.) --
-; it's just for saving specified .o files.
+; it's just for saving specified .o files. (This impression seems to be
+; confirmed at http://stackoverflow.com/questions/7686246/saving-lisp-state .)
; Here we document steps to take towards possibly porting to ECL in the future.
@@ -942,7 +953,7 @@
(setq acl2::*copy-of-acl2-version*
; Keep this in sync with the value of acl2-version in *initial-global-table*.
(concatenate 'string
- "ACL2 Version 6.2"
+ "ACL2 Version 6.3"
#+non-standard-analysis
"(r)"
#+(and mcl (not ccl))
@@ -971,6 +982,7 @@
#-cltl2 'user::*acl2-compiler-enabled*))
`(progn (dolist (pair *initial-global-table*)
(f-put-global (car pair) (cdr pair) *the-live-state*))
+ (f-put-global 'acl2-sources-dir (our-pwd) *the-live-state*)
(f-put-global 'iprint-ar
(compress1 'iprint-ar
(f-get-global 'iprint-ar *the-live-state*))
@@ -1429,6 +1441,29 @@
which is saved just in case it's needed later.")
(defun set-new-dispatch-macro-character (char subchar fn)
+
+; This function currently causes an error when attempting to build ACL2(h) on
+; top of CLISP, where (get-dispatch-macro-character #\# #\Y) evaluates to
+; #. Here is a discussion of that
+; issue.
+
+; With some thought we might be able to avoid the special cases below for which
+; char is #\# and subchar is, for example, #\Y -- i.e., smashing (in that
+; example) which reader is invoked by #\Y. We certainly have in mind our own
+; semantics for ACL2 source files, to be read using *acl2-readtable*, while the
+; host Lisp's semantics are expected for compiled files. But consider files
+; like .cert and @expansion.lsp files, i.e., files that may be written by the
+; host Lisp (see the call of prin1 in print-object$-ser) but are read by ACL2.
+; Perhaps the issue goes away if we are using the serialize reader and writer,
+; as must be the case when we install a reader for #\Y. We may think all this
+; through when there is sufficient reason to do so. For now, the only problem
+; pertaining to our handling of dispatch macro characters is in the case of
+; CLISP and ACL2(h), since #\Y is already defined in CLISP -- this function
+; causes an error when attempting to build ACL2(h) on CLISP. Since CLISP is
+; much slower than the other six host Lisps that we support, and since ACL2(h)
+; is optimized for CCL such that it is really only intended for CCL at this
+; point (June 2013), we can live without CLISP support for ACL2(h).
+
(let ((old (get-dispatch-macro-character char subchar)))
(cond ((or (null old)
(eql fn old)
@@ -1858,16 +1893,31 @@
; COMPILING and LOADING, PART 2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defun non-trivial-acl2-proclaims-file-p ()
+ (with-open-file (str "acl2-proclaims.lisp"
+ :direction :input
+ :if-does-not-exist nil)
+ (and str
+ (let* ((new-cons (cons nil nil))
+ (val (read str nil new-cons)))
+ (and (not (eq new-cons val))
+
+; We might not need the following, but just in case we decide always to print
+; an in-package form into the file, we require that the file have at least two
+; forms.
+
+ (not (eq new-cons
+ (read str nil new-cons))))))))
+
(defun compile-acl2 (&optional use-acl2-proclaims)
- (declare (ignorable use-acl2-proclaims))
(with-warnings-suppressed
#+sbcl
(declaim (optimize (safety 0) (space 0) (speed 3) (debug 0)))
-; Here is a natural place to put compiler options. In fact, we put
-; them above, globally.
+; Here is a natural place to put compiler options. In fact, we put them above,
+; globally.
; (declaim (optimize (safety 0) (space 0) (speed 3)))
@@ -1905,23 +1955,33 @@
;(12) once the bug is fixed, be sure to change the declaim
; back to (safety 0) (speed 3) before recompiling.
-; Note on loading before compiling. We load each ACL2 source file
-; before compiling it to make sure that the functions needed to
-; execute macros have been defun-ed before they are called. Normal
-; Common Lisp compilation does not do this. So we cause all forms to
-; be executed before we start the compilation. This guarantees that
-; when macros run, the functions they call have been defined.
-
-; In general, and for the same reason, all ACL2 user checked files
-; are also be loaded before they are compiled.
-
- #-acl2-mv-as-values
- (when use-acl2-proclaims
- (return-from compile-acl2 nil))
+; Note on loading before compiling. We load each ACL2 source file before
+; compiling it to make sure that the functions needed to execute macros have
+; been defun-ed before they are called. Normal Common Lisp compilation does
+; not do this. So we cause all forms to be executed before we start the
+; compilation. This guarantees that when macros run, the functions they call
+; have been defined.
+
+; In general, and for the same reason, all ACL2 user checked files are also
+; loaded before they are compiled.
; As of version 18a, cmulisp spews gc messages to the terminal even when
; standard and error output are redirected. So we turn them off.
+ (when (and use-acl2-proclaims
+ (not (non-trivial-acl2-proclaims-file-p)))
+
+; Note that GNUmakefile provides special treatment for the value :REUSE of
+; environment/make variable USE_ACL2_PROCLAIMS. With that treatment, we avoid
+; calling compile-acl2 with use-acl2-proclaims = t, and thus we don't get to
+; this point.
+
+ (error "Note: Skipping compilation that is intended to use generated ~
+ file \"acl2-proclaims.lisp\", because that file is missing or ~
+ has no forms in it."))
+ (when (and (not use-acl2-proclaims)
+ (probe-file "acl2-proclaims.lisp"))
+ (delete-file "acl2-proclaims.lisp"))
(cond
((or (not (probe-file *acl2-status-file*))
(with-open-file (str *acl2-status-file*
@@ -1940,7 +2000,7 @@
(compiler:*suppress-compiler-notes* t))
(when use-acl2-proclaims
- (load "acl2-proclaims.lisp"))
+ (proclaim-files nil "acl2-proclaims.lisp" nil))
(dolist (name *acl2-files*)
(or (equal name "defpkgs")
(let ((source (make-pathname :name name
@@ -1959,86 +2019,37 @@
:type *compiled-file-extension*))))))))))
(note-compile-ok)))
-(defun no-object-file-or-out-of-date-object-file (fl)
- (or (null (probe-file
- (make-pathname :name fl :type *compiled-file-extension*)))
- (> (file-write-date
- (make-pathname :name fl :type *lisp-extension*))
- (file-write-date
- (make-pathname :name fl :type *compiled-file-extension*)))))
-
-(defun quick-compile-acl2 (&optional very-fast use-acl2-proclaims)
- (with-warnings-suppressed
-
-; Here is a natural place to put compiler options.
-
-; (declaim (optimize (safety 0) (space 0) (speed 3)))
-
-; As of version 18a, cmulisp spews gc messages to the terminal even when
-; standard and error output are redirected. So we turn them off.
-
- #+cmu
- (setq extensions::*gc-verbose* nil)
-
- (cond
- ((or (not (probe-file (make-pathname :name "acl2-status"
- :type "txt")))
- (with-open-file (str (make-pathname :name "acl2-status"
- :type "txt")
- :direction :input)
- (not (eq (read str nil)
- :checked))))
- (check-suitability-for-acl2)))
- (our-with-compilation-unit
- (let ((compile-rest-flg nil)
- (*readtable* *acl2-readtable*)
- #+akcl
- (si:*notify-gbc* nil)
- #+akcl
-
-; AKCL compiler note stuff. We have so many tail recursive functions
-; that the notes about tail recursion optimization are just too much
-; to take.
-
- (compiler:*suppress-compiler-notes* t)
- (files (remove "defpkgs" *acl2-files* :test #'equal)))
- (cond
- ((some #'no-object-file-or-out-of-date-object-file files)
- (when use-acl2-proclaims
- (load "acl2-proclaims.lisp"))
- (dolist
- (fl files)
- (let ((source (make-pathname :name fl :type *lisp-extension*))
- (object (make-pathname :name fl :type *compiled-file-extension*)))
- (cond
- ((or *suppress-compile-build-time*
- (equal fl "proof-checker-pkg"))
- (load source))
- ((or compile-rest-flg (no-object-file-or-out-of-date-object-file fl))
- (load source)
- (proclaim-file source)
- (when (not very-fast)
- (setq compile-rest-flg t))
- (compile-file source)
- (load-compiled object))
- (t (load-compiled object)
- (proclaim-file source))))))
- (t "Nothing to do."))))
- (note-compile-ok)))
-
#+gcl
(defvar user::*fast-acl2-gcl-build* nil)
(defun load-acl2 (&optional fast)
- #-akcl (declare (ignore fast)) ; fast only avoids slow growth during gcl init
+; If fast is true, then we are welcome to avoid optimizations that might make
+; for a better saved image. For example, we use fast = t when building simply
+; to write proclaim forms into acl2-proclaims.lisp.
+
+ (declare (ignorable fast))
(our-with-compilation-unit ; only needed when *suppress-compile-build-time*
(with-warnings-suppressed
-; If we are in the first pass of two passes because of acl2-mv-as-values, then
-; don't waste time doing the slow build for GCL (where we compile all *1*
-; functions as we go through initialization).
+ (when (and *suppress-compile-build-time*
+ (not fast))
+
+; When we rely on Lisp to compile on-the-fly, we want to proclaim before
+; loading. This might actually be broken; we got an error when trying to do
+; proclaiming here for GCL, complaining that "The variable
+; *COMMON-LISP-SYMBOLS-FROM-MAIN-LISP-PACKAGE* is unbound." If we ever decide
+; to proclaim when *suppress-compile-build-time* is true, we can deal with that
+; problem then, perhaps by using
+; *copy-of-common-lisp-symbols-from-main-lisp-package* instead (though we
+; haven't tried that).
+
+ (proclaim-files nil "acl2-proclaims.lisp" t))
+
+; If we are in the first pass of two passes, then don't waste time doing the
+; slow build for GCL (where we compile all *1* functions as we go through
+; initialization).
#+(and gcl acl2-mv-as-values)
(when fast
@@ -2075,11 +2086,9 @@
:direction :input)
(not (member (read str nil)
'(:compiled :initialized)))))
- (error "Please compile ACL2 using ~s or~%~
- ~s, which will write the~%~
- token :compiled to the file acl2-status.txt."
- '(compile-acl2)
- '(quick-compile-acl2 t))))
+ (error "Please compile ACL2 using ~s, which will write~%~
+ the token :COMPILED to the file acl2-status.txt."
+ '(compile-acl2))))
(let ((*readtable* *acl2-readtable*)
(extension (if *suppress-compile-build-time*
*lisp-extension*
@@ -2091,6 +2100,9 @@
(load-compiled (make-pathname :name name
:type extension)))))
(load "defpkgs.lisp")
+ (when (and (not *suppress-compile-build-time*) ; other case is above
+ (not fast))
+ (proclaim-files nil "acl2-proclaims.lisp" t))
(in-package "ACL2")
; Do not make state special, as that can interfere with tail recursion removal.
@@ -2480,9 +2492,11 @@
nil))
(terpri *debug-io*)
(break-current))))))
+#+(and gcl (not cltl2))
+(in-package "ACL2")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; Some hacks for CCL
+; Additional hacks for CCL
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Also see the acl2h-init code.
diff -Nru acl2-6.2/akcl-acl2-trace.lisp acl2-6.3/akcl-acl2-trace.lisp
--- acl2-6.2/akcl-acl2-trace.lisp 2013-06-06 16:30:53.000000000 +0000
+++ acl2-6.3/akcl-acl2-trace.lisp 2013-09-29 21:27:51.000000000 +0000
@@ -1,4 +1,4 @@
-; ACL2 Version 6.2 -- A Computational Logic for Applicative Common Lisp
+; ACL2 Version 6.3 -- A Computational Logic for Applicative Common Lisp
; Copyright (C) 2013, Regents of the University of Texas
; This version of ACL2 is a descendent of ACL2 Version 1.9, Copyright
diff -Nru acl2-6.2/allegro-acl2-trace.lisp acl2-6.3/allegro-acl2-trace.lisp
--- acl2-6.2/allegro-acl2-trace.lisp 2013-06-06 16:30:53.000000000 +0000
+++ acl2-6.3/allegro-acl2-trace.lisp 2013-09-29 21:27:51.000000000 +0000
@@ -1,4 +1,4 @@
-; ACL2 Version 6.2 -- A Computational Logic for Applicative Common Lisp
+; ACL2 Version 6.3 -- A Computational Logic for Applicative Common Lisp
; Copyright (C) 2013, Regents of the University of Texas
; This version of ACL2 is a descendent of ACL2 Version 1.9, Copyright
diff -Nru acl2-6.2/axioms.lisp acl2-6.3/axioms.lisp
--- acl2-6.2/axioms.lisp 2013-06-06 16:30:52.000000000 +0000
+++ acl2-6.3/axioms.lisp 2013-09-29 21:27:51.000000000 +0000
@@ -1,4 +1,4 @@
-; ACL2 Version 6.2 -- A Computational Logic for Applicative Common Lisp
+; ACL2 Version 6.3 -- A Computational Logic for Applicative Common Lisp
; Copyright (C) 2013, Regents of the University of Texas
; This version of ACL2 is a descendent of ACL2 Version 1.9, Copyright
@@ -1298,9 +1298,6 @@
(defconstant *non-existent-stream*
'acl2_invisible::|A Non-Existent Stream|)
-(defmacro live-state-p (x)
- (list 'eq x '*the-live-state*))
-
; We get ready to handle errors in such a way that they return to the
; top level logic loop if we are under it.
@@ -1325,6 +1322,82 @@
(error "ACL2 Halted"))))
(t (error "ACL2 error: ~a." args))))
+#-acl2-loop-only
+(declaim (inline
+
+; Here we take a suggestion from Jared Davis and inline built-in functions,
+; starting after Version_6.2, based on successful use of such inlining at
+; Centaur Technology for many months on their local copy of ACL2. Indeed, the
+; original list below (added on June 16, 2013) comes directly from that copy,
+; except for inclusion of aref1 and aref2 (as noted below). As Jared said in a
+; log message when he added inline declarations for 33 functions to a local
+; copy of ACL2 at Centaur:
+
+; This should give us a useful speedup on CCL for many functions that recur
+; with ZP at the end. I measured a 12% speedup for a naive FIB function.
+
+; We are seeing perhaps 2% speedup on regressions, but we believe that this
+; inlining could provide much greater benefit in some cases.
+
+; Some of these functions could probably be inlined using the defun-inline
+; feature of ACL2, but we prefer not to fight with the likely resulting
+; boot-strapping problem during the ACL2 build.
+
+; We may modify this list from time to time, for example based on user request.
+; It surely is safe to add any function symbol to the list that is not defined
+; recursively in raw Lisp (and maybe even if it is). But of course that could
+; interfere with tracing and redefinition, so care should be taken before
+; adding a function symbol that might be traced or redefined.
+
+; We endeavor to keep the list sorted alphabetically, simply to make it easy to
+; search visually.
+
+ acl2-numberp
+ add-to-set-eq-exec
+ aref1 ; already inlined in Version_6.2 and before
+ aref2 ; already inlined in Version_6.2 and before
+ booleanp
+ complex-rationalp
+ eqlablep
+ fix
+ fn-symb
+ iff
+ ifix
+ implies
+ integer-abs
+ integer-range-p
+ len
+ member-equal
+ natp
+ nfix
+ peek-char$
+ posp
+ quotep
+ random$
+ read-byte$
+ read-char$
+ realfix
+ rfix
+ signed-byte-p
+ strip-cars
+ strip-cdrs
+ symbol-<
+ unsigned-byte-p
+ xor
+ zip
+ zp
+ zpf
+ )
+
+; For ACL2 built on CMUCL 20D Unicode, an attempt failed on 9/12/2013 to
+; certify the community book books/models/jvm/m1/defsys.lisp. During
+; debugging, we found a note that mentioned "*Inline-Expansion-Limit* (400)
+; exceeded". The following declaim form, which may be quite harmless, solves
+; the problem.
+
+ #+cmu
+ (notinline len))
+
; We provide here ``raw'' implementations of basic functions that we
; ``wish'' were already in Common Lisp, to support primitives of the
; ACL2 logic.
@@ -1383,30 +1456,8 @@
; package can be redefined only if its imports list is identical to that in its
; old definition.
-; The following alist associates package names with Common Lisp packages, and
-; is used in function find-package-fast, which is used by princ$ in place of
-; find-package in order to save perhaps 15% of the print time.
-(defparameter *package-alist* nil)
-
-(defun-one-output find-package-fast (string)
- (or (cdr (assoc-equal string *package-alist*))
- (let ((pkg (find-package string)))
- (push (cons string pkg) *package-alist*)
- pkg)))
-
(defvar **1*-symbol-key* (make-symbol "**1*-SYMBOL-KEY*"))
-(defvar *global-symbol-key* (make-symbol "*GLOBAL-SYMBOL-KEY*"))
-
-(defun global-symbol (x)
- (or (get x *global-symbol-key*)
- (setf (get x *global-symbol-key*)
- (intern (symbol-name x)
- (find-package-fast
- (concatenate 'string
- *global-package-prefix*
- (symbol-package-name x)))))))
-
(defun *1*-symbol (x)
; Keep this in sync with *1*-symbol?.
(or (get x **1*-symbol-key*)
@@ -1857,10 +1908,12 @@
(defmacro make-event (&whole event-form
form
- &key check-expansion on-behalf-of)
+ &key
+ expansion? check-expansion on-behalf-of)
(declare (ignore form on-behalf-of))
(cond ((consp check-expansion)
check-expansion)
+ (expansion?)
(t `(error ; not er; so certify-book and include-book fail
"It is illegal to execute make-event in raw Lisp (including ~%~
raw mode) unless :check-expansion is a cons, which represents ~%~
@@ -2883,7 +2936,7 @@
To see the ACL2 definition of this function, ~pl[pf].~/"
(declare (xargs :mode :logic
- :guard (or (consp x) (equal x nil))))
+ :guard (or (consp x) (eq x nil))))
(atom x))
#+acl2-loop-only
@@ -5601,7 +5654,7 @@
in raw Lisp. That is, the call of ~c[fn] is made on its evaluated arguments
as though this call is being made in the ACL2 top-level loop, rather than in
raw Lisp. In particular, the ~il[guard] of ~c[fn] is checked, at least by
- default (~pl[set-guard-checking].~eq[]
+ default (~pl[set-guard-checking]).~eq[]
Note that in the term (ec-call (fn term1 ... termk))~c[], only the indicated
call of ~c[fn] is made in the logic; each ~c[termi] is evaluated in the
@@ -6039,19 +6092,29 @@
identity function used to force a hypothesis~/
- When a hypothesis of a conditional rule has the form ~c[(force hyp)] it
- is logically equivalent to ~c[hyp] but has a pragmatic effect. In
- particular, when the rule is considered, the needed instance of the
- hypothesis, ~c[hyp'], is assumed and a special case is generated,
- requiring the system to prove that ~c[hyp'] is true in the current
- context. The proofs of all such ``forced assumptions'' are delayed
- until the successful completion of the main goal.
- ~l[forcing-round].
-
- Forcing should only be used on hypotheses that are always expected to be
- true, as is commonly the case for ~il[guard]s of functions. All the power of
- the theorem prover is brought to bear on a forced hypothesis and no
- backtracking is possible. Forced goals can be attacked immediately
+ ~c[Force] is the identity function: ~c[(force x)] is equal to ~c[x].
+ However, for rules of many classes (~pl[rule-classes]), a hypothesis of the
+ form ~c[(force term)] is given special treatment, as described below. This
+ treatment takes place for rule classes ~c[:]~ilc[rewrite], ~c[:]~ilc[linear],
+ ~c[:]~ilc[type-prescription], ~c[:]~ilc[definition], ~c[:]~ilc[meta] (actually
+ in that case, the result of evaluating the hypothesis metafunction call), and
+ ~c[:]~ilc[forward-chaining].
+
+ When a hypothesis of a conditional rule (of one of the classes listed above)
+ has the form ~c[(force hyp)], it is logically equivalent to ~c[hyp] but has a
+ pragmatic effect. In particular, when the rule is considered, the needed
+ instance of the hypothesis, ~c[hyp'], may be assumed if the usual process
+ fails to prove it or its negation. In that situation, if the rule is
+ eventually applied, then a special case is generated, requiring the system to
+ prove that ~c[hyp'] is true in the current context. The proofs of all such
+ ``forced assumptions'' are, by default, delayed until the successful
+ completion of the main goal. ~l[forcing-round] and
+ ~pl[immediate-force-modep].
+
+ Forcing is generally used on hypotheses that are always expected to be true,
+ as is commonly the case for ~il[guard]s of functions. All the power of the
+ theorem prover is brought to bear on a forced hypothesis and no backtracking
+ is possible. Forced goals can be attacked immediately
(~pl[immediate-force-modep]) or in a subsequent forcing round
(~pl[forcing-round]). Also ~pl[case-split] for a related utility. If the
~c[:]~ilc[executable-counterpart] of the function ~c[force] is ~il[disable]d,
@@ -6227,14 +6290,22 @@
like force but immediately splits the top-level goal on the hypothesis~/
- When a hypothesis of a conditional rule has the form ~c[(case-split hyp)]
- it is logically equivalent to ~c[hyp]. However it affects the
- application of the rule generated as follows: if ACL2
- attempts to apply the rule but cannot establish that the required
- instance of ~c[hyp] holds in the current context, it considers the
- hypothesis true anyhow, but (assuming all hypotheses are seen to be true and
- the rule is applied) creates a subgoal in which that instance of ~c[hyp] is
- assumed false. (There are exceptions, noted below.)~/
+ ~c[Case-split] is an variant of ~ilc[force], which has similar special
+ treatment in hypotheses of rules for the same ~il[rule-classes] as for
+ ~c[force] (~pl[force]). This treatment takes place for rule classes
+ ~c[:]~ilc[rewrite], ~c[:]~ilc[linear], ~c[:]~ilc[type-prescription],
+ ~c[:]~ilc[definition], ~c[:]~ilc[meta] (actually in that case, the result of
+ evaluating the hypothesis metafunction call), and
+ ~c[:]~ilc[forward-chaining].
+
+ When a hypothesis of a conditional rule (of one of the classes listed above)
+ has the form ~c[(case-split hyp)] it is logically equivalent to ~c[hyp].
+ However it affects the application of the rule generated as follows: if ACL2
+ attempts to apply the rule but cannot establish that the required instance of
+ ~c[hyp] holds in the current context, it considers the hypothesis true
+ anyhow, but (assuming all hypotheses are seen to be true and the rule is
+ applied) creates a subgoal in which that instance of ~c[hyp] is assumed
+ false. (There are exceptions, noted below.)~/
For example, given the rule
~bv[]
@@ -6251,14 +6322,14 @@
(IMPLIES (AND (NOT (P1 (CAR X))) (P3 X))
(P2 (CAR X))).
~ev[]
- Unlike ~ilc[force], ~c[case-split] does not delay the ``false case'' to
- a forcing round but tackles it more or less immediately.
+ Unlike ~ilc[force], ~c[case-split] does not delay the ``false case'' to a
+ forcing round but tackles it more or less immediately.
The special ``split'' treatment of ~c[case-split] can be disabled by
- disabling forcing: ~pl[force] for a discussion of disabling forcing, and
- also ~pl[disable-forcing]. Finally, we should mention that the rewriter is
- never willing to split when there is an ~ilc[if] term present in the goal
- being simplified. Since ~ilc[and] terms and ~ilc[or] terms are merely
+ disabling forcing: ~pl[force] for a discussion of disabling forcing, and also
+ ~pl[disable-forcing]. Finally, we should mention that the rewriter is never
+ willing to split when there is an ~ilc[if] term present in the goal being
+ simplified. Since ~ilc[and] terms and ~ilc[or] terms are merely
abbreviations for ~ilc[if] terms, they also prevent splitting. Note that
~ilc[if] terms are ultimately eliminated using the ordinary flow of the proof
(but ~pl[set-case-split-limitations]), so ~c[case-split] will ultimately
@@ -6415,11 +6486,17 @@
(declare (xargs :guard t))
":Doc-Section Miscellaneous
- attach a heuristic filter on a ~c[:]~ilc[rewrite], ~c[:]~ilc[meta], or ~c[:]~ilc[linear] rule~/
+ attach a heuristic filter on a rule~/
+
+ A calls of ~c[syntaxp] in the hypothesis of a ~c[:]~ilc[rewrite],
+ ~c[:]~ilc[definition], or ~c[:]~ilc[linear] rule is treated specially, as
+ described below. Similar treatment is given to the evaluation of a
+ ~c[:]~ilc[meta] rule's hypothesis function call.
+
+ For example, consider the ~c[:]~ilc[rewrite] rule created from the following
+ formula.
~bv[]
Example:
- Consider the :REWRITE rule created from
-
(IMPLIES (SYNTAXP (NOT (AND (CONSP X)
(EQ (CAR X) 'NORM))))
(EQUAL (LXD X)
@@ -6455,12 +6532,12 @@
display this internal representation.
There are two types of ~c[syntaxp] hypotheses. The simpler type may be a
- hypothesis of a ~c[:]~ilc[rewrite] or ~c[:]~ilc[linear] rule provided
- ~c[test] contains at least one variable but no free variables
- (~pl[free-variables]). In particular, ~c[test] may not use ~il[stobj]s; any
- stobj name will be treated as an ordinary variable. The case of
- ~c[:]~ilc[meta] rules is similar to the above, except that it applies to the
- result of applying the hypothesis metafunction. (Later below we will
+ hypothesis of a ~c[:]~ilc[rewrite], ~c[:]~ilc[definition], or
+ ~c[:]~ilc[linear] rule provided ~c[test] contains at least one variable but
+ no free variables (~pl[free-variables]). In particular, ~c[test] may not use
+ ~il[stobj]s; any stobj name will be treated as an ordinary variable. The
+ case of ~c[:]~ilc[meta] rules is similar to the above, except that it applies
+ to the result of applying the hypothesis metafunction. (Later below we will
describe the second type, an ~em[extended] ~c[syntaxp] hypothesis, which may
use ~ilc[state].)
@@ -6846,7 +6923,7 @@
(not (member-eq nil vars))))))
":Doc-Section Miscellaneous
- to bind free variables of a rewrite or linear rule~/
+ to bind free variables of a rewrite, definition, or linear rule~/
~bv[]
Examples:
(IMPLIES (AND (RATIONALP LHS)
@@ -6871,39 +6948,43 @@
(BIND-FREE term t)
(BIND-FREE term)
~ev[]
- A rule which uses a ~c[bind-free] hypothesis has similarities to both a
- rule which uses a ~ilc[syntaxp] hypothesis and to a ~c[:]~ilc[meta] rule.
- ~c[Bind-free] is like ~ilc[syntaxp], in that it logically always
- returns ~c[t] but may affect the application of a ~c[:]~ilc[rewrite]
- or ~c[:]~ilc[linear] rule when it is called at the top-level of a
- hypothesis. It is like a ~c[:]~ilc[meta] rule, in that it allows the
- user to perform transformations of terms under progammatic control.
+ A rule which uses a ~c[bind-free] hypothesis has similarities to both a rule
+ which uses a ~ilc[syntaxp] hypothesis and to a ~c[:]~ilc[meta] rule.
+ ~c[Bind-free] is like ~ilc[syntaxp], in that it logically always returns
+ ~c[t] but may affect the application of a ~c[:]~ilc[rewrite],
+ ~c[:]~ilc[definition], or ~c[:]~ilc[linear] rule when it is called at the
+ top-level of a hypothesis. It is like a ~c[:]~ilc[meta] rule, in that it
+ allows the user to perform transformations of terms under progammatic
+ control.
Note that a ~c[bind-free] hypothesis does not, in general, deal with the
- meaning or semantics or values of the terms, but rather with their
- syntactic forms. Before attempting to write a rule which uses
- ~c[bind-free], the user should be familiar with ~ilc[syntaxp] and the
- internal form that ACL2 uses for terms. This internal form is
- similar to what the user sees, but there are subtle and important
- differences. ~ilc[Trans] can be used to view this internal form.
-
- Just as for a ~ilc[syntaxp] hypothesis, there are two types of
- ~c[bind-free] hypotheses. The simpler type of ~c[bind-free]
- hypothesis may be used as the nth hypothesis in a ~c[:]~ilc[rewrite]
+ meaning or semantics or values of the terms, but rather with their syntactic
+ forms. Before attempting to write a rule which uses ~c[bind-free], the user
+ should be familiar with ~ilc[syntaxp] and the internal form that ACL2 uses
+ for terms. This internal form is similar to what the user sees, but there
+ are subtle and important differences. ~ilc[Trans] can be used to view this
+ internal form.
+
+ Just as for a ~ilc[syntaxp] hypothesis, there are two basic types of
+ ~c[bind-free] hypotheses. The simpler type of ~c[bind-free] hypothesis may
+ be used as the nth hypothesis in a ~c[:]~ilc[rewrite], ~c[:]~ilc[definition],
or ~c[:]~ilc[linear] rule whose ~c[:]~ilc[corollary] is
~c[(implies (and hyp1 ... hypn ... hypk) (equiv lhs rhs))] provided ~c[term]
is a term, ~c[term] contains at least one variable, and every variable
occuring freely in ~c[term] occurs freely in ~c[lhs] or in some ~c[hypi],
- ~c[i
@@ -7016,26 +7095,23 @@
Question: What is the internal form of this result?~nl[]
Hint: Use ~c[:]~ilc[trans].
- When this rule fires, it adds the negation of a common term
- to both sides of the equality by selecting a binding for the
- otherwise-free variable ~c[x], under programmatic control. Note
- that other mechanisms such as the binding of ~il[free-variables]
- may also extend the substitution alist.
-
- Just as for a ~ilc[syntaxp] test, a ~c[bind-free] form signals
- failure by returning ~c[nil]. However, while a ~ilc[syntaxp] test
- signals success by returning true, a ~c[bind-free] form signals
- success by returning an alist which is used to extend the current
- substitution alist. Because of this use of the alist, there are
- several restrictions on it ~-[] in particular the alist must only
- bind variables, these variables must not be already bound by the
- substitution alist, and the variables must be bound to ACL2 terms.
- If ~c[term] returns an alist and the alist meets these restrictions,
- we append the alist to the substitution alist and use the result as
- the new current substitution alist. This new current
- substitution alist is then used when we attempt to relieve the next
- hypothesis or, if there are no more, instantiate the right hand side
- of the rule.
+ When this rule fires, it adds the negation of a common term to both sides of
+ the equality by selecting a binding for the otherwise-free variable ~c[x],
+ under programmatic control. Note that other mechanisms such as the binding
+ of ~il[free-variables] may also extend the substitution alist.
+
+ Just as for a ~ilc[syntaxp] test, a ~c[bind-free] form signals failure by
+ returning ~c[nil]. However, while a ~ilc[syntaxp] test signals success by
+ returning true, a ~c[bind-free] form signals success by returning an alist
+ which is used to extend the current substitution alist. Because of this use
+ of the alist, there are several restrictions on it ~-[] in particular the
+ alist must only bind variables, these variables must not be already bound by
+ the substitution alist, and the variables must be bound to ACL2 terms. If
+ ~c[term] returns an alist and the alist meets these restrictions, we append
+ the alist to the substitution alist and use the result as the new current
+ substitution alist. This new current substitution alist is then used when we
+ attempt to relieve the next hypothesis or, if there are no more, instantiate
+ the right hand side of the rule.
There is also a second, optional, ~c[var-list] argument to a ~c[bind-free]
hypothesis. If provided, it must be either ~c[t] or a list of variables. If
@@ -7046,15 +7122,97 @@
this list of variables, as it allows some consistency checks to be performed
at the time of the rule's admittance which are not possible otherwise.
- An extended ~c[bind-free] hypothesis is similar to the simple type
- described above, but it uses two additional variables, ~c[mfc] and ~c[state],
- which must not be bound by the left hand side or an earlier hypothesis
- of the rule. They must be the last two variables mentioned by ~c[term]:
- first ~c[mfc], then ~c[state]. These two variables give access to
- the functions ~c[mfc-]xxx; ~pl[extended-metafunctions]. As
- described there, ~c[mfc] is bound to the so-called
- metafunction-context and ~c[state] to ACL2's ~ilc[state]. ~l[bind-free-examples]
- for examples of the use of these extended ~c[bind-free] hypotheses.~/"
+ An extended ~c[bind-free] hypothesis is similar to the simple type described
+ above, but it uses two additional variables, ~c[mfc] and ~c[state], which
+ must not be bound by the left hand side or an earlier hypothesis of the rule.
+ They must be the last two variables mentioned by ~c[term]: first ~c[mfc],
+ then ~c[state]. These two variables give access to the functions
+ ~c[mfc-]xxx; ~pl[extended-metafunctions]. As described there, ~c[mfc] is
+ bound to the so-called metafunction-context and ~c[state] to ACL2's
+ ~ilc[state]. ~l[bind-free-examples] for examples of the use of these
+ extended ~c[bind-free] hypotheses.
+
+ ~st[SECTION]: Returning a list of alists.
+
+ As promised above, we conclude with a discussion of the case that evaluation
+ of the ~c[bind-free] term produces a list of alists, ~c[x], rather than a
+ single alist. In this case each member ~c[b] of ~c[x] is considered in turn,
+ starting with the first and proceeding through the list. Each such ~c[b] is
+ handled exactly as discussed above, as though it were the result of
+ evaluating the ~c[bind-free] term. Thus, each ~c[b] extends the current
+ variable binding alist, and all remaining hypotheses are then relieved, as
+ though ~c[b] had been the value obtained by evaluating the ~c[bind-free]
+ term. As soon as one such ~c[b] leads to successful relieving of all
+ remaining hypotheses, the process of relieving hypotheses concludes, so no
+ further members of ~c[x] are considered.
+
+ We illustrate with a simple pedagogical example. First introduce functions
+ ~c[p1] and ~c[p2] such that a rewrite rule specifies that ~c[p2] implies
+ ~c[p1], but with a free variable.
+ ~bv[]
+
+ (defstub p1 (x) t)
+ (defstub p2 (x y) t)
+
+ (defaxiom p2-implies-p1
+ (implies (p2 x y)
+ (p1 x)))
+
+ ~ev[]
+ If we add the following axiom, then ~c[(p1 x)] follows logically for all
+ ~c[x].
+ ~bv[]
+
+ (defaxiom p2-instance
+ (p2 v (cons v 4)))
+
+ ~ev[]
+ Unfortunately, evaluation of ~c[(thm (p1 a))] fails, because ACL2 fails to
+ bind the free variable ~c[y] in order to apply the rule ~c[p2-instance].
+
+ Let's define a function that produces a list of alists, each binding the
+ variable ~c[y]. Of course, we know that only the middle one below is
+ necessary in this simple example. In more complex examples, one might use
+ heuristics to construct such a list of alists.
+ ~bv[]
+
+ (defun my-alists (x)
+ (list (list (cons 'y (fcons-term* 'cons x ''3)))
+ (list (cons 'y (fcons-term* 'cons x ''4)))
+ (list (cons 'y (fcons-term* 'cons x ''5)))))
+
+ ~ev[]
+ The following rewrite rule uses ~c[bind-free] to return a list of candidate
+ alists binding ~c[y].
+ ~bv[]
+
+ (defthm p2-implies-p1-better
+ (implies (and (bind-free (my-alists x)
+ (y)) ; the second argument, (y), is optional
+ (p2 x y))
+ (p1 x)))
+
+ ~ev[]
+ Now the proof succeeds for ~c[(thm (p1 a))]. Why? When ACL2 applies the
+ ~c[rewrite] rule ~c[p2-implies-p1-better], it evaluates ~c[my-alists], as we
+ can see from the following ~il[trace], to bind ~c[y] in three different
+ alists.
+ ~bv[]
+
+ ACL2 !>(thm (p1 a))
+ 1> (ACL2_*1*_ACL2::MY-ALISTS A)
+ <1 (ACL2_*1*_ACL2::MY-ALISTS (((Y CONS A '3))
+ ((Y CONS A '4))
+ ((Y CONS A '5))))
+
+ Q.E.D.
+
+ ~ev[]
+ The first alist, binding ~c[y] to ~c[(cons a '3)], fails to allow the
+ hypothesis ~c[(p2 x y)] to be proved. But the next binding of ~c[y], to
+ ~c[(cons a '4)], succeeds: then the current binding alist is
+ ~c[((x . a) (y . (cons a '4)))], for which the hypothesis ~c[(p2 x y)]
+ rewrites to true using the rewrite rule ~c[p2-instance].~/"
(if vars
`(synp (quote ,vars) (quote (bind-free ,form ,vars)) (quote ,form))
@@ -7068,7 +7226,12 @@
examples pertaining to ~ilc[bind-free] hypotheses~/
~l[bind-free] for a basic discussion of the use of ~c[bind-free] to control
- rewriting.~/
+ rewriting.
+
+ Note that the examples below all illustrate the common case in which a
+ ~c[bind-free] hypothesis generates a binding alist. ~l[bind-free], in
+ particular the final section, for a discussion of the case that instead a
+ list of binding alists is generated.~/
We give examples of the use of ~ilc[bind-free] hypotheses from the
perspective of a user interested in reasoning about arithmetic, but
@@ -7350,9 +7513,9 @@
~il[documentation] facilities do not permit us to use keywords below).
~/
- See also ~ilc[force], ~il[case-split], ~ilc[syntaxp], and ~ilc[bind-free]
- for ``pragmas'' one can wrap around individual hypotheses of ~c[linear] and
- ~c[rewrite] rules to affect how the hypothesis is relieved.
+ See also ~ilc[force], ~il[case-split], ~ilc[syntaxp], and ~ilc[bind-free] for
+ ``pragmas'' one can wrap around individual hypotheses of certain classes of
+ rules to affect how the hypothesis is relieved.
Before we get into the discussion of rule classes, let us return to an
important point. In spite of the large variety of rule classes available, at
@@ -11348,15 +11511,14 @@
~ilc[verify-guards]), some introduce exactly one (e.g., ~ilc[defmacro] and
~ilc[defthm]), and some may introduce many (e.g., ~ilc[encapsulate] ).
- ACL2 typically completes processing of an event by printing a summary that
- includes a breakdown of runtime (cpu time) used and, unless proofs are
- skipped (~pl[ld-skip-proofsp]) or summary output is inhibited
- (~pl[set-inhibit-output-lst]), information about the proof attempt
- (if any) including a list of rules used, a summary of warnings, and the
- number of ``prover steps'' (if any; ~pl[with-prover-step-limit]). A detail:
- The time is calculated using Common Lisp function ~c[get-internal-run-time],
- which may ignore calls to external tools (~pl[sys-call] and
- ~pl[clause-processor]).
+ ACL2 typically completes processing of an event by printing a summary.
+ Unless proofs are skipped (~pl[ld-skip-proofsp]) or summary output is
+ inhibited (~pl[set-inhibit-output-lst]), information about the proof attempt
+ (if any) is printed that includes a list of rules used, a summary of
+ warnings, and the number of ``prover steps'' (if any;
+ ~pl[with-prover-step-limit]). A breakdown of the time used is also printed,
+ which by default is runtime (cpu time), but can be changed to realtime
+ (wall clock time); ~pl[get-internal-time].
~l[embedded-event-form] for a discussion of events permitted in
~il[books].~/")
@@ -11387,10 +11549,12 @@
To view the documentation in a web browser, open a browser to file
~c[doc/HTML/acl2-doc.html] under your ACL2 source directory, or just go to
the ACL2 home page at ~url[http://www.cs.utexas.edu/users/moore/acl2/].
- Alternatively, follow a link on the ACL2 home page to the new ``xdoc''
- version of the manual, which can be found locally after running a regression
- by pointing your web browser at community books file
- ~c[books/xdoc/manual/preview.html].
+
+ Alternatively, follow a link on the ACL2 home page to a manual, known as the
+ xdoc manual, which incorporates (but rearranges) the ACL2 documentation as
+ well as documentation from many ACL2 community books. You can build a local
+ copy of that manual; see for example the section ``BUILDING THE XDOC MANUAL''
+ in the community books ~c[Makefile] for instructions.
To use Emacs Info (inside Emacs), first load distributed file
~c[emacs/emacs-acl2.el] (perhaps inside your ~c[.emacs] file) and then
@@ -12221,11 +12385,11 @@
; Same effect as just above:
(with-output
:on summary
- :summary :all ; equivalently, the value (a list) of *summary-types*
+ :summary nil
:gag-mode :goals
(defthm app-assoc (equal (app (app x y) z) (app x (app y z)))))
- ; Same as just above, but turn off only the indicated parts of the summary.
+ ; Turn on only the indicated parts of the summary.
(with-output
:on summary
:summary (time rules)
@@ -12252,31 +12416,31 @@
(with-output :key1 val1 ... :keyk valk form)
~ev[]
where each ~c[:keyi] is either ~c[:off], ~c[:on], ~c[:stack],
- ~c[:summary], or ~c[:gag-mode], and ~c[vali] is as follows. If ~c[:keyi]
- is ~c[:off] or ~c[:on], then ~c[vali] can be ~c[:all], and otherwise is a
- symbol or non-empty list of symbols representing output types that can be
- inhibited; ~pl[set-inhibit-output-lst]. If ~c[:keyi] is ~c[:gag-mode], then
- ~c[vali] is one of the legal values for ~c[:]~ilc[set-gag-mode].
- If ~c[:keyi] is ~c[:summary], then ~c[vali] is either ~c[:all] or a true-list
- of symbols each of which belongs to the list ~c[*summary-types*]. Otherwise
- ~c[:keyi] is ~c[:stack], in which case ~c[:vali] is ~c[:push] or ~c[:pop];
- for now assume that ~c[:stack] is not specified (we'll return to it below).
- The result of evaluating the General Form above is to evaluate ~c[form], but
- in an environment where output occurs as follows. If ~c[:on :all] is
- specified, then every output type is turned on except as inhibited by
- ~c[:off]; else if ~c[:off :all] is specified, then every output type is
- inhibited except as specified by ~c[:on]; and otherwise, the
- currently-inhibited output types are reduced as specified by ~c[:on] and then
- extended as specified by ~c[:off]. But if ~c[:gag-mode] is specified, then
- before modifying how output is inhibited, ~ilc[gag-mode] is set for the
- evaluation of ~c[form] as specified by the value of ~c[:gag-mode];
- ~pl[set-gag-mode]. If ~c[summary] is among the output types that are turned
- on (not inhibited), then if ~c[:summary] is specified, the only parts of the
- summary to be printed will be those specified by the value of ~c[:summary].
- The correspondence should be clear, except perhaps that ~c[header] refers to
- the line containing only the word ~c[Summary], and ~c[value] refers to the
- value of the form printed during evaluation of sequences of events as for
- ~ilc[progn] and ~ilc[encapsulate].
+ ~c[:summary], or ~c[:gag-mode]; ~c[form] evaluates to an error triple
+ (~pl[error-triples]); and ~c[vali] is as follows. If ~c[:keyi] is ~c[:off]
+ or ~c[:on], then ~c[vali] can be ~c[:all], and otherwise is a symbol or
+ non-empty list of symbols representing output types that can be inhibited;
+ ~pl[set-inhibit-output-lst]. If ~c[:keyi] is ~c[:gag-mode], then ~c[vali] is
+ one of the legal values for ~c[:]~ilc[set-gag-mode]. If ~c[:keyi] is
+ ~c[:summary], then ~c[vali] is either ~c[:all] or a true-list of symbols each
+ of which belongs to the list ~c[*summary-types*]. Otherwise ~c[:keyi] is
+ ~c[:stack], in which case ~c[:vali] is ~c[:push] or ~c[:pop]; for now assume
+ that ~c[:stack] is not specified (we'll return to it below). The result of
+ evaluating the General Form above is to evaluate ~c[form], but in an
+ environment where output occurs as follows. If ~c[:on :all] is specified,
+ then every output type is turned on except as inhibited by ~c[:off]; else if
+ ~c[:off :all] is specified, then every output type is inhibited except as
+ specified by ~c[:on]; and otherwise, the currently-inhibited output types are
+ reduced as specified by ~c[:on] and then extended as specified by ~c[:off].
+ But if ~c[:gag-mode] is specified, then before modifying how output is
+ inhibited, ~ilc[gag-mode] is set for the evaluation of ~c[form] as specified
+ by the value of ~c[:gag-mode]; ~pl[set-gag-mode]. If ~c[summary] is among
+ the output types that are turned on (not inhibited), then if ~c[:summary] is
+ specified, the only parts of the summary to be printed will be those
+ specified by the value of ~c[:summary]. The correspondence should be clear,
+ except perhaps that ~c[header] refers to the line containing only the word
+ ~c[Summary], and ~c[value] refers to the value of the form printed during
+ evaluation of sequences of events as for ~ilc[progn] and ~ilc[encapsulate].
Note that the handling of the ~c[:stack] argument pays no attention to the
~c[:summary] argument.
@@ -12643,9 +12807,9 @@
proof. If an error message is produced by evaluating a call of the function
on a list of arguments that includes ~c[state] or user-defined ~ilc[stobj]s,
these arguments will be shown as symbols such as ~c[||] in the error
- message. In the case of a user-defined stobj bound by
- ~ilc[with-local-stobj] or ~ilc[stobj-let], the symbol printed will include
- the suffix ~c[{instance}], for example, ~c[|{instance}|].
+ message. In the case of a user-defined stobj bound by ~ilc[with-local-stobj]
+ or ~ilc[stobj-let], the symbol printed will include the suffix
+ ~c[{instance}], for example, ~c[|{instance}|].
It is harmless to include ~c[:non-executable t] in your own ~ilc[xargs]
~ilc[declare] form; ~c[defun-nx] will still lay down its own such
@@ -13359,15 +13523,129 @@
(defmacro msg (str &rest args)
-; This macro returns a pair suitable giving to the fmt directive ~@. Fmt is
-; defined much later. But we need msg now because several of our macros
+; Fmt is defined much later. But we need msg now because several of our macros
; generate calls of msg and thus msg must be a function when terms using those
; macros are translated.
-; In any case, suppose that #\0, say, is bound to the value of this function.
-; Then the fmt directive ~@0 will print out the string, str, above, in the
-; context of the alist in which the successive fmt variables #\0 through
-; possibly #\9 are bound to the successive elements of args.
+ ":Doc-Section ACL2::ACL2-built-ins
+
+ construct a ``message'' suitable for the ~c[~~@] directive of ~ilc[fmt]~/
+
+ ~l[fmt] for background on formatted printing with ACL2.
+
+ We document ~c[msg] precisely below, but first, we give an informal
+ introduction and illustrate with an example. Suppose you are writing a
+ program that is to do some printing. Typically, you will either pass the
+ ACL2 state around (~pl[programming-with-state]) and use formatted printing
+ functions that take the state as an argument (~pl[fmt])), or else you might
+ avoid using state by calling the utility, ~ilc[cw], to do you printing.
+ Alternatively, you might print error messages upon encountering illegal
+ situations; ~pl[er]. But there are times where instead of printing
+ immediately, you may prefer to pass messages around, for example to
+ accumulate them before printing a final message. In such cases, it may be
+ desirable to construct ``message'' objects to pass around.
+
+ For example, consider the following pair of little programs. The first
+ either performs a computation or prints an error, and the second calls the
+ first on two inputs.
+ ~bv[]
+
+ (defun invert1 (x)
+ (if (consp x)
+ (cons (cdr x) (car x))
+ (prog2$ (cw \"ERROR: ~~x0 expected a cons, but was given ~~x1.~~|\"
+ 'invert1 x)
+ nil)))
+
+ (defun invert2 (x1 x2)
+ (list (invert1 x1) (invert1 x2)))
+
+ ~ev[]
+ For example:
+ ~bv[]
+
+ ACL2 !>(invert1 '(3 . 4))
+ (4 . 3)
+ ACL2 !>(invert1 'a)
+ ERROR: INVERT1 expected a cons, but was given A.
+ NIL
+ ACL2 !>(invert2 '(3 . 4) '(5 . 6))
+ ((4 . 3) (6 . 5))
+ ACL2 !>(invert2 'a 'b)
+ ERROR: INVERT1 expected a cons, but was given A.
+ ERROR: INVERT1 expected a cons, but was given B.
+ (NIL NIL)
+ ACL2 !>
+
+ ~ev[]
+ Notice that when there are errors, there is no attempt to explain that these
+ are due to a call of ~c[invert2]. That could be fixed, of course, by
+ arranging for ~c[invert2] to print its own error; but for complicated
+ programs it can be awkward to coordinate printing from many sources. So
+ let's try a different approach. This time, the first function returns two
+ results. The first result is an ``error indicator'' ~-[] either a message
+ object or ~c[nil] ~-[] while the second is the computed value (only of
+ interest when the first result is ~c[nil]). Then the higher-level function
+ can print a single error message that includes the error message(s) from the
+ lower-level function, as shown below.
+ ~bv[]
+
+ (defun invert1a (x)
+ (if (consp x)
+ (mv nil
+ (cons (cdr x) (car x)))
+ (mv (msg \"ERROR: ~~x0 expected a cons, but was given ~~x1.~~|\"
+ 'invert1a x)
+ nil)))
+
+ (defun invert2a (x1 x2)
+ (mv-let (erp1 y1)
+ (invert1a x1)
+ (mv-let (erp2 y2)
+ (invert1a x2)
+ (if erp1
+ (if erp2
+ (cw \"~~x0 failed with two errors:~~| ~~@1 ~~@2\"
+ 'invert2a erp1 erp2)
+ (cw \"~~x0 failed with one error:~~| ~~@1\"
+ 'invert2a erp1))
+ (if erp2
+ (cw \"~~x0 failed with one error:~~| ~~@1\"
+ 'invert2a erp2)
+ (list y1 y2))))))
+ ~ev[]
+ For example:
+ ~bv[]
+ ACL2 !>(invert2a '(3 . 4) '(5 . 6))
+ ((4 . 3) (6 . 5))
+ ACL2 !>(invert2a '(3 . 4) 'b)
+ INVERT2A failed with one error:
+ ERROR: INVERT1A expected a cons, but was given B.
+ NIL
+ ACL2 !>(invert2a 'a 'b)
+ INVERT2A failed with two errors:
+ ERROR: INVERT1A expected a cons, but was given A.
+ ERROR: INVERT1A expected a cons, but was given B.
+ NIL
+ ACL2 !>
+ ~ev[]
+
+ If you study the example above, you might well understand ~c[msg]. But we
+ conclude with precise documentation.~/
+
+ ~bv[]
+ General Form:
+ (msg str arg1 ... argk)
+ ~ev[]
+ where ~c[str] is a string and ~c[k] is at most 9.
+
+ This macro returns a pair suitable for giving to the ~c[fmt] directive
+ ~c[~~@]. Thus, suppose that ~c[#\\c] is bound to the value of
+ ~c[(msg str arg1 ... argk)], where ~c[c] is a character and ~c[k] is at most
+ 9. Then the ~c[fmt] directive ~c[~~@c] will print out the string, ~c[str],
+ in the context of the alist in which the successive ~c[fmt] variables
+ ~c[#\\0], ~c[#\\1], ..., ~c[#\\k] are bound to the successive elements of
+ ~c[(arg1 ... argk)].~/"
(declare (xargs :guard (<= (length args) 10)))
@@ -14160,7 +14438,7 @@
Note that if you download community books as tarfiles, then you should be
sure to download the `nonstd' books, from
- ~url[http://acl2-books.googlecode.com/files/nonstd-6.2.tar.gz]. Then certify
+ ~url[http://acl2-books.googlecode.com/files/nonstd-6.3.tar.gz]. Then certify
them from your acl2-sources directory, shown here as
~c[]:
~bv[]
@@ -15788,9 +16066,6 @@
(defparameter *acl2-unwind-protect-stack* nil)
#-acl2-loop-only
-(defvar *lp-ever-entered-p* nil)
-
-#-acl2-loop-only
(defmacro push-car (item place ctx)
(let ((g (gensym)))
`(let ((,g ,place))
@@ -16862,6 +17137,11 @@
of guard verification is to ensure that during evaluation of an expression
without free variables, no guard violation takes place.
+ Technical note: the first argument of ~c[verify-guards] must be a function
+ symbol or the name of a ~ilc[defthm] or ~ilc[defaxiom] event, not a
+ macro-alias for a function symbol (~pl[macro-aliases-table]).
+ ~l[verify-guards+] for a utility that does not have this restriction.
+
Guard verification is intended to guarantee that for any call of a given
function, if its ~il[guard] holds for that call then the ~il[guard] will hold
for every function call in the body of that function. Moreover, in order to
@@ -17157,6 +17437,84 @@
(list 'quote doc)
(list 'quote event-form)))
+(defmacro verify-guards+ (name &rest rest)
+
+; We considered renaming verify-guards as verify-guards-basic, and then
+; defining verify-guards on top of verify-guards-basic just as we now define
+; verify-guards+ on top of verify-guards. But that could be complicated to
+; carry out during the boot-strap, and it could be challenging to present a
+; nice view to the user, simulataneously promoting the fiction that
+; verify-guards is a primitive while giving accurate feedback. So we are
+; leaving verify-guards as the primitive, but improving it to point to
+; verify-guards+ when there is a macro alias.
+
+; The example in the documentation below doesn't immediately yield a proof of
+; nil, but perhaps mbe could be used for that (we haven't tried). At any rate,
+; violation of the intent of guard verification is bad enough.
+
+ ":Doc-Section Events
+
+ verify the ~il[guard]s of a function~/
+
+ We assume familiarity with ~il[guard] verification; ~pl[verify-guards].
+ Unlike ~c[verify-guards], the macro call ~c[(verify-guards+ mac ...)] will
+ verify guards for a function, ~c[fn], such that the macro ~c[mac] is
+ associated with the function symbol ~c[fn] in ~ilc[macro-aliases-table]
+ (also ~pl[add-macro-alias]). For example, if you define a macro ~c[app] and
+ list append function ~c[binary-app], and you associate macro ~c[app] with
+ function symbol ~c[binary-app] in ~ilc[macro-aliases-table], then evaluation
+ of the form ~c[(verify-guard+ app)] will have the effect of evaluating
+ ~c[(verify-guards fn)]. Note that in this setting, evaluation of
+ ~c[(verify-guard app)] would cause an error, because ~c[app] is a macro and
+ ~c[verify-guards], unlike ~c[verify-guards+], cannot handle macros.~/
+
+ The rest of this ~il[documentation] topic discusses why we do not simply
+ arrange that ~c[verify-guards] be permitted to take a macro alias. The
+ following example shows a soundness issue in doing so.
+ ~bv[]
+ (encapsulate
+ ()
+ (defun f1 (x)
+ (declare (xargs :guard (consp x)
+ :verify-guards nil))
+ (car x))
+ (defun f2 (x)
+ (declare (xargs :guard t
+ :verify-guards nil))
+ (cdr x))
+ (defmacro mac (x)
+ x)
+ (add-macro-alias mac f2) ; silly macro alias ;
+ (local (add-macro-alias mac f1)) ; alternate silly macro alias ;
+ (verify-guards mac))
+ ~ev[]
+
+ If we were to allow macro aliases in ~ilc[verify-guards], this event would be
+ admitted, because on the first pass we are verifying guards of ~c[f1]. But
+ after the ~ilc[encapsulate] form completes evaluation, it would appear that
+ ~c[f2] is guard-verified. That could of course cause a raw Lisp error.
+
+ The enhanced functionality provided by ~c[verify-guards+] does not have the
+ above problem, because it takes advantage of ~ilc[make-event] to avoid taking
+ advantage of the contradictory results produced by the two calls of
+ ~c[add-macro-alias]. ~l[make-event]. If the specific example above is
+ modified by replacing ~c[verify-guards] with ~c[verify-guards+], then the
+ first pass through the ~ilc[encapsulate] form will expand the form
+ ~c[(verify-guards+ mac)] to ~c[(verify-guards f1)]. That same expansion will
+ be used for the ~c[verify-guards+] call during the second pass through the
+ ~c[encapsulate] form, which is evaluated successfully and leaves us in a
+ ~il[world] where ~c[f1] is guard-verified and ~c[f2] is not.~/"
+
+ `(make-event
+ (let* ((name ',name)
+ (rest ',rest)
+ (fn (deref-macro-name name (macro-aliases (w state)))))
+ (pprogn (observation 'verify-guards+
+ "Attempting to verify guards for ~x0."
+ fn)
+ (value (list* 'verify-guards fn rest))))
+ :expansion? (verify-guards ,name ,@rest)))
+
(defdoc defpun
":Doc-Section acl2::Events
@@ -17323,7 +17681,7 @@
(defconst-fast *x* (expensive-fn ...))
~ev[]
A more general utility may be found in community book
- ~c[books/tools/defconsts.lisp]. Also ~il[using-tables-efficiently] for an
+ ~c[books/tools/defconsts.lisp]. Also ~pl[using-tables-efficiently] for an
analogous issue with ~ilc[table] events.
It may be of interest to note that ~c[defconst] is implemented at the
@@ -17964,20 +18322,20 @@
:congruent-to old-stobj-name)
~ev[]
where ~c[name] is a new symbol, each ~c[fieldi] is a symbol, each ~c[typei]
- is either a ~ilc[type-spec] or ~c[(ARRAY] ~ilc[type-spec] ~c[(max))], each
- ~c[vali] is an object satisfying ~c[typei], and each ~c[bi] is ~c[t] or
- ~c[nil]. Each pair ~c[:initially vali] and ~c[:resizable bi] may be omitted;
- more on this below. The ~c[:renaming alist] argument is optional and allows
- the user to override the default function names introduced by this event.
- The ~ilc[doc-string] is also optional. The ~c[:inline flg] Boolean argument
- is also optional and declares to ACL2 that the generated access and update
- functions for the stobj should be implemented as macros under the hood (which
- has the effect of inlining the function calls). The optional
- ~c[:congruent-to old-stobj-name] argument specifies an existing stobj with
- exactly the same structure, and is discussed below. We describe further
- restrictions on the ~c[fieldi], ~c[typei], ~c[vali], and on ~c[alist] below.
- We recommend that you read about single-threaded objects (stobjs) in ACL2
- before proceeding; ~pl[stobj].
+ is either a type-indicator (a ~ilc[type-spec] or ~il[stobj] name) or of the
+ form ~c[(ARRAY type-indicator max)], each ~c[vali] is an object satisfying
+ ~c[typei], and each ~c[bi] is ~c[t] or ~c[nil]. Each pair
+ ~c[:initially vali] and ~c[:resizable bi] may be omitted; more on this below.
+ The ~c[:renaming alist] argument is optional and allows the user to override
+ the default function names introduced by this event. The ~ilc[doc-string] is
+ also optional. The ~c[:inline flg] Boolean argument is also optional and
+ declares to ACL2 that the generated access and update functions for the stobj
+ should be implemented as macros under the hood (which has the effect of
+ inlining the function calls). The optional ~c[:congruent-to old-stobj-name]
+ argument specifies an existing stobj with exactly the same structure, and is
+ discussed below. We describe further restrictions on the ~c[fieldi],
+ ~c[typei], ~c[vali], and on ~c[alist] below. We recommend that you read
+ about single-threaded objects (stobjs) in ACL2 before proceeding; ~pl[stobj].
The effect of this event is to introduce a new single-threaded object (i.e.,
a ``~il[stobj]''), named ~c[name], and the associated recognizers, creator,
@@ -18000,7 +18358,7 @@
a type-spec; ~pl[type-spec]. However, ~c[type-indicator] can also be the
name of a stobj that was previously introduced (by ~c[defstobj] or
~ilc[defabsstobj]). We ignore this ``nested stobj'' case below;
- ~pl[stobj-let] for a discussion of stobjs within stobjs.
+ ~pl[nested-stobjs] for a discussion of stobjs within stobjs.
The keyword value ~c[:initially val] specifies the initial value of a field,
except for the case of a ~c[:type] ~c[(ARRAY type-indicator (max))], in which
@@ -18027,10 +18385,10 @@
are not evaluated. If omitted, the type defaults to ~c[t] (unrestricted) and
the initial value defaults to ~c[nil].
- Each ~c[typei] must be either a ~ilc[type-spec] (with the exception noted
- above for nested stobjs, discussed elsewhere; ~pl[stobj-let]) or else a list
- of the form ~c[(ARRAY type-spec (max))]. The latter forms are said to be
- ``array types.'' Examples of legal ~c[typei] are:
+ Each ~c[typei] must be either a ~ilc[type-spec] or else a list of the form
+ ~c[(ARRAY type-spec (max))]. (Again, we are ignoring the case of nested
+ stobjs, discussed elsewhere; ~pl[nested-stobjs].) The latter forms are said
+ to be ``array types.'' Examples of legal ~c[typei] are:
~bv[]
(INTEGER 0 31)
(SIGNED-BYTE 31)
@@ -19077,7 +19435,8 @@
the theorem ~c[foo-preserves-consp] is encountered in the second pass,
~c[foo] is a known function symbol with the indicated signature.
- We turn now to more complete documentation.
+ We turn now to more complete documentation. But discussion of redundancy for
+ ~c[encapsulate] events may be found elsewhere; ~pl[redundant-encapsulate].
~bv[]
Other Examples:
@@ -19225,27 +19584,6 @@
made to the ~il[world] by the superior ~c[encapsulate], to permit
~c[an-element] to be used as a function symbol in ~c[thm1].
- The typical way for an ~c[encapsulate] event to be redundant is when a
- syntactically identical ~c[encapsulate] has already been executed under the
- same ~ilc[default-defun-mode], ~ilc[default-ruler-extenders], and
- ~ilc[default-verify-guards-eagerness]. More generally, the ~c[encapsulate]
- events need not be syntactically identical, but rather, need only to
- correspond in the following sense: they contain the same signatures and the
- same number of top-level events ~-[] let ~c[k] be that number ~-[] and for
- each ~c[i < k], the ~c[i]th top-level events ~c[E1] and ~c[E2] from the
- earlier and current ~c[encapsulate]s have one of the following properties.
-
- o ~c[E1] and ~c[E2] are equal; or
-
- o ~c[E1] is of the form ~c[(record-expansion E2 ...)]; or else
-
- o ~c[E1] and ~c[E2] are equal after replacing each ~ilc[local] sub-event by
- ~c[(local (value-triple :elided))], where a sub-event of an event ~c[E] is
- either ~c[E] itself, or a sub-event of a constituent event of ~c[E] in the
- case that ~c[E] is a call of ~ilc[with-output], ~ilc[with-prover-time-limit],
- ~ilc[with-prover-step-limit], ~c[record-expansion], ~ilc[time$], ~ilc[progn],
- ~ilc[progn!], or ~c[encapsulate] itself.
-
Remark for ACL2(r) (~pl[real]). For ACL2(r), ~ilc[encapsulate] can be used
to introduce classical and non-classical functions, as determined by the
signatures; ~pl[signature]. Those marked as classical (respectively
@@ -19261,6 +19599,99 @@
'state
(list 'quote event-form)))
+(defdoc redundant-encapsulate
+ ":Doc-Section encapsulate
+
+ redundancy of ~ilc[encapsulate] ~il[events]~/
+
+ For this ~il[documentation] topic we assume familiarity with ~c[encapsulate]
+ events and the notion of redundancy for ~il[events]; ~pl[encapsulate] and
+ ~pl[redundant-events].
+
+ The typical way for an ~c[encapsulate] event to be redundant is when a
+ syntactically identical ~c[encapsulate] has already been executed under the
+ same ~ilc[default-defun-mode], ~ilc[default-ruler-extenders], and
+ ~ilc[default-verify-guards-eagerness]. But more generally, the
+ ~c[encapsulate] events need not be syntactically identical; for example, it
+ suffices that they agree when the contents of ~ilc[local] sub-events are
+ ignored. The precise criterion for redundancy is given below, but let us
+ first look at a consequence of the point just made about ignoring the
+ contents of ~ilc[local] sub-events. Consider the following sequence of two
+ events.
+ ~bv[]
+ (encapsulate
+ ()
+ (defun f (x) x)
+ (local (defthm f-identity
+ (equal (f x) x))))
+
+ (encapsulate
+ ()
+ (defun f (x) x)
+ (local (defthm false-claim
+ (equal (f x) (not x)))))
+ ~ev[]
+ You might be surprised to learn that the second is actually redundant, even
+ though ~c[false-claim] is clearly not a theorem; indeed, its negation is a
+ theorem! The following two points may soften the blow. First, this behavior
+ is as specified above (and is specified more precisely below): the contents
+ of ~il[local] events are ignored when checking redundancy of
+ ~ilc[encapsulate] events. Second, this behavior is sound, because the
+ logical meaning of an ~ilc[encapsulate] event is taken from the events that
+ it exports, which do not include events that are ~il[local] to the
+ ~c[encapsulate] event.
+
+ Some users, however, want to use ~ilc[encapsulate] events for testing in a
+ way that is thwarted by this ignoring of ~il[local] sub-events. Consider
+ the following sort of example.
+ ~bv[]
+ (encapsulate ()
+ (local (defthm test1 ...)))
+
+ (encapsulate ()
+ (local (defthm test2 ...)))
+ ~ev[]
+ Since the contents of local events are ignored when checking redundancy of an
+ ~c[encapsulate] event, the second form just above is indeed redundant,
+ presumably not as expected by whomever wrote these two tests. A solution is
+ to add distinct non-local forms, for example as follows.
+ ~bv[]
+ (encapsulate ()
+ (value-triple \"test1\")
+ (local (defthm test1 ...)))
+
+ (encapsulate ()
+ (value-triple \"test2\")
+ (local (defthm test2 ...)))
+ ~ev[]
+ A different solution is to use ~ilc[make-event] for testing, as follows.
+ ~bv[]
+ (make-event (er-progn (defthm test1 ...)
+ (value '(value-triple nil))))
+ (make-event (er-progn (defthm test2 ...)
+ (value '(value-triple nil))))
+ ~ev[]
+ Also see community books ~c[misc/eval.lisp], ~c[make-event/eval-check.lisp],
+ and ~c[make-event/eval-tests.lisp] for more ways to test in books.
+
+ The precise criterion for redundancy of ~ilc[encapsulate] ~il[events] is that
+ the existing and proposed ~c[encapsulate] events contain the same signatures
+ and the same number of top-level events ~-[] let ~c[k] be that number ~-[]
+ and for each ~c[i < k], the ~c[i]th top-level events ~c[E1] and ~c[E2] from
+ the earlier and current ~c[encapsulate]s have one of the following
+ properties.
+
+ o ~c[E1] and ~c[E2] are equal; or
+
+ o ~c[E1] is of the form ~c[(record-expansion E2 ...)]; or else
+
+ o ~c[E1] and ~c[E2] are equal after replacing each ~ilc[local] sub-event by
+ ~c[(local (value-triple :elided))], where a sub-event of an event ~c[E] is
+ either ~c[E] itself, or a sub-event of a constituent event of ~c[E] in the
+ case that ~c[E] is a call of ~ilc[with-output], ~ilc[with-prover-time-limit],
+ ~ilc[with-prover-step-limit], ~c[record-expansion], ~ilc[time$], ~ilc[progn],
+ ~ilc[progn!], or ~c[encapsulate] itself.~/~/")
+
(defconst *load-compiled-file-values*
'(t nil :warn :default :comp))
@@ -19422,11 +19853,10 @@
At the beginning of execution of an ~c[include-book] form, even before
executing ~il[portcullis] ~il[command]s, the value of
- ~ilc[acl2-defaults-table] is restored to the value it had at startup, except
- that the value of key ~c[:inhibit-warnings] is preserved. After execution of
- an ~c[include-book] form, the value of ~ilc[acl2-defaults-table] is restored
- to what it was immediately before that ~c[include-book] form was executed.
- ~l[acl2-defaults-table].
+ ~ilc[acl2-defaults-table] is restored to the value it had at startup. After
+ execution of an ~c[include-book] form, the value of ~ilc[acl2-defaults-table]
+ is restored to what it was immediately before that ~c[include-book] form was
+ executed. ~l[acl2-defaults-table].
~b[Books Directory.] We refer to the ``books directory'' of an executable
image as the full pathname string of the directory associated with
@@ -19471,7 +19901,8 @@
#+acl2-loop-only
(defmacro make-event (&whole event-form
form
- &key check-expansion on-behalf-of)
+ &key
+ expansion? check-expansion on-behalf-of)
; Essay on Make-event
@@ -19540,7 +19971,8 @@
~st[Detailed Documentation]~nl[]
~st[Error Reporting]~nl[]
~st[Restriction to Event Contexts]~nl[]
- ~st[Examples illustrating how to access state]
+ ~st[Examples Illustrating How to Access State]~nl[]
+ ~st[Advanced Expansion Control]
We begin with an informal introduction, which focuses on examples and
introduces the key notion of ``expansion phase''.
@@ -19736,34 +20168,37 @@
; should return the same value as it did when the book was
; certified.
(make-event (generate-form state)
- :check-expansion t)
+ :CHECK-EXPANSION t)
- ; As above (where the :check-expansion value can be included or
+ ; As above (where the :CHECK-EXPANSION value can be included or
; not), where if there is an error during expansion, then the error
; message will explain that expansion was on behalf of the indicated
; object, typically specified as the first argument.
(make-event (generate-form state)
- :on-behalf-of (generate-form state))
+ :ON-BEHALF-OF (generate-form state))
General Form:
- (make-event form :check-expansion chk :on-behalf-of obj)
+ (make-event form :CHECK-EXPANSION chk :ON-BEHALF-OF obj :EXPANSION? form)
~ev[]
where ~c[chk] is ~c[nil] (the default), ~c[t], or the intended ``expansion
result'' from the evaluation of ~c[form] (as explained below); and if
supplied, ~c[obj] is an arbitrary ACL2 object, used only in reporting errors
- in expansion, i.e., in the evaluation of form.
+ in expansion, i.e., in the evaluation of form. The ~c[:EXPANSION?] keyword
+ is discussed in the final section, on Advanced Expansion Control.
We strongly recommend that you browse some ~c[.lisp] files in the community
books directory ~c[books/make-event/]. You may even find it helpful, in
order to understand ~c[make-event], to do so before continuing to read this
- documentation. For example, ~c[eval.lisp] contains definitions of macros
+ documentation. You may also find it useful to browse community book
+ ~c[books/misc/eval.lisp], which contains definitions of macros
~c[must-succeed] and ~c[must-fail] that are useful for testing and are used
- in many other books in that directory, especially ~c[eval-tests.lisp].
- Another example, ~c[defrule.lisp], shows how to use macros whose calls expand
- to ~c[make-event] forms, which in turn can generate ~il[events]. For more
- examples, see file ~c[Readme.lsp] in the above directory. Other than the
- examples, the explanations here should suffice for most users. If you want
- explanations of subtler details, ~pl[make-event-details].
+ in many books in the ~c[books/make-event/] directory, especially
+ ~c[eval-tests.lisp]. Another example, ~c[books/make-event/defrule.lisp],
+ shows how to use macros whose calls expand to ~c[make-event] forms, which in
+ turn can generate ~il[events]. For more examples, see file
+ ~c[books/make-event/Readme.lsp]. Other than the examples, the explanations
+ here should suffice for most users. If you want explanations of subtler
+ details, ~pl[make-event-details].
Note that ~c[make-event] may only be used at the ``top level'' or where an
event is expected. See the section ``Restriction to Event Contexts'', below.
@@ -19771,7 +20206,9 @@
~c[Make-event] is related to Lisp macroexpansion in the sense that its
argument is evaluated to obtain an expansion result, which is evaluated
again. Let us elaborate on each of these notions in turn: ``is evaluated,''
- ``expansion result'', and ``evaluated again.''~bq[]
+ ``expansion result'', and ``evaluated again.'' The final section, on
+ Advanced Expansion Control, will generalize these processes in a way that we
+ ignore for now.~bq[]
``is evaluated'' ~-[] The argument can be any expression, which is evaluated
as would be any expression submitted to ACL2's top level loop. Thus,
@@ -19784,34 +20221,31 @@
~ilc[state] global variables (~pl[assign]) are preserved). So, for example,
events might be evaluated during expansion, but they will disappear from the
logical ~il[world] after expansion returns its result. Moreover, proofs are
- enabled by default at the start of expansion (~pl[ld-skip-proofsp]), because
- an anticipated use of ~c[make-event] is to call the prover to decide which
- event to generate, and that would presumably be necessary even if proofs had
- been disabled.
+ enabled by default at the start of expansion (~pl[ld-skip-proofsp]) if
+ keyword ~c[:CHECK-EXPANSION] is supplied and has a non-~c[nil] value.
``expansion result'' ~-[] The above expansion may result in an ordinary
(non-~ilc[state], non-~ilc[stobj]) value, which we call the ``expansion
result.'' Or, expansion may result in a multiple value of the form
- ~c[(mv erp val state stobj-1 ... stobj-k)], where ~c[k] may be 0; in fact the
- most common case is probably ~c[(mv erp val state)]. In that case, if
- ~c[erp] is not ~c[nil], then there is no expansion result, and the original
- ~c[make-event] evaluates to a soft error. If however ~c[erp] is ~c[nil],
- then the resulting value is ~c[val]. Moreover, ~c[val] must be an embedded
- event form (~pl[embedded-event-form]); otherwise, the original ~c[make-event]
- evaluates to a soft error. Note that error messages from expansion are
- printed as described under ``Error Reporting'' below.
+ ~c[(mv erp val state)], or, more generally,
+ ~c[(mv erp val state stobj-1 ... stobj-k)] where each ~c[stobj-i] is a
+ ~il[stobj]; then the expansion result is ~c[val] unless ~c[erp] is not
+ ~c[nil], in which case there is no expansion result, and the original
+ ~c[make-event] evaluates to a soft error. In either case (single or multiple
+ value), either ~c[val] is an embedded event form (~pl[embedded-event-form]),
+ or else the original ~c[make-event] evaluates to a soft error, printed as
+ described under ``Error Reporting'' below.
``evaluated again'' ~-[] the expansion result is evaluated in place of the
original ~c[make-event].
- ~eq[]Note that the result of expansion can be an ordinary event, but it can
- instead be another call of ~c[make-event], or even of a call of a macro that
- expands to a call of ~c[make-event]. Or, expansion itself can cause
- subsidiary calls of ~c[make-event], for example if expansion uses ~ilc[ld] to
- evaluate some ~c[make-event] forms. The state global variable
- ~c[make-event-debug] may be set to a non-~c[nil] value in order to see a
- trace of the expansion process, where the level shown (as in ``~c[3>]'')
- indicates the depth of expansions in progress.
+ ~eq[]The expansion process can invoke subsidiary calls of ~c[make-event], and
+ the expansion result can (perhaps after macroexpansion) be a call of
+ ~c[make-event]. It can be useful to track all these ~c[make-event] calls.
+ The ~il[state] global variable ~c[make-event-debug] may be set to a
+ non-~c[nil] value, for example ~c[(assign make-event-debug t)], in order to
+ see a trace of the expansion process, where a level is displayed (as in
+ ``~c[3>]'') to indicate the depth of subsidiary expansions.
Expansion of a ~c[make-event] call will yield an event that replaces the
original ~c[make-event] call. In particular, if you put a ~c[make-event]
@@ -19819,52 +20253,57 @@
created during the proof pass of the ~ilc[certify-book] process. We now
elaborate on this idea of keeping the original expansion.
- By default, a ~c[make-event] call in a certified book is replaced (by a
- process hidden from the user, in an ~c[:expansion-alist] field of the book's
- ~il[certificate]) by the expansion result from evaluation of its first
- argument. Thus, although the book is not textually altered during
- certification, one may imagine a ``book expansion'' corresponding to the
- original book in which all of the events for which expansion took place
- (during the proof phase of certification) have been replaced by their
- expansions. A subsequent ~ilc[include-book] will then include the book
- expansion corresponding to the indicated book. When a book is compiled
- during ~ilc[certify-book], it is actually the corresponding book expansion,
- stored as a temporary file, that is compiled instead. That temporary file is
- deleted after compilation unless one first evaluates the form
- ~c[(assign keep-tmp-files t)]. Note however that all of the original forms
- must still be legal ~il[events] (~pl[embedded-event-form]). So for example,
- if the first event in a book is ~c[(local (defmacro my-id (x) x))], followed
- by ~c[(my-id (make-event ...))], the final ``~c[include-book]'' pass of
- ~ilc[certify-book] will fail because ~c[my-id] is not defined when the
- ~c[my-id] call is encountered.
-
- The preceding paragraph begins with ``by default'' because if you specify
- ~c[:check-expansion t], then subsequent evaluation of the same ~c[make-event]
- call ~-[] during the second pass of an ~ilc[encapsulate] or during event
- processing on behalf of ~ilc[include-book] ~-[] will do the expansion again
- and check that the expansion result equals the original expansion result. In
- the unusual case that you know the expected expansion result, ~c[res], you
- can specify ~c[:check-expansion res]. This will will cause a check that
- every subsequent expansion result for the ~c[make-event] form is ~c[res],
- including the original one. IMPORTANT NOTE: That expansion check is only
- done when processing events, not during a preliminary load of a book's
- compiled file. The following paragraph elaborates.
+ A ~c[make-event] call generates a ``~c[make-event] replacement'' that may be
+ stored by the system. In the simplest case, this replacement is the
+ expansion result. When a book is certified, these replacements are stored in
+ a book's certificate (technically, in the ~c[:EXPANSION-ALIST] field). Thus,
+ although the book is not textually altered during certification, one may
+ imagine a ``book expansion'' corresponding to the original book, in which
+ events are substituted by replacements that were generated during the proof
+ phase of certification. A subsequent ~ilc[include-book] will then include
+ the book expansion corresponding to the indicated book. When a book is
+ compiled during ~ilc[certify-book], it is actually the corresponding book
+ expansion, stored as a temporary file, that is compiled instead. That
+ temporary file is deleted after compilation unless one first evaluates the
+ form ~c[(assign keep-tmp-files t)]. Note however that all of the original
+ forms must still be legal ~il[events]; ~pl[embedded-event-form]. So for
+ example, if the first event in a book is ~c[(local (defmacro my-id (x) x))],
+ and is followed by ~c[(my-id (make-event ...))], the final
+ ``~c[include-book]'' pass of ~ilc[certify-book] will fail because ~c[my-id]
+ is not defined when the ~c[my-id] call is encountered.
+
+ A ~c[make-event] replacement might not be the expansion when either of the
+ keyword arguments ~c[:CHECK-EXPANSION] or ~c[:EXPANSION?] is supplied. We
+ deal with the latter in the final section, on Advanced Expansion Control. If
+ ~c[:CHECK-EXPANSION t] is supplied and the expansion is ~c[exp], then the
+ replacement is obtained from the original ~c[make-event] call, by
+ substituting ~c[exp] for ~c[t] as the value of keyword ~c[:CHECK-EXPANSION].
+ Such a ~c[make-event] call ~-[] during the second pass of an
+ ~ilc[encapsulate] or during event processing on behalf of ~ilc[include-book]
+ ~-[] will do the expansion again and check that the expansion result is equal
+ to the original expansion result, ~c[exp]. In the unusual case that you know
+ the expected expansion result, ~c[res], you can specify
+ ~c[:CHECK-EXPANSION res] in the first place, so that the check is also done
+ during the initial evaluation of the ~c[make-event] form. IMPORTANT BUT
+ OBSCURE DETAIL: That expansion check is only done when processing events, not
+ during a preliminary load of a book's compiled file. The following paragraph
+ elaborates.
(Here are details on the point made just above, for those who use the
- ~c[:check-expansion] argument to perform side-effects on the ~il[state].
+ ~c[:CHECK-EXPANSION] argument to perform side-effects on the ~il[state].
When you include a book, ACL2 generally loads a compiled file before
processing the events in the book; ~pl[book-compiled-file]. While it is true
- that a non-~c[nil] ~c[:check-expansion] argument causes ~ilc[include-book] to
+ that a non-~c[nil] ~c[:CHECK-EXPANSION] argument causes ~ilc[include-book] to
perform expansion of the ~c[make-event] form during event processing it does
~em[not] perform expansion when the compiled file (or expansion file; again,
~pl[book-compiled-file]) is loaded.)
- ACL2 performs the following space-saving optimization for book certificates:
- a ~ilc[local] event arising from ~c[make-event] expansion is replaced in that
- expansion by ~c[(local (value-triple :ELIDED))].
+ ACL2 performs the following space-saving optimization: when the expansion
+ result is a ~ilc[local] event, then the ~c[make-event] replacement is
+ ~c[(local (value-triple :ELIDED))].
- We note that ACL2 extends the notion of ``make-event expansion'' to the case
- that a call of ~c[make-event] is found in the course of macroexpansion. The
+ The notion of ``expansion'' and ``replacement'' extend to the case that a
+ call of ~c[make-event] is found in the course of macroexpansion. The
following example illustrates this point.
~bv[]
(encapsulate
@@ -19875,7 +20314,7 @@
:pe :here
~ev[]
The above call of ~ilc[pe] shows that the form ~c[(my-mac)] has a
- ~c[make-event] expansion of ~c[(DEFUN FOO (X) X)]:
+ ~c[make-event] expansion (and replacement) of ~c[(DEFUN FOO (X) X)]:
~bv[]
(ENCAPSULATE NIL
(DEFMACRO MY-MAC
@@ -19897,10 +20336,12 @@
~st[Restriction to Event Contexts]
- A ~c[make-event] call must occur either at the top level or as an argument of
- an event constructor, as explained in more detail below. This restriction is
- imposed to enable ACL2 to track expansions produced by ~c[make-event]. The
- following examples illustrate this restriction.
+ A ~c[make-event] call must occur either at the top level, or during
+ ~c[make-event] expansion, or as an argument of an event constructor. We
+ explain in more detail below. This restriction is imposed to enable ACL2 to
+ track expansions produced by ~c[make-event].
+
+ The following examples illustrate this restriction.
~bv[]
; Legal:
(progn (with-output
@@ -19913,10 +20354,12 @@
(mv erp val state))
~ev[]
- More precisely: after macroexpansion has taken place, a ~c[make-event] call
- must be in an ``event context'', defined recursively as follows. (All but
- the first two cases below correspond to similar cases for constructing
- events; ~pl[embedded-event-form].)
+ More precisely: a ~c[make-event] call that is not itself evaluated during
+ ~c[make-event] expansion is subject to the following requirement. After
+ macroexpansion has taken place, such a ~c[make-event] call must be in an
+ ``event context'', defined recursively as follows. (All but the first two
+ cases below correspond to similar cases for constructing events;
+ ~pl[embedded-event-form].)
~bq[]
o A form submitted at the top level, or more generally, supplied to a call of
@@ -19938,17 +20381,17 @@
~c[(]~ilc[WITH-PROVER-TIME-LIMIT]~c[ ... x1)] is in an event context, then so
is ~c[x1].
- o Given a call of ~ilc[PROGN] or ~ilc[PROGN!] in an event context, each of its
- arguments is in an event context.
+ o For any call of ~ilc[PROGN] or ~ilc[PROGN!], each of its arguments is in an
+ event context.
- o Given a call of ~ilc[ENCAPSULATE] in an event context, each of its
- arguments except the first (the signature list) is in an event context.
+ o For any call of ~ilc[ENCAPSULATE], each of its arguments except the
+ first (the signature list) is in an event context.
o If ~c[(RECORD-EXPANSION x1 x2)] is in an event context, then ~c[x1] and
~c[x2] are in event contexts. Note: ~c[record-expansion] is intended for use
only by the implementation, which imposes the additional restriction that
~c[x1] and its subsidiary ~c[make-event] calls (if any) must specify a
- ~c[:check-expansion] argument that is a ~il[consp].
+ ~c[:CHECK-EXPANSION] argument that is a ~il[consp].
~eq[]
Low-level remark, for system implementors. There is the one exception to
@@ -19959,11 +20402,11 @@
~ev[]
However, the following form may be preferable (~pl[progn!]):
~bv[]
- (progn! :state-global-bindings (make-event ...))
+ (progn! :STATE-GLOBAL-BINDINGS (make-event ...))
~ev[]
Also ~pl[remove-untouchable] for an interesting use of this exception.
- ~st[Examples illustrating how to access state]
+ ~st[Examples Illustrating How to Access State]
You can modify the ACL2 ~il[state] by doing your state-changing computation
during the expansion phase, before expansion returns the event that is
@@ -20011,7 +20454,7 @@
~bv[]
(make-event
(let ((world-len (length (w state))))
- `(progn (table my-table :stored-world-length ,world-len)
+ `(progn (table my-table :STORED-WORLD-LENGTH ,world-len)
(defun foo (x) (cons x ,world-len)))))
~ev[]
Then:
@@ -20027,11 +20470,169 @@
By the way, most built-in ~il[state] globals revert after expansion. But
your own global (like ~c[my-global] above) can be set during expansion, and
- the new value will persist."
+ the new value will persist.
+
+ ~st[Advanced Expansion Control]
+
+ We conclude this ~il[documentation] section by discussing three kinds of
+ additional control over ~c[make-event] expansion. These are all illustrated
+ in community book ~c[books/make-event/make-event-keywords-or-exp.lisp].
+ The discussion below is split into the following three parts.
+
+ (1) The value produced by expansion may have the form ~c[(:DO-PROOFS exp)],
+ which specifies ~c[exp] as the expansion result, to be evaluated without
+ skipping proofs even when including a book.
+
+ (2) The value produced by expansion may have the form
+ ~c[(:OR exp-1 ... exp-k)], which specifies that the first form ~c[exp-i] to
+ evaluate without error is the expansion result.
+
+ (3) The keyword argument ~c[:EXPANSION?] can serve to eliminate the storing
+ of ~c[make-event] replacements, as described above for the ``book expansion''
+ of a book.
+
+ We now elaborate on each of these.
+
+ (1) ~c[:DO-PROOFS] ``call'' produced by expansion.
+
+ We have discussed the expansion result produced by the expansion phase of
+ evaluating a ~c[make-event] call. However, if the expansion phase produces
+ an expression of the form ~c[(:DO-PROOFS exp)], then the expansion result is
+ actually ~c[exp]. The ~c[:DO-PROOFS] wrapper indicates that even if proofs
+ are currently being skipped (~pl[ld-skip-proofsp]), then evaluation of
+ ~c[exp] should take place with proofs not skipped. For example, proofs will
+ be performed when evaluating the ~c[make-event] expansion, namely the
+ indicated ~c[defthm] event, in the following example.
+ ~bv[]
+ (set-ld-skip-proofsp t state)
+ (make-event '(:DO-PROOFS
+ (defthm app-assoc (equal
+ (append (append x y) z)
+ (append x y z)))))
+ ~ev[]
+
+ Note that such use of ~c[:DO-PROOFS] causes proofs to be performed when
+ evaluating the expansion while including an uncertified book. But when
+ including a certified book, then unless ~c[:CHECK-EXPANSION] is supplied a
+ non-~c[nil] value, the ~c[make-event] replacement will just be the expansion,
+ which does not include the ~c[:DO-PROOFS] wrapper and hence will be evaluated
+ with proofs skipped.
+
+ (2) ~c[:OR] ``call'' produced by expansion.
+
+ There may be times where you want to try different expansions. For example,
+ the community book ~c[books/make-event/proof-by-arith.lisp] attempts to admit
+ a given event, which we'll denote ~c[EV], by trying events of the following
+ form as ~c[BOOK] varies over different community books.
+ ~bv[]
+ (encapsulate
+ ()
+ (local (include-book BOOK :DIR :SYSTEM))
+ EV)
+ ~ev[]
+ A naive implementation of this macro would evaluate all such
+ ~ilc[encapsulate] events until one succeeds, and then return that successful
+ event as the expansion. Then that event would need to be evaluated again!
+ With some hacking one could avoid that re-evaluation by using
+ ~ilc[skip-proofs], but that won't work if you are trying to create a
+ certified book without skipped proofs. Instead, the implementation creates
+ an expansion of the form ~c[(:OR ev-1 ev-2 ... ev-k)], where the list
+ ~c[(ev-1 ev-2 ... ev-k)] enumerates the generated encapsulate events. In
+ general, for this ``disjunctive case'' of a result from expansion, each
+ ~c[ev-i] is evaluated in sequence, and the first that succeeds without error
+ is considered to be the expansion result ~-[] and a repeat evaluation is
+ avoided. If evaluation of each ~c[ev-i] results in an error, then so does
+ the ~c[make-event] call.
+
+ This special use of ~c[:OR] in a value produced by expansion is only
+ supported at the top level. That is, the result can be
+ ~c[(:OR ev-1 ev-2 ... ev-k)] but then each ~c[ev-i] must be a legal expansion
+ result, without such further use of ~c[:OR] ~-[] except, ~c[ev-i] may be
+ ~c[(:DO-PROOFS ev-i')], where ~c[ev-i'] then would serve as the expansion
+ rather than ~c[ev-i].
+
+ (3) The ~c[:EXPANSION?] keyword argument.
+
+ If keyword argument ~c[:EXPANSION?] has a non~c[nil] value, then the
+ ~c[:CHECK-EXPANSION] keyword must be omitted or have value ~c[nil] or ~c[t],
+ hence not a cons pair.
+
+ The idea of the ~c[:EXPANSION?] keyword is to give you a way to avoid storing
+ expansion results in a book's ~il[certificate]. Roughly speaking, when the
+ expansion result matches the value of ~c[:EXPANSION?], then no expansion
+ result is stored for the event by book certification; then when the book is
+ later included, the value of ~c[:EXPANSION?] is used as the expansion, thus
+ bypassing the expansion phase. One could say that the event is its own
+ make-event replacement, but it is more accurate to say that there is no
+ make-event replacement at all, since nothing is stored in the certificate for
+ this event. Below, we elaborate on make-event replacements when
+ ~c[:EXPANSION] is used and also discuss other properties of this keyword.
+
+ We modify the notion of ``expansion result'' for ~c[make-event] forms to
+ comprehend the use of the ~c[:EXPANSION?] keyword. For that purpose, let's
+ consider a call of ~c[make-event] to be ``reducible'' if it has an
+ ~c[:EXPANSION?] keyword with non-~c[nil] value, ~c[exp], and its
+ ~c[:CHECK-EXPANSION] keyword is missing or has value ~c[nil], in which case
+ the ``reduction'' of this ~c[make-event] call is defined to be ~c[exp]. The
+ expansion result as originally defined is modified by the following
+ ``recursive reduction'' process: recur through the original expansion,
+ passing through calls of ~ilc[local], ~ilc[skip-proofs], ~ilc[with-output],
+ ~ilc[with-prover-step-limit], and ~ilc[with-prover-time-limit], and
+ replacing (recursively) any reducible call of ~c[make-event] by its
+ reduction. Furthermore, we refer to two forms as ``reduction equivalent'' if
+ their recursive reductions are equal. Note that the recursive reduction
+ process does not pass through ~ilc[progn] or ~ilc[encapsulate], but that
+ process is applied to the computation of expansions for their subsidiary
+ ~ilc[make-event] calls.
+
+ To explain further the effect of ~c[:EXPANSION? exp], we split into the
+ following two cases.
+
+ o Case 1: Evaluation is not taking place when including a book or evaluating
+ the second pass of an ~ilc[encapsulate] event; more precisely, the value of
+ ~c[(ld-skip-proofsp state)] is not the symbol ~c[INCLUDE-BOOK]. There are
+ two subcases.
+ ~bq[]
+
+ - Case 1a: The expansion result is not reduction-equivalent to ~c[exp]. Then
+ the ~c[make-event] call is processed as though the ~c[:EXPANSION?] keyword
+ had been omitted.
+
+ - Case 2a: The expansion result is reduction-equivalent to ~c[exp]. Then
+ there is no ~c[make-event] replacement for this call of ~c[make-event]; no
+ replacement will be put into the ~il[certificate] file for a book containing
+ this ~c[make-event] call. When that book is subsequently included, the
+ original form will be evaluated in the manner described in the next
+ case.~eq[]
+
+ o Case 2: Evaluation is taking place when including a book or evaluating the
+ second pass of an ~ilc[encapsulate] event; more precisely, the value of
+ ~c[(ld-skip-proofsp state)] is the symbol ~c[INCLUDE-BOOK]. Then the
+ expansion is ~c[exp]. The expansion phase is skipped unless
+ ~c[:CHECK-EXPANSION] is ~c[t].
+
+ The ~c[:EXPANSION?] keyword can be particularly useful in concert with the
+ disjunctive (``~c[:OR]'') case (2) discussed above. Suppose that expansion
+ produces a value as discussed in (2) above, ~c[(:OR exp-1 ... exp-k)]. If
+ one of these expressions ~c[exp-i] is more likely than the others to be the
+ expansion, then you may wish to specify ~c[:EXPANSION? exp-i], as this will
+ avoid storing a ~c[make-event] replacement in that common case. This could
+ be useful if the expressions are large, to avoid enlarging the
+ ~il[certificate] file for a book containing the ~c[make-event] call.
+
+ It is legal to specify both ~c[:EXPANSION? exp] and ~c[:CHECK-EXPANSION t].
+ When either ~c[(ld-skip-proofsp state)] is the symbol ~c[INCLUDE-BOOK], or
+ evaluation is taking place in raw Lisp, then this combination is treated the
+ same as if ~c[:EXPANSION?] is omitted and the value of ~c[:CHECK-EXPANSION]
+ is ~c[exp]. Otherwise, this combination is treated the same as
+ ~c[:CHECK-EXPANSION t], modified to accommodate the effect of ~c[:EXPANSION?]
+ as discussed above: if the expansion is indeed the value of ~c[:EXPANSION?],
+ then no ~c[make-event] replacement is generated."
(declare (xargs :guard t))
; Keep this in sync with the -acl2-loop-only definition.
`(make-event-fn ',form
+ ',expansion?
',check-expansion
',on-behalf-of
',event-form
@@ -21402,10 +22003,10 @@
Below we explain ~c[defattach] in some detail. But it is important to keep
in mind that evaluation with the attachment equations takes place in an
extension of the logical theory of the session. ACL2 guarantees that this
- so-called ``evaluation theory'' remains consistent, assuming that the absence
- of ~ilc[defaxiom] ~il[events] from the user. This guarantee is a consequence
- of a more general guarantee: an ACL2 logical ~il[world] exists in
- which (loosely speaking) the attachment equation for ~c[(defattach f g)], as
+ so-called ``evaluation theory'' remains consistent, assuming the absence of
+ ~ilc[defaxiom] ~il[events] from the user. This guarantee is a consequence of
+ a more general guarantee: an ACL2 logical ~il[world] exists in which (loosely
+ speaking) the attachment equation for ~c[(defattach f g)], as
~c[(defun f (...) (g ...))], takes the place of the original defining event
for ~c[f], for each ~c[defattach] event. This more general guarantee holds
even if there are ~ilc[defaxiom] events, though as explained below, no
@@ -22330,7 +22931,7 @@
":Doc-Section ACL2::ACL2-built-ins
- modify an association list by associating a value with a key~/
+ remove the first pair from an association list for a given key~/
~bv[]
General Forms:
(delete-assoc key alist)
@@ -23400,9 +24001,6 @@
; is a terrible performance penalty, so in #+ACL2-PAR, we do not use array
; caching.
-(declaim (inline aref1))
-(declaim (inline aref2))
-
(defparameter *acl2-array-cache*
; This special is always the same cons, but its car and cdr may be
@@ -23579,6 +24177,7 @@
:rule-classes (:type-prescription
(:forward-chaining :trigger-terms ((assoc-equal name l)))))
+#+acl2-loop-only
(defmacro f-get-global (x st)
":Doc-Section ACL2::ACL2-built-ins
@@ -23609,29 +24208,6 @@
structures even though you may undo back past where you computed and saved
them.~/"
- #-acl2-loop-only
- (cond ((and (consp x)
- (eq 'quote (car x))
- (symbolp (cadr x))
- (null (cddr x)))
-
-; The cmulisp compiler complains about unreachable code every (perhaps) time
-; that f-get-global is called in which st is *the-live-state*. The following
-; optimization is included primarily in order to eliminate those warnings;
-; the extra efficiency is pretty minor, though a nice side effect.
-
- (if (eq st '*the-live-state*)
- `(let ()
- (declare (special ,(global-symbol (cadr x))))
- ,(global-symbol (cadr x)))
- (let ((s (gensym)))
- `(let ((,s ,st))
- (declare (special ,(global-symbol (cadr x))))
- (cond ((live-state-p ,s)
- ,(global-symbol (cadr x)))
- (t (get-global ,x ,s)))))))
- (t `(get-global ,x ,st)))
- #+acl2-loop-only
(list 'get-global x st))
#-acl2-loop-only
@@ -27254,7 +27830,7 @@
~sc[Timings]
- For how to obtain the runtime elapsed since the start of the ACL2 session,
+ For how to obtain the time elapsed since the start of the ACL2 session,
~pl[read-run-time].
For a utility for saving times into the ACL2 state and for printing those
@@ -27734,7 +28310,7 @@
ev-fncall-w ; *the-live-state*
ev-rec ; wormhole-eval
setup-simplify-clause-pot-lst1 ; dmr-flush
- save-exec ; save-exec-raw, etc.
+ save-exec-fn ; save-exec-raw, etc.
cw-gstack-fn ; *deep-gstack*
recompress-global-enabled-structure ; get-acl2-array-property
ev-w ; *the-live-state*
@@ -27941,6 +28517,7 @@
set-absstobj-debug-fn
sys-call-status ; *last-sys-call-status*
sys-call ; system-call
+ sys-call+ ; system-call+
canonical-pathname ; under dependent clause-processor
@@ -27953,7 +28530,6 @@
mfc-unify-subst ; *metafunction-context*
mfc-world ; *metafunction-context*
mfc-ap-fn ; under dependent clause-processor
- mfc-ap-ttree ; under dependent clause-processor
mfc-relieve-hyp-fn ; under dependent clause-processor
mfc-relieve-hyp-ttree ; under dependent clause-processor
mfc-rw+-fn ; under dependent clause-processor
@@ -28007,7 +28583,7 @@
logic er deflabel mv-let program value-triple
set-body comp set-bogus-defun-hints-ok
dmr-stop defpkg set-measure-function
- set-inhibit-warnings defthm mv
+ set-inhibit-warnings! defthm mv
f-big-clock-negative-p reset-prehistory
mutual-recursion set-rewrite-stack-limit set-prover-step-limit
add-match-free-override
@@ -28070,6 +28646,7 @@
catch-throw-to-local-top-level
with-fast-alist-raw with-stolen-alist-raw fast-alist-free-on-exit-raw
stobj-let
+ add-ld-keyword-alias! set-ld-keyword-aliases!
))
(defmacro with-live-state (form)
@@ -28401,7 +28978,7 @@
`((abbrev-evisc-tuple . :default)
(accumulated-ttree . nil) ; just what succeeded; tracking the rest is hard
(acl2-raw-mode-p . nil)
-
+ (acl2-sources-dir . nil) ; set by initialize-state-globals
(acl2-version .
; Keep this value in sync with the value assigned to
@@ -28410,7 +28987,7 @@
; The reason MCL needs special treatment is that (char-code #\Newline) = 13 in
; MCL, not 10. See also :DOC version.
-; ACL2 Version 6.2
+; ACL2 Version 6.3
; We put the version number on the line above just to remind ourselves to bump
; the value of state global 'acl2-version, which gets printed out with the
@@ -28436,7 +29013,7 @@
; reformatting :DOC comments.
,(concatenate 'string
- "ACL2 Version 6.2"
+ "ACL2 Version 6.3"
#+non-standard-analysis
"(r)"
#+(and mcl (not ccl))
@@ -28486,6 +29063,7 @@
(gag-mode-evisc-tuple . nil)
(gag-state . nil)
(gag-state-saved . nil) ; saved when gag-state is set to nil
+ (get-internal-time-as-realtime . nil) ; seems harmless to change
(global-enabled-structure . nil) ; initialized in enter-boot-strap-mode
(gstackp . nil)
(guard-checking-on . t)
@@ -28507,6 +29085,7 @@
(iprint-soft-bound . ,*iprint-soft-bound-default*)
(keep-tmp-files . nil)
(last-make-event-expansion . nil)
+ (last-prover-steps . nil)
(last-step-limit . -1) ; any number should be OK
(ld-level . 0)
(ld-okp . :default) ; see :DOC calling-ld-in-bad-contexts
@@ -29291,17 +29870,17 @@
(global-table state-state))
state-state))
+#+acl2-loop-only
(defun get-global (x state-state)
; Wart: We use state-state instead of state because of a bootstrap problem.
+; Keep this in sync with the #+acl2-loop-only definition of get-global (which
+; uses qfuncall).
+
(declare (xargs :guard (and (symbolp x)
(state-p1 state-state)
(boundp-global1 x state-state))))
- #-acl2-loop-only
- (cond ((live-state-p state-state)
- (return-from get-global
- (symbol-value (the symbol (global-symbol x))))))
(cdr (assoc x (global-table state-state))))
(defun put-global (key value state-state)
@@ -29418,7 +29997,6 @@
(ld-skip-proofsp . nil)
(ld-redefinition-action . nil)
(ld-prompt . t)
- (ld-keyword-aliases . nil)
(ld-missing-input-ok . nil)
(ld-pre-eval-filter . :all)
(ld-pre-eval-print . nil)
@@ -29879,6 +30457,23 @@
; least as reasonable.
(defun signed-byte-p (bits x)
+
+ ":Doc-Section ACL2::ACL2-built-ins
+
+ recognizer for signed integers that fit in a specified bit width~/
+
+ ~c[(Signed-byte-p bits x)] is ~c[T] when ~c[bits] is a positive integer and
+ ~c[x] is a signed integer whose 2's complement representation fits in a
+ bit-width of ~c[bits], i.e., ~c[-2^(bits-1) <= x < 2^(bits-1)].~/
+
+ Note that a ~il[type-spec] of ~c[(signed-byte i)] for a variable ~c[x] in a
+ function's ~ilc[declare] form translates to a ~il[guard] condition of
+ ~c[(signed-byte-p i x)].
+
+ The ~il[guard] for ~c[signed-byte-p] is ~c[T].
+
+ To see the ACL2 definition of this function, ~pl[pf].~/"
+
(declare (xargs :guard t))
(and (integerp bits)
(< 0 bits)
@@ -29887,6 +30482,23 @@
x)))
(defun unsigned-byte-p (bits x)
+
+ ":Doc-Section ACL2::ACL2-built-ins
+
+ recognizer for natural numbers that fit in a specified bit width~/
+
+ ~c[(Unsigned-byte-p bits x)] is ~c[T] when ~c[bits] is a positive integer and
+ ~c[x] is a nonnegative integer that fits into a bit-width of ~c[bits], i.e.,
+ ~c[0 <= x < 2^bits].~/
+
+ Note that a ~il[type-spec] of ~c[(unsigned-byte i)] for a variable ~c[x] in a
+ function's ~ilc[declare] form translates to a ~il[guard] condition of
+ ~c[(unsigned-byte-p i x)].
+
+ The ~il[guard] for ~c[unsigned-byte-p] is ~c[T].
+
+ To see the ACL2 definition of this function, ~pl[pf].~/"
+
(declare (xargs :guard t))
(and (integerp bits)
(<= 0 bits)
@@ -32027,6 +32639,10 @@
":Doc-Section ACL2::ACL2-built-ins
print an error message and ``cause an error''~/
+
+ ~l[fmt] for a general discussion of formatted printing in ACL2. All calls of
+ ~c[er] print formatted strings, just as is done by ~ilc[fmt].
+
~bv[]
Example Forms:
(er hard 'top-level \"Illegal inputs, ~~x0 and ~~x1.\" a b)
@@ -34872,20 +35488,78 @@
(t (car (idates state-state))))
(update-idates (cdr (idates state-state)) state-state)))
+#-acl2-loop-only
+(defun get-internal-time ()
+ (if (f-get-global 'get-internal-time-as-realtime *the-live-state*)
+ (get-internal-real-time)
+ (get-internal-run-time)))
+
+(defdoc get-internal-time
+ ":Doc-Section Miscellaneous
+
+ runtime vs. realtime in ACL2 timings~/
+
+ The ACL2 system provides utilities that deal with elapsed time. The most
+ visible of these is in the time summaries printed when completing evaluation
+ of ~il[events]. For others, ~pl[with-prover-time-limit], ~pl[read-run-time],
+ ~pl[time-tracker], ~pl[time-tracker-tau], and ~pl[pstack].
+
+ By default, these utilities all use an underlying notion of run time provided
+ by the host Common Lisp implementation: specifically, Common Lisp function
+ ~c[get-internal-run-time]. However, Common Lisp also provides function
+ ~c[get-internal-run-time], which returns the real time (wall clock time).
+ While the latter is specified to measure elapsed time, the former is left to
+ the implementation, which might well only measure time spent in the Lisp
+ process. Consider the following example, which is a bit arcane but basically
+ sleeps for 2 seconds.
+ ~bv[]
+ (defttag t) ; to allow sys-call
+ (make-event
+ (prog2$ (sys-call \"sleep\" '(\"2\"))
+ (value '(value-triple nil))))
+ ~ev[]
+ A typical time summary might be as follows, drastically under-reporting the
+ elapsed time.
+ ~bv[]
+ Time: 0.01 seconds (prove: 0.00, print: 0.00, other: 0.01)
+ ~ev[]
+ However, you can instruct ACL2 to switch to using elapsed time (run time), in
+ summaries and elsewhere, by evaluating the following form.
+ ~bv[]
+ (assign get-internal-time-as-realtime t)
+ ~ev[]
+ To return to using runtime:
+ ~bv[]
+ (assign get-internal-time-as-realtime nil)
+ ~ev[]
+ While the above example is rather silly, the issue becomes significant in
+ time summaries for proofs that call out to external tools (~pl[sys-call] and
+ ~pl[clause-processor]).
+
+ Note that a function ~c[get-internal-time] is defined in raw Lisp but is not
+ available inside the ACL2 loop. However, the expression
+ ~c[(read-run-time state)] provides an interface to this function that is
+ available inside the ACL2 loop; ~pl[read-run-time].
+
+ We are open to changing the default to elapsed wall-clock time (realtime),
+ and may do so in future ACL2 releases.~/~/")
+
(defun read-run-time (state-state)
":Doc-Section ACL2::ACL2-built-ins
read elapsed runtime~/
- ~c[(Read-run-time state)] returns ~c[(mv runtime state)], where runtime is
- the elapsed runtime in seconds since the start of the current ACL2 session
- and ~c[state] is the resulting ACL2 ~il[state].~/
+ By default, ~c[(read-run-time state)] returns ~c[(mv runtime state)], where
+ runtime is the elapsed runtime in seconds since the start of the current ACL2
+ session and ~c[state] is the resulting ACL2 ~il[state]. But
+ ~c[read-run-time] can be made to return elapsed realtime (wall clock time)
+ instead; ~pl[get-internal-time].~/
The logical definition probably won't concern many users, but for
completeness, we say a word about it here. That definition uses the function
- ~c[read-acl2-oracle], which modifies state by popping the returned
- ~c[runtime] value from its acl2-oracle field.~/"
+ ~c[read-acl2-oracle], which modifies state by popping the value to return
+ from its acl2-oracle field.~/"
(declare (xargs :guard (state-p1 state-state)))
@@ -34901,7 +35575,7 @@
; read-run-time to work even when *wormholep* is non-nil.
(return-from read-run-time
- (mv (/ (get-internal-run-time)
+ (mv (/ (get-internal-time)
internal-time-units-per-second)
state-state))))
(mv (cond ((or (null (acl2-oracle state-state))
@@ -35139,11 +35813,13 @@
(sys-call-status state))
~ev[]
The first argument of ~c[sys-call] is a command for the host operating
- system, and the second argument is a list of strings that are the
- arguments for that command. In GCL and perhaps other lisps, you can put the
+ system, and the second argument is a list of strings that are the arguments
+ for that command. In GCL and perhaps some other lisps, you can put the
arguments with the command; but this is not the case, for example, in Allegro
CL running on Linux.
+ For a related utility, ~pl[sys-call+].
+
The use of ~ilc[prog2$] above is optional, but illustrates a typical sort
of use when one wishes to get the return status. ~l[sys-call-status].~/
~bv[]
@@ -35194,13 +35870,12 @@
Finally, we make a comment about output redirection, which also applies to
other related features that one may expect of a shell. ~c[Sys-call] does not
directly support output redirection. If you want to run a program, ~c[P],
- and redirect its output, we suggest that you create a wrapper script, ~c[W]
+ and redirect its output, one option is to create a wrapper script, ~c[W]
to call instead. Thus ~c[W] might be a shell script containing the line:
~bv[]
P $* >& foo.out
~ev[]
- If this sort of solution proves inadequate, please contact the ACL2
- implementors and perhaps we can come up with a solution."
+ For a different, more direct solution, ~pl[sys-call+]."
(declare (xargs :guard t))
#+acl2-loop-only
@@ -35210,8 +35885,7 @@
(progn (setq *last-sys-call-status* rslt)
nil))
#+acl2-loop-only
- nil
- )
+ nil)
(defun sys-call-status (state)
@@ -35237,7 +35911,282 @@
(mv *last-sys-call-status* state)))
(mv-let (erp val state)
(read-acl2-oracle state)
- (mv (and erp val) state)))
+ (declare (ignore erp))
+ (mv val state)))
+
+#-acl2-loop-only
+(defun read-file-by-lines (file &optional delete-after-reading)
+ (let ((acc nil)
+ (eof '(nil))
+ missing-newline-p)
+ (with-open-file
+ (s file :direction :input)
+ (loop (multiple-value-bind (line temp)
+ (read-line s nil eof)
+ (cond ((eq line eof)
+ (return acc))
+ (t
+ (setq missing-newline-p temp)
+ (setq acc
+ (if acc
+ (concatenate 'string acc (string #\Newline) line)
+ line)))))))
+ (when delete-after-reading
+ (delete-file file))
+ (if missing-newline-p
+ acc
+ (concatenate 'string acc (string #\Newline)))))
+
+#-acl2-loop-only
+(defun system-call+ (string arguments)
+
+; Warning: Keep this in sync with system-call.
+
+ (let* (exit-code ; assigned below
+ #+(or gcl clisp)
+ (tmp-file (format nil
+ "~a/tmp~s"
+ (or (f-get-global 'tmp-dir *the-live-state*)
+ "/tmp")
+ (getpid$)))
+ no-error
+ (output-string
+ (our-ignore-errors
+ (prog1
+ #+gcl ; does wildcard expansion
+ (progn (setq exit-code
+ (si::system
+ (let ((result string))
+ (dolist
+ (x arguments)
+ (setq result (concatenate 'string result " " x)))
+ (concatenate 'string result " > " tmp-file))))
+ (read-file-by-lines tmp-file t))
+ #+lispworks ; does wildcard expansion (see comment below)
+ (with-output-to-string
+ (s)
+ (setq exit-code
+ (system::call-system-showing-output
+
+; It was tempting to use (cons string arguments). This would cause the given
+; command, string, to be applied to the given arguments, without involving the
+; shell. But then a command such as "ls" would not work; one would have to
+; provide a string such as "/bin/ls". So instead of using a list here, we use
+; a string, which according to the LispWorks manual will invoke the shell,
+; which will find commands (presumably including built-ins and also using the
+; user's path).
+
+ (let ((result string))
+ (dolist
+ (x arguments)
+ (setq result (concatenate 'string result " " x)))
+ result)
+ :output-stream s
+ :prefix ""
+ :show-cmd nil
+ :kill-process-on-abort t))
+ #+windows ; process is returned above, not exit code
+ (setq exit-code nil))
+ #+allegro ; does wildcard expansion
+ (multiple-value-bind
+ (stdout-lines stderr-lines exit-status)
+ (excl.osi::command-output
+ (let ((result string))
+ (dolist
+ (x arguments)
+ (setq result (concatenate 'string result " " x)))
+ result))
+ (declare (ignore stderr-lines))
+ (setq exit-code exit-status)
+ (let ((acc nil))
+ (loop for line in stdout-lines
+ do
+ (setq acc
+ (if acc
+ (concatenate 'string
+ acc
+ (string #\Newline)
+ line)
+ line)))
+ acc))
+ #+cmu
+ (with-output-to-string
+ (s)
+ (setq exit-code
+ (let (temp)
+ (if (ignore-errors
+ (progn
+ (setq temp
+ (ext:process-exit-code
+ (common-lisp-user::run-program
+ string arguments
+ :output s)))
+ 1))
+ temp
+ 1))))
+ #+sbcl
+ (with-output-to-string
+ (s)
+ (setq exit-code
+ (let (temp)
+ (if (ignore-errors
+ (progn
+ (setq temp
+ (sb-ext:process-exit-code
+ (sb-ext:run-program string arguments
+ :output s
+ :search t)))
+ 1))
+ temp
+ 1))))
+ #+clisp
+ (progn (setq exit-code
+ (or (ext:run-program string
+ :arguments arguments
+ :output tmp-file)
+ 0))
+ (read-file-by-lines tmp-file t))
+ #+ccl
+ (with-output-to-string
+ (s)
+ (setq exit-code
+ (let* ((proc
+ (ccl::run-program string arguments
+ :output s
+ :wait t))
+ (status (multiple-value-list
+ (ccl::external-process-status proc))))
+ (if (not (and (consp status)
+ (eq (car status) :EXITED)
+ (consp (cdr status))
+ (integerp (cadr status))))
+ 1 ; just some non-zero exit code here
+ (cadr status)))))
+ #-(or gcl lispworks allegro cmu sbcl clisp ccl)
+ (declare (ignore string arguments))
+ #-(or gcl lispworks allegro cmu sbcl clisp ccl)
+ (error "SYSTEM-CALL is not yet defined in this Lisp.")
+ (setq no-error t)))))
+ (values (cond ((integerp exit-code)
+ exit-code)
+ ((null exit-code)
+ (if no-error 0 1))
+ (t (format t
+ "WARNING: System-call produced non-integer, ~
+ non-nil exit code:~%~a~%"
+ exit-code)
+ 0))
+ (if (stringp output-string)
+ output-string
+ ""))))
+
+(encapsulate
+ ()
+
+; Before Version_2.9.3, len-update-nth had the form of the local lemma below.
+; It turns out that an easy way to prove the improved version below,
+; contributed by Jared Davis, is to prove the old version first as a lemma:
+
+ (local
+ (defthm len-update-nth-lemma
+ (implies (< (nfix n) (len x))
+ (equal (len (update-nth n val x))
+ (len x)))))
+
+ (defthm len-update-nth
+ (equal (len (update-nth n val x))
+ (max (1+ (nfix n))
+ (len x)))))
+
+(defthm update-acl2-oracle-preserves-state-p1
+ (implies (and (state-p1 state)
+ (true-listp x))
+ (state-p1 (update-acl2-oracle x state)))
+ :hints (("Goal" :in-theory (enable state-p1))))
+
+(in-theory (disable update-acl2-oracle))
+
+(defun sys-call+ (command-string args state)
+
+ ":Doc-Section ACL2::ACL2-built-ins
+
+ make a system call to the host OS, returning status and output~/
+ ~bv[]
+ Example Form:
+ ; The following returns (mv nil s state), where s is the standard output
+ ; from the command: ls -l ./
+ (sys-call+ \"ls\" '(\"-l\" \"./\") state)
+
+ General Form:
+ (sys-call+ cmd args state)
+ ~ev[]
+ where ~c[cmd] is a command to the host operating system and ~c[args] is a
+ list of strings. Also ~pl[sys-call]; but there are two differences between
+ ~ilc[sys-call] and ~c[sys-call+]. First, the latter takes an extra argument,
+ ~c[state]. Second, while ~c[sys-call] returns ~c[nil], ~c[sys-call+] returns
+ three values: a so-called error triple (~pl[error-triples]),
+ ~c[(mv erp val state)]. While execution returns values as described just
+ below, further below we explain the logical return values. In the following,
+ please keep in mind that the exact behavior depends on the platform; the
+ description is only a guide. For example, on some platforms ~c[erp] might
+ always be ~c[nil], even if in the error case, and ~c[val] might or might not
+ include error output. (For details, look at the ACL2 source code for
+ function ~c[system-call+], whose output is converted by replacing an ~c[erp]
+ of ~c[nil] by 0.)
+ ~bq[]
+
+ ~c[Erp] is either ~c[nil] or a non-zero integer. Normally, ~c[nil] indicates
+ that the command ran without error, and otherwise ~c[erp] is the exit
+ status.
+
+ ~c[Val] is a string, typically the output generated by the call of ~c[cmd].
+
+ ~c[State] is an ACL2 ~il[state].~eq[]
+
+ While the description above pertains to the values returned by executing
+ ~c[sys-call+], the logical values are as follows. For a discussion of the
+ ~c[acl2-oracle] field of an ACL2 state, ~pl[state].
+ ~bq[]
+
+ ~c[Erp] is the first element of the ~c[acl2-oracle] of the input state if
+ that element is a nonzero integer, and otherwise is ~c[nil].
+
+ ~c[Val] is the second element of the ~c[acl2-oracle] of the input state if it
+ is a string, else the empty string, ~c[\"\"].
+
+ ~c[State] is the result of popping the ~c[acl2-oracle] field twice from the
+ input state.~eq[]
+
+ Note that unlike ~ilc[sys-call], a call of ~ilc[sys-call+] has no effect on
+ subsequent calls of ~ilc[sys-call-status].
+
+ As is the case for ~c[sys-call], a trust tag is required to call
+ ~c[sys-call+]. For discussion of this and more, ~pl[sys-call].~/~/"
+
+ (declare (xargs :stobjs state))
+ #+acl2-loop-only
+ (declare (ignore command-string args))
+ #+acl2-loop-only
+ (mv-let (erp1 erp state)
+ (read-acl2-oracle state)
+ (declare (ignore erp1))
+ (mv-let (erp2 val state)
+ (read-acl2-oracle state)
+ (declare (ignore erp2))
+ (mv (and (integerp erp)
+ (not (eql 0 erp))
+ erp)
+ (if (stringp val) val "")
+ state)))
+ #-acl2-loop-only
+ (multiple-value-bind
+ (status rslt)
+ (system-call+ command-string args)
+ (mv (if (eql status 0)
+ nil
+ status)
+ rslt
+ state)))
; End of system calls
@@ -35300,32 +36249,6 @@
; to two decimal places. We just print the number, without leading or
; trailing spaces or even the word ``seconds''.
-(encapsulate
- ()
-
-; Before Version_2.9.3, len-update-nth had the form of the local lemma below.
-; It turns out that an easy way to prove the improved version below,
-; contributed by Jared Davis, is to prove the old version first as a lemma:
-
- (local
- (defthm len-update-nth-lemma
- (implies (< (nfix n) (len x))
- (equal (len (update-nth n val x))
- (len x)))))
-
- (defthm len-update-nth
- (equal (len (update-nth n val x))
- (max (1+ (nfix n))
- (len x)))))
-
-(defthm update-acl2-oracle-preserves-state-p1
- (implies (and (state-p1 state)
- (true-listp x))
- (state-p1 (update-acl2-oracle x state)))
- :hints (("Goal" :in-theory (enable state-p1))))
-
-(in-theory (disable update-acl2-oracle))
-
(local
(defthm rational-listp-cdr
(implies (rational-listp x)
@@ -36218,6 +37141,10 @@
; in-local-flg.
; in-local-flg
+; Since in-prove-flg need not be untouchable (currently it is only used by
+; break-on-error), we omit it from this list. It is used by community book
+; misc/bash.lisp.
+
axiomsp
current-acl2-world
@@ -36282,7 +37209,6 @@
standard-co
proofs-co
ld-prompt
- ld-keyword-aliases
ld-missing-input-ok
ld-pre-eval-filter
ld-pre-eval-print
@@ -36343,6 +37269,8 @@
deferred-ttag-notes-saved
pc-assign
illegal-to-certify-message
+ acl2-sources-dir
+ last-prover-steps ; being conservative here; perhaps could omit
))
; There are a variety of state global variables, 'ld-skip-proofsp among them,
@@ -37460,8 +38388,6 @@
(member-eq val '(t nil :warn)))
((eq key :ignore-ok)
(member-eq val '(t nil :warn)))
- ((eq key :inhibit-warnings)
- (string-listp val))
((eq key :bdd-constructors)
; We could insist that the symbols are function symbols by using
@@ -37644,21 +38570,6 @@
or ~c[:warn] (which makes the check but merely warns when the check
fails). ~l[set-ignore-ok].
~bv[]
- :inhibit-warnings
- ~ev[]
- ACL2 prints warnings that may, from time to time, seem excessive to
- experienced users. Each warning is ``labeled'' with a string
- identifying the type of warning. Consider for example
- ~bv[]
- ACL2 Warning [Use] in ( THM ...): It is unusual to :USE ....
- ~ev[]
- Here, the label is \"Use\". The value of the key
- ~c[:inhibit-warnings] is a list of such labels, where case is
- ignored. Any warning whose label is a member of this list (where
- again, case is ignored) is suppressed.
- ~l[set-inhibit-warnings] and also
- ~pl[set-inhibit-output-lst].
- ~bv[]
:bdd-constructors
~ev[]
This key's value is a list of function symbols used to define the
@@ -37942,7 +38853,7 @@
~ev[]"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :enforce-redundancy ,x)
(table acl2-defaults-table :enforce-redundancy))))
@@ -37992,7 +38903,7 @@
~ev[]"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :ignore-doc-string-error ,x)
(table acl2-defaults-table :ignore-doc-string-error))))
@@ -38064,7 +38975,7 @@
~c[(default-verify-guards-eagerness (w state))]."
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :verify-guards-eagerness ,x)
(table acl2-defaults-table :verify-guards-eagerness))))
@@ -38132,7 +39043,7 @@
:cited-by Programming"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :compile-fns ,x)
(table acl2-defaults-table :compile-fns))))
@@ -38208,7 +39119,7 @@
~ilc[acl2-count].~/"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :measure-function ',name)
(table acl2-defaults-table :measure-function))))
@@ -38258,7 +39169,7 @@
arguments decreases according to ~c[rel].~/"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :well-founded-relation ',rel)
(table acl2-defaults-table :well-founded-relation))))
@@ -38360,7 +39271,7 @@
~l[embedded-event-form]."
'(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'summary (@ inhibit-output-lst))))
(er-progn (table acl2-defaults-table :defun-mode :logic)
(value :invisible))))
@@ -38419,7 +39330,7 @@
~l[embedded-event-form]."
'(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'summary (@ inhibit-output-lst))))
(er-progn (table acl2-defaults-table :defun-mode :program)
(value :invisible))))
@@ -38696,7 +39607,7 @@
~c[(set-bogus-defun-hints-ok :warn)].~/~/"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :bogus-defun-hints-ok ,x)
(table acl2-defaults-table :bogus-defun-hints-ok))))
@@ -38751,7 +39662,7 @@
:cited-by Programming"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :bogus-mutual-recursion-ok ,x)
(table acl2-defaults-table :bogus-mutual-recursion-ok))))
@@ -39170,7 +40081,7 @@
; not available for the expression of that event.
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(er-progn
(chk-ruler-extenders ,x soft 'set-ruler-extenders (w state))
(progn
@@ -39223,7 +40134,7 @@
:cited-by Programming"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :irrelevant-formals-ok ,x)
(table acl2-defaults-table :irrelevant-formals-ok))))
@@ -39272,7 +40183,7 @@
:cited-by Programming"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :ignore-ok ,x)
(table acl2-defaults-table :ignore-ok))))
@@ -39282,11 +40193,34 @@
nil)
#-acl2-loop-only
-(defmacro set-inhibit-warnings (&rest x)
+(defmacro set-inhibit-warnings! (&rest x)
(declare (ignore x))
nil)
+(table inhibit-warnings-table nil nil
+ :guard
+ (stringp key))
+
#+acl2-loop-only
+(defmacro set-inhibit-warnings! (&rest lst)
+
+ ":Doc-Section switches-parameters-and-modes
+
+ control warnings non-~ilc[local]ly~/
+
+ Please ~pl[set-inhibit-warnings], which is the same as
+ ~c[set-inhibit-warnings!] except that the latter is not ~ilc[local] to the
+ ~ilc[encapsulate] or the book in which it occurs. Probably
+ ~il[set-inhibit-warnings] is to be preferred unless you have a good reason
+ for wanting to export the effect of this event outside the enclosing
+ ~ilc[encapsulate] or book.~/~/"
+
+ (declare (xargs :guard (string-listp lst)))
+ `(state-global-let*
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
+ (progn (table inhibit-warnings-table nil ',(pairlis$ lst nil) :clear)
+ (value-triple ',lst))))
+
(defmacro set-inhibit-warnings (&rest lst)
":Doc-Section switches-parameters-and-modes
@@ -39298,36 +40232,44 @@
~ev[]
Note: This is an event! It does not print the usual event summary
but nevertheless changes the ACL2 logical ~il[world] and is so
- recorded. Moreover, its effect is to set the ~ilc[acl2-defaults-table], and
- hence its effect is ~ilc[local] to the book or ~ilc[encapsulate] form
- containing it; ~pl[acl2-defaults-table].~/
+ recorded. It is ~ilc[local] to the book or ~ilc[encapsulate] form in which it
+ occurs; ~pl[set-inhibit-warnings!] for a corresponding non-~ilc[local]
+ event. Indeed, ~c[(set-inhibit-warnings ...)] is equivalent to
+ ~c[(local (set-inhibit-warnings! ...))].~/
~bv[]
General Form:
(set-inhibit-warnings string1 string2 ...)
~ev[]
- where each string is considered without regard to case. This macro
- is equivalent to ~c[(table acl2-defaults-table :inhibit-warnings lst)],
- where ~c[lst] is the list of strings supplied. This macro is an event
- (~pl[table]), but no output results from a
- ~c[set-inhibit-warnings] event.
-
- The effect of this event is to suppress any warning whose label is a
- member of this list (where again, case is ignored). For example,
- the warning
- ~bv[]
- ACL2 Warning [Use] in ( THM ...): It is unusual to :USE ....
- ~ev[]
- will not be printed if ~c[\"use\"] (or ~c[\"USE\"], etc.) is a member
- of the given list of strings.
-
- Of course, if warnings are inhibited overall ~-[]
- ~pl[set-inhibit-output-lst] ~-[] then the value of
- ~c[:inhibit-warnings] is entirely irrelevant."
+ where each string is considered without regard to case. This macro is
+ equivalent to ~c[(local (table inhibit-warnings-table nil 'lst :clear))],
+ where ~c[lst] is the list of strings supplied. This macro is an
+ event (~pl[table]), but no output results from a ~c[set-inhibit-warnings]
+ event.
- `(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
- (progn (table acl2-defaults-table :inhibit-warnings ',lst)
- (table acl2-defaults-table :inhibit-warnings))))
+ ACL2 prints warnings that may, from time to time, seem excessive to
+ experienced users. Each warning is ``labeled'' with a string identifying the
+ type of warning. Consider for example
+ ~bv[]
+ ACL2 Warning [Use] in ( THM ...): It is unusual to :USE ....
+ ~ev[]
+ Here, the label is \"Use\". The argument list for ~c[set-inhibit-warnings]
+ is a list of such labels, each of which is a string. Any warning is
+ suppressed if its label is a member of this list, where case is ignored, .
+ Thus, for example, the warning above will not be printed after a call of
+ ~c[set-inhibit-warnings] that contains the string, ~c[\"Use\"] (or any string
+ that is ~ilc[string-equal] to ~c[\"Use\"], such as ~c[\"use\"] or
+ ~c[\"USE\"]). In summary: the effect of this event is to suppress any
+ warning whose label is a member of the given argument list, where case is
+ ignored.
+
+ The list of currently inhibited warnings is the list of keys in the
+ ~il[table] named ~c[inhibit-warnings-table]. (The values in the table are
+ irrelevant.) One way to get that value is to get the result from evaluating
+ the following form: ~c[(table-alist 'inhibit-warnings-table (w state))]. Of
+ course, if warnings are inhibited overall ~-[] ~pl[set-inhibit-output-lst]
+ ~-[] then this value is entirely irrelevant."
+
+ `(local (set-inhibit-warnings! ,@lst)))
(defmacro set-inhibit-output-lst (lst)
@@ -39520,7 +40462,7 @@
"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :state-ok ,x)
(table acl2-defaults-table :state-ok))))
@@ -39576,7 +40518,7 @@
Thus, the mode may be set locally in books."
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :let*-abstractionp ,x)
(table acl2-defaults-table :let*-abstractionp))))
@@ -39656,7 +40598,7 @@
The default limit is ~c[(nil nil)]."
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :backchain-limit
(let ((limit ,limit))
(if (atom limit)
@@ -39885,7 +40827,7 @@
The initial default backchain-limit is ~c[nil]."
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :default-backchain-limit
(let ((limit ,limit))
(if (atom limit)
@@ -40015,7 +40957,9 @@
limit on prover steps for a single event, rather than globally. For a
related utility based on time instead of prover steps,
~pl[with-prover-time-limit]. For examples of how step limits work, see the
- community book ~c[books/misc/misc2/step-limits.lisp].
+ community book ~c[books/misc/misc2/step-limits.lisp]. For a utility that
+ returns an indicator of the number of prover steps most recently taken,
+ ~pl[last-prover-steps].
Note: This is an event! It does not print the usual event summary
but nevertheless changes the ACL2 logical ~il[world] and is so
@@ -40052,6 +40996,11 @@
the exception stated above: if the ``limit'' is ~c[nil] or is the value of
~c[*default-step-limit*], then no limit is imposed.
+ There is at best a loose connection between the counting of steps and
+ ~ilc[with-prover-time-limit]. In particular, for a call of ~c[mfc-rw] or any
+ ~c[mfc-] function (~pl[extended-metafunctions]), the steps taken during that
+ call are forgotten when returning from that call.
+
The limit is relevant for every event, as well as for calls of ~ilc[thm] and
~ilc[certify-book] ~-[] and more generally, to any form that creates a
``summary context'' to print the usual event summary. The limit is also put
@@ -40126,14 +41075,10 @@
Prover steps counted: 41090
NIL
ACL2 !>
- ~ev[]
-
- Technical Remark. For a call of ~c[mfc-rw] or any ~c[mfc-]
- function (~pl[extended-metafunctions]), the steps taken during that call are
- forgotten when returning from that call.~/"
+ ~ev[]~/"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(pprogn
(let ((rec (f-get-global 'step-limit-record state))
(limit (or ,limit *default-step-limit*)))
@@ -40156,7 +41101,8 @@
:strictp)))
state))
(t state)))
- (progn (table acl2-defaults-table :step-limit ,limit)
+ (progn (table acl2-defaults-table :step-limit
+ (or ,limit *default-step-limit*))
(table acl2-defaults-table :step-limit)))))
#-acl2-loop-only
@@ -40257,7 +41203,7 @@
(set-rewrite-stack-limit 30) ; set to small limit
:set-rewrite-stack-limit 30 ; same as above
(set-rewrite-stack-limit *default-rewrite-stack-limit*) ; the default
- :set-rewrite-stack-limit (1- (expt 2 28)) ; maximum legal limit
+ (set-rewrite-stack-limit (1- (expt 2 28))) ; maximum legal limit
:set-rewrite-stack-limit nil ; same as above -- essentially, no limit
~ev[]
This event sets the maximum stack depth for calls of certain functions that
@@ -40274,7 +41220,7 @@
For a different but somewhat related concept, ~pl[backchain-limit]."
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :rewrite-stack-limit
,(if (or (null limit) (equal limit (kwote nil)))
(1- (expt 2 28))
@@ -40381,7 +41327,7 @@
nu-rewriter."
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :nu-rewriter-mode ,x)
(table acl2-defaults-table :nu-rewriter-mode))))
@@ -40579,7 +41525,7 @@
the standard proofs output.~/"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :case-split-limitations
(let ((lst ,lst))
(cond ((eq lst nil)
@@ -40805,7 +41751,7 @@
; :cited-by free-variables add-match-free-override set-match-free-error
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :match-free-default ,x)
(table acl2-defaults-table :match-free-default))))
@@ -40966,7 +41912,7 @@
; :cited-by free-variables set-match-free-default set-match-free-error
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
,(cond
((eq flg :clear)
(cond
@@ -41199,7 +42145,7 @@
The initial value is ~c[nil]."
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :non-linearp ,toggle)
(table acl2-defaults-table :non-linearp))))
@@ -41369,7 +42315,7 @@
settings of those two flags."
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table :tau-auto-modep ,toggle)
(table acl2-defaults-table :tau-auto-modep))))
@@ -41636,7 +42582,7 @@
(declare (xargs :guard (symbolp tag-name)))
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table acl2-defaults-table
:ttag
',(and tag-name
@@ -42380,7 +43326,7 @@
Note: This is an event! It does not print the usual event summary
but nevertheless changes the ACL2 logical ~il[world] and is so
recorded. It is ~ilc[local] to the book or ~ilc[encapsulate] form in which it
- occurs (~pl[set-default-hints!] for a corresponding non-~ilc[local] event).~/
+ occurs; ~pl[set-default-hints!] for a corresponding non-~ilc[local] event.~/
~bv[]
General Form:
(set-default-hints lst)
@@ -42435,7 +43381,7 @@
outside the enclosing ~ilc[encapsulate] or book.~/~/"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table default-hints-table t ,lst)
(table default-hints-table t))))
@@ -42505,7 +43451,7 @@
outside the enclosing ~ilc[encapsulate] or book.~/~/"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table default-hints-table t
(if ,at-end
(append (default-hints world) ,lst)
@@ -42569,7 +43515,7 @@
outside the enclosing ~ilc[encapsulate] or book.~/~/"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table default-hints-table t
(set-difference-equal (default-hints world) ,lst))
(table default-hints-table t))))
@@ -42582,7 +43528,7 @@
#+acl2-loop-only
(defmacro set-override-hints-macro (lst at-end ctx)
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'summary (@ inhibit-output-lst))))
(set-override-hints-fn ,lst ,at-end ,ctx (w state) state)))
#-acl2-loop-only
@@ -42998,7 +43944,7 @@
in which it occurs.~/~/"
`(state-global-let*
- ((inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ ((inhibit-output-lst (list* 'event 'summary (@ inhibit-output-lst))))
(progn (table rw-cache-state-table t ,val)
(table rw-cache-state-table t))))
@@ -44591,7 +45537,7 @@
(let ((time-limit-var (gensym)))
`(let* ((,time-limit-var ,time)
- (temp (+ (get-internal-run-time)
+ (temp (+ (get-internal-time)
(* internal-time-units-per-second
(if (consp ,time-limit-var)
(car ,time-limit-var)
@@ -44638,7 +45584,7 @@
where ~c[time] evaluates to a positive rational number or to a list
containing such, and ~c[form] is arbitrary. Logically,
~c[(with-prover-time-limit time form)] is equivalent to ~c[form]. However,
- if the runtime for evaluation of ~c[form] exceeds the value specified by
+ if the time for evaluation of ~c[form] exceeds the value specified by
~c[time], and if ACL2 notices this fact during a proof, then that proof will
abort, for example like this:
~bv[]
@@ -44649,6 +45595,9 @@
allowed to push that time further into the future unless the inner time is
specified as a list containing a rational, rather than as a rational.
+ Note that by default, the time used is runtime (cpu time); to switch to
+ realtime (elapsed time), ~pl[get-internal-time].
+
For a related utility based on prover steps instead of time,
~pl[with-prover-step-limit]; also ~pl[set-prover-step-limit]. Those
utilities have the advantage of having platform-independent behavior, unlike
@@ -44766,7 +45715,7 @@
; Where should we call this function? We want to strike a balance between
; calling it often enough that we get reasonably tight results for
; with-prover-time-limit, yet calling it rarely enough so that we don't slow
-; down the prover, in particular from calls of (get-internal-run-time).
+; down the prover, in particular from calls of (get-internal-time).
; As of this writing we call this function in add-poly,
; quick-and-dirty-subsumption-replacement-step, subsumption-replacement-loop,
@@ -44795,7 +45744,7 @@
; rewrite not in the scope of catch-time-limit5.
(member-eq 'time-limit5-tag *time-limit-tags*)
- (< *acl2-time-limit* (get-internal-run-time)))
+ (< *acl2-time-limit* (get-internal-time)))
(setq *next-acl2-oracle-value*
(if (eql *acl2-time-limit* 0)
"Aborting due to an interrupt."
@@ -46959,8 +47908,31 @@
tbl)))
:clear))
+(defun splice-keyword-alist (key new-segment keyword-alist)
+ (declare (xargs :guard (and (keywordp key)
+ (keyword-value-listp keyword-alist)
+ (true-listp new-segment))))
+ (cond
+ ((endp keyword-alist) nil)
+ ((eq key (car keyword-alist))
+ (append new-segment (cddr keyword-alist)))
+ (t (cons (car keyword-alist)
+ (cons (cadr keyword-alist)
+ (splice-keyword-alist key new-segment
+ (cddr keyword-alist)))))))
+
+(deflabel custom-keyword-hints
+ :doc
+ ":Doc-Section Miscellaneous
+
+ user-defined hints~/
+
+ ~l[add-custom-keyword-hint] for a discussion of how advanced users can define
+ their own hint keywords. For examples, see the community books directory
+ ~c[books/hints/], in particular ~c[basic-tests.lisp].~/~/")
+
(defmacro show-custom-keyword-hint-expansion (flg)
- ":Doc-Section Events
+ ":Doc-Section custom-keyword-hints
print out custom keyword hints when they are expanded~/
~bv[]
@@ -46986,29 +47958,6 @@
`(f-put-global 'show-custom-keyword-hint-expansion ,flg state))
-(defun splice-keyword-alist (key new-segment keyword-alist)
- (declare (xargs :guard (and (keywordp key)
- (keyword-value-listp keyword-alist)
- (true-listp new-segment))))
- (cond
- ((endp keyword-alist) nil)
- ((eq key (car keyword-alist))
- (append new-segment (cddr keyword-alist)))
- (t (cons (car keyword-alist)
- (cons (cadr keyword-alist)
- (splice-keyword-alist key new-segment
- (cddr keyword-alist)))))))
-
-(deflabel custom-keyword-hints
- :doc
- ":Doc-Section Miscellaneous
-
- user-defined hints~/
-
- ~l[add-custom-keyword-hint] for a discussion of how advanced users can define
- their own hint keywords. For examples, see the community books directory
- ~c[books/hints/], in particular ~c[basic-tests.lisp].~/~/")
-
; Start implementation of search.
(defun search-fn-guard (seq1 seq2 from-end test start1 start2 end1 end2
@@ -48143,6 +49092,30 @@
(break)))
nil)
+#-acl2-loop-only
+(defvar *ccl-print-call-history-count*
+
+; This variable is only used by CCL, but we define it for all Lisps so that
+; this name is equally unavailable as a name for defconst in all host Lisps.
+
+; The user is welcome to change this in raw Lisp. Perhaps we should advertise
+; it and use a state global. We have attempted to choose a value sufficiently
+; large to get well into the stack, but not so large as to swamp the system.
+; Even with the default for CCL (as of mid-2013) of -Z 2M, the stack without
+; this restriction could be much larger. For example, in the ACL2 loop we
+; made the definition
+
+; (defun foo (x) (if (atom x) nil (cons (car x) (foo (cdr x)))))
+
+; and then ran (foo (make-list 1000000)), and after 65713 abbreviated stack
+; frames CCL just hung. But with this restriction, it took less than 6 seconds
+; to evaluate the following in raw Lisp, including printing the stack to the
+; terminal (presumably it would be much faster to print to a file):
+
+; (time$ (ignore-errors (ld '((foo (make-list 1000000))))))
+
+ 10000)
+
(defun print-call-history ()
; We welcome suggestions from users or Lisp-specific experts for how to improve
@@ -48161,7 +49134,8 @@
#+(and ccl (not acl2-loop-only))
(when (fboundp 'ccl::print-call-history)
; See CCL file lib/backtrace.lisp for more options
- (eval '(ccl::print-call-history :detailed-p nil)))
+ (eval '(ccl::print-call-history :detailed-p nil
+ :count *ccl-print-call-history-count*)))
; It seems awkward to deal with GCL, both because of differences in debugger
; handling and because we haven't found documentation on how to get a
@@ -48362,13 +49336,21 @@
(defun set-debugger-enable-fn (val state)
(declare (xargs :guard (and (state-p state)
(member-eq val '(t nil :never :break :bt
- :break-bt :bt-break)))))
- (f-put-global 'debugger-enable val state)
+ :break-bt :bt-break)))
+ :guard-hints (("Goal" :in-theory (enable state-p1)))))
#+(and (not acl2-loop-only)
(and gcl (not cltl2)))
(when (live-state-p state)
- (setq lisp::*break-enable* (debugger-enabledp state))
- state))
+ (setq lisp::*break-enable* (debugger-enabledp state)))
+ (pprogn
+ (f-put-global 'debugger-enable val state)
+ (if (consp (f-get-global 'dmrp state))
+
+; Then user invoked this function, so avoid having a later stop-dmr change the
+; value of 'debugger-enable.
+
+ (f-put-global 'dmrp t state)
+ state)))
; See comment in true-listp-cadr-assoc-eq-for-open-channels-p.
(in-theory (disable true-listp-cadr-assoc-eq-for-open-channels-p))
@@ -49178,13 +50160,16 @@
display time spent during specified evaluation~/
- The ~c[time-tracker] macro is a utility for displaying runtime (cpu time)
- spent during specified evaluation. In general, the user provides this
- specification. However, ACL2 itself uses this utility for tracking uses of
- its ~il[tau-system] reasoning utility (~pl[time-tracker-tau]). We discuss
- that use as an example before discussing the general form for calls of
+ The ~c[time-tracker] macro is a utility for displaying time spent during
+ specified evaluation. In general, the user provides this specification.
+ However, ACL2 itself uses this utility for tracking uses of its
+ ~il[tau-system] reasoning utility (~pl[time-tracker-tau]). We discuss that
+ use as an example before discussing the general form for calls of
~c[time-tracker].
+ Note that by default, the time being tracked is runtime (cpu time); to switch
+ to realtime (elapsed time), ~pl[get-internal-time].
+
Remark for ACL2(p) users (~pl[parallelism]): ~c[time-tracker] is merely a
no-op in ACL2(p).
@@ -49214,7 +50199,8 @@
~c[time-tracker] are evaluated, the first argument is typically a keyword and
the second is always a keyword, and such arguments evaluate to themselves.
- An ACL2 function invoked at the start of a proof includes the following code.
+ An ACL2 function invoked at the start of a proof includes approximately the
+ following code.
~bv[]
(progn$
(time-tracker :tau :end)
@@ -49302,7 +50288,7 @@
We conclude with a precise discussion of all arguments. Note that all
arguments are evaluated; thus when we refer to an argument, we are discussing
the value of that argument. All times discussed are runtimes, i.e., cpu
- times.
+ times, unless that default is changed; ~pl[get-internal-time].
~bv[]
General forms:
diff -Nru acl2-6.2/basis.lisp acl2-6.3/basis.lisp
--- acl2-6.2/basis.lisp 2013-06-06 16:30:53.000000000 +0000
+++ acl2-6.3/basis.lisp 2013-09-29 21:27:51.000000000 +0000
@@ -1,4 +1,4 @@
-; ACL2 Version 6.2 -- A Computational Logic for Applicative Common Lisp
+; ACL2 Version 6.3 -- A Computational Logic for Applicative Common Lisp
; Copyright (C) 2013, Regents of the University of Texas
; This version of ACL2 is a descendent of ACL2 Version 1.9, Copyright
@@ -647,7 +647,6 @@
(ld-skip-proofsp 'same ld-skip-proofspp)
(ld-redefinition-action 'save ld-redefinition-actionp)
(ld-prompt ''wormhole-prompt)
- (ld-keyword-aliases 'same ld-keyword-aliasesp)
(ld-missing-input-ok 'same ld-missing-input-okp)
(ld-pre-eval-filter 'same ld-pre-eval-filterp)
(ld-pre-eval-print 'same ld-pre-eval-printp)
@@ -683,7 +682,6 @@
:ld-skip-proofsp ... ; nil, t or 'include-book
:ld-redefinition-action ; nil or '(:a . :b)
:ld-prompt ... ; nil, t, or some prompt printer fn
- :ld-keyword-aliases ... ; an alist pairing keywords to parse info
:ld-missing-input-ok ... ; nil, t, :warn, or warning message
:ld-pre-eval-filter ... ; :all, :query, or some new name
:ld-pre-eval-print ... ; nil, t, or :never
@@ -1124,10 +1122,6 @@
,ld-redefinition-action))
nil)
(list `(cons 'ld-prompt ,ld-prompt))
- (if ld-keyword-aliasesp
- (list `(cons 'ld-keyword-aliases
- ,ld-keyword-aliases))
- nil)
(if ld-missing-input-okp
(list `(cons 'ld-missing-input-ok ,ld-missing-input-ok))
nil)
@@ -8038,10 +8032,9 @@
; computation on behalf of disabled warnings.
(or (and summary
- (member-string-equal
+ (assoc-string-equal
summary
- (cdr (assoc-eq :inhibit-warnings
- (table-alist 'acl2-defaults-table wrld)))))
+ (table-alist 'inhibit-warnings-table wrld)))
; The above is sufficient to turn off (warning$ "string" ...). But even when
; the above condition isn't met, we turn off all warnings -- with the exception
@@ -9619,10 +9612,10 @@
(cond ((eq fn 'cons)
; We call this function on cons so often we optimize it.
'(nil))
- ((eq fn 'return-last)
+ ((member-eq fn '(if return-last))
(er hard! 'stobjs-out
"Implementation error: Attempted to find stobjs-out for ~x0."
- 'return-last))
+ fn))
(t (getprop fn 'stobjs-out '(nil) 'current-acl2-world w))))
; With stobjs-out defined, we can define user-defined-functions-table.
@@ -12279,8 +12272,9 @@
(defun sublis-var (alist form)
-; The two following comments come from the nqthm version of this
-; function and do not necessarily pertain to ACL2 (but see below).
+; Call this function with alist = nil to put form into quote-normal form so
+; that for example if form is (cons '1 '2) then '(1 . 2) is returned. The
+; following two comments come from the nqthm version of this function.
; In REWRITE-WITH-LEMMAS we use this function with the nil alist
; to put form into quote normal form. Do not optimize this
@@ -12291,9 +12285,8 @@
; However, even this function requires that form be at least a
; pseudo-termp.
-; Note however the comment from rewrite-with-lemma that says:
-; The sublis-var below normalizes the explicit constant
-; constructors in evaled-hyp, e.g., (cons '1 '2) becomes '(1 . 2).
+; We rely on quote-normal form for the return value, for example in calls of
+; sublis-var in rewrite-with-lemma and in apply-top-hints-clause1.
(declare (xargs :guard (and (symbol-alistp alist)
(pseudo-term-listp (strip-cdrs alist))
@@ -13507,39 +13500,70 @@
(defun ld-keyword-aliases (state)
- ":Doc-Section Miscellaneous
+ ":Doc-Section switches-parameters-and-modes
- allows the abbreviation of some keyword commands~/
+ abbreviation of some keyword commands~/
~bv[]
- Example:
+ Examples:
(set-ld-keyword-aliases '((:q 0 q-fn)
(:e 0 exit-acl2-macro))
state)
+ (ld-keyword-aliases state) ; current value of the ld-keyword-aliases table
~ev[]
- ~c[Ld-keyword-aliases] is an ~ilc[ld] special (~pl[ld]). The accessor
- is ~c[(ld-keyword-aliases state)] and the updater is
- ~c[(set-ld-keyword-aliases val state)]. ~c[Ld-keyword-aliases] must be an
- alist, each element of which is of the form ~c[(:keyword n fn)], where
- ~c[:keyword] is a keyword, ~c[n] is a nonnegative integer, and ~c[fn] is a
- function symbol of arity ~c[n], a macro symbol, or a ~c[lambda] expression
- of arity ~c[n]. When ~c[keyword] is typed as an ~ilc[ld] command, ~c[n] more forms
- are read, ~c[x1, ..., xn], and the form ~c[(fn 'x1 ... 'xn)] is then
- evaluated. The initial value of ~c[ld-keyword-aliases] is ~c[nil].
+ ~c[Ld-keyword-aliases] is the name of a ACL2 table (~pl[table]) and also the
+ name of a function of ~c[state] that returns the value of this table. That
+ value must be an alist, each element of which is of the form
+ ~c[(:keyword n fn)], where ~c[:keyword] is a keyword, ~c[n] is a nonnegative
+ integer, and ~c[fn] is a function symbol of arity ~c[n], a macro symbol, or a
+ ~c[lambda] expression of arity ~c[n]. When ~c[keyword] is typed as an
+ ~ilc[ld] command, ~c[n] more forms are read, ~c[x1, ..., xn], and the form
+ ~c[(fn 'x1 ... 'xn)] is then evaluated. The initial value of the
+ ~c[ld-keyword-aliases] ~il[table] is ~c[nil].
- In the example above, ~c[:]~ilc[q] has been redefined to have the effect of
- executing ~c[(q-fn)], so for example if you define
+ ACL2 provides functions to modify the ~c[ld-keyword-aliases] table, as
+ follows.
+ ~bq[]
+
+ ~c[(Set-ld-keyword-aliases val state)]: sets the table to ~c[val], which must
+ be a legal alist as described above. This is an event that may go into a
+ book (~pl[events]), but its effect will be ~il[local] to that book.
+
+ ~c[Set-ld-keyword-aliases!] is the same as ~c[set-ld-keyword-aliases], except
+ that its effect is not ~il[local]. Indeed, the form
+ ~c[(set-ld-keyword-aliases val state)] is equivalent to the form
+ ~c[(local (set-ld-keyword-aliases! val state)].
+
+ ~c[(Add-ld-keyword-alias key val state)]: modifies the table by binding the
+ keyword ~c[key] to ~c[val], which must be a legal value as described above.
+ This is an event that may go into a book (~pl[events]), but its effect will
+ be ~il[local] to that book.
+
+ ~c[Add-ld-keyword-alias!] is the same as ~c[add-ld-keyword-alias], except
+ that its effect is not ~il[local]. Indeed, the form
+ ~c[(add-ld-keyword-alias key val state)] is equivalent to the form
+ ~c[(local (add-ld-keyword-alias! key val state)].
+
+ ~eq[]
+ Consider the first example above:
+ ~bv[]
+ (set-ld-keyword-aliases '((:q 0 q-fn)
+ (:e 0 exit-acl2-macro))
+ state)
+ ~ev[]
+ With this event, ~c[:]~ilc[q] is redefined to have the effect of executing
+ ~c[(q-fn)], so for example if you have defined ~c[q-fn] with
~bv[]
(defmacro q-fn ()
'(er soft 'q \"You un-bound :q and now we have a soft error.\"))
~ev[]
- then ~c[:]~ilc[q] will cause an error, and if you define
+ then ~c[:]~ilc[q] will cause an error, and if you have defined
~bv[]
(defmacro exit-acl2-macro () '(exit-ld state))
~ev[]
then ~c[:e] will cause the effect (it so happens) that ~c[:]~ilc[q] normally
- has. If you prefer ~c[:e] to ~c[:]~ilc[q] for exiting the ACL2 loop, you might
- even want to put such definitions of ~c[q-fn] and ~c[exit-acl2-macro]
- together with the ~c[set-ld-keyword-aliases] form above in your
+ has. If you prefer ~c[:e] to ~c[:]~ilc[q] for exiting the ACL2 loop, you
+ might even want to put such definitions of ~c[q-fn] and ~c[exit-acl2-macro]
+ together with the ~c[set-ld-keyword-aliases] form above into your
~c[\"acl2-customization.lsp\"] file; ~pl[acl2-customization].~/
The general-purpose ACL2 read-eval-print loop, ~ilc[ld], reads forms from
@@ -13547,51 +13571,73 @@
However, there are various flags that control ~ilc[ld]'s behavior and
~c[ld-keyword-aliases] is one of them. ~c[Ld-keyword-aliases] affects how
keyword commands are parsed. Generally speaking, ~ilc[ld]'s command
- interpreter reads ``~c[:fn x1 ... xn]'' as ``~c[(fn 'x1 ... 'xn)]'' when ~c[:fn]
- is a keyword and ~c[fn] is the name of an ~c[n]-ary function;
+ interpreter reads ``~c[:fn x1 ... xn]'' as ``~c[(fn 'x1 ... 'xn)]'' when
+ ~c[:fn] is a keyword and ~c[fn] is the name of an ~c[n]-ary function;
~pl[keyword-commands]. But this parse is overridden, as described above, for
- the keywords bound in ~c[ld-keyword-aliases]."
+ the keywords bound in the ~c[ld-keyword-aliases] ~il[table]."
- (f-get-global 'ld-keyword-aliases state))
+ (table-alist 'ld-keyword-aliases (w state)))
-(defun ld-keyword-aliasesp (x wrld)
- (cond ((atom x) (null x))
- ((and (true-listp (car x))
- (= (length (car x)) 3))
- (let ((key (car (car x)))
- (n (cadr (car x)))
- (fn (caddr (car x))))
- (and (keywordp key)
- (integerp n)
- (>= n 0)
- (cond
- ((and (symbolp fn)
- (function-symbolp fn wrld))
- (equal (arity fn wrld) n))
- ((and (symbolp fn)
- (getprop fn 'macro-body nil
- 'current-acl2-world wrld))
- t)
- (t (and (true-listp fn)
- (>= (length fn) 3)
- (<= (length fn) 4)
- (eq (car fn) 'lambda)
- (arglistp (cadr fn))
- (int= (length (cadr fn)) n))))
- (ld-keyword-aliasesp (cdr x) wrld))))
- (t nil)))
+(defun ld-keyword-aliasesp (key val wrld)
+ (and (keywordp key)
+ (true-listp val)
+ (int= (length val) 2)
+ (let ((n (car val))
+ (fn (cadr val)))
+ (and (natp n)
+ (cond
+ ((and (symbolp fn)
+ (function-symbolp fn wrld))
+ (equal (arity fn wrld) n))
+ ((and (symbolp fn)
+ (getprop fn 'macro-body nil
+ 'current-acl2-world wrld))
+ t)
+ (t (and (true-listp fn)
+ (>= (length fn) 3)
+ (<= (length fn) 4)
+ (eq (car fn) 'lambda)
+ (arglistp (cadr fn))
+ (int= (length (cadr fn)) n))))))))
-(defun chk-ld-keyword-aliases (val ctx state)
- (cond ((ld-keyword-aliasesp val (w state))
- (value nil))
- (t (er soft ctx *ld-special-error* 'ld-keyword-aliases val))))
+(table ld-keyword-aliases nil nil
+ :guard
+ (ld-keyword-aliasesp key val world))
-(defun set-ld-keyword-aliases (val state)
- (er-progn
- (chk-ld-keyword-aliases val 'set-ld-keyword-aliases state)
- (pprogn
- (f-put-global 'ld-keyword-aliases val state)
- (value val))))
+#+acl2-loop-only
+(defmacro add-ld-keyword-alias! (key val)
+ `(state-global-let*
+ ((inhibit-output-lst (list* 'summary 'event (@ inhibit-output-lst))))
+ (progn (table ld-keyword-aliases ,key ,val)
+ (table ld-keyword-aliases))))
+
+#-acl2-loop-only
+(defmacro add-ld-keyword-alias! (key val)
+ (declare (ignore key val))
+ nil)
+
+(defmacro add-ld-keyword-alias (key val)
+ `(local (add-ld-keyword-alias! ,key ,val)))
+
+#+acl2-loop-only
+(defmacro set-ld-keyword-aliases! (alist)
+ `(state-global-let*
+ ((inhibit-output-lst (list* 'summary 'event (@ inhibit-output-lst))))
+ (progn (table ld-keyword-aliases nil ',alist :clear)
+ (table ld-keyword-aliases))))
+
+#-acl2-loop-only
+(defmacro set-ld-keyword-aliases! (alist)
+ (declare (ignore alist))
+ nil)
+
+(defmacro set-ld-keyword-aliases (alist &optional state)
+
+; We add state (optionally) just for backwards compatibility through
+; Version_6.2. We might eliminate it after Version_6.3.
+
+ (declare (ignore state))
+ `(local (set-ld-keyword-aliases! ,alist)))
(defun ld-missing-input-ok (state)
@@ -14862,7 +14908,7 @@
(or (eq *verbose-pstk* t)
(not (member-eq ',(car form) *verbose-pstk*))))
(setq *pstk-start-time-stack*
- (cons (get-internal-run-time) *pstk-start-time-stack*))
+ (cons (get-internal-time) *pstk-start-time-stack*))
(format t "~V@TCP~D> ~S~%"
(* 2 *pstk-level*)
*pstk-level*
@@ -14883,7 +14929,7 @@
(* 2 *pstk-level*)
*pstk-level*
',(car form)
- (/ (- (get-internal-run-time)
+ (/ (- (get-internal-time)
(pop *pstk-start-time-stack*))
(float internal-time-units-per-second))))
(setq *pstk-stack* (cdr *pstk-stack*))
diff -Nru acl2-6.2/bdd.lisp acl2-6.3/bdd.lisp
--- acl2-6.2/bdd.lisp 2013-06-06 16:30:52.000000000 +0000
+++ acl2-6.3/bdd.lisp 2013-09-29 21:27:51.000000000 +0000
@@ -1,4 +1,4 @@
-; ACL2 Version 6.2 -- A Computational Logic for Applicative Common Lisp
+; ACL2 Version 6.3 -- A Computational Logic for Applicative Common Lisp
; Copyright (C) 2013, Regents of the University of Texas
; This version of ACL2 is a descendent of ACL2 Version 1.9, Copyright
@@ -117,12 +117,7 @@
(cond ((< x ,(mx-id-bound))
(1+f x))
- (t (ifix
-
-; This use of ifix looks goofy, but the reason is that we want the compiler
-; to behave properly, and we have proclaimed (at least in GCL) that this
-; function returns a fixnum.
-
+ (t (the-fixnum ; the-fixnum call may help with proclaiming
(er-hard-val 0 'bdd
"Maximum id for bdds exceeded. Current maximum id is ~x0."
x)))))))
diff -Nru acl2-6.2/books/Makefile acl2-6.3/books/Makefile
--- acl2-6.2/books/Makefile 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/Makefile 2013-09-30 17:53:32.000000000 +0000
@@ -77,6 +77,10 @@
# - is optional and defaults to "all" when omitted,
# or names the target you want to build (see below).
+# Of course, the usual GNU make options are available. In particular,
+# -k is useful for causing make to keep going when an error is
+# encountered (but return a non-zero error status at the end).
+
# Major top-level targets:
# - `all' is the default
# - `everything' includes everything in `all' and also some slow books
@@ -100,6 +104,10 @@
# - ACL2_BOOK_DIRS
# Augments the targets with all targets that have a prefix among
# this list of strings.
+# - USE_QUICKLISP
+# Set this if you want to build Quicklisp (which is sort of like
+# CPAN or RubyGems but for Lisp). Required for certain books in
+# oslib.
# Jared Davis has summarized the improvements over the earlier
# Makefile as follows.
@@ -155,10 +163,18 @@
# default to simply (certify-book "foo" ? t)
# These instructions specify arguments to certify-book, for example:
# ; cert-flags: ? t :ttags :all
-# - Books that depend on ACL2(h), such as centaur/tutorial/alu16-book.lisp,
-# contain this line (or, a cert_param directive can be in the
-# .acl2 file that is consulted, as discussed above):
-# ; cert_param: (hons-only)
+# - In the following cases, books may be skipped in which case,
+# recursively, so are books that include such books, books that
+# include those parent books, and so on. In each case, the
+# indicated line may be placed either in the .lisp file or in the
+# .acl2 file that is consulted, as discussed above.
+# - Books that depend on ACL2(h), such as
+# centaur/tutorial/alu16-book.lisp, contain this line:
+# ; cert_param: (hons-only)
+# - Books that require glucose (a SAT solver) contain this line:
+# ; cert_param: (uses-glucose)
+# - Books that require quicklisp contain this line:
+# ; cert_param: (uses-quicklisp)
# - Two-pass certification is handled as follows, for example in
# books/make-event/stobj-test.acl2 (as indicated above, this can
# also go into the book instead of the relevant .acl2 file):
@@ -190,6 +206,18 @@
# should be something like: if you give a certify-book command, we use it;
# otherwise we generate one using the cert-flags.
+# BUILDING THE XDOC MANUAL
+
+# The xdoc manual is built in centaur/manual/, top page index.html, as
+# a byproduct of building centaur/doc.cert with ACL2(h) using
+# USE_QUICKLISP=1 on the `make' command line. This has been tested
+# using CCL on Linux, but may work for other OS/Lisp combinations.
+# See also centaur/README.html. ACL2(h) is required for that build of
+# the xdoc manual, because it is required for some of the books
+# included in centaur/doc.lisp. You can create a manual for your own
+# books using ACL2 or ACL2(h); see topic SAVE (parent topic XDOC) in
+# the xdoc manual, either in centaur/manual/ or on the web at
+# http://fv.centtech.com/acl2/latest/doc/.
# STATUS / TODO LIST / MISSING FEATURES / BOZOS:
#
@@ -218,7 +246,7 @@
##############################
ifneq ($(ACL2_JOBS), )
-$(error Error: variable ACL2_JOBS is obsolete (use -j instead); see :DOC book-makefiles)
+${error Error: variable ACL2_JOBS is obsolete -- use -j instead -- see :DOC book-makefiles }
endif # ifneq ($(ACL2_JOBS), )
ACL2 ?= acl2
@@ -236,6 +264,48 @@
.PHONY: all everything
all:
+QUICKLISP_DIR=centaur/quicklisp
+
+ifneq ($(USE_QUICKLISP), )
+
+$(QUICKLISP_DIR)/quicklisp.lisp:
+ @echo "Downloading Quicklisp"
+ @cd $(QUICKLISP_DIR); curl -O http://beta.quicklisp.org/quicklisp.lisp
+ @ls -l $(QUICKLISP_DIR)/quicklisp.lisp
+
+$(QUICKLISP_DIR)/setup.lisp: $(QUICKLISP_DIR)/quicklisp.lisp \
+ $(QUICKLISP_DIR)/install.lsp
+ @echo "Setting up Quicklisp"
+ @cd $(QUICKLISP_DIR); $(STARTJOB) -c "$(ACL2) < install.lsp &> install.out"
+ @ls -l $(QUICKLISP_DIR)/setup.lisp
+
+$(QUICKLISP_DIR)/top.cert: $(QUICKLISP_DIR)/setup.lisp \
+ $(QUICKLISP_DIR)/cert.acl2 \
+ tools/include-raw.cert
+
+
+all: $(QUICKLISP_DIR)/top.cert
+
+endif # USE_QUICKLISP
+
+# [Jared]: I moved these out of the USE_QUICKLISP section so that "make clean"
+# will always remove the quicklisp files if you have ever built with
+# USE_QUICKLISP before. The goal is to ensure that stale quicklisp files
+# aren't left around after a "make clean" by accident.
+
+.PHONY: quicklisp_clean
+
+quicklisp_clean:
+ @echo "Removing downloaded quicklisp files (if any)"
+ @cd $(QUICKLISP_DIR); rm -rf setup.lisp quicklisp.lisp asdf.lisp \
+ cache dists local-projects tmp install.out quicklisp Makefile-tmp
+
+clean: quicklisp_clean
+
+
+# Ensure that the following variable is simply expanded.
+ACL2_CUSTOM_TARGETS :=
+
##############################
### Section: Create auxiliary files (Makefile-xxx) and initial OK_CERTS
##############################
@@ -253,18 +323,26 @@
ifndef NO_RESCAN
-# In the following, we exclude centaur/quicklisp explicitly rather
-# than using the usual cert_pl_exclude file, because centaur/quicklisp
-# uses cert.pl to certify books. We exclude centaur/quicklisp
-# explicitly since when we do want to make it, it will use cert.pl and
-# hence we can't put a cert_pl_exclude file in that directory. Some
-# others we exclude because there are subdirectories and it's simply
-# easiest to stop at the root.
+# We skip the scan for excluded prefixes. This change was implemented
+# by Matt Kaufmann on 9/25/2013 as part of the process of fixing
+# ACL2(r) regressions. (Note that nonstd/Makefile includes this
+# Makefile.)
+ifneq ($(EXCLUDED_PREFIXES), )
+space = # just a space
+EGREP_EXTRA_EXCLUDE_STRING = |$(subst $(space) $(space),|,$(strip $(EXCLUDED_PREFIXES)))
+endif # ifneq ($(EXCLUDED_PREFIXES), )
+
+# We exclude centaur/quicklisp explicitly, instead of using a cert_pl_exclude
+# file, because when people actually install Quicklisp packages, it ends up
+# having subdirectories that we don't know about ahead of time. We exclude
+# some other directories because there are subdirectories and it's just easiest
+# to stop at the root.
$(info Scanning for books...)
REBUILD_MAKEFILE_BOOKS := $(shell \
rm -f Makefile-books; \
time find . -name "*.lisp" \
- | egrep -v '^(\./)?(interface|nonstd|centaur/quicklisp|clause-processors/SULFA|workshops/2003/kaufmann/support)' \
+ | egrep -v '^(\./)?(interface|nonstd|centaur/quicklisp|milawa|clause-processors/SULFA|workshops/2003/kaufmann/support|models/y86/$(EGREP_EXTRA_EXCLUDE_STRING))' \
+ | fgrep -v '.\#' \
> Makefile-books; \
ls -l Makefile-books)
#$(info $(REBUILD_MAKEFILE_BOOKS))
@@ -297,6 +375,15 @@
"$(ACL2) < cert_features.lsp &> Makefile-features.out" ;\
ls -l Makefile-features)
+$(info Determining whether Glucose is installed)
+# If glucose doesn't exist, then the error message saying it can't be
+# found is redirected to /dev/null, resulting in an empty value for
+# GLUCOSE_EXISTS
+GLUCOSE_EXISTS := $(shell glucose --version 2>/dev/null)
+ifdef GLUCOSE_EXISTS
+ OS_HAS_GLUCOSE := 1
+endif # ifdef GLUCOSE_EXISTS
+
# Only conditionally include Makefile-features, so that make clean works even
# if ACL2 isn't built.
-include Makefile-features
@@ -305,28 +392,102 @@
$(info ACL2_HAS_REALS := $(ACL2_HAS_REALS))
$(info ACL2_COMP_EXT := $(ACL2_COMP_EXT))
$(info ACL2_HOST_LISP := $(ACL2_HOST_LISP))
+$(info OS_HAS_GLUCOSE := $(OS_HAS_GLUCOSE))
+$(info USE_QUICKLISP := $(USE_QUICKLISP))
$(info Done with features.)
+# Cause error for illegal certification attempts:
+
+ifeq ($(ACL2_HAS_HONS), )
+
+$(CERT_PL_HONS_ONLY):
+ $(MAKE) no_hons_error NO_RESCAN=1 CERT_PL_HONS_ONLY_BOOK=$@
+
+.PHONY: no_hons_error
+no_hons_error:
+ @echo "Error! Target $(CERT_PL_HONS_ONLY_BOOK) requires hons."
+ @exit 1
+
+endif
+
+# End of "Cause error for illegal certification attempts".
+
OK_CERTS := $(CERT_PL_CERTS)
ifeq ($(ACL2_HAS_HONS), )
-# $(info Excluding books that depend on ACL2(h))
+# We use "{...}" delimeters to avoid errors in version 3.80 of make.
+${info Excluding books that need ACL2(h) [...]}
OK_CERTS := $(filter-out $(CERT_PL_HONS_ONLY), $(OK_CERTS))
endif # ifeq ($(ACL2_HAS_HONS), )
-# SLOW_BOOKS are books that are too slow to include as part of an
-# ordinary regression. There are currently comments in some of the
-# corresponding Makefiles that explain something about these books.
+ifeq ($(OS_HAS_GLUCOSE), )
-SLOW_BOOKS := \
+$(info Excluding books that need Glucose: [$(CERT_PL_USES_GLUCOSE)])
+OK_CERTS := $(filter-out $(CERT_PL_USES_GLUCOSE), $(OK_CERTS))
+
+endif # ifeq ($(OS_HAS_GLUCOSE), )
+
+ifeq ($(USE_QUICKLISP), )
+$(info Excluding books that depend on Quicklisp: [$(CERT_PL_USES_QUICKLISP)])
+OK_CERTS := $(filter-out $(CERT_PL_USES_QUICKLISP), $(OK_CERTS))
+endif
+
+# SLOW_BOOKS is a list of books that are too slow to include as part
+# of an ordinary regression. There are currently comments in some of
+# the corresponding Makefiles that explain something about these
+# books. WARNING: It is probably a bad idea to include targets here
+# that are in ACL2_CUSTOM_TARGETS: SLOW_BOOKS is removed from OK_CERTS
+# just below, but later, ACL2_CUSTOM_TARGETS adds its targets to
+# OK_CERTS.
+
+# Before defining SLOW_BOOKS, we define ADDED_BOOKS to be the books
+# that we want to add back in when using target "everything" instead
+# of the default target, "all".
+
+ADDED_BOOKS := \
coi/termination/assuming/complex.cert \
models/jvm/m5/apprentice.cert \
parallel/proofs/ideal-speedup.cert \
workshops/2009/sumners/support/examples.cert \
workshops/2011/krug-et-al/support/MinVisor/va-to-pa-thm.cert \
- workshops/2011/krug-et-al/support/MinVisor/setup-nested-page-tables.cert
+ workshops/2011/krug-et-al/support/MinVisor/setup-nested-page-tables.cert \
+ $(filter rtl/rel7/%, $(OK_CERTS))
+
+# The following has taken only a couple of minutes on a decent Linux
+# system in 2013. However, ACL2 built on GCL 2.6.8 and Mac OS 10.6
+# cannot complete the certification without running exhausting STRING
+# storage, probably because it contains a large stobj. So we certify
+# it only in "everything" regressions.
+
+ADDED_BOOKS += workshops/2013/hardin-hardin/support/APSP.cert
+
+# Now SLOW_BOOKS is defined as the list above, except that below, we
+# also include books that are too slow for both an ordinary regression
+# (target "all") and an "everything" regression.
+
+SLOW_BOOKS := $(ADDED_BOOKS)
+
+# Note that models/y86/ is already excluded in the setting of
+# REBUILD_MAKEFILE_BOOKS above, but these books are built if
+# models/y86-target.cert is included. File models/y86-target.lisp is
+# already labeled as hons-only, but even with ACL2(h) we want to
+# exclude some host Lisps. Certainly CCL can handle these books,
+# since it has significant optimizations for ACL2(h). But in one ANSI
+# GCL ACL2(h) regression, certification runs were still proceeding
+# after more than 10 hours for each of four books under models/y86/
+# (y86-basic/common/x86-state, y86-two-level/common/x86-state,
+# y86-two-level-abs/common/x86-state-concrete, and
+# y86-basic/py86/popcount), probably because of the demands of
+# def-gl-thm. Moreover, LispWorks has too small a value for
+# array-dimension-limit to support these certifications.
+
+ifeq ($(filter CCL ALLEGRO SBCL, $(ACL2_HOST_LISP)), )
+# When the Lisp is not one of those mentioned on the line above, we
+# skip the models/y86/ books.
+ SLOW_BOOKS += models/y86-target.cert
+endif
OK_CERTS := $(filter-out $(SLOW_BOOKS), $(OK_CERTS))
@@ -339,7 +500,6 @@
# script will remove things like .cert and .fasl files.
CLEAN_FILES_EXPLICIT := \
- xdoc-impl/bookdoc.dat \
Makefile-comp \
Makefile-comp-pre \
Makefile-deps \
@@ -351,7 +511,6 @@
nonstd/workshops/1999/calculus/book/tree.lisp
MORECLEAN_FILES_EXPLICIT := \
- xdoc-impl/manual \
centaur/manual
.PHONY: clean_books clean
@@ -362,13 +521,15 @@
# We test that directory centaur/quicklisp exists because it probably
# doesn't for nonstd/, and we include this makefile from that
-# directory.
+# directory. Also, we clean models/y86 explicitly, since
+# models/Makefile (from custom target models/y86-target.cert) doesn't
+# exist.
clean: clean_books
@echo "Removing extra, explicitly temporary files."
rm -rf $(CLEAN_FILES_EXPLICIT)
- for dir in centaur/quicklisp $(dir $(ACL2_CUSTOM_TARGETS)) ; \
+ for dir in $(dir $(ACL2_CUSTOM_TARGETS)) models/y86 ; \
do \
- if [ -d $$dir ] ; then \
+ if [ -f $$dir/Makefile ] ; then \
(cd $$dir ; $(MAKE) clean) ; \
fi ; \
done
@@ -383,20 +544,6 @@
# Next, we deal with books that need special handling.
-# xdoc-impl is tricky because we have to generate bookdoc.dat.
-
-xdoc-impl/bookdoc.dat: \
- xdoc-impl/acl2-customization.lsp \
- xdoc-impl/bookdoc.lsp \
- xdoc/package.lsp \
- $(wildcard xdoc/*.lisp) \
- $(wildcard xdoc-impl/*.lisp) \
- xdoc-impl/extra-packages.cert
- @echo "Making xdoc-impl/bookdoc.dat"
- @cd xdoc-impl; \
- $(STARTJOB) -c "$(ACL2) < bookdoc.lsp &> bookdoc.out"
- @ls -l xdoc-impl/bookdoc.dat
-
# We assume that ACL2_HAS_REALS indicates a regression being done in
# nonstd/.
ifeq ($(ACL2_HAS_REALS), )
@@ -474,16 +621,30 @@
# cert_pl_exclude file or else be explicitly excluded in the egrep
# command that is used to define REBUILD_MAKEFILE_BOOKS, above.
# Otherwise we might make the same file twice, would could cause
-# conflicts if -j is other than 1.
+# conflicts if -j is other than 1. Also: Do not include any targets,
+# such as models/y86-target.cert, that we don't always want built with
+# "all".
+
ACL2_CUSTOM_TARGETS := \
clause-processors/SULFA/target.cert \
fix-cert/fix-cert.cert \
+ translators/l3-to-acl2/target.cert \
workshops/1999/multiplier/proof.cert \
workshops/2003/greve-wilding-vanfleet/support/firewallworks.cert \
workshops/2003/kaufmann/support/input/defs-in.cert \
workshops/2004/sumners-ray/support/success.txt \
workshops/2011/verbeek-schmaltz/sources/correctness2.cert
+# Warning! For each target below, if there is a cert_pl_exclude file
+# in the directory or it is exluded explicitly by
+# REBUILD_MAKEFILE_BOOKS, and a "deps" file is used, then that "deps"
+# file should be placed in a different directory (that is not
+# excluded). For example, translators/l3-to-acl2/target.cert below
+# depends on translators/l3-to-acl2-deps.cert, for which dependencies
+# will be generated since there is no cert_pl_exclude file in
+# translators/ (even though there is a cert_pl_exclude in
+# translators/l3-to-acl2/).
+
# We only make the books under SULFA if a documented test for an
# installed SAT solver succeeds.
clause-processors/SULFA/target.cert: \
@@ -499,6 +660,18 @@
fix-cert/fix-cert.cert:
cd $(@D) ; $(STARTJOB) -c "$(MAKE)"
+# The following need not be made a custom target, since it's not in an
+# excluded directory. Note that we use -j 1 because of the
+# potentially large memory requirements.
+ifneq ($(ACL2_HAS_HONS), )
+models/y86-target.cert:
+ cd $(@D)/y86 ; $(STARTJOB) -c "$(MAKE) -j 1"
+endif
+
+translators/l3-to-acl2/target.cert: \
+ translators/l3-to-acl2-deps.cert
+ cd $(@D) ; $(STARTJOB) -c "$(MAKE) -j 1"
+
workshops/1999/multiplier/proof.cert: \
workshops/1999/deps-multiplier.cert
cd $(@D) ; $(STARTJOB) -c "$(MAKE)"
@@ -581,7 +754,7 @@
# its books.)
$(info For building compiled (.$(ACL2_COMP_EXT)) files, excluding centaur books)
OK_CERTS := $(filter-out centaur/%, \
- $(filter-out models/y86/%, \
+ $(filter-out models/y86%, \
$(OK_CERTS)))
ifndef NO_RESCAN
@@ -641,6 +814,9 @@
# The .acl2 files specify no compilation:
BOOKS_SKIP_COMP += $(patsubst %.cert, %.$(ACL2_COMP_EXT), $(wildcard workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/*.cert))
+# The .acl2 file specifies no compilation:
+BOOKS_SKIP_COMP += ccg/ccg.$(ACL2_COMP_EXT)
+
# Some .acl2 files specify no compilation, including ed3.acl2, and
# many books depend on ed3:
BOOKS_SKIP_COMP += $(patsubst %.cert, %.$(ACL2_COMP_EXT), $(wildcard workshops/2006/cowles-gamboa-euclid/Euclid/*.cert))
@@ -715,6 +891,10 @@
### Section: Exclude EXCLUDED_PREFIXES
##############################
+# It might no longer be necessary to filter out EXCLUDED_PREFIXES from
+# OK_CERTS, now that EGREP_EXTRA_EXCLUDE_STRING contributes to the
+# exclusion process, but we go ahead and do so here, for robustness.
+
OK_CERTS := $(filter-out $(addsuffix %, $(EXCLUDED_PREFIXES)), $(OK_CERTS))
##############################
@@ -746,57 +926,18 @@
# accordingly. Note that the pathnames in ACL2_BOOK_DIRS should be
# relative to the top-level books directory, not absolute pathnames.
-# So that ACL2_BOOK_CERTS is not recursive:
+# So that ACL2_BOOK_CERTS is not recursive (but don't set it to the
+# empty string, since it might be set on the command line!).
ACL2_BOOK_CERTS := $(ACL2_BOOK_CERTS)
ifneq ($(ACL2_BOOK_DIRS), )
$(info ACL2_BOOK_DIRS = $(ACL2_BOOK_DIRS))
ACL2_BOOK_DIRS_PATTERNS := $(addsuffix /%, $(ACL2_BOOK_DIRS))
-ACL2_BOOK_CERTS += $(ACL2_BOOK_CERTS) \
- $(filter $(ACL2_BOOK_DIRS_PATTERNS), $(OK_CERTS))
+ACL2_BOOK_CERTS += $(filter $(ACL2_BOOK_DIRS_PATTERNS), $(OK_CERTS))
endif # ifneq ($(ACL2_BOOK_DIRS), )
ifneq ($(ACL2_BOOK_CERTS), )
$(info ACL2_BOOK_CERTS = $(ACL2_BOOK_CERTS))
OK_CERTS := $(ACL2_BOOK_CERTS)
-else
-
-# Normal case, where neither ACL2_BOOK_DIRS nor ACL2_BOOK_CERTS is
-# defined:
-
-# We prefer not to certify books under the directories filtered out
-# just below, for the following reasons.
-# - rtl/rel7/: This directory isn't used anywhere else and it doesn't
-# add much from a regression perspective, given the other rtl/
-# subdirectories that are included in the regression.
-
-# However, we want cert.pl to scan within any such directory, to
-# support the "everything" target, so we avoid putting cert_pl_exclude
-# files in such a directory or excluding them from the egrep command
-# that is used to define REBUILD_MAKEFILE_BOOKS, above. Instead, we
-# exclude them from the "all" target now.
-
-OK_CERTS_EXCLUSIONS := $(filter rtl/rel7/%, $(OK_CERTS))
-
-ifneq ($(ACL2_HAS_HONS), )
-ifeq ($(filter CCL ALLEGRO SBCL, $(ACL2_HOST_LISP)), )
-
-# We exclude models/y86/ for ACL2(h) except for CCL, which has
-# significant optimizations for ACL2(h), and except for other Lisps
-# that we have observed to perform acceptably on certifying these
-# books. In an ANSI GCL ACL2(h) regression, certification runs were
-# still proceeding after more than 10 hours for each of four books
-# under models/y86/ (y86-basic/common/x86-state,
-# y86-two-level/common/x86-state,
-# y86-two-level-abs/common/x86-state-concrete, and
-# y86-basic/py86/popcount), probably because of the demands of
-# def-gl-thm. Moreover, LispWorks has too small a value for
-# array-dimension-limit to support these certifications.
-
-OK_CERTS_EXCLUSIONS += $(filter models/y86/%, $(OK_CERTS))
-endif # ifeq ($(ACL2_HOST_LISP), GCL)
-endif # ifneq ($(ACL2_HAS_HONS), )
-
-OK_CERTS := $(filter-out $(OK_CERTS_EXCLUSIONS), $(OK_CERTS))
endif # ifneq ($(ACL2_BOOK_CERTS), )
@@ -807,11 +948,14 @@
all: $(OK_CERTS)
-# OK_CERTS_EXCLUSIONS is undefined if ACL2_BOOK_CERTS is defined, but
-# that's not a problem; after all, in that case OK_CERTS wasn't
-# filtered by OK_CERTS_EXCLUSIONS. Besides, we don't intend to
-# support "everything" when ACL2_BOOK_CERTS is defined.
-everything: all $(OK_CERTS_EXCLUSIONS) $(SLOW_BOOKS)
+# It was tempting to handle the `everything' target as follows:
+# everything: USE_QUICKLISP = 1
+# everything: all $(ADDED_BOOKS)
+# But that didn't work, presumably because the value of OK_CERTS was
+# on a first pass through the Makefile without USE_QUICKLISP being
+# set.
+everything:
+ $(MAKE) all $(ADDED_BOOKS) USE_QUICKLISP=1
# The critical path report will work only if you have set up certificate timing
# BEFORE you build the books. See ./critpath.pl --help for details.
@@ -838,6 +982,8 @@
coi: $(filter coi/%, $(OK_CERTS))
+xdoc: $(filter xdoc/%, $(OK_CERTS))
+
workshops: $(filter workshops/%, $(OK_CERTS))
workshop1999: $(filter workshops/1999/%, $(OK_CERTS))
workshop2000: $(filter workshops/2000/%, $(OK_CERTS))
@@ -967,3 +1113,25 @@
# workshops/2003/greve-wilding-vanfleet/deps.cert
# workshops/2003/kaufmann/deps.cert
# workshops/2011/verbeek-schmaltz/deps.cert
+
+
+
+
+# VL Toolkit
+
+centaur/vl/bin/vl: centaur/vl/kit/top.cert
+ @echo "Making VL Verilog Toolkit executable"
+ @cd centaur/vl/kit; \
+ ACL2_CUSTOMIZATION=NONE $(STARTJOB) -c "$(ACL2) < save.lsp &> save.out"
+ @ls -la centaur/vl/bin/vl
+
+.PHONY: vl
+vl: centaur/vl/bin/vl
+
+.PHONY: clean_vl
+clean_vl:
+ @echo "Cleaning centaur/vl/bin directory"
+ @rm -f centaur/vl/bin/*
+
+clean: clean_vl
+
diff -Nru acl2-6.2/books/Makefile-big acl2-6.3/books/Makefile-big
--- acl2-6.2/books/Makefile-big 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/Makefile-big 1970-01-01 00:00:00.000000000 +0000
@@ -1,70 +0,0 @@
-
-
-######################################################################
-## NOTE. This file is not part of the standard ACL2 books build
-## process; it is part of an experimental build system that is not yet
-## intended, for example, to be capable of running the whole
-## regression. The ACL2 developers do not maintain this file.
-##
-## Please contact Jared Davis or Sol Swords
-## with any questions/comments.
-######################################################################
-
-# Copyright 2008 by Jared Davis and Sol Swords.
-# Credit to Matt Kaufmann and J Strother Moore for code from Makefile-generic.
-
-
-# This makefile is designed to support file-level dependencies among
-# ACL2 books. The make-all-deps.sh script produces a dependency file
-# called Makefile-alldeps reflecting the dependencies among all the
-# libraries that support this scheme.
-
-
-all:
-
-Makefile-alldeps:
- @echo "Running make-all-deps.sh" ;\
- bash make-all-deps.sh ;
-
-include Makefile-alldeps
-
-all: $(BOOKS)
-
-%.cert: %.lisp
- @echo "Making `pwd`/$*.cert on `date`" ;\
- DIR=`dirname $*` ;\
- FILE=`basename $*` ;\
- ACL2=`which $(ACL2)` ;\
- cd $$DIR ;\
- rm -f $$FILE.cert ;\
- echo '(acl2::value :q)' > workxxx.$$FILE ;\
- echo '(in-package "ACL2")' >> workxxx.$$FILE ;\
- echo '(acl2::lp)' >> workxxx.$$FILE ;\
- echo '$(INHIBIT)' >> workxxx.$$FILE ;\
- if [ -f $$FILE.acl2 ] ;\
- then \
- cat $$FILE.acl2 >> workxxx.$$FILE ;\
- elif [ -f cert.acl2 ] ;\
- then \
- cat cert.acl2 >> workxxx.$$FILE ;\
- echo "" >> workxxx.$$FILE ;\
- echo "(certify-book \"$$FILE\" ? t)" >> workxxx.$$FILE ;\
- else \
- echo "" >> workxxx.$$FILE ;\
- echo "(certify-book! \"$$FILE\" 0 t)" >> workxxx.$$FILE ;\
- fi ;\
- echo "" >> workxxx.$$FILE ;\
- echo '(acl2::value :q)' >> workxxx.$$FILE ;\
- echo '(acl2::exit-lisp)' >> workxxx.$$FILE ;\
- ($$ACL2 < workxxx.$$FILE 2>&1) > $$FILE.out ;\
- rm -f workxxx.$$FILE ;\
- ((test -f $$FILE.cert) && (ls -al $$FILE.cert)) || (echo "**CERTIFICATION FAILED** for `pwd`/$$FILE.lisp" ; exit 1)
-
-
-
-%.lisp:
- @echo "Trying to generate $*.lisp" ;\
- DIR=`dirname $*` ;\
- FILE=`basename $*` ;\
- cd $$DIR ;\
- $(MAKE) $$FILE.lisp
diff -Nru acl2-6.2/books/Makefile-fast acl2-6.3/books/Makefile-fast
--- acl2-6.2/books/Makefile-fast 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/Makefile-fast 1970-01-01 00:00:00.000000000 +0000
@@ -1,80468 +0,0 @@
-
-# This makefile was generated by running:
-# cert.pl -s Makefile-fast --targets regression-targets -b .
-
-# Cert.pl is a build system for ACL2 books. The cert.pl executable is
-# located under your ACL2_SYSTEM_BOOKS directory; run "cert.pl -h" for
-# usage options.
-
-
-ACL2_SYSTEM_BOOKS ?= .
-include $(ACL2_SYSTEM_BOOKS)/make_cert
-
-
-.PHONY: all-cert-pl-certs
-
-# Depends on all certificate files.
-all-cert-pl-certs:
-
-CERT_PL_CERTS := \
- arithmetic-2/floor-mod/floor-mod-helper.cert \
- arithmetic-2/floor-mod/floor-mod.cert \
- arithmetic-2/meta/cancel-terms-helper.cert \
- arithmetic-2/meta/cancel-terms-meta.cert \
- arithmetic-2/meta/collect-terms-meta.cert \
- arithmetic-2/meta/common-meta.cert \
- arithmetic-2/meta/expt-helper.cert \
- arithmetic-2/meta/expt.cert \
- arithmetic-2/meta/integerp-meta.cert \
- arithmetic-2/meta/integerp.cert \
- arithmetic-2/meta/mini-theories.cert \
- arithmetic-2/meta/non-linear.cert \
- arithmetic-2/meta/numerator-and-denominator.cert \
- arithmetic-2/meta/post.cert \
- arithmetic-2/meta/pre.cert \
- arithmetic-2/meta/top.cert \
- arithmetic-2/pass1/basic-arithmetic-helper.cert \
- arithmetic-2/pass1/basic-arithmetic.cert \
- arithmetic-2/pass1/expt-helper.cert \
- arithmetic-2/pass1/expt.cert \
- arithmetic-2/pass1/inequalities.cert \
- arithmetic-2/pass1/mini-theories.cert \
- arithmetic-2/pass1/numerator-and-denominator-helper.cert \
- arithmetic-2/pass1/numerator-and-denominator.cert \
- arithmetic-2/pass1/prefer-times.cert \
- arithmetic-2/pass1/top.cert \
- arithmetic-3/bind-free/arithmetic-theory.cert \
- arithmetic-3/bind-free/banner.cert \
- arithmetic-3/bind-free/basic-helper.cert \
- arithmetic-3/bind-free/basic.cert \
- arithmetic-3/bind-free/building-blocks.cert \
- arithmetic-3/bind-free/collect.cert \
- arithmetic-3/bind-free/common.cert \
- arithmetic-3/bind-free/default-hint.cert \
- arithmetic-3/bind-free/integerp-meta.cert \
- arithmetic-3/bind-free/integerp.cert \
- arithmetic-3/bind-free/mini-theories-helper.cert \
- arithmetic-3/bind-free/mini-theories.cert \
- arithmetic-3/bind-free/normalize.cert \
- arithmetic-3/bind-free/numerator-and-denominator.cert \
- arithmetic-3/bind-free/remove-weak-inequalities.cert \
- arithmetic-3/bind-free/simplify-helper.cert \
- arithmetic-3/bind-free/simplify.cert \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/extra/ext.cert \
- arithmetic-3/extra/top-ext.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- arithmetic-3/floor-mod/mod-expt-fast.cert \
- arithmetic-3/pass1/basic-arithmetic-helper.cert \
- arithmetic-3/pass1/basic-arithmetic.cert \
- arithmetic-3/pass1/expt-helper.cert \
- arithmetic-3/pass1/expt.cert \
- arithmetic-3/pass1/inequalities.cert \
- arithmetic-3/pass1/mini-theories.cert \
- arithmetic-3/pass1/non-linear.cert \
- arithmetic-3/pass1/num-and-denom-helper.cert \
- arithmetic-3/pass1/numerator-and-denominator.cert \
- arithmetic-3/pass1/prefer-times.cert \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/top.cert \
- arithmetic-5/lib/basic-ops/arithmetic-theory.cert \
- arithmetic-5/lib/basic-ops/banner.cert \
- arithmetic-5/lib/basic-ops/basic.cert \
- arithmetic-5/lib/basic-ops/building-blocks-helper.cert \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/collect.cert \
- arithmetic-5/lib/basic-ops/common.cert \
- arithmetic-5/lib/basic-ops/default-hint.cert \
- arithmetic-5/lib/basic-ops/distributivity.cert \
- arithmetic-5/lib/basic-ops/dynamic-e-d.cert \
- arithmetic-5/lib/basic-ops/elim-hint.cert \
- arithmetic-5/lib/basic-ops/expt-helper.cert \
- arithmetic-5/lib/basic-ops/expt.cert \
- arithmetic-5/lib/basic-ops/forcing-types.cert \
- arithmetic-5/lib/basic-ops/if-normalization.cert \
- arithmetic-5/lib/basic-ops/integerp-helper.cert \
- arithmetic-5/lib/basic-ops/integerp-meta.cert \
- arithmetic-5/lib/basic-ops/integerp.cert \
- arithmetic-5/lib/basic-ops/mini-theories.cert \
- arithmetic-5/lib/basic-ops/natp-posp.cert \
- arithmetic-5/lib/basic-ops/normalize.cert \
- arithmetic-5/lib/basic-ops/numerator-and-denominator.cert \
- arithmetic-5/lib/basic-ops/remove-weak-inequalities.cert \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.cert \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.cert \
- arithmetic-5/lib/basic-ops/simplify-helper.cert \
- arithmetic-5/lib/basic-ops/simplify.cert \
- arithmetic-5/lib/basic-ops/top.cert \
- arithmetic-5/lib/basic-ops/types-helper.cert \
- arithmetic-5/lib/basic-ops/types.cert \
- arithmetic-5/lib/basic-ops/we-are-here.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic-helper.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic.cert \
- arithmetic-5/lib/floor-mod/floor-mod-helper.cert \
- arithmetic-5/lib/floor-mod/floor-mod.cert \
- arithmetic-5/lib/floor-mod/forcing-types.cert \
- arithmetic-5/lib/floor-mod/if-normalization.cert \
- arithmetic-5/lib/floor-mod/logand-helper.cert \
- arithmetic-5/lib/floor-mod/logand.cert \
- arithmetic-5/lib/floor-mod/mod-expt-fast.cert \
- arithmetic-5/lib/floor-mod/more-floor-mod.cert \
- arithmetic-5/lib/floor-mod/top.cert \
- arithmetic-5/lib/floor-mod/truncate-rem.cert \
- arithmetic-5/support/basic-arithmetic-helper.cert \
- arithmetic-5/support/basic-arithmetic.cert \
- arithmetic-5/support/expt-helper.cert \
- arithmetic-5/support/expt.cert \
- arithmetic-5/support/inequalities.cert \
- arithmetic-5/support/mini-theories.cert \
- arithmetic-5/support/non-linear.cert \
- arithmetic-5/support/num-and-denom-helper.cert \
- arithmetic-5/support/numerator-and-denominator.cert \
- arithmetic-5/support/prefer-times.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/top.cert \
- arithmetic/abs.cert \
- arithmetic/binomial.cert \
- arithmetic/equalities.cert \
- arithmetic/factorial.cert \
- arithmetic/idiv.cert \
- arithmetic/inequalities.cert \
- arithmetic/mod-gcd.cert \
- arithmetic/nat-listp.cert \
- arithmetic/natp-posp.cert \
- arithmetic/rational-listp.cert \
- arithmetic/rationals.cert \
- arithmetic/sumlist.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top.cert \
- bdd/alu-proofs.cert \
- bdd/alu.cert \
- bdd/bdd-primitives.cert \
- bdd/bool-ops.cert \
- bdd/cbf.cert \
- bdd/hamming.cert \
- bdd/pg-theory.cert \
- centaur/4v-sexpr/4v-logic.cert \
- centaur/4v-sexpr/bitspecs.cert \
- centaur/4v-sexpr/compose-sexpr.cert \
- centaur/4v-sexpr/g-sexpr-eval.cert \
- centaur/4v-sexpr/nsexprs.cert \
- centaur/4v-sexpr/onehot-rewrite.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-3v.cert \
- centaur/4v-sexpr/sexpr-advanced.cert \
- centaur/4v-sexpr/sexpr-building.cert \
- centaur/4v-sexpr/sexpr-equivs.cert \
- centaur/4v-sexpr/sexpr-eval.cert \
- centaur/4v-sexpr/sexpr-fixpoint-correct.cert \
- centaur/4v-sexpr/sexpr-fixpoint-rewriting.cert \
- centaur/4v-sexpr/sexpr-fixpoint-spec.cert \
- centaur/4v-sexpr/sexpr-fixpoint-top.cert \
- centaur/4v-sexpr/sexpr-fixpoint.cert \
- centaur/4v-sexpr/sexpr-loop-debug.cert \
- centaur/4v-sexpr/sexpr-rewrites.cert \
- centaur/4v-sexpr/sexpr-to-faig.cert \
- centaur/4v-sexpr/sexpr-vars-1pass.cert \
- centaur/4v-sexpr/sexpr-vars.cert \
- centaur/4v-sexpr/svarmap.cert \
- centaur/4v-sexpr/top.cert \
- centaur/aig/aig-equivs.cert \
- centaur/aig/aig-vars-ext.cert \
- centaur/aig/aig-vars.cert \
- centaur/aig/aiger.cert \
- centaur/aig/base.cert \
- centaur/aig/bddify-correct.cert \
- centaur/aig/bddify.cert \
- centaur/aig/eval-restrict.cert \
- centaur/aig/g-aig-eval.cert \
- centaur/aig/induction.cert \
- centaur/aig/misc.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/three-four.cert \
- centaur/aig/vuaig.cert \
- centaur/aig/witness.cert \
- centaur/bitops/bits-between.cert \
- centaur/bitops/bitsets-opt.cert \
- centaur/bitops/bitsets.cert \
- centaur/bitops/congruences.cert \
- centaur/bitops/equal-by-logbitp.cert \
- centaur/bitops/extra-defs.cert \
- centaur/bitops/ihs-extensions.cert \
- centaur/bitops/ihsext-basics.cert \
- centaur/bitops/install-bit.cert \
- centaur/bitops/integer-length.cert \
- centaur/bitops/part-select.cert \
- centaur/bitops/rotate.cert \
- centaur/bitops/sbitsets.cert \
- centaur/bitops/sign-extend.cert \
- centaur/bitops/top.cert \
- centaur/bridge/portcullis.cert \
- centaur/bridge/to-json.cert \
- centaur/bridge/top.cert \
- centaur/defrstobj/array-lemmas.cert \
- centaur/defrstobj/basic-tests.cert \
- centaur/defrstobj/def-typed-record.cert \
- centaur/defrstobj/defrstobj.cert \
- centaur/defrstobj/fancy-worseguy.cert \
- centaur/defrstobj/g-delete-keys.cert \
- centaur/defrstobj/groundwork/array-rec.cert \
- centaur/defrstobj/groundwork/demo1.cert \
- centaur/defrstobj/groundwork/demo2.cert \
- centaur/defrstobj/groundwork/demo3.cert \
- centaur/defrstobj/groundwork/demo4.cert \
- centaur/defrstobj/groundwork/demo5.cert \
- centaur/defrstobj/groundwork/local.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/typed-record-tests.cert \
- centaur/defrstobj/typed-records.cert \
- centaur/esim/esim-paths.cert \
- centaur/esim/esim-primitives.cert \
- centaur/esim/esim-sexpr-correct.cert \
- centaur/esim/esim-sexpr-support-thms.cert \
- centaur/esim/esim-sexpr-support.cert \
- centaur/esim/esim-sexpr.cert \
- centaur/esim/esim-spec.cert \
- centaur/esim/esim-vcd.cert \
- centaur/esim/esim-vl.cert \
- centaur/esim/follow-backwards.cert \
- centaur/esim/local-theory.cert \
- centaur/esim/plist.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/steps.cert \
- centaur/esim/stv/stv-compile.cert \
- centaur/esim/stv/stv-debug.cert \
- centaur/esim/stv/stv-doc.cert \
- centaur/esim/stv/stv-expand.cert \
- centaur/esim/stv/stv-run.cert \
- centaur/esim/stv/stv-sim.cert \
- centaur/esim/stv/stv-top.cert \
- centaur/esim/stv/stv-util.cert \
- centaur/esim/stv/stv-widen.cert \
- centaur/gl/always-equal-prep.cert \
- centaur/gl/auto-bindings.cert \
- centaur/gl/bfr-aig-bddify.cert \
- centaur/gl/bfr-sat.cert \
- centaur/gl/bfr.cert \
- centaur/gl/bvec-ite.cert \
- centaur/gl/bvecs.cert \
- centaur/gl/def-gl-clause-proc.cert \
- centaur/gl/defagg.cert \
- centaur/gl/defapply.cert \
- centaur/gl/eval-f-i-cp.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/factor-fns.cert \
- centaur/gl/g-always-equal.cert \
- centaur/gl/g-ash.cert \
- centaur/gl/g-binary-+.cert \
- centaur/gl/g-binary-mult.cert \
- centaur/gl/g-code-char.cert \
- centaur/gl/g-coerce.cert \
- centaur/gl/g-cons.cert \
- centaur/gl/g-equal.cert \
- centaur/gl/g-floor.cert \
- centaur/gl/g-gl-mbe.cert \
- centaur/gl/g-hide.cert \
- centaur/gl/g-if.cert \
- centaur/gl/g-integer-length.cert \
- centaur/gl/g-intern.cert \
- centaur/gl/g-lessthan.cert \
- centaur/gl/g-logand.cert \
- centaur/gl/g-logbitp.cert \
- centaur/gl/g-logior.cert \
- centaur/gl/g-lognot.cert \
- centaur/gl/g-make-fast-alist.cert \
- centaur/gl/g-mod.cert \
- centaur/gl/g-predicates.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/g-rem.cert \
- centaur/gl/g-truncate.cert \
- centaur/gl/g-unary--.cert \
- centaur/gl/g-unary-concrete.cert \
- centaur/gl/general-object-thms.cert \
- centaur/gl/general-objects.cert \
- centaur/gl/generic-geval.cert \
- centaur/gl/gify-clause-proc.cert \
- centaur/gl/gify-thms.cert \
- centaur/gl/gify.cert \
- centaur/gl/gl-doc-string.cert \
- centaur/gl/gl-generic-clause-proc.cert \
- centaur/gl/gl-mbe.cert \
- centaur/gl/gl-misc-defs.cert \
- centaur/gl/gl-misc-doc.cert \
- centaur/gl/gl-util.cert \
- centaur/gl/gl.cert \
- centaur/gl/glcp-templates.cert \
- centaur/gl/gobject-type-thms.cert \
- centaur/gl/gobject-types.cert \
- centaur/gl/gobjectp-thms.cert \
- centaur/gl/gobjectp.cert \
- centaur/gl/gtests.cert \
- centaur/gl/gtype-thms.cert \
- centaur/gl/gtypes.cert \
- centaur/gl/hyp-fix-logic.cert \
- centaur/gl/hyp-fix.cert \
- centaur/gl/ite-merge.cert \
- centaur/gl/param.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/run-gified-cp.cert \
- centaur/gl/rws.cert \
- centaur/gl/shape-spec.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/misc/absstobjs.cert \
- centaur/misc/alist-defs.cert \
- centaur/misc/alist-equiv.cert \
- centaur/misc/alist-witness.cert \
- centaur/misc/ap.cert \
- centaur/misc/arith-equivs.cert \
- centaur/misc/context-rw.cert \
- centaur/misc/defapply.cert \
- centaur/misc/dfs-measure.cert \
- centaur/misc/equal-by-nths.cert \
- centaur/misc/equal-sets.cert \
- centaur/misc/evaluator-metatheorems.cert \
- centaur/misc/fal-graphs.cert \
- centaur/misc/fast-alists.cert \
- centaur/misc/filter-alist.cert \
- centaur/misc/hons-alphorder-merge.cert \
- centaur/misc/hons-extra.cert \
- centaur/misc/hons-remove-dups.cert \
- centaur/misc/hons-sets.cert \
- centaur/misc/interp-function-lookup.cert \
- centaur/misc/introduce-var.cert \
- centaur/misc/lists.cert \
- centaur/misc/load-stobj-tests.cert \
- centaur/misc/load-stobj.cert \
- centaur/misc/memory-mgmt-logic.cert \
- centaur/misc/memory-mgmt-raw.cert \
- centaur/misc/mfc-utils.cert \
- centaur/misc/nat-list-duplicates.cert \
- centaur/misc/numlist.cert \
- centaur/misc/osets-witnessing.cert \
- centaur/misc/patterns.cert \
- centaur/misc/seed-random.cert \
- centaur/misc/smm-impl.cert \
- centaur/misc/smm.cert \
- centaur/misc/sneaky-load.cert \
- centaur/misc/suffixp.cert \
- centaur/misc/tailrec.cert \
- centaur/misc/top.cert \
- centaur/misc/tshell.cert \
- centaur/misc/tuplep.cert \
- centaur/misc/u32-listp.cert \
- centaur/misc/universal-equiv.cert \
- centaur/misc/vecs-ints.cert \
- centaur/misc/witness-cp.cert \
- centaur/ubdds/core.cert \
- centaur/ubdds/extra-operations.cert \
- centaur/ubdds/lite.cert \
- centaur/ubdds/param.cert \
- centaur/ubdds/sanity-check-macros.cert \
- centaur/ubdds/subset.cert \
- centaur/ubdds/witness.cert \
- centaur/vl/checkers/checkers.cert \
- centaur/vl/checkers/condcheck.cert \
- centaur/vl/checkers/dupeinst-check.cert \
- centaur/vl/checkers/duperhs.cert \
- centaur/vl/checkers/duplicate-detect.cert \
- centaur/vl/checkers/leftright.cert \
- centaur/vl/checkers/multidrive-detect.cert \
- centaur/vl/checkers/oddexpr.cert \
- centaur/vl/checkers/portcheck.cert \
- centaur/vl/checkers/qmarksize-check.cert \
- centaur/vl/checkers/selfassigns.cert \
- centaur/vl/checkers/skip-detect.cert \
- centaur/vl/checkers/typo-detect.cert \
- centaur/vl/checkers/use-set-report.cert \
- centaur/vl/checkers/use-set-tool.cert \
- centaur/vl/checkers/use-set.cert \
- centaur/vl/lint/bit-use-set.cert \
- centaur/vl/lint/check-case.cert \
- centaur/vl/lint/check-namespace.cert \
- centaur/vl/lint/disconnected.cert \
- centaur/vl/lint/lint.cert \
- centaur/vl/lint/use-set-ignore.cert \
- centaur/vl/lint/xf-drop-missing-submodules.cert \
- centaur/vl/lint/xf-drop-unresolved-submodules.cert \
- centaur/vl/lint/xf-lint-stmt-rewrite.cert \
- centaur/vl/lint/xf-remove-toohard.cert \
- centaur/vl/lint/xf-suppress-warnings.cert \
- centaur/vl/lint/xf-undefined-names.cert \
- centaur/vl/loader/defines.cert \
- centaur/vl/loader/filemap.cert \
- centaur/vl/loader/find-file.cert \
- centaur/vl/loader/inject-comments.cert \
- centaur/vl/loader/lexer-tests.cert \
- centaur/vl/loader/lexer-tokens.cert \
- centaur/vl/loader/lexer-utils.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/loader/loader.cert \
- centaur/vl/loader/make-implicit-wires.cert \
- centaur/vl/loader/overrides.cert \
- centaur/vl/loader/parse-blockitems.cert \
- centaur/vl/loader/parse-delays.cert \
- centaur/vl/loader/parse-error.cert \
- centaur/vl/loader/parse-eventctrl.cert \
- centaur/vl/loader/parse-expressions-def.cert \
- centaur/vl/loader/parse-expressions-eof.cert \
- centaur/vl/loader/parse-expressions-error.cert \
- centaur/vl/loader/parse-expressions-progress.cert \
- centaur/vl/loader/parse-expressions-result.cert \
- centaur/vl/loader/parse-expressions-tokenlist.cert \
- centaur/vl/loader/parse-expressions-warnings.cert \
- centaur/vl/loader/parse-expressions.cert \
- centaur/vl/loader/parse-functions.cert \
- centaur/vl/loader/parse-gates.cert \
- centaur/vl/loader/parse-insts.cert \
- centaur/vl/loader/parse-lvalues.cert \
- centaur/vl/loader/parse-modules.cert \
- centaur/vl/loader/parse-nets.cert \
- centaur/vl/loader/parse-ports.cert \
- centaur/vl/loader/parse-ranges.cert \
- centaur/vl/loader/parse-statements-def.cert \
- centaur/vl/loader/parse-statements-error.cert \
- centaur/vl/loader/parse-statements-progress.cert \
- centaur/vl/loader/parse-statements-result.cert \
- centaur/vl/loader/parse-statements-tokenlist.cert \
- centaur/vl/loader/parse-statements-warninglist.cert \
- centaur/vl/loader/parse-statements.cert \
- centaur/vl/loader/parse-strengths.cert \
- centaur/vl/loader/parse-utils.cert \
- centaur/vl/loader/parser.cert \
- centaur/vl/loader/preprocessor-tests.cert \
- centaur/vl/loader/preprocessor.cert \
- centaur/vl/loader/read-file.cert \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/mlib/atts.cert \
- centaur/vl/mlib/clean-concats.cert \
- centaur/vl/mlib/comment-writer.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/mlib/ctxexprs.cert \
- centaur/vl/mlib/delta.cert \
- centaur/vl/mlib/expr-building.cert \
- centaur/vl/mlib/expr-parse.cert \
- centaur/vl/mlib/expr-slice.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/filter.cert \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/mlib/find-module.cert \
- centaur/vl/mlib/fmt.cert \
- centaur/vl/mlib/hid-tools.cert \
- centaur/vl/mlib/hierarchy.cert \
- centaur/vl/mlib/lvalues-mentioning.cert \
- centaur/vl/mlib/lvalues.cert \
- centaur/vl/mlib/modname-sets.cert \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/mlib/namemangle.cert \
- centaur/vl/mlib/port-tools.cert \
- centaur/vl/mlib/print-context.cert \
- centaur/vl/mlib/print-warnings.cert \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/mlib/relocate.cert \
- centaur/vl/mlib/remove-bad.cert \
- centaur/vl/mlib/rvalues.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/mlib/sub-counts.cert \
- centaur/vl/mlib/warnings.cert \
- centaur/vl/mlib/welltyped.cert \
- centaur/vl/mlib/writer.cert \
- centaur/vl/onehot.cert \
- centaur/vl/parsetree.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/primitives.cert \
- centaur/vl/toe/toe-add-res-modules.cert \
- centaur/vl/toe/toe-add-zdrivers.cert \
- centaur/vl/toe/toe-emodwire.cert \
- centaur/vl/toe/toe-eocc-allnames.cert \
- centaur/vl/toe/toe-preliminary.cert \
- centaur/vl/toe/toe-top.cert \
- centaur/vl/toe/toe-verilogify.cert \
- centaur/vl/toe/toe-wirealist.cert \
- centaur/vl/top.cert \
- centaur/vl/transforms/always/conditions.cert \
- centaur/vl/transforms/always/elimalways.cert \
- centaur/vl/transforms/always/eliminitial.cert \
- centaur/vl/transforms/always/elimnegedge.cert \
- centaur/vl/transforms/always/flopcode-debug.cert \
- centaur/vl/transforms/always/flopcode-prog.cert \
- centaur/vl/transforms/always/flopcode-synth.cert \
- centaur/vl/transforms/always/ifmerge.cert \
- centaur/vl/transforms/always/latchcode.cert \
- centaur/vl/transforms/always/make-flop.cert \
- centaur/vl/transforms/always/make-latch.cert \
- centaur/vl/transforms/always/stmtrewrite.cert \
- centaur/vl/transforms/always/stmttemps.cert \
- centaur/vl/transforms/always/synthalways.cert \
- centaur/vl/transforms/always/top.cert \
- centaur/vl/transforms/always/unelse.cert \
- centaur/vl/transforms/always/util.cert \
- centaur/vl/transforms/cn-hooks.cert \
- centaur/vl/transforms/occform/add.cert \
- centaur/vl/transforms/occform/compare.cert \
- centaur/vl/transforms/occform/div.cert \
- centaur/vl/transforms/occform/mul.cert \
- centaur/vl/transforms/occform/select.cert \
- centaur/vl/transforms/occform/shl.cert \
- centaur/vl/transforms/occform/shr.cert \
- centaur/vl/transforms/occform/simple.cert \
- centaur/vl/transforms/occform/top.cert \
- centaur/vl/transforms/occform/util.cert \
- centaur/vl/transforms/occform/xdet.cert \
- centaur/vl/transforms/xf-addinstnames.cert \
- centaur/vl/transforms/xf-annotate-mods.cert \
- centaur/vl/transforms/xf-argresolve.cert \
- centaur/vl/transforms/xf-array-indexing.cert \
- centaur/vl/transforms/xf-assign-trunc.cert \
- centaur/vl/transforms/xf-blankargs.cert \
- centaur/vl/transforms/xf-clean-params.cert \
- centaur/vl/transforms/xf-clean-selects.cert \
- centaur/vl/transforms/xf-delayredux.cert \
- centaur/vl/transforms/xf-designregs.cert \
- centaur/vl/transforms/xf-designwires.cert \
- centaur/vl/transforms/xf-drop-blankports.cert \
- centaur/vl/transforms/xf-elim-supply.cert \
- centaur/vl/transforms/xf-expand-functions.cert \
- centaur/vl/transforms/xf-expr-simp.cert \
- centaur/vl/transforms/xf-expr-split.cert \
- centaur/vl/transforms/xf-follow-hids.cert \
- centaur/vl/transforms/xf-gate-elim.cert \
- centaur/vl/transforms/xf-gateredux.cert \
- centaur/vl/transforms/xf-gatesplit.cert \
- centaur/vl/transforms/xf-hid-elim.cert \
- centaur/vl/transforms/xf-inline.cert \
- centaur/vl/transforms/xf-oprewrite.cert \
- centaur/vl/transforms/xf-optimize-rw.cert \
- centaur/vl/transforms/xf-orig.cert \
- centaur/vl/transforms/xf-portdecl-sign.cert \
- centaur/vl/transforms/xf-propagate.cert \
- centaur/vl/transforms/xf-replicate-insts.cert \
- centaur/vl/transforms/xf-resolve-ranges.cert \
- centaur/vl/transforms/xf-sizing.cert \
- centaur/vl/transforms/xf-subst.cert \
- centaur/vl/transforms/xf-unparameterize.cert \
- centaur/vl/transforms/xf-unused-reg.cert \
- centaur/vl/transforms/xf-weirdint-elim.cert \
- centaur/vl/translation.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/bits.cert \
- centaur/vl/util/character-list-listp.cert \
- centaur/vl/util/clean-alist.cert \
- centaur/vl/util/commentmap.cert \
- centaur/vl/util/cw-unformatted.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/util/defs.cert \
- centaur/vl/util/defwellformed.cert \
- centaur/vl/util/echars.cert \
- centaur/vl/util/esim-lemmas.cert \
- centaur/vl/util/gc.cert \
- centaur/vl/util/intersectp-equal.cert \
- centaur/vl/util/namedb.cert \
- centaur/vl/util/nat-alists.cert \
- centaur/vl/util/next-power-of-2.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/util/position.cert \
- centaur/vl/util/prefix-hash.cert \
- centaur/vl/util/prefixp.cert \
- centaur/vl/util/print-htmlencode.cert \
- centaur/vl/util/print-urlencode.cert \
- centaur/vl/util/print.cert \
- centaur/vl/util/string-alists.cert \
- centaur/vl/util/subsetp-equal.cert \
- centaur/vl/util/sum-nats.cert \
- centaur/vl/util/toposort.cert \
- centaur/vl/util/warnings.cert \
- centaur/vl/wf-ranges-resolved-p.cert \
- centaur/vl/wf-reasonable-p.cert \
- centaur/vl/wf-widthsfixed-p.cert \
- clause-processors/autohide.cert \
- clause-processors/basic-examples.cert \
- clause-processors/bv-add-common.cert \
- clause-processors/bv-add-tests.cert \
- clause-processors/bv-add.cert \
- clause-processors/decomp-hint.cert \
- clause-processors/equality.cert \
- clause-processors/ev-find-rules.cert \
- clause-processors/ev-theoremp.cert \
- clause-processors/find-subterms.cert \
- clause-processors/generalize.cert \
- clause-processors/instantiate.cert \
- clause-processors/join-thms.cert \
- clause-processors/just-expand.cert \
- clause-processors/meta-extract-simple-test.cert \
- clause-processors/meta-extract-user.cert \
- clause-processors/multi-env-trick.cert \
- clause-processors/null-fail-hints.cert \
- clause-processors/nvalues-thms.cert \
- clause-processors/replace-defined-consts.cert \
- clause-processors/replace-impl.cert \
- clause-processors/stobj-preservation.cert \
- clause-processors/sublis-var-meaning.cert \
- clause-processors/term-patterns.cert \
- clause-processors/unify-subst.cert \
- clause-processors/use-by-hint.cert \
- clause-processors/witness-cp.cert \
- coi/adviser/adviser-pkg.cert \
- coi/adviser/adviser.cert \
- coi/adviser/test.cert \
- coi/alists/alist-pkg.cert \
- coi/alists/bindequiv.cert \
- coi/alists/clearkey.cert \
- coi/alists/deshadow.cert \
- coi/alists/equiv.cert \
- coi/alists/keyquiv.cert \
- coi/alists/preimage.cert \
- coi/alists/strip.cert \
- coi/alists/subkeyquiv.cert \
- coi/alists/top.cert \
- coi/bags/basic.cert \
- coi/bags/bind-free-rules.cert \
- coi/bags/cons.cert \
- coi/bags/eric-meta.cert \
- coi/bags/extras.cert \
- coi/bags/meta.cert \
- coi/bags/neq.cert \
- coi/bags/pick-a-point.cert \
- coi/bags/top.cert \
- coi/bags/two-level-meta.cert \
- coi/bags/two-level.cert \
- coi/defpun/ack.cert \
- coi/defpun/defminterm.cert \
- coi/defpun/defpun.cert \
- coi/defpun/defxch.cert \
- coi/defstructure/defstructure-pkg.cert \
- coi/defstructure/defstructure.cert \
- coi/dtrees/base.cert \
- coi/dtrees/child.cert \
- coi/dtrees/deps.cert \
- coi/dtrees/equiv.cert \
- coi/dtrees/erase.cert \
- coi/dtrees/leafp.cert \
- coi/dtrees/raw.cert \
- coi/dtrees/royalp.cert \
- coi/dtrees/set.cert \
- coi/dtrees/top.cert \
- coi/gacc/abstract-gacc.cert \
- coi/gacc/addr-range.cert \
- coi/gacc/bits.cert \
- coi/gacc/block.cert \
- coi/gacc/finite.cert \
- coi/gacc/fr-path-connection.cert \
- coi/gacc/gacc-exports.cert \
- coi/gacc/gacc-pkg.cert \
- coi/gacc/gacc.cert \
- coi/gacc/gacc2.cert \
- coi/gacc/gacc3.cert \
- coi/gacc/gax.cert \
- coi/gacc/list-ops-common.cert \
- coi/gacc/list-ops-fast.cert \
- coi/gacc/list-ops.cert \
- coi/gacc/mem-fast.cert \
- coi/gacc/mem.cert \
- coi/gacc/ram.cert \
- coi/gacc/ram0.cert \
- coi/gacc/ram2.cert \
- coi/gacc/ram2b.cert \
- coi/gacc/ram3.cert \
- coi/gacc/top.cert \
- coi/gacc/tr-path-connection.cert \
- coi/gacc/wrap.cert \
- coi/generalize/generalize.cert \
- coi/gensym/gensym-list.cert \
- coi/gensym/gensym.cert \
- coi/lists/acl2-count.cert \
- coi/lists/basic.cert \
- coi/lists/disjoint.cert \
- coi/lists/find-index.cert \
- coi/lists/list-top.cert \
- coi/lists/listset-induction.cert \
- coi/lists/map-cons.cert \
- coi/lists/memberp.cert \
- coi/lists/mixed.cert \
- coi/lists/mv-nth.cert \
- coi/lists/nth-and-update-nth.cert \
- coi/lists/nth-meta.cert \
- coi/lists/nth-meta2.cert \
- coi/lists/remove-induction.cert \
- coi/lists/remove.cert \
- coi/lists/repeat.cert \
- coi/lists/set.cert \
- coi/lists/subsetp.cert \
- coi/lists/update-nth-array.cert \
- coi/maps/aliases.cert \
- coi/maps/maps.cert \
- coi/maps/typed-maps.cert \
- coi/nary/example.cert \
- coi/nary/nary.cert \
- coi/nary/nth-rules.cert \
- coi/nary/ordinal-order.cert \
- coi/nary/rewrite-equal-hint.cert \
- coi/osets/computed-hints.cert \
- coi/osets/conversions.cert \
- coi/osets/extras.cert \
- coi/osets/fast.cert \
- coi/osets/instance.cert \
- coi/osets/listsets.cert \
- coi/osets/map.cert \
- coi/osets/membership.cert \
- coi/osets/multiappend.cert \
- coi/osets/multicons.cert \
- coi/osets/outer.cert \
- coi/osets/primitives.cert \
- coi/osets/quantify.cert \
- coi/osets/set-order.cert \
- coi/osets/set-processor.cert \
- coi/osets/sets.cert \
- coi/osets/sort.cert \
- coi/paths/compatibility.cert \
- coi/paths/cp-set.cert \
- coi/paths/defs.cert \
- coi/paths/diverge.cert \
- coi/paths/dominates.cert \
- coi/paths/equiv.cert \
- coi/paths/hints.cert \
- coi/paths/list-path-connection.cert \
- coi/paths/meta.cert \
- coi/paths/path.cert \
- coi/paths/pm.cert \
- coi/quantification/quantification.cert \
- coi/records/defarray.cert \
- coi/records/defrecord-fast.cert \
- coi/records/defrecord.cert \
- coi/records/domain.cert \
- coi/records/fixedpoint.cert \
- coi/records/mem-domain.cert \
- coi/records/memory.cert \
- coi/records/record-exports.cert \
- coi/records/records.cert \
- coi/records/set-domain.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/ash.cert \
- coi/super-ihs/basics.cert \
- coi/super-ihs/bit-functions.cert \
- coi/super-ihs/bit-twiddling-logops.cert \
- coi/super-ihs/byte-p.cert \
- coi/super-ihs/c-functions.cert \
- coi/super-ihs/carry.cert \
- coi/super-ihs/eric.cert \
- coi/super-ihs/evenp.cert \
- coi/super-ihs/fast.cert \
- coi/super-ihs/from-rtl.cert \
- coi/super-ihs/hacks.cert \
- coi/super-ihs/inductions.cert \
- coi/super-ihs/iter-sqrt.cert \
- coi/super-ihs/logapp.cert \
- coi/super-ihs/logbit.cert \
- coi/super-ihs/logbitp.cert \
- coi/super-ihs/logcar.cert \
- coi/super-ihs/logcdr.cert \
- coi/super-ihs/logcons.cert \
- coi/super-ihs/logext.cert \
- coi/super-ihs/loghead.cert \
- coi/super-ihs/logical-logops.cert \
- coi/super-ihs/logior-logapp-crock.cert \
- coi/super-ihs/loglist.cert \
- coi/super-ihs/logpair.cert \
- coi/super-ihs/logtail.cert \
- coi/super-ihs/lshu.cert \
- coi/super-ihs/meta.cert \
- coi/super-ihs/min-max.cert \
- coi/super-ihs/plus-logapp-suck.cert \
- coi/super-ihs/signed-byte-p-overflow.cert \
- coi/super-ihs/super-ihs.cert \
- coi/super-ihs/unsigned-byte-p.cert \
- coi/symbol-fns/symbol-fns-exports.cert \
- coi/symbol-fns/symbol-fns.cert \
- coi/syntax/auxilary.cert \
- coi/syntax/defbinding.cert \
- coi/syntax/defevaluator.cert \
- coi/syntax/quine.cert \
- coi/syntax/syn-pkg.cert \
- coi/syntax/syntax-extensions.cert \
- coi/syntax/syntax.cert \
- coi/termination/assuming/compiler-proof.cert \
- coi/termination/assuming/compiler.cert \
- coi/termination/assuming/zero.cert \
- coi/util/clause-processor.cert \
- coi/util/debug.cert \
- coi/util/defbinding.cert \
- coi/util/defdoc.cert \
- coi/util/deffix.cert \
- coi/util/defsubtype.cert \
- coi/util/defun-support.cert \
- coi/util/defun.cert \
- coi/util/extra-info-test.cert \
- coi/util/extra-info.cert \
- coi/util/fixequiv.cert \
- coi/util/good-rewrite-order.cert \
- coi/util/ifdef.cert \
- coi/util/iff.cert \
- coi/util/ifixequiv.cert \
- coi/util/implies.cert \
- coi/util/in-conclusion.cert \
- coi/util/ith.cert \
- coi/util/mv-nth.cert \
- coi/util/nfixequiv.cert \
- coi/util/ordinal-order.cert \
- coi/util/pseudo-translate.cert \
- coi/util/recursion-support.cert \
- coi/util/rewrite-equiv.cert \
- coi/util/rule-sets-documentation.cert \
- coi/util/rule-sets-support.cert \
- coi/util/rule-sets.cert \
- coi/util/skip-rewrite.cert \
- coi/util/syntaxp.cert \
- coi/util/table.cert \
- concurrent-programs/bakery/apply-total-order.cert \
- concurrent-programs/bakery/fairenv.cert \
- concurrent-programs/bakery/final-theorems.cert \
- concurrent-programs/bakery/initial-state.cert \
- concurrent-programs/bakery/inv-persists.cert \
- concurrent-programs/bakery/inv-sufficient.cert \
- concurrent-programs/bakery/labels.cert \
- concurrent-programs/bakery/lexicographic-pos.cert \
- concurrent-programs/bakery/lexicographic.cert \
- concurrent-programs/bakery/measures.cert \
- concurrent-programs/bakery/pos-temp.cert \
- concurrent-programs/bakery/programs.cert \
- concurrent-programs/bakery/properties-of-sets.cert \
- concurrent-programs/bakery/properties.cert \
- concurrent-programs/bakery/records.cert \
- concurrent-programs/bakery/stutter1-match.cert \
- concurrent-programs/bakery/stutter2.cert \
- concurrent-programs/bakery/variables.cert \
- concurrent-programs/german-protocol/german.cert \
- countereg-gen/acl2s-parameter.cert \
- countereg-gen/base.cert \
- countereg-gen/basis.cert \
- countereg-gen/data.cert \
- countereg-gen/graph.cert \
- countereg-gen/library-support.cert \
- countereg-gen/main.cert \
- countereg-gen/mv-proof.cert \
- countereg-gen/num-list-fns.cert \
- countereg-gen/num-list-thms.cert \
- countereg-gen/random-state-basis1.cert \
- countereg-gen/random-state.cert \
- countereg-gen/random.cert \
- countereg-gen/rem-and-floor.cert \
- countereg-gen/simple-graph-array.cert \
- countereg-gen/splitnat.cert \
- countereg-gen/switchnat.cert \
- countereg-gen/top.cert \
- countereg-gen/type.cert \
- countereg-gen/utilities.cert \
- countereg-gen/with-timeout.cert \
- cowles/acl2-agp.cert \
- cowles/acl2-asg.cert \
- cowles/acl2-crg.cert \
- cutil/da-base.cert \
- cutil/defaggregate-tests.cert \
- cutil/defaggregate.cert \
- cutil/defalist-tests.cert \
- cutil/defalist.cert \
- cutil/defenum.cert \
- cutil/define-tests.cert \
- cutil/define.cert \
- cutil/deflist-aux.cert \
- cutil/deflist-tests.cert \
- cutil/deflist.cert \
- cutil/defmapappend-tests.cert \
- cutil/defmapappend.cert \
- cutil/defmvtypes.cert \
- cutil/defprojection-tests.cert \
- cutil/defprojection.cert \
- cutil/defsection.cert \
- cutil/formals.cert \
- cutil/look-up.cert \
- cutil/maybe-defthm.cert \
- cutil/portcullis.cert \
- cutil/returnspecs.cert \
- cutil/support.cert \
- cutil/top.cert \
- cutil/wizard.cert \
- data-structures/alist-defthms.cert \
- data-structures/alist-defuns.cert \
- data-structures/alist-theory.cert \
- data-structures/array1.cert \
- data-structures/defalist.cert \
- data-structures/deflist.cert \
- data-structures/doc-section.cert \
- data-structures/list-defthms.cert \
- data-structures/list-defuns.cert \
- data-structures/list-theory.cert \
- data-structures/memories/log2.cert \
- data-structures/memories/memory-impl.cert \
- data-structures/memories/memory.cert \
- data-structures/memories/memtree.cert \
- data-structures/memories/private.cert \
- data-structures/no-duplicates.cert \
- data-structures/number-list-defthms.cert \
- data-structures/number-list-defuns.cert \
- data-structures/number-list-theory.cert \
- data-structures/set-defthms.cert \
- data-structures/set-defuns.cert \
- data-structures/set-theory.cert \
- data-structures/structures.cert \
- data-structures/utilities.cert \
- deduction/passmore/bewijs.cert \
- deduction/passmore/general.cert \
- deduction/passmore/paramod.cert \
- deduction/passmore/prover.cert \
- deduction/passmore/resolution.cert \
- deduction/passmore/unification.cert \
- deduction/passmore/weighting.cert \
- defexec/dag-unification/basic.cert \
- defexec/dag-unification/dag-unification-l.cert \
- defexec/dag-unification/dag-unification-rules.cert \
- defexec/dag-unification/dag-unification-st.cert \
- defexec/dag-unification/dags.cert \
- defexec/dag-unification/list-unification-rules.cert \
- defexec/dag-unification/matching.cert \
- defexec/dag-unification/subsumption-subst.cert \
- defexec/dag-unification/subsumption.cert \
- defexec/dag-unification/terms-as-dag.cert \
- defexec/dag-unification/terms-dag-stobj.cert \
- defexec/dag-unification/terms.cert \
- defexec/defpun-exec/defpun-exec.cert \
- defexec/find-path/fpst.cert \
- defexec/find-path/graph/find-path1.cert \
- defexec/find-path/graph/find-path2.cert \
- defexec/find-path/graph/find-path3.cert \
- defexec/find-path/graph/helpers.cert \
- defexec/find-path/graph/linear-find-path.cert \
- defexec/find-path/run-fpst.cert \
- defexec/ordinals/supporting-ordinals.cert \
- defexec/other-apps/misc/memos.cert \
- defexec/other-apps/misc/stobjsim.cert \
- defexec/other-apps/qsort/extraction.cert \
- defexec/other-apps/qsort/final-theorem.cert \
- defexec/other-apps/qsort/first-last.cert \
- defexec/other-apps/qsort/intermediate-program.cert \
- defexec/other-apps/qsort/intermediate-to-spec.cert \
- defexec/other-apps/qsort/load-extract.cert \
- defexec/other-apps/qsort/merge-intermediate.cert \
- defexec/other-apps/qsort/nth-update-nth.cert \
- defexec/other-apps/qsort/permutations.cert \
- defexec/other-apps/qsort/programs.cert \
- defexec/other-apps/qsort/sort-qs-properties.cert \
- defexec/other-apps/qsort/spec-properties.cert \
- defexec/other-apps/qsort/split-qs-properties.cert \
- defexec/other-apps/qsort/total-order.cert \
- defexec/other-apps/records/inline.cert \
- defexec/other-apps/records/records-bsd.cert \
- defexec/other-apps/records/records.cert \
- defexec/other-apps/records/recordsim.cert \
- defexec/reflexive/reflexive.cert \
- defsort/defsort.cert \
- defsort/duplicated-members.cert \
- defsort/duplicity.cert \
- defsort/examples.cert \
- defsort/generic-impl.cert \
- defsort/generic.cert \
- defsort/remove-dups.cert \
- defsort/uniquep.cert \
- demos/list-theory.cert \
- demos/modeling/memories.cert \
- demos/modeling/network-state-basic.cert \
- demos/modeling/network-state.cert \
- demos/modeling/nondeterminism.cert \
- finite-set-theory/osets/cardinality.cert \
- finite-set-theory/osets/computed-hints.cert \
- finite-set-theory/osets/delete.cert \
- finite-set-theory/osets/difference.cert \
- finite-set-theory/osets/instance.cert \
- finite-set-theory/osets/intersect.cert \
- finite-set-theory/osets/map-tests.cert \
- finite-set-theory/osets/map.cert \
- finite-set-theory/osets/membership.cert \
- finite-set-theory/osets/outer.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/primitives.cert \
- finite-set-theory/osets/quantify.cert \
- finite-set-theory/osets/sets.cert \
- finite-set-theory/osets/sort.cert \
- finite-set-theory/osets/under-set-equiv.cert \
- finite-set-theory/osets/union.cert \
- finite-set-theory/set-theory.cert \
- finite-set-theory/total-ordering.cert \
- hacking/all.cert \
- hacking/bridge.cert \
- hacking/defcode.cert \
- hacking/defstruct-parsing.cert \
- hacking/doc-section.cert \
- hacking/dynamic-make-event-test.cert \
- hacking/dynamic-make-event.cert \
- hacking/evalable-ld-printing.cert \
- hacking/hacker.cert \
- hacking/progn-bang-enh.cert \
- hacking/raw.cert \
- hacking/redefun.cert \
- hacking/rewrite-code.cert \
- hacking/subsumption.cert \
- hacking/table-guard.cert \
- hints/basic-tests.cert \
- hints/consider-hint-tests.cert \
- hints/consider-hint.cert \
- hints/huet-lang-algorithm-tests.cert \
- hints/huet-lang-algorithm.cert \
- hints/merge-hint.cert \
- ihs/@logops.cert \
- ihs/basic-definitions.cert \
- ihs/ihs-definitions.cert \
- ihs/ihs-doc-topic.cert \
- ihs/ihs-init.cert \
- ihs/ihs-lemmas.cert \
- ihs/ihs-theories.cert \
- ihs/logops-definitions.cert \
- ihs/logops-lemmas.cert \
- ihs/math-lemmas.cert \
- ihs/quotient-remainder-lemmas.cert \
- leftist-trees/leftist-tree-defthms.cert \
- leftist-trees/leftist-tree-defuns.cert \
- leftist-trees/leftist-tree-sort-equivalent.cert \
- leftist-trees/leftist-tree-sort-equivalent2.cert \
- leftist-trees/leftist-tree-sort-equivalent3.cert \
- leftist-trees/leftist-tree-sort.cert \
- leftist-trees/top.cert \
- make-event/acl2x-help.cert \
- make-event/assert-check-include-1.cert \
- make-event/assert-check-include.cert \
- make-event/assert-check.cert \
- make-event/assert-include.cert \
- make-event/assert.cert \
- make-event/basic-check.cert \
- make-event/basic-pkg-check.cert \
- make-event/basic-pkg.cert \
- make-event/basic.cert \
- make-event/defconst-fast-examples.cert \
- make-event/defconst-fast.cert \
- make-event/defrefine.cert \
- make-event/defrule.cert \
- make-event/defspec.cert \
- make-event/dotimes.cert \
- make-event/embeddable-event-forms.cert \
- make-event/eval-check-tests.cert \
- make-event/eval-check.cert \
- make-event/eval-tests.cert \
- make-event/eval.cert \
- make-event/gen-defthm-check.cert \
- make-event/gen-defthm.cert \
- make-event/gen-defun-check.cert \
- make-event/gen-defun.cert \
- make-event/inline-book.cert \
- make-event/local-elided-include.cert \
- make-event/local-elided.cert \
- make-event/local-requires-skip-check-include.cert \
- make-event/local-requires-skip-check.cert \
- make-event/logical-tangent.cert \
- make-event/macros-include.cert \
- make-event/macros-skip-proofs-include.cert \
- make-event/macros-skip-proofs.cert \
- make-event/macros.cert \
- make-event/make-redundant.cert \
- make-event/nested-check.cert \
- make-event/nested.cert \
- make-event/portcullis-expansion-include.cert \
- make-event/portcullis-expansion.cert \
- make-event/proof-by-arith.cert \
- make-event/read-from-file.cert \
- make-event/require-book.cert \
- make-event/test-case-check.cert \
- make-event/test-case.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- meta/meta-times-equal.cert \
- meta/meta.cert \
- meta/pseudo-termp-lemmas.cert \
- meta/term-defuns.cert \
- meta/term-lemmas.cert \
- misc/assert.cert \
- misc/bash.cert \
- misc/beta-reduce.cert \
- misc/callers-and-ancestors.cert \
- misc/character-encoding-test.cert \
- misc/check-acl2-exports.cert \
- misc/check-state.cert \
- misc/computed-hint-rewrite.cert \
- misc/computed-hint.cert \
- misc/congruent-stobjs-test.cert \
- misc/csort.cert \
- misc/dead-events.cert \
- misc/defabsstobj-example-1.cert \
- misc/defabsstobj-example-2.cert \
- misc/defabsstobj-example-3.cert \
- misc/defabsstobj-example-4.cert \
- misc/defattach-bang.cert \
- misc/defattach-example.cert \
- misc/definline.cert \
- misc/defmac.cert \
- misc/defopener.cert \
- misc/defp.cert \
- misc/defproxy-test.cert \
- misc/defpun.cert \
- misc/defun-plus.cert \
- misc/dft-ex.cert \
- misc/dft.cert \
- misc/dijkstra-shortest-path.cert \
- misc/disassemble.cert \
- misc/doc-section.cert \
- misc/dump-events.cert \
- misc/equal-by-g-help.cert \
- misc/equal-by-g.cert \
- misc/eval.cert \
- misc/evalable-printing.cert \
- misc/expander.cert \
- misc/fast-coerce.cert \
- misc/fibonacci.cert \
- misc/file-io.cert \
- misc/find-lemmas.cert \
- misc/gentle.cert \
- misc/getprop.cert \
- misc/goodstein.cert \
- misc/grcd.cert \
- misc/hanoi.cert \
- misc/hons-help.cert \
- misc/hons-help2.cert \
- misc/hons-tests.cert \
- misc/how-to-prove-thms.cert \
- misc/int-division.cert \
- misc/integer-type-set-test.cert \
- misc/invariants.cert \
- misc/meta-lemmas.cert \
- misc/misc2/defpun-exec-domain-example.cert \
- misc/misc2/misc.cert \
- misc/misc2/reverse-by-separation.cert \
- misc/misc2/ruler-extenders-tests.cert \
- misc/misc2/step-limits.cert \
- misc/mult.cert \
- misc/oprof.cert \
- misc/priorities.cert \
- misc/problem13.cert \
- misc/process-book-readme.cert \
- misc/profiling.cert \
- misc/qi-correct.cert \
- misc/qi.cert \
- misc/radix.cert \
- misc/random.cert \
- misc/records-bsd.cert \
- misc/records.cert \
- misc/records0.cert \
- misc/redef-pkg.cert \
- misc/rtl-untranslate.cert \
- misc/save-time.cert \
- misc/seq.cert \
- misc/seqw.cert \
- misc/simplify-defuns.cert \
- misc/simplify-thm.cert \
- misc/sin-cos.cert \
- misc/sort-symbols.cert \
- misc/sticky-disable.cert \
- misc/symbol-btree.cert \
- misc/total-order-bsd.cert \
- misc/total-order.cert \
- misc/trace-star.cert \
- misc/transfinite.cert \
- misc/untranslate-patterns.cert \
- misc/wet.cert \
- models/jvm/m1-original/m1-story.cert \
- models/jvm/m1-original/problem-set-1-answers.cert \
- models/jvm/m1/alternating-sum-variant.cert \
- models/jvm/m1/alternating-sum.cert \
- models/jvm/m1/bexpt.cert \
- models/jvm/m1/defsys-utilities.cert \
- models/jvm/m1/defsys.cert \
- models/jvm/m1/div.cert \
- models/jvm/m1/even-solution-1.cert \
- models/jvm/m1/even-solution-2.cert \
- models/jvm/m1/expt.cert \
- models/jvm/m1/fact.cert \
- models/jvm/m1/fib.cert \
- models/jvm/m1/find-k!.cert \
- models/jvm/m1/funny-fact.cert \
- models/jvm/m1/implementation.cert \
- models/jvm/m1/lessp.cert \
- models/jvm/m1/low-seven.cert \
- models/jvm/m1/m1.cert \
- models/jvm/m1/magic.cert \
- models/jvm/m1/power.cert \
- models/jvm/m1/sign.cert \
- models/jvm/m1/sum.cert \
- models/jvm/m1/sumsq.cert \
- models/jvm/m1/template.cert \
- models/jvm/m1/theorems-a-and-b.cert \
- models/jvm/m1/tmi-reductions.cert \
- models/jvm/m1/wormhole-abstraction.cert \
- models/jvm/m5/apprentice-state.cert \
- models/jvm/m5/demo.cert \
- models/jvm/m5/idemo.cert \
- models/jvm/m5/infinite-fair-schedule.cert \
- models/jvm/m5/isort.cert \
- models/jvm/m5/jvm-fact-setup.cert \
- models/jvm/m5/m5.cert \
- models/jvm/m5/partial.cert \
- models/jvm/m5/perm.cert \
- models/jvm/m5/universal-never-returns.cert \
- models/jvm/m5/universal.cert \
- models/jvm/m5/utilities.cert \
- ordinals/e0-ordinal.cert \
- ordinals/lexicographic-book.cert \
- ordinals/lexicographic-ordering-without-arithmetic.cert \
- ordinals/lexicographic-ordering.cert \
- ordinals/limits.cert \
- ordinals/ordinal-addition.cert \
- ordinals/ordinal-basic-thms.cert \
- ordinals/ordinal-counter-examples.cert \
- ordinals/ordinal-definitions.cert \
- ordinals/ordinal-exponentiation.cert \
- ordinals/ordinal-isomorphism.cert \
- ordinals/ordinal-multiplication.cert \
- ordinals/ordinal-total-order.cert \
- ordinals/ordinals-without-arithmetic.cert \
- ordinals/ordinals.cert \
- ordinals/proof-of-well-foundedness.cert \
- ordinals/top-with-meta.cert \
- oslib/catpath.cert \
- oslib/date.cert \
- oslib/getpid.cert \
- oslib/ls.cert \
- oslib/portcullis.cert \
- oslib/read-acl2-oracle.cert \
- oslib/tempfile.cert \
- oslib/top.cert \
- paco/database.cert \
- paco/elim-dest.cert \
- paco/foundations.cert \
- paco/induct.cert \
- paco/output-module.cert \
- paco/paco.cert \
- paco/prove.cert \
- paco/rewrite.cert \
- paco/simplify.cert \
- paco/type-set.cert \
- paco/utilities.cert \
- parallel/fibonacci.cert \
- parallel/hint-tests.cert \
- parallel/matrix-multiplication-parallel.cert \
- parallel/matrix-multiplication-serial.cert \
- parallel/matrix-multiplication-setup.cert \
- parallel/spec-mv-let.cert \
- parallel/stress-tests.cert \
- parallel/syntax-tests.cert \
- parallel/with-waterfall-parallelism.cert \
- parallel/without-waterfall-parallelism.cert \
- powerlists/algebra.cert \
- powerlists/batcher-sort.cert \
- powerlists/bitonic-sort.cert \
- powerlists/cla-adder.cert \
- powerlists/gray-code.cert \
- powerlists/merge-sort.cert \
- powerlists/prefix-sum.cert \
- powerlists/simple.cert \
- powerlists/sort.cert \
- proofstyles/completeness/assertions-partial.cert \
- proofstyles/completeness/assertions-total.cert \
- proofstyles/completeness/clock-partial.cert \
- proofstyles/completeness/clock-total.cert \
- proofstyles/completeness/generic-partial.cert \
- proofstyles/completeness/generic-total.cert \
- proofstyles/completeness/stepwise-invariants-partial.cert \
- proofstyles/completeness/stepwise-invariants-total.cert \
- proofstyles/counterexamples/halt-flg.cert \
- proofstyles/counterexamples/memory-clearing.cert \
- proofstyles/counterexamples/realistic.cert \
- proofstyles/invclock/c2i/c2i-partial.cert \
- proofstyles/invclock/c2i/c2i-total.cert \
- proofstyles/invclock/c2i/clock-to-inv.cert \
- proofstyles/invclock/compose/compose-c-c-partial.cert \
- proofstyles/invclock/compose/compose-c-c-total.cert \
- proofstyles/invclock/i2c/i2c-partial.cert \
- proofstyles/invclock/i2c/i2c-total.cert \
- proofstyles/invclock/i2c/inv-to-clock.cert \
- proofstyles/soundness/assertions-partial.cert \
- proofstyles/soundness/assertions-total.cert \
- proofstyles/soundness/clock-partial.cert \
- proofstyles/soundness/clock-total.cert \
- proofstyles/soundness/stepwise-invariants-partial.cert \
- proofstyles/soundness/stepwise-invariants-total.cert \
- quadratic-reciprocity/eisenstein.cert \
- quadratic-reciprocity/euclid.cert \
- quadratic-reciprocity/euler.cert \
- quadratic-reciprocity/fermat.cert \
- quadratic-reciprocity/gauss.cert \
- quadratic-reciprocity/mersenne.cert \
- regex/defset-encapsulates.cert \
- regex/defset-macros.cert \
- regex/equal-based-set.cert \
- regex/grep-command-line.cert \
- regex/input-list.cert \
- regex/portcullis.cert \
- regex/regex-chartrans.cert \
- regex/regex-defs.cert \
- regex/regex-exec.cert \
- regex/regex-fileio.cert \
- regex/regex-parse-brace.cert \
- regex/regex-parse-bracket.cert \
- regex/regex-parse.cert \
- regex/regex-tests.cert \
- regex/regex-ui.cert \
- rtl/rel1/lib1/basic.cert \
- rtl/rel1/lib1/bits.cert \
- rtl/rel1/lib1/brat.cert \
- rtl/rel1/lib1/float.cert \
- rtl/rel1/lib1/reps.cert \
- rtl/rel1/lib1/round.cert \
- rtl/rel1/lib1/top.cert \
- rtl/rel1/lib3/basic.cert \
- rtl/rel1/lib3/bits.cert \
- rtl/rel1/lib3/brat.cert \
- rtl/rel1/lib3/fadd.cert \
- rtl/rel1/lib3/float.cert \
- rtl/rel1/lib3/reps.cert \
- rtl/rel1/lib3/round.cert \
- rtl/rel1/lib3/top.cert \
- rtl/rel1/support/add.cert \
- rtl/rel1/support/away.cert \
- rtl/rel1/support/basic.cert \
- rtl/rel1/support/divsqrt.cert \
- rtl/rel1/support/fadd/add3.cert \
- rtl/rel1/support/fadd/lop1.cert \
- rtl/rel1/support/fadd/lop2.cert \
- rtl/rel1/support/fadd/lop3.cert \
- rtl/rel1/support/fadd/stick.cert \
- rtl/rel1/support/fadd/top.cert \
- rtl/rel1/support/float.cert \
- rtl/rel1/support/floor.cert \
- rtl/rel1/support/fp.cert \
- rtl/rel1/support/logdefs.cert \
- rtl/rel1/support/loglemmas.cert \
- rtl/rel1/support/logxor-def.cert \
- rtl/rel1/support/logxor-lemmas.cert \
- rtl/rel1/support/merge.cert \
- rtl/rel1/support/near.cert \
- rtl/rel1/support/odd.cert \
- rtl/rel1/support/proofs.cert \
- rtl/rel1/support/reps.cert \
- rtl/rel1/support/rewrite-theory.cert \
- rtl/rel1/support/rnd.cert \
- rtl/rel1/support/sticky.cert \
- rtl/rel1/support/trunc.cert \
- rtl/rel1/support/x-2xx.cert \
- rtl/rel4/arithmetic/arith.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/arithmetic/basic.cert \
- rtl/rel4/arithmetic/cg.cert \
- rtl/rel4/arithmetic/common-factor-defuns.cert \
- rtl/rel4/arithmetic/common-factor.cert \
- rtl/rel4/arithmetic/complex-rationalp.cert \
- rtl/rel4/arithmetic/denominator.cert \
- rtl/rel4/arithmetic/even-odd.cert \
- rtl/rel4/arithmetic/even-odd2-proofs.cert \
- rtl/rel4/arithmetic/even-odd2.cert \
- rtl/rel4/arithmetic/expo-proofs.cert \
- rtl/rel4/arithmetic/expo.cert \
- rtl/rel4/arithmetic/expt-proofs.cert \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/arithmetic/extra-rules.cert \
- rtl/rel4/arithmetic/fl-expt.cert \
- rtl/rel4/arithmetic/fl-hacks.cert \
- rtl/rel4/arithmetic/fl-proofs.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/floor-proofs.cert \
- rtl/rel4/arithmetic/floor.cert \
- rtl/rel4/arithmetic/fp.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/hacks.cert \
- rtl/rel4/arithmetic/induct.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/inverted-factor.cert \
- rtl/rel4/arithmetic/mod-expt.cert \
- rtl/rel4/arithmetic/mod-proofs.cert \
- rtl/rel4/arithmetic/mod.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/nniq.cert \
- rtl/rel4/arithmetic/numerator.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/product-proofs.cert \
- rtl/rel4/arithmetic/product.cert \
- rtl/rel4/arithmetic/rationalp.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/arithmetic/unary-divide.cert \
- rtl/rel4/arithmetic/x-2xx.cert \
- rtl/rel4/lib/arith.cert \
- rtl/rel4/lib/basic.cert \
- rtl/rel4/lib/bits.cert \
- rtl/rel4/lib/bvecp-helpers.cert \
- rtl/rel4/lib/bvecp-raw-helpers.cert \
- rtl/rel4/lib/clocks.cert \
- rtl/rel4/lib/fadd.cert \
- rtl/rel4/lib/float.cert \
- rtl/rel4/lib/openers.cert \
- rtl/rel4/lib/package-defs.cert \
- rtl/rel4/lib/reps.cert \
- rtl/rel4/lib/rom-helpers.cert \
- rtl/rel4/lib/round.cert \
- rtl/rel4/lib/rtl.cert \
- rtl/rel4/lib/rtlarr.cert \
- rtl/rel4/lib/simple-loop-helpers.cert \
- rtl/rel4/lib/simplify-model-helpers.cert \
- rtl/rel4/lib/top.cert \
- rtl/rel4/lib/util.cert \
- rtl/rel4/support/add3-proofs.cert \
- rtl/rel4/support/add3.cert \
- rtl/rel4/support/all-ones.cert \
- rtl/rel4/support/ash.cert \
- rtl/rel4/support/away-proofs.cert \
- rtl/rel4/support/away.cert \
- rtl/rel4/support/badguys.cert \
- rtl/rel4/support/bias-proofs.cert \
- rtl/rel4/support/bias.cert \
- rtl/rel4/support/bitn-proofs.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/bits-extra.cert \
- rtl/rel4/support/bits-proofs.cert \
- rtl/rel4/support/bits-trunc-proofs.cert \
- rtl/rel4/support/bits-trunc.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bvecp-helpers.cert \
- rtl/rel4/support/bvecp-lemmas.cert \
- rtl/rel4/support/bvecp-proofs.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/cat-def.cert \
- rtl/rel4/support/cat-proofs.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/clocks.cert \
- rtl/rel4/support/decode-proofs.cert \
- rtl/rel4/support/decode.cert \
- rtl/rel4/support/drnd.cert \
- rtl/rel4/support/encode.cert \
- rtl/rel4/support/ereps-proofs.cert \
- rtl/rel4/support/ereps.cert \
- rtl/rel4/support/fadd.cert \
- rtl/rel4/support/fast-and.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/support/ireps.cert \
- rtl/rel4/support/land-proofs.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lextra-proofs.cert \
- rtl/rel4/support/lextra.cert \
- rtl/rel4/support/lior-proofs.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lnot-proofs.cert \
- rtl/rel4/support/lnot.cert \
- rtl/rel4/support/log-equal.cert \
- rtl/rel4/support/log-proofs.cert \
- rtl/rel4/support/log.cert \
- rtl/rel4/support/logand-proofs.cert \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/logeqv.cert \
- rtl/rel4/support/logior-proofs.cert \
- rtl/rel4/support/logior.cert \
- rtl/rel4/support/logior1-proofs.cert \
- rtl/rel4/support/logior1.cert \
- rtl/rel4/support/lognot.cert \
- rtl/rel4/support/logorc1.cert \
- rtl/rel4/support/logs.cert \
- rtl/rel4/support/logxor.cert \
- rtl/rel4/support/lop1-proofs.cert \
- rtl/rel4/support/lop1.cert \
- rtl/rel4/support/lop2-proofs.cert \
- rtl/rel4/support/lop2.cert \
- rtl/rel4/support/lop3-proofs.cert \
- rtl/rel4/support/lop3.cert \
- rtl/rel4/support/lxor-proofs.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/merge2.cert \
- rtl/rel4/support/mod4.cert \
- rtl/rel4/support/model-helpers.cert \
- rtl/rel4/support/mulcat-proofs.cert \
- rtl/rel4/support/mulcat.cert \
- rtl/rel4/support/near+-proofs.cert \
- rtl/rel4/support/near+.cert \
- rtl/rel4/support/near-proofs.cert \
- rtl/rel4/support/near.cert \
- rtl/rel4/support/ocat.cert \
- rtl/rel4/support/oddr-proofs.cert \
- rtl/rel4/support/oddr.cert \
- rtl/rel4/support/openers.cert \
- rtl/rel4/support/package-defs.cert \
- rtl/rel4/support/rewrite-theory.cert \
- rtl/rel4/support/rnd.cert \
- rtl/rel4/support/rom-helpers.cert \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/rtlarr.cert \
- rtl/rel4/support/setbitn-proofs.cert \
- rtl/rel4/support/setbitn.cert \
- rtl/rel4/support/setbits-proofs.cert \
- rtl/rel4/support/setbits.cert \
- rtl/rel4/support/sgn.cert \
- rtl/rel4/support/shft.cert \
- rtl/rel4/support/simple-loop-helpers.cert \
- rtl/rel4/support/simplify-model-helpers.cert \
- rtl/rel4/support/stick-proofs.cert \
- rtl/rel4/support/stick.cert \
- rtl/rel4/support/sticky-proofs.cert \
- rtl/rel4/support/sticky.cert \
- rtl/rel4/support/sumbits.cert \
- rtl/rel4/support/top.cert \
- rtl/rel4/support/top1.cert \
- rtl/rel4/support/trunc-proofs.cert \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/util.cert \
- rtl/rel4/user/away.cert \
- rtl/rel4/user/bias.cert \
- rtl/rel4/user/bitn.cert \
- rtl/rel4/user/bits-trunc.cert \
- rtl/rel4/user/bits.cert \
- rtl/rel4/user/brat.cert \
- rtl/rel4/user/bvecp.cert \
- rtl/rel4/user/cat.cert \
- rtl/rel4/user/decode.cert \
- rtl/rel4/user/ereps.cert \
- rtl/rel4/user/land.cert \
- rtl/rel4/user/lextra.cert \
- rtl/rel4/user/lior.cert \
- rtl/rel4/user/lnot.cert \
- rtl/rel4/user/logior1.cert \
- rtl/rel4/user/lxor.cert \
- rtl/rel4/user/mulcat.cert \
- rtl/rel4/user/near.cert \
- rtl/rel4/user/setbitn.cert \
- rtl/rel4/user/setbits.cert \
- rtl/rel4/user/stick.cert \
- rtl/rel4/user/sumbits.cert \
- rtl/rel4/user/top.cert \
- rtl/rel4/user/trunc.cert \
- rtl/rel5/arithmetic/arith.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/arithmetic/basic.cert \
- rtl/rel5/arithmetic/cg.cert \
- rtl/rel5/arithmetic/common-factor-defuns.cert \
- rtl/rel5/arithmetic/common-factor.cert \
- rtl/rel5/arithmetic/complex-rationalp.cert \
- rtl/rel5/arithmetic/denominator.cert \
- rtl/rel5/arithmetic/even-odd.cert \
- rtl/rel5/arithmetic/even-odd2-proofs.cert \
- rtl/rel5/arithmetic/even-odd2.cert \
- rtl/rel5/arithmetic/expo-proofs.cert \
- rtl/rel5/arithmetic/expo.cert \
- rtl/rel5/arithmetic/expt-proofs.cert \
- rtl/rel5/arithmetic/expt.cert \
- rtl/rel5/arithmetic/extra-rules.cert \
- rtl/rel5/arithmetic/fl-expt.cert \
- rtl/rel5/arithmetic/fl-hacks.cert \
- rtl/rel5/arithmetic/fl-proofs.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/floor-proofs.cert \
- rtl/rel5/arithmetic/floor.cert \
- rtl/rel5/arithmetic/fp.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/hacks.cert \
- rtl/rel5/arithmetic/induct.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/inverted-factor.cert \
- rtl/rel5/arithmetic/mod-expt.cert \
- rtl/rel5/arithmetic/mod-proofs.cert \
- rtl/rel5/arithmetic/mod.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/nniq.cert \
- rtl/rel5/arithmetic/numerator.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/product-proofs.cert \
- rtl/rel5/arithmetic/product.cert \
- rtl/rel5/arithmetic/rationalp.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/arithmetic/unary-divide.cert \
- rtl/rel5/arithmetic/x-2xx.cert \
- rtl/rel5/lib/add.cert \
- rtl/rel5/lib/arith.cert \
- rtl/rel5/lib/basic.cert \
- rtl/rel5/lib/bits.cert \
- rtl/rel5/lib/bvecp-helpers.cert \
- rtl/rel5/lib/bvecp-raw-helpers.cert \
- rtl/rel5/lib/clocks.cert \
- rtl/rel5/lib/float.cert \
- rtl/rel5/lib/log.cert \
- rtl/rel5/lib/openers.cert \
- rtl/rel5/lib/package-defs.cert \
- rtl/rel5/lib/reps.cert \
- rtl/rel5/lib/rom-helpers.cert \
- rtl/rel5/lib/round.cert \
- rtl/rel5/lib/rtl.cert \
- rtl/rel5/lib/rtlarr.cert \
- rtl/rel5/lib/simple-loop-helpers.cert \
- rtl/rel5/lib/simplify-model-helpers.cert \
- rtl/rel5/lib/top.cert \
- rtl/rel5/lib/util.cert \
- rtl/rel5/support/add3-proofs.cert \
- rtl/rel5/support/add3.cert \
- rtl/rel5/support/all-ones.cert \
- rtl/rel5/support/ash.cert \
- rtl/rel5/support/away-proofs.cert \
- rtl/rel5/support/away.cert \
- rtl/rel5/support/badguys.cert \
- rtl/rel5/support/bias-proofs.cert \
- rtl/rel5/support/bias.cert \
- rtl/rel5/support/bitn-proofs.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/bits-proofs.cert \
- rtl/rel5/support/bits-trunc-proofs.cert \
- rtl/rel5/support/bits-trunc.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bvecp-helpers.cert \
- rtl/rel5/support/bvecp-lemmas.cert \
- rtl/rel5/support/bvecp-proofs.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/cat-def.cert \
- rtl/rel5/support/cat-proofs.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/clocks.cert \
- rtl/rel5/support/decode-proofs.cert \
- rtl/rel5/support/decode.cert \
- rtl/rel5/support/drnd.cert \
- rtl/rel5/support/encode.cert \
- rtl/rel5/support/ereps-proofs.cert \
- rtl/rel5/support/ereps.cert \
- rtl/rel5/support/fadd-extra.cert \
- rtl/rel5/support/fadd-extra0.cert \
- rtl/rel5/support/fadd.cert \
- rtl/rel5/support/fast-and.cert \
- rtl/rel5/support/float-extra.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/support/ireps.cert \
- rtl/rel5/support/land.cert \
- rtl/rel5/support/land0-proofs.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lextra-proofs.cert \
- rtl/rel5/support/lextra.cert \
- rtl/rel5/support/lextra0.cert \
- rtl/rel5/support/lior.cert \
- rtl/rel5/support/lior0-proofs.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lnot-proofs.cert \
- rtl/rel5/support/lnot.cert \
- rtl/rel5/support/log-equal.cert \
- rtl/rel5/support/log-proofs.cert \
- rtl/rel5/support/log.cert \
- rtl/rel5/support/logand-proofs.cert \
- rtl/rel5/support/logand.cert \
- rtl/rel5/support/logeqv.cert \
- rtl/rel5/support/logior-proofs.cert \
- rtl/rel5/support/logior.cert \
- rtl/rel5/support/logior1-proofs.cert \
- rtl/rel5/support/logior1.cert \
- rtl/rel5/support/lognot.cert \
- rtl/rel5/support/logorc1.cert \
- rtl/rel5/support/logs.cert \
- rtl/rel5/support/logxor.cert \
- rtl/rel5/support/lop1-proofs.cert \
- rtl/rel5/support/lop1.cert \
- rtl/rel5/support/lop2-proofs.cert \
- rtl/rel5/support/lop2.cert \
- rtl/rel5/support/lop3-proofs.cert \
- rtl/rel5/support/lop3.cert \
- rtl/rel5/support/lxor.cert \
- rtl/rel5/support/lxor0-proofs.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/merge2.cert \
- rtl/rel5/support/mod4.cert \
- rtl/rel5/support/model-helpers.cert \
- rtl/rel5/support/mulcat-proofs.cert \
- rtl/rel5/support/mulcat.cert \
- rtl/rel5/support/near+-proofs.cert \
- rtl/rel5/support/near+.cert \
- rtl/rel5/support/near-proofs.cert \
- rtl/rel5/support/near.cert \
- rtl/rel5/support/ocat.cert \
- rtl/rel5/support/oddr-proofs.cert \
- rtl/rel5/support/oddr.cert \
- rtl/rel5/support/openers.cert \
- rtl/rel5/support/package-defs.cert \
- rtl/rel5/support/rewrite-theory.cert \
- rtl/rel5/support/rnd.cert \
- rtl/rel5/support/rom-helpers.cert \
- rtl/rel5/support/round-extra.cert \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/rtlarr.cert \
- rtl/rel5/support/setbitn-proofs.cert \
- rtl/rel5/support/setbitn.cert \
- rtl/rel5/support/setbits-proofs.cert \
- rtl/rel5/support/setbits.cert \
- rtl/rel5/support/sgn.cert \
- rtl/rel5/support/shft.cert \
- rtl/rel5/support/simple-loop-helpers.cert \
- rtl/rel5/support/simplify-model-helpers.cert \
- rtl/rel5/support/stick-proofs.cert \
- rtl/rel5/support/stick.cert \
- rtl/rel5/support/sticky-proofs.cert \
- rtl/rel5/support/sticky.cert \
- rtl/rel5/support/sumbits.cert \
- rtl/rel5/support/top.cert \
- rtl/rel5/support/top1.cert \
- rtl/rel5/support/trunc-proofs.cert \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/support/util.cert \
- rtl/rel5/user/away.cert \
- rtl/rel5/user/bias.cert \
- rtl/rel5/user/bitn.cert \
- rtl/rel5/user/bits-trunc.cert \
- rtl/rel5/user/bits.cert \
- rtl/rel5/user/brat.cert \
- rtl/rel5/user/bvecp.cert \
- rtl/rel5/user/cat.cert \
- rtl/rel5/user/decode.cert \
- rtl/rel5/user/ereps.cert \
- rtl/rel5/user/land.cert \
- rtl/rel5/user/lextra.cert \
- rtl/rel5/user/lior.cert \
- rtl/rel5/user/lnot.cert \
- rtl/rel5/user/logior1.cert \
- rtl/rel5/user/lxor.cert \
- rtl/rel5/user/mulcat.cert \
- rtl/rel5/user/near.cert \
- rtl/rel5/user/setbitn.cert \
- rtl/rel5/user/setbits.cert \
- rtl/rel5/user/stick.cert \
- rtl/rel5/user/sumbits.cert \
- rtl/rel5/user/top.cert \
- rtl/rel5/user/trunc.cert \
- rtl/rel8/arithmetic/arith.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/arithmetic/cg.cert \
- rtl/rel8/arithmetic/common-factor-defuns.cert \
- rtl/rel8/arithmetic/common-factor.cert \
- rtl/rel8/arithmetic/complex-rationalp.cert \
- rtl/rel8/arithmetic/denominator.cert \
- rtl/rel8/arithmetic/even-odd.cert \
- rtl/rel8/arithmetic/even-odd2-proofs.cert \
- rtl/rel8/arithmetic/even-odd2.cert \
- rtl/rel8/arithmetic/expo-proofs.cert \
- rtl/rel8/arithmetic/expo.cert \
- rtl/rel8/arithmetic/expt-proofs.cert \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/arithmetic/extra-rules.cert \
- rtl/rel8/arithmetic/fl-expt.cert \
- rtl/rel8/arithmetic/fl-hacks.cert \
- rtl/rel8/arithmetic/fl-proofs.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/floor-proofs.cert \
- rtl/rel8/arithmetic/floor.cert \
- rtl/rel8/arithmetic/fp.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/hacks.cert \
- rtl/rel8/arithmetic/induct.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/inverted-factor.cert \
- rtl/rel8/arithmetic/mod-expt.cert \
- rtl/rel8/arithmetic/mod-proofs.cert \
- rtl/rel8/arithmetic/mod.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/nniq.cert \
- rtl/rel8/arithmetic/numerator.cert \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/product-proofs.cert \
- rtl/rel8/arithmetic/product.cert \
- rtl/rel8/arithmetic/rationalp.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/arithmetic/unary-divide.cert \
- rtl/rel8/arithmetic/x-2xx.cert \
- rtl/rel8/lib/add.cert \
- rtl/rel8/lib/arith.cert \
- rtl/rel8/lib/basic.cert \
- rtl/rel8/lib/bits.cert \
- rtl/rel8/lib/bvecp-helpers.cert \
- rtl/rel8/lib/bvecp-raw-helpers.cert \
- rtl/rel8/lib/clocks.cert \
- rtl/rel8/lib/float.cert \
- rtl/rel8/lib/log.cert \
- rtl/rel8/lib/logn.cert \
- rtl/rel8/lib/logn2log.cert \
- rtl/rel8/lib/mult.cert \
- rtl/rel8/lib/openers.cert \
- rtl/rel8/lib/package-defs.cert \
- rtl/rel8/lib/reps.cert \
- rtl/rel8/lib/rom-helpers.cert \
- rtl/rel8/lib/round.cert \
- rtl/rel8/lib/rtl.cert \
- rtl/rel8/lib/rtlarr.cert \
- rtl/rel8/lib/simple-loop-helpers.cert \
- rtl/rel8/lib/simplify-model-helpers.cert \
- rtl/rel8/lib/top.cert \
- rtl/rel8/lib/util.cert \
- rtl/rel8/support/lib1.delta1/arith-extra.cert \
- rtl/rel8/support/lib1.delta1/arith.cert \
- rtl/rel8/support/lib1.delta1/basic-extra.cert \
- rtl/rel8/support/lib1.delta1/basic.cert \
- rtl/rel8/support/lib1.delta1/bits-extra.cert \
- rtl/rel8/support/lib1.delta1/bits.cert \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.cert \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.cert \
- rtl/rel8/support/lib1.delta1/float-extra2.cert \
- rtl/rel8/support/lib1.delta1/float.cert \
- rtl/rel8/support/lib1.delta1/mult-proofs.cert \
- rtl/rel8/support/lib1.delta1/mult.cert \
- rtl/rel8/support/lib1.delta1/round-extra2.cert \
- rtl/rel8/support/lib1.delta1/round.cert \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.cert \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers.cert \
- rtl/rel8/support/lib1.delta2/float-extra.cert \
- rtl/rel8/support/lib1.delta2/float.cert \
- rtl/rel8/support/lib1/add.cert \
- rtl/rel8/support/lib1/arith.cert \
- rtl/rel8/support/lib1/basic.cert \
- rtl/rel8/support/lib1/bits.cert \
- rtl/rel8/support/lib1/bvecp-helpers.cert \
- rtl/rel8/support/lib1/bvecp-raw-helpers.cert \
- rtl/rel8/support/lib1/clocks.cert \
- rtl/rel8/support/lib1/float.cert \
- rtl/rel8/support/lib1/log.cert \
- rtl/rel8/support/lib1/openers.cert \
- rtl/rel8/support/lib1/package-defs.cert \
- rtl/rel8/support/lib1/reps.cert \
- rtl/rel8/support/lib1/rom-helpers.cert \
- rtl/rel8/support/lib1/round.cert \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/rtlarr.cert \
- rtl/rel8/support/lib1/simple-loop-helpers.cert \
- rtl/rel8/support/lib1/simplify-model-helpers.cert \
- rtl/rel8/support/lib1/top.cert \
- rtl/rel8/support/lib1/util.cert \
- rtl/rel8/support/lib2.delta1/add-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/add-new.cert \
- rtl/rel8/support/lib2.delta1/add-proofs.cert \
- rtl/rel8/support/lib2.delta1/add.cert \
- rtl/rel8/support/lib2.delta1/arith.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/bits-new.cert \
- rtl/rel8/support/lib2.delta1/bits-proofs.cert \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/bvecp-helpers.cert \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.cert \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.cert \
- rtl/rel8/support/lib2.delta1/float-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/float-new.cert \
- rtl/rel8/support/lib2.delta1/float-proofs.cert \
- rtl/rel8/support/lib2.delta1/float.cert \
- rtl/rel8/support/lib2.delta1/log-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2.delta1/log-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-support-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-support.cert \
- rtl/rel8/support/lib2.delta1/log.cert \
- rtl/rel8/support/lib2.delta1/logn-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/logn-new.cert \
- rtl/rel8/support/lib2.delta1/logn-proofs.cert \
- rtl/rel8/support/lib2.delta1/logn.cert \
- rtl/rel8/support/lib2.delta1/logn2log-proofs.cert \
- rtl/rel8/support/lib2.delta1/logn2log.cert \
- rtl/rel8/support/lib2.delta1/mult-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/mult-new.cert \
- rtl/rel8/support/lib2.delta1/mult-proofs.cert \
- rtl/rel8/support/lib2.delta1/mult.cert \
- rtl/rel8/support/lib2.delta1/reps-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/reps-new.cert \
- rtl/rel8/support/lib2.delta1/reps-proofs.cert \
- rtl/rel8/support/lib2.delta1/reps.cert \
- rtl/rel8/support/lib2.delta1/round-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/round-new.cert \
- rtl/rel8/support/lib2.delta1/round-proofs.cert \
- rtl/rel8/support/lib2.delta1/round.cert \
- rtl/rel8/support/lib2.delta1/rtl-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/rtl-new.cert \
- rtl/rel8/support/lib2.delta1/rtl-proofs.cert \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/rtlarr-new.cert \
- rtl/rel8/support/lib2.delta1/rtlarr.cert \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.cert \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers.cert \
- rtl/rel8/support/lib2.delta1/top.cert \
- rtl/rel8/support/lib2.delta1/util.cert \
- rtl/rel8/support/lib2.delta2/add-lib.cert \
- rtl/rel8/support/lib2.delta2/add.cert \
- rtl/rel8/support/lib2.delta2/base.cert \
- rtl/rel8/support/lib2.delta2/bits.cert \
- rtl/rel8/support/lib2.delta2/log.cert \
- rtl/rel8/support/lib2/add.cert \
- rtl/rel8/support/lib2/arith.cert \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/basic.cert \
- rtl/rel8/support/lib2/bits.cert \
- rtl/rel8/support/lib2/bvecp-helpers.cert \
- rtl/rel8/support/lib2/bvecp-raw-helpers.cert \
- rtl/rel8/support/lib2/clocks.cert \
- rtl/rel8/support/lib2/float.cert \
- rtl/rel8/support/lib2/log.cert \
- rtl/rel8/support/lib2/mult.cert \
- rtl/rel8/support/lib2/openers.cert \
- rtl/rel8/support/lib2/package-defs.cert \
- rtl/rel8/support/lib2/reps.cert \
- rtl/rel8/support/lib2/rom-helpers.cert \
- rtl/rel8/support/lib2/round.cert \
- rtl/rel8/support/lib2/rtl.cert \
- rtl/rel8/support/lib2/rtlarr.cert \
- rtl/rel8/support/lib2/simple-loop-helpers.cert \
- rtl/rel8/support/lib2/simplify-model-helpers.cert \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/support/lib2/util.cert \
- rtl/rel8/support/support/add3-proofs.cert \
- rtl/rel8/support/support/add3.cert \
- rtl/rel8/support/support/all-ones.cert \
- rtl/rel8/support/support/ash.cert \
- rtl/rel8/support/support/away-proofs.cert \
- rtl/rel8/support/support/away.cert \
- rtl/rel8/support/support/badguys.cert \
- rtl/rel8/support/support/bias-proofs.cert \
- rtl/rel8/support/support/bias.cert \
- rtl/rel8/support/support/bitn-proofs.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/bits-proofs.cert \
- rtl/rel8/support/support/bits-trunc-proofs.cert \
- rtl/rel8/support/support/bits-trunc.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bvecp-helpers.cert \
- rtl/rel8/support/support/bvecp-lemmas.cert \
- rtl/rel8/support/support/bvecp-proofs.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/cat-def.cert \
- rtl/rel8/support/support/cat-proofs.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/clocks.cert \
- rtl/rel8/support/support/decode-proofs.cert \
- rtl/rel8/support/support/decode.cert \
- rtl/rel8/support/support/drnd-original.cert \
- rtl/rel8/support/support/encode.cert \
- rtl/rel8/support/support/ereps-proofs.cert \
- rtl/rel8/support/support/ereps.cert \
- rtl/rel8/support/support/fadd-extra.cert \
- rtl/rel8/support/support/fadd-extra0.cert \
- rtl/rel8/support/support/fadd.cert \
- rtl/rel8/support/support/fast-and.cert \
- rtl/rel8/support/support/float-extra.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/guards.cert \
- rtl/rel8/support/support/ireps.cert \
- rtl/rel8/support/support/land.cert \
- rtl/rel8/support/support/land0-proofs.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lextra-proofs.cert \
- rtl/rel8/support/support/lextra.cert \
- rtl/rel8/support/support/lextra0.cert \
- rtl/rel8/support/support/lior.cert \
- rtl/rel8/support/support/lior0-proofs.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lnot-proofs.cert \
- rtl/rel8/support/support/lnot.cert \
- rtl/rel8/support/support/log-equal.cert \
- rtl/rel8/support/support/log-proofs.cert \
- rtl/rel8/support/support/log.cert \
- rtl/rel8/support/support/logand-proofs.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/logeqv.cert \
- rtl/rel8/support/support/logior-proofs.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/support/logior1-proofs.cert \
- rtl/rel8/support/support/logior1.cert \
- rtl/rel8/support/support/lognot.cert \
- rtl/rel8/support/support/logorc1.cert \
- rtl/rel8/support/support/logs.cert \
- rtl/rel8/support/support/logxor.cert \
- rtl/rel8/support/support/lop1-proofs.cert \
- rtl/rel8/support/support/lop1.cert \
- rtl/rel8/support/support/lop2-proofs.cert \
- rtl/rel8/support/support/lop2.cert \
- rtl/rel8/support/support/lop3-proofs.cert \
- rtl/rel8/support/support/lop3.cert \
- rtl/rel8/support/support/lxor.cert \
- rtl/rel8/support/support/lxor0-proofs.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/merge2.cert \
- rtl/rel8/support/support/mod4.cert \
- rtl/rel8/support/support/model-helpers.cert \
- rtl/rel8/support/support/mulcat-proofs.cert \
- rtl/rel8/support/support/mulcat.cert \
- rtl/rel8/support/support/near+-proofs.cert \
- rtl/rel8/support/support/near+.cert \
- rtl/rel8/support/support/near-proofs.cert \
- rtl/rel8/support/support/near.cert \
- rtl/rel8/support/support/ocat.cert \
- rtl/rel8/support/support/oddr-proofs.cert \
- rtl/rel8/support/support/oddr.cert \
- rtl/rel8/support/support/openers.cert \
- rtl/rel8/support/support/package-defs.cert \
- rtl/rel8/support/support/rewrite-theory.cert \
- rtl/rel8/support/support/rnd.cert \
- rtl/rel8/support/support/rom-helpers.cert \
- rtl/rel8/support/support/round-extra.cert \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/rtlarr.cert \
- rtl/rel8/support/support/setbitn-proofs.cert \
- rtl/rel8/support/support/setbitn.cert \
- rtl/rel8/support/support/setbits-proofs.cert \
- rtl/rel8/support/support/setbits.cert \
- rtl/rel8/support/support/sgn.cert \
- rtl/rel8/support/support/shft.cert \
- rtl/rel8/support/support/simple-loop-helpers.cert \
- rtl/rel8/support/support/simplify-model-helpers.cert \
- rtl/rel8/support/support/stick-proofs.cert \
- rtl/rel8/support/support/stick.cert \
- rtl/rel8/support/support/sticky-proofs.cert \
- rtl/rel8/support/support/sticky.cert \
- rtl/rel8/support/support/sumbits.cert \
- rtl/rel8/support/support/top.cert \
- rtl/rel8/support/support/top1.cert \
- rtl/rel8/support/support/trunc-proofs.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/util.cert \
- rtl/rel8/support/top/top.cert \
- security/jfkr/diffie-helman.cert \
- security/jfkr/encryption.cert \
- security/jfkr/jfkr.cert \
- security/jfkr/random.cert \
- security/suite-b/sha-2.cert \
- security/util/byte-operations.cert \
- serialize/serialize-tests.cert \
- serialize/serialize-tests2.cert \
- serialize/unsound-read.cert \
- sorting/bsort.cert \
- sorting/convert-perm-to-how-many.cert \
- sorting/equisort.cert \
- sorting/equisort2.cert \
- sorting/equisort3.cert \
- sorting/isort.cert \
- sorting/msort.cert \
- sorting/no-dups-qsort.cert \
- sorting/ordered-perms.cert \
- sorting/perm.cert \
- sorting/qsort.cert \
- sorting/sorts-equivalent.cert \
- sorting/sorts-equivalent2.cert \
- sorting/sorts-equivalent3.cert \
- std/io/base.cert \
- std/io/close-input-channel.cert \
- std/io/combine.cert \
- std/io/file-measure.cert \
- std/io/nthcdr-bytes.cert \
- std/io/open-input-channel.cert \
- std/io/open-input-channels.cert \
- std/io/peek-char.cert \
- std/io/read-byte.cert \
- std/io/read-char.cert \
- std/io/read-file-bytes.cert \
- std/io/read-file-characters-no-error.cert \
- std/io/read-file-characters.cert \
- std/io/read-file-lines.cert \
- std/io/read-file-objects.cert \
- std/io/read-ints.cert \
- std/io/read-object.cert \
- std/io/sign-byte.cert \
- std/io/signed-byte-listp.cert \
- std/io/take-bytes.cert \
- std/io/unsigned-byte-listp.cert \
- std/ks/base10-digit-charp.cert \
- std/ks/explode-atom.cert \
- std/ks/explode-nonnegative-integer.cert \
- std/ks/intern-in-package-of-symbol.cert \
- std/ks/string-append.cert \
- std/ks/two-nats-measure.cert \
- std/lists/app.cert \
- std/lists/append.cert \
- std/lists/coerce.cert \
- std/lists/consless-listp.cert \
- std/lists/equiv.cert \
- std/lists/final-cdr.cert \
- std/lists/flatten.cert \
- std/lists/list-defuns.cert \
- std/lists/list-fix.cert \
- std/lists/make-character-list.cert \
- std/lists/mfc-utils.cert \
- std/lists/nat-listp.cert \
- std/lists/nthcdr.cert \
- std/lists/prefixp.cert \
- std/lists/repeat.cert \
- std/lists/rev.cert \
- std/lists/revappend.cert \
- std/lists/reverse.cert \
- std/lists/sets.cert \
- std/lists/take.cert \
- str/abbrevs.cert \
- str/arithmetic.cert \
- str/case-conversion.cert \
- str/cat.cert \
- str/char-case.cert \
- str/digitp.cert \
- str/eqv.cert \
- str/fast-cat.cert \
- str/firstn-chars.cert \
- str/hexify.cert \
- str/html-encode.cert \
- str/ieqv.cert \
- str/iless.cert \
- str/iprefixp.cert \
- str/isort.cert \
- str/istrpos.cert \
- str/istrprefixp.cert \
- str/isubstrp.cert \
- str/natstr.cert \
- str/pad.cert \
- str/portcullis.cert \
- str/prefix-lines.cert \
- str/stringify.cert \
- str/strline.cert \
- str/strnatless.cert \
- str/strpos.cert \
- str/strprefixp.cert \
- str/strrpos.cert \
- str/strsplit.cert \
- str/strsubst.cert \
- str/strtok.cert \
- str/strval.cert \
- str/subseq.cert \
- str/substrp.cert \
- str/suffixp.cert \
- str/top.cert \
- symbolic/generic/assertions.cert \
- symbolic/generic/defsimulate.cert \
- symbolic/generic/factorial-jvm-correct.cert \
- symbolic/generic/measures.cert \
- symbolic/generic/partial-correctness.cert \
- symbolic/generic/tiny-fib-correct.cert \
- symbolic/generic/total-correctness.cert \
- symbolic/m5/demo.cert \
- symbolic/m5/utilities.cert \
- symbolic/tiny-fib/defstobj+.cert \
- symbolic/tiny-fib/fib-def.cert \
- symbolic/tiny-fib/tiny-rewrites.cert \
- symbolic/tiny-fib/tiny.cert \
- symbolic/tiny-triangle/tiny-triangle-correct.cert \
- symbolic/tiny-triangle/triangle-def.cert \
- system/compare-out-files.cert \
- system/convert-normalized-term-to-pairs.cert \
- system/extend-pathname.cert \
- system/f-put-global.cert \
- system/gather-dcls.cert \
- system/hl-addr-combine.cert \
- system/io.cert \
- system/legal-variablep.cert \
- system/meta-extract.cert \
- system/pseudo-good-worldp.cert \
- system/pseudo-termp-lemmas.cert \
- system/subcor-var.cert \
- system/sublis-var.cert \
- system/subst-expr.cert \
- system/subst-var.cert \
- system/too-many-ifs.cert \
- system/top.cert \
- system/update-state.cert \
- system/verified-termination-and-guards.cert \
- system/worldp-check.cert \
- taspi/code/brlens/brlens.cert \
- taspi/code/brlens/trees-with-brlens.cert \
- taspi/code/build/build-term-guards.cert \
- taspi/code/build/build-term.cert \
- taspi/code/fringes/fringes-guards.cert \
- taspi/code/fringes/fringes-props.cert \
- taspi/code/fringes/fringes.cert \
- taspi/code/gen-helper/bdd-functions.cert \
- taspi/code/gen-helper/extra.cert \
- taspi/code/gen-helper/fast-lists.cert \
- taspi/code/gen-helper/sets.cert \
- taspi/code/gen-helper/top.cert \
- taspi/code/gen-trees/app-rev-lists.cert \
- taspi/code/gen-trees/btrees-bdds-sets.cert \
- taspi/code/gen-trees/btrees-bdds.cert \
- taspi/code/gen-trees/btrees.cert \
- taspi/code/gen-trees/sets-lists-trees.cert \
- taspi/code/gen-trees/top.cert \
- taspi/code/gen-trees/tree-predicates.cert \
- taspi/code/replete/replete-guards.cert \
- taspi/code/replete/replete-helper.cert \
- taspi/code/replete/replete.cert \
- taspi/code/sequences/align.cert \
- taspi/code/sequences/p-inform.cert \
- taspi/code/sequences/seqs.cert \
- taspi/code/tree-manip/insertion-based-sort.cert \
- taspi/code/tree-manip/merge-based-sort.cert \
- taspi/code/tree-manip/mv-root.cert \
- taspi/code/tree-manip/quicksort.cert \
- taspi/code/tree-manip/sort-help.cert \
- taspi/code/tree-manip/top.cert \
- taspi/database/db-from-list.cert \
- taspi/database/db.cert \
- taspi/database/entry.cert \
- taspi/database/filters.cert \
- taspi/database/props.cert \
- taspi/proofs/fringes-taspi.cert \
- taspi/proofs/omerge-good-order.cert \
- taspi/proofs/sets.cert \
- taspi/sets-input/consensus.cert \
- taspi/sets-input/greedy.cert \
- taspi/sets-input/mast.cert \
- taspi/sets-input/mct.cert \
- taspi/sets-input/multipolar-loose.cert \
- taspi/sets-input/top.cert \
- taspi/sets-input/tree-compat.cert \
- taspi/sets-input/tree-support-in-set.cert \
- taspi/single-input/taxa-based.cert \
- taspi/single-input/tree-stats.cert \
- taspi/tree-distance/rf.cert \
- taspi/tree-distance/symm-diff.cert \
- taspi/tree-generation/branch-and-bound/bandb.cert \
- taspi/tree-generation/distance-based/naive-quartet-method.cert \
- taspi/tree-generation/heuristics/do-search.cert \
- taspi/tree-generation/heuristics/spr.cert \
- taspi/tree-generation/heuristics/tbr.cert \
- taspi/tree-generation/tree-gen-helper/basics.cert \
- taspi/tree-score/ambig-score.cert \
- taspi/tree-score/circle-scoring.cert \
- taspi/tree-score/costs.cert \
- taspi/tree-score/efficient-pscores-help.cert \
- taspi/tree-score/efficient-pscores.cert \
- taspi/tree-score/fitch-scoring.cert \
- taspi/tree-score/min-length.cert \
- taspi/tree-score/opt-pairwise.cert \
- taspi/tree-score/pscores.cert \
- tau/bounders/elementary-bounders.cert \
- tau/bounders/find-maximal-1d.cert \
- tau/bounders/find-maximal-2d.cert \
- tau/bounders/find-minimal-1d.cert \
- tau/bounders/find-minimal-2d.cert \
- textbook/chap10/ac-example.cert \
- textbook/chap10/adder.cert \
- textbook/chap10/compiler.cert \
- textbook/chap10/fact.cert \
- textbook/chap10/insertion-sort.cert \
- textbook/chap10/tree.cert \
- textbook/chap11/compress.cert \
- textbook/chap11/encap.cert \
- textbook/chap11/finite-sets.cert \
- textbook/chap11/how-many-soln1.cert \
- textbook/chap11/how-many-soln2.cert \
- textbook/chap11/mergesort.cert \
- textbook/chap11/perm-append.cert \
- textbook/chap11/perm.cert \
- textbook/chap11/qsort.cert \
- textbook/chap11/starters.cert \
- textbook/chap11/summations-book.cert \
- textbook/chap11/summations.cert \
- textbook/chap11/tautology.cert \
- textbook/chap11/xtr.cert \
- textbook/chap11/xtr2.cert \
- textbook/chap3/programs.cert \
- textbook/chap4/solutions-logic-mode.cert \
- textbook/chap4/solutions-program-mode.cert \
- textbook/chap5/solutions.cert \
- textbook/chap6/selected-solutions.cert \
- tools/bstar.cert \
- tools/case-splitting-rules.cert \
- tools/clone-stobj.cert \
- tools/cws.cert \
- tools/def-functional-instance.cert \
- tools/defconsts.cert \
- tools/defevaluator-fast.cert \
- tools/define-keyed-function.cert \
- tools/defined-const.cert \
- tools/defmacfun.cert \
- tools/defredundant.cert \
- tools/defsum.cert \
- tools/deftuple.cert \
- tools/do-not.cert \
- tools/easy-simplify.cert \
- tools/fake-event.cert \
- tools/flag.cert \
- tools/in-raw-mode.cert \
- tools/include-raw.cert \
- tools/mv-nth.cert \
- tools/oracle-eval-real.cert \
- tools/oracle-eval.cert \
- tools/pack.cert \
- tools/pattern-match.cert \
- tools/plev-ccl.cert \
- tools/plev.cert \
- tools/rulesets.cert \
- tools/safe-case.cert \
- tools/saved-errors.cert \
- tools/stobj-frame.cert \
- tools/stobj-help.cert \
- tools/templates.cert \
- tools/theory-tools.cert \
- tools/time-dollar-with-gc.cert \
- tools/types-misc.cert \
- tools/with-arith5-help.cert \
- tools/with-quoted-forms.cert \
- tutorial-problems/introductory-challenge-problem-4-athena.cert \
- tutorial-problems/introductory-challenge-problem-4.cert \
- unicode/partition.cert \
- unicode/read-utf8.cert \
- unicode/sum-list.cert \
- unicode/uchar.cert \
- unicode/utf8-decode.cert \
- unicode/utf8-encode.cert \
- unicode/utf8-table35.cert \
- unicode/utf8-table36.cert \
- unicode/z-listp.cert \
- workshops/1999/calculus/solutions/mesh-append.cert \
- workshops/1999/calculus/solutions/mesh-make-partition.cert \
- workshops/1999/calculus/solutions/partition-defuns.cert \
- workshops/1999/calculus/solutions/partitionp-make-partition-rec.cert \
- workshops/1999/calculus/solutions/partitionp-make-partition.cert \
- workshops/1999/calculus/solutions/riemann-rcfn-helpers.cert \
- workshops/1999/compiler/compiler.cert \
- workshops/1999/compiler/evaluator.cert \
- workshops/1999/compiler/exercises.cert \
- workshops/1999/compiler/machine.cert \
- workshops/1999/compiler/proof.cert \
- workshops/1999/compiler/proof1.cert \
- workshops/1999/de-hdl/arity.cert \
- workshops/1999/de-hdl/de4.cert \
- workshops/1999/de-hdl/examples.cert \
- workshops/1999/de-hdl/help-defuns.cert \
- workshops/1999/de-hdl/measure.cert \
- workshops/1999/de-hdl/primitives.cert \
- workshops/1999/de-hdl/sts-okp.cert \
- workshops/1999/de-hdl/syntax.cert \
- workshops/1999/de-hdl/thm-example.cert \
- workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.cert \
- workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.cert \
- workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.cert \
- workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.cert \
- workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.cert \
- workshops/1999/embedded/Proof-Of-Contribution/CRT.cert \
- workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Generic.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Mapping.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.cert \
- workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.cert \
- workshops/1999/graph/find-path1.cert \
- workshops/1999/graph/find-path2.cert \
- workshops/1999/graph/find-path3.cert \
- workshops/1999/graph/helpers.cert \
- workshops/1999/graph/linear-find-path.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/alls.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/cnf.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/derive.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/flip.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/keval.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/modeler.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/nnf.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/paramod.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/prover.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/resolve.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sets.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/simplify.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/substitution.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sugar.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/top.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/variables.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/xeval.cert \
- workshops/1999/knuth-91/aof.cert \
- workshops/1999/knuth-91/exercise1.cert \
- workshops/1999/knuth-91/exercise2.cert \
- workshops/1999/knuth-91/exercise3.cert \
- workshops/1999/knuth-91/exercise4a.cert \
- workshops/1999/knuth-91/exercise4b.cert \
- workshops/1999/knuth-91/exercise5.cert \
- workshops/1999/knuth-91/exercise6a.cert \
- workshops/1999/knuth-91/exercise6b.cert \
- workshops/1999/knuth-91/exercise7a.cert \
- workshops/1999/knuth-91/exercise7b.cert \
- workshops/1999/knuth-91/knuth-arch.cert \
- workshops/1999/mu-calculus/book/fast-sets.cert \
- workshops/1999/mu-calculus/book/fixpoints.cert \
- workshops/1999/mu-calculus/book/models.cert \
- workshops/1999/mu-calculus/book/relations.cert \
- workshops/1999/mu-calculus/book/semantics.cert \
- workshops/1999/mu-calculus/book/sets.cert \
- workshops/1999/mu-calculus/book/syntax.cert \
- workshops/1999/mu-calculus/solutions/ctl.cert \
- workshops/1999/mu-calculus/solutions/defung.cert \
- workshops/1999/mu-calculus/solutions/fast-sets.cert \
- workshops/1999/mu-calculus/solutions/fixpoints.cert \
- workshops/1999/mu-calculus/solutions/meta.cert \
- workshops/1999/mu-calculus/solutions/models.cert \
- workshops/1999/mu-calculus/solutions/perm.cert \
- workshops/1999/mu-calculus/solutions/relations.cert \
- workshops/1999/mu-calculus/solutions/semantics.cert \
- workshops/1999/mu-calculus/solutions/sets.cert \
- workshops/1999/mu-calculus/solutions/syntax.cert \
- workshops/1999/pipeline/b-ops-aux-def.cert \
- workshops/1999/pipeline/b-ops-aux.cert \
- workshops/1999/pipeline/basic-def.cert \
- workshops/1999/pipeline/basic-lemmas.cert \
- workshops/1999/pipeline/exercise.cert \
- workshops/1999/pipeline/ihs.cert \
- workshops/1999/pipeline/model.cert \
- workshops/1999/pipeline/proof.cert \
- workshops/1999/pipeline/table-def.cert \
- workshops/1999/pipeline/trivia.cert \
- workshops/1999/pipeline/utils.cert \
- workshops/1999/simulator/exercises.cert \
- workshops/1999/simulator/tiny.cert \
- workshops/1999/ste/assertion.cert \
- workshops/1999/ste/boolean.cert \
- workshops/1999/ste/circuit.cert \
- workshops/1999/ste/example.cert \
- workshops/1999/ste/expression.cert \
- workshops/1999/ste/fundamental.cert \
- workshops/1999/ste/inference.cert \
- workshops/1999/ste/lemma-4.cert \
- workshops/1999/ste/run.cert \
- workshops/1999/ste/state.cert \
- workshops/1999/ste/trajectory.cert \
- workshops/1999/ste/util.cert \
- workshops/1999/vhdl/exercises.cert \
- workshops/1999/vhdl/fact-proof.cert \
- workshops/1999/vhdl/fact.cert \
- workshops/1999/vhdl/vhdl.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/base.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/compile.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/cstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/expr.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/lstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/mstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/pstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/setup.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/simulator.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/util.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.cert \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.cert \
- workshops/2000/manolios/pipeline/pipeline/top/ihs.cert \
- workshops/2000/manolios/pipeline/pipeline/top/meta.cert \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.cert \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux.cert \
- workshops/2000/manolios/pipeline/trivial/basic-def.cert \
- workshops/2000/manolios/pipeline/trivial/basic-lemmas.cert \
- workshops/2000/manolios/pipeline/trivial/ihs.cert \
- workshops/2000/manolios/pipeline/trivial/model.cert \
- workshops/2000/manolios/pipeline/trivial/proof.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/model.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/proof.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/utils.cert \
- workshops/2000/manolios/pipeline/trivial/table-def.cert \
- workshops/2000/manolios/pipeline/trivial/trivia.cert \
- workshops/2000/manolios/pipeline/trivial/utils.cert \
- workshops/2000/medina/polynomials/addition.cert \
- workshops/2000/medina/polynomials/congruences-1.cert \
- workshops/2000/medina/polynomials/congruences-2.cert \
- workshops/2000/medina/polynomials/examples.cert \
- workshops/2000/medina/polynomials/lexicographical-ordering.cert \
- workshops/2000/medina/polynomials/monomial.cert \
- workshops/2000/medina/polynomials/multiplication.cert \
- workshops/2000/medina/polynomials/negation.cert \
- workshops/2000/medina/polynomials/normal-form.cert \
- workshops/2000/medina/polynomials/polynomial.cert \
- workshops/2000/medina/polynomials/term.cert \
- workshops/2000/moore-manolios/partial-functions/defpun-original.cert \
- workshops/2000/moore-manolios/partial-functions/defpun.cert \
- workshops/2000/moore-manolios/partial-functions/examples.cert \
- workshops/2000/moore-manolios/partial-functions/mod-1-property.cert \
- workshops/2000/moore-manolios/partial-functions/report.cert \
- workshops/2000/moore-manolios/partial-functions/tjvm-examples.cert \
- workshops/2000/moore-manolios/partial-functions/tjvm.cert \
- workshops/2000/ruiz/multiset/defmul.cert \
- workshops/2000/ruiz/multiset/examples/ackermann/ackermann.cert \
- workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.cert \
- workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.cert \
- workshops/2000/ruiz/multiset/examples/newman/confluence-v0.cert \
- workshops/2000/ruiz/multiset/examples/newman/confluence.cert \
- workshops/2000/ruiz/multiset/examples/newman/local-confluence.cert \
- workshops/2000/ruiz/multiset/examples/newman/newman.cert \
- workshops/2000/ruiz/multiset/multiset.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/constants.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/declarations.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/exec.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/inputs.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/main.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/model.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/pipe.cert \
- workshops/2000/russinoff-short/crt.cert \
- workshops/2000/russinoff-short/summary.cert \
- workshops/2000/sumners1/cdeq/cdeq-defs.cert \
- workshops/2000/sumners1/cdeq/cdeq-phase1.cert \
- workshops/2000/sumners1/cdeq/cdeq-phase2.cert \
- workshops/2000/sumners1/cdeq/cdeq-phase3.cert \
- workshops/2000/sumners1/cdeq/cdeq-phase4.cert \
- workshops/2000/sumners1/cdeq/records.cert \
- workshops/2000/sumners2/bdds/bdd-mgr.cert \
- workshops/2000/sumners2/bdds/bdd-prf.cert \
- workshops/2000/sumners2/bdds/bdd-spec.cert \
- workshops/2002/cowles-flat/support/flat-ackermann.cert \
- workshops/2002/cowles-flat/support/flat-nested.cert \
- workshops/2002/cowles-flat/support/flat-primitive.cert \
- workshops/2002/cowles-flat/support/flat-reverse.cert \
- workshops/2002/cowles-flat/support/flat-tail.cert \
- workshops/2002/cowles-flat/support/flat-z.cert \
- workshops/2002/cowles-flat/support/flat.cert \
- workshops/2002/cowles-primrec/support/bad-def.cert \
- workshops/2002/cowles-primrec/support/bad-def1.cert \
- workshops/2002/cowles-primrec/support/defpr.cert \
- workshops/2002/cowles-primrec/support/fix.cert \
- workshops/2002/cowles-primrec/support/primitive.cert \
- workshops/2002/cowles-primrec/support/tail.cert \
- workshops/2002/georgelin-borrione-ostier/support/acl2-transl.cert \
- workshops/2002/georgelin-borrione-ostier/support/generates-functions.cert \
- workshops/2002/georgelin-borrione-ostier/support/generates-theorems.cert \
- workshops/2002/georgelin-borrione-ostier/support/utils.cert \
- workshops/2002/kaufmann-sumners/support/records.cert \
- workshops/2002/kaufmann-sumners/support/records0.cert \
- workshops/2002/kaufmann-sumners/support/sets.cert \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.cert \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.cert \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.cert \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.cert \
- workshops/2002/manolios-kaufmann/support/records/records-original.cert \
- workshops/2002/manolios-kaufmann/support/records/records.cert \
- workshops/2002/manolios-kaufmann/support/records/total-order.cert \
- workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.cert \
- workshops/2002/manolios-kaufmann/support/sorting/perm-order.cert \
- workshops/2002/manolios-kaufmann/support/sorting/perm.cert \
- workshops/2002/manolios-kaufmann/support/sorting/quicksort.cert \
- workshops/2002/manolios-kaufmann/support/sorting/total-order.cert \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.cert \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.cert \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.cert \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.cert \
- workshops/2002/martin-alonso-perez-sancho/support/Adleman.cert \
- workshops/2002/medina-palomo-alonso/support/section-2/npol.cert \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-1.cert \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-2.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/monomial.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/term.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/upol.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.cert \
- workshops/2003/austel/support/abs-type.cert \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.cert \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.cert \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.cert \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.cert \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.cert \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.cert \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.cert \
- workshops/2003/gamboa-cowles-van-baalen/support/linalg.cert \
- workshops/2003/greve-wilding_defrecord/support/defrecord.cert \
- workshops/2003/greve-wilding_mbe/support/fpst.cert \
- workshops/2003/greve-wilding_mbe/support/run-fpst.cert \
- workshops/2003/hbl/support/sol1.cert \
- workshops/2003/hbl/support/sol2.cert \
- workshops/2003/hendrix/support/madd.cert \
- workshops/2003/hendrix/support/matrices.cert \
- workshops/2003/hendrix/support/mdefthms.cert \
- workshops/2003/hendrix/support/mdefuns.cert \
- workshops/2003/hendrix/support/mentry.cert \
- workshops/2003/hendrix/support/mid.cert \
- workshops/2003/hendrix/support/mmult.cert \
- workshops/2003/hendrix/support/mscal.cert \
- workshops/2003/hendrix/support/msub.cert \
- workshops/2003/hendrix/support/mtrans.cert \
- workshops/2003/hendrix/support/mzero.cert \
- workshops/2003/hendrix/support/vector.cert \
- workshops/2003/matlin-mccune/support/simp.cert \
- workshops/2003/moore_rockwell/support/memory-taggings.cert \
- workshops/2003/moore_vcg/support/demo.cert \
- workshops/2003/moore_vcg/support/m5.cert \
- workshops/2003/moore_vcg/support/utilities.cert \
- workshops/2003/moore_vcg/support/vcg-examples.cert \
- workshops/2003/ray-matthews-tuttle/support/apply-total-order.cert \
- workshops/2003/ray-matthews-tuttle/support/bisimilarity.cert \
- workshops/2003/ray-matthews-tuttle/support/circuit-bisim.cert \
- workshops/2003/ray-matthews-tuttle/support/circuits.cert \
- workshops/2003/ray-matthews-tuttle/support/concrete-ltl.cert \
- workshops/2003/ray-matthews-tuttle/support/cone-of-influence.cert \
- workshops/2003/ray-matthews-tuttle/support/conjunction.cert \
- workshops/2003/ray-matthews-tuttle/support/impl-hack.cert \
- workshops/2003/ray-matthews-tuttle/support/ltl.cert \
- workshops/2003/ray-matthews-tuttle/support/records.cert \
- workshops/2003/ray-matthews-tuttle/support/reductions.cert \
- workshops/2003/ray-matthews-tuttle/support/sets.cert \
- workshops/2003/ray-matthews-tuttle/support/total-order.cert \
- workshops/2003/schmaltz-al-sammane-et-al/support/consistency.cert \
- workshops/2003/schmaltz-borrione/support/arbiter.cert \
- workshops/2003/schmaltz-borrione/support/decoder.cert \
- workshops/2003/schmaltz-borrione/support/inequalities.cert \
- workshops/2003/schmaltz-borrione/support/predicates.cert \
- workshops/2003/schmaltz-borrione/support/transfers.cert \
- workshops/2003/sumners/support/cfair.cert \
- workshops/2003/sumners/support/example1.cert \
- workshops/2003/sumners/support/example2.cert \
- workshops/2003/sumners/support/example3.cert \
- workshops/2003/sumners/support/fair1.cert \
- workshops/2003/sumners/support/fair2.cert \
- workshops/2003/sumners/support/n2n.cert \
- workshops/2003/sumners/support/simple.cert \
- workshops/2003/sustik/support/dickson.cert \
- workshops/2003/toma-borrione/support/bv-op-defthms.cert \
- workshops/2003/toma-borrione/support/bv-op-defuns.cert \
- workshops/2003/toma-borrione/support/misc.cert \
- workshops/2003/toma-borrione/support/padding-1-256.cert \
- workshops/2003/toma-borrione/support/padding-384-512.cert \
- workshops/2003/toma-borrione/support/parsing.cert \
- workshops/2003/toma-borrione/support/sha-1.cert \
- workshops/2003/toma-borrione/support/sha-256.cert \
- workshops/2003/toma-borrione/support/sha-384-512.cert \
- workshops/2003/toma-borrione/support/sha-functions.cert \
- workshops/2003/tsong/support/shim.cert \
- workshops/2004/cowles-gamboa/support/WyoM1-correct.cert \
- workshops/2004/cowles-gamboa/support/WyoM1-utilities.cert \
- workshops/2004/cowles-gamboa/support/WyoM1.cert \
- workshops/2004/cowles-gamboa/support/knuth.cert \
- workshops/2004/cowles-gamboa/support/tail-rec.cert \
- workshops/2004/davis/support/computed-hints.cert \
- workshops/2004/davis/support/fast.cert \
- workshops/2004/davis/support/instance.cert \
- workshops/2004/davis/support/map.cert \
- workshops/2004/davis/support/membership.cert \
- workshops/2004/davis/support/outer.cert \
- workshops/2004/davis/support/primitives.cert \
- workshops/2004/davis/support/quantify.cert \
- workshops/2004/davis/support/set-order.cert \
- workshops/2004/davis/support/sets.cert \
- workshops/2004/davis/support/sort.cert \
- workshops/2004/gameiro-manolios/support/interval.cert \
- workshops/2004/gameiro-manolios/support/nth-thms.cert \
- workshops/2004/gameiro-manolios/support/top-with-meta.cert \
- workshops/2004/gameiro-manolios/support/transversality.cert \
- workshops/2004/greve/support/defrecord.cert \
- workshops/2004/greve/support/mark.cert \
- workshops/2004/legato/support/generic-theories.cert \
- workshops/2004/legato/support/generic-theory-alternative-induction-mult.cert \
- workshops/2004/legato/support/generic-theory-alternative-induction-sum.cert \
- workshops/2004/legato/support/generic-theory-loop-invariant-mult.cert \
- workshops/2004/legato/support/generic-theory-loop-invariant-sum.cert \
- workshops/2004/legato/support/generic-theory-tail-recursion-mult.cert \
- workshops/2004/legato/support/generic-theory-tail-recursion-sum.cert \
- workshops/2004/legato/support/proof-by-generalization-mult.cert \
- workshops/2004/legato/support/proof-by-generalization-sum.cert \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.cert \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.cert \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/records.cert \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.cert \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.cert \
- workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.cert \
- workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.cert \
- workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.cert \
- workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.cert \
- workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.cert \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.cert \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.cert \
- workshops/2004/ray/support/defcoerce.cert \
- workshops/2004/ray/support/defpun-exec.cert \
- workshops/2004/ray/support/generic.cert \
- workshops/2004/roach-fraij/support/roach-fraij-script.cert \
- workshops/2004/ruiz-et-al/support/basic.cert \
- workshops/2004/ruiz-et-al/support/dag-unification-rules.cert \
- workshops/2004/ruiz-et-al/support/dags.cert \
- workshops/2004/ruiz-et-al/support/lists.cert \
- workshops/2004/ruiz-et-al/support/matching.cert \
- workshops/2004/ruiz-et-al/support/prefix-unification-rules.cert \
- workshops/2004/ruiz-et-al/support/q-dag-unification-rules.cert \
- workshops/2004/ruiz-et-al/support/q-dag-unification-st.cert \
- workshops/2004/ruiz-et-al/support/q-dag-unification.cert \
- workshops/2004/ruiz-et-al/support/subsumption-subst.cert \
- workshops/2004/ruiz-et-al/support/subsumption.cert \
- workshops/2004/ruiz-et-al/support/terms-as-dag.cert \
- workshops/2004/ruiz-et-al/support/terms.cert \
- workshops/2004/sawada/support/bv.cert \
- workshops/2004/sawada/support/ihs.cert \
- workshops/2004/schmaltz-borrione/support/collect_msg_book.cert \
- workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.cert \
- workshops/2004/schmaltz-borrione/support/intersect.cert \
- workshops/2004/schmaltz-borrione/support/local_trip_book.cert \
- workshops/2004/schmaltz-borrione/support/make_travel_list_book.cert \
- workshops/2004/schmaltz-borrione/support/mod_lemmas.cert \
- workshops/2004/schmaltz-borrione/support/node.cert \
- workshops/2004/schmaltz-borrione/support/octagon_book.cert \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.cert \
- workshops/2004/schmaltz-borrione/support/routing_defuns.cert \
- workshops/2004/schmaltz-borrione/support/routing_local_lemmas.cert \
- workshops/2004/schmaltz-borrione/support/routing_main.cert \
- workshops/2004/schmaltz-borrione/support/scheduler_book.cert \
- workshops/2004/schmaltz-borrione/support/switch.cert \
- workshops/2004/schmaltz-borrione/support/trip_book.cert \
- workshops/2004/schmaltz-borrione/support/trip_thms.cert \
- workshops/2004/smith-et-al/support/bags/bag-exports.cert \
- workshops/2004/smith-et-al/support/bags/bag-pkg.cert \
- workshops/2004/smith-et-al/support/bags/basic.cert \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.cert \
- workshops/2004/smith-et-al/support/bags/cons.cert \
- workshops/2004/smith-et-al/support/bags/eric-meta.cert \
- workshops/2004/smith-et-al/support/bags/meta.cert \
- workshops/2004/smith-et-al/support/bags/neq.cert \
- workshops/2004/smith-et-al/support/bags/top.cert \
- workshops/2004/smith-et-al/support/bags/two-level-meta.cert \
- workshops/2004/smith-et-al/support/bags/two-level.cert \
- workshops/2004/smith-et-al/support/lists/list-exports.cert \
- workshops/2004/smith-et-al/support/lists/list-top.cert \
- workshops/2004/smith-et-al/support/lists/lists.cert \
- workshops/2004/smith-et-al/support/lists/mv-nth.cert \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.cert \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.cert \
- workshops/2004/smith-et-al/support/syntax/auxilary.cert \
- workshops/2004/smith-et-al/support/syntax/syn-pkg.cert \
- workshops/2004/smith-et-al/support/syntax/syntax-extensions.cert \
- workshops/2004/smith-et-al/support/syntax/syntax.cert \
- workshops/2004/sumners-ray/support/basis.cert \
- workshops/2004/sumners-ray/support/crit.cert \
- workshops/2004/sumners-ray/support/mesi.cert \
- workshops/2004/sumners-ray/support/records.cert \
- workshops/2004/sumners-ray/support/sets.cert \
- workshops/2004/sumners-ray/support/total-order.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed1.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.cert \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.cert \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.cert \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.cert \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.cert \
- workshops/2006/greve/nary/example.cert \
- workshops/2006/greve/nary/nary.cert \
- workshops/2006/greve/nary/nth-rules.cert \
- workshops/2006/hunt-reeber/support/acl2.cert \
- workshops/2006/hunt-reeber/support/bdd.cert \
- workshops/2006/hunt-reeber/support/sat.cert \
- workshops/2006/kaufmann-moore/support/austel.cert \
- workshops/2006/kaufmann-moore/support/greve1.cert \
- workshops/2006/kaufmann-moore/support/greve2.cert \
- workshops/2006/kaufmann-moore/support/greve3.cert \
- workshops/2006/kaufmann-moore/support/mini-proveall-plus.cert \
- workshops/2006/kaufmann-moore/support/mini-proveall.cert \
- workshops/2006/kaufmann-moore/support/rhs1-iff.cert \
- workshops/2006/kaufmann-moore/support/rhs1.cert \
- workshops/2006/kaufmann-moore/support/rhs2.cert \
- workshops/2006/kaufmann-moore/support/smith1.cert \
- workshops/2006/kaufmann-moore/support/sumners1.cert \
- workshops/2006/kaufmann-moore/support/warnings.cert \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.cert \
- workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.cert \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.cert \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.cert \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.cert \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.cert \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.cert \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.cert \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.cert \
- workshops/2006/rager/support/ptest-fib.cert \
- workshops/2006/rager/support/ptest-if-normalization.cert \
- workshops/2006/rager/support/ptest-mergesort.cert \
- workshops/2006/ray/tail/exists.cert \
- workshops/2006/ray/tail/forall.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.cert \
- workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.cert \
- workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.cert \
- workshops/2006/swords-cook/lcsoundness/defsum-thms.cert \
- workshops/2006/swords-cook/lcsoundness/defsum.cert \
- workshops/2006/swords-cook/lcsoundness/pattern-match.cert \
- workshops/2007/cowles-et-al/support/cowles/while-loop.cert \
- workshops/2007/cowles-et-al/support/greve/ack.cert \
- workshops/2007/cowles-et-al/support/greve/defminterm.cert \
- workshops/2007/cowles-et-al/support/greve/defpun.cert \
- workshops/2007/cowles-et-al/support/greve/defxch.cert \
- workshops/2007/cowles-et-al/support/greve/while.cert \
- workshops/2007/cowles-et-al/support/ray/reflexive-macros.cert \
- workshops/2007/cowles-et-al/support/ray/reflexive.cert \
- workshops/2007/dillinger-et-al/code/all.cert \
- workshops/2007/dillinger-et-al/code/bridge.cert \
- workshops/2007/dillinger-et-al/code/defcode-macro.cert \
- workshops/2007/dillinger-et-al/code/defcode.cert \
- workshops/2007/dillinger-et-al/code/defstruct-parsing.cert \
- workshops/2007/dillinger-et-al/code/hacker.cert \
- workshops/2007/dillinger-et-al/code/raw.cert \
- workshops/2007/dillinger-et-al/code/redefun.cert \
- workshops/2007/dillinger-et-al/code/rewrite-code.cert \
- workshops/2007/dillinger-et-al/code/subsumption.cert \
- workshops/2007/dillinger-et-al/code/table-guard.cert \
- workshops/2007/erickson/bprove/bash.cert \
- workshops/2007/erickson/bprove/exdefs.cert \
- workshops/2007/erickson/bprove/gen.cert \
- workshops/2007/erickson/bprove/lemgen.cert \
- workshops/2007/erickson/bprove/refute.cert \
- workshops/2007/rimlinger/support/Rimlinger.cert \
- workshops/2007/rubio/support/abstract-reductions/abstract-proofs.cert \
- workshops/2007/rubio/support/abstract-reductions/confluence.cert \
- workshops/2007/rubio/support/abstract-reductions/convergent.cert \
- workshops/2007/rubio/support/abstract-reductions/newman.cert \
- workshops/2007/rubio/support/multisets/defmul.cert \
- workshops/2007/rubio/support/multisets/multiset.cert \
- workshops/2007/rubio/support/simplicial-topology/generate-degenerate.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.cert \
- workshops/2009/fraij-roach/support/functions.cert \
- workshops/2009/fraij-roach/support/theorems.cert \
- workshops/2009/hardin/deque-stobj/deque-stobj.cert \
- workshops/2009/hardin/deque-stobj/deque-thms.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.cert \
- workshops/2009/liu/support/error-analysis-tool3.cert \
- workshops/2009/liu/support/mylet.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.cert \
- workshops/2009/sumners/support/kas.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.cert \
- workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.cert \
- workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.cert \
- workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.cert \
- workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.cert \
- wp-gen/mutrec/mutrec.cert \
- wp-gen/shared.cert \
- wp-gen/wp-gen.cert \
- xdoc-impl/autolink.cert \
- xdoc-impl/extra-packages.cert \
- xdoc-impl/fmt-to-str.cert \
- xdoc-impl/import-acl2doc.cert \
- xdoc-impl/mkdir-raw.cert \
- xdoc-impl/mkdir.cert \
- xdoc-impl/parse-xml.cert \
- xdoc-impl/portcullis.cert \
- xdoc-impl/preprocess.cert \
- xdoc-impl/save.cert \
- xdoc-impl/sort.cert \
- xdoc-impl/topics.cert \
- xdoc-impl/write-acl2-xdoc.cert \
- xdoc/base.cert \
- xdoc/book-thms.cert \
- xdoc/defxdoc-raw.cert \
- xdoc/names.cert \
- xdoc/portcullis.cert \
- xdoc/top.cert
-
-all-cert-pl-certs: $(CERT_PL_CERTS)
-
-CERT_PL_SOURCES := \
- arithmetic-2/floor-mod/floor-mod-helper.lisp \
- arithmetic-2/floor-mod/floor-mod.lisp \
- arithmetic-2/meta/cancel-terms-helper.lisp \
- arithmetic-2/meta/cancel-terms-meta.lisp \
- arithmetic-2/meta/collect-terms-meta.lisp \
- arithmetic-2/meta/common-meta.lisp \
- arithmetic-2/meta/expt-helper.lisp \
- arithmetic-2/meta/expt.lisp \
- arithmetic-2/meta/integerp-meta.lisp \
- arithmetic-2/meta/integerp.lisp \
- arithmetic-2/meta/mini-theories.lisp \
- arithmetic-2/meta/non-linear.lisp \
- arithmetic-2/meta/numerator-and-denominator.lisp \
- arithmetic-2/meta/post.lisp \
- arithmetic-2/meta/pre.lisp \
- arithmetic-2/meta/top.lisp \
- arithmetic-2/pass1/basic-arithmetic-helper.lisp \
- arithmetic-2/pass1/basic-arithmetic.lisp \
- arithmetic-2/pass1/expt-helper.lisp \
- arithmetic-2/pass1/expt.lisp \
- arithmetic-2/pass1/inequalities.lisp \
- arithmetic-2/pass1/mini-theories.lisp \
- arithmetic-2/pass1/numerator-and-denominator-helper.lisp \
- arithmetic-2/pass1/numerator-and-denominator.lisp \
- arithmetic-2/pass1/prefer-times.lisp \
- arithmetic-2/pass1/top.lisp \
- arithmetic-3/bind-free/arithmetic-theory.lisp \
- arithmetic-3/bind-free/banner.lisp \
- arithmetic-3/bind-free/basic-helper.lisp \
- arithmetic-3/bind-free/basic.lisp \
- arithmetic-3/bind-free/building-blocks.lisp \
- arithmetic-3/bind-free/collect.lisp \
- arithmetic-3/bind-free/common.lisp \
- arithmetic-3/bind-free/default-hint.lisp \
- arithmetic-3/bind-free/integerp-meta.lisp \
- arithmetic-3/bind-free/integerp.lisp \
- arithmetic-3/bind-free/mini-theories-helper.lisp \
- arithmetic-3/bind-free/mini-theories.lisp \
- arithmetic-3/bind-free/normalize.lisp \
- arithmetic-3/bind-free/numerator-and-denominator.lisp \
- arithmetic-3/bind-free/remove-weak-inequalities.lisp \
- arithmetic-3/bind-free/simplify-helper.lisp \
- arithmetic-3/bind-free/simplify.lisp \
- arithmetic-3/bind-free/top.lisp \
- arithmetic-3/extra/ext.lisp \
- arithmetic-3/extra/top-ext.lisp \
- arithmetic-3/floor-mod/floor-mod.lisp \
- arithmetic-3/floor-mod/mod-expt-fast.lisp \
- arithmetic-3/pass1/basic-arithmetic-helper.lisp \
- arithmetic-3/pass1/basic-arithmetic.lisp \
- arithmetic-3/pass1/expt-helper.lisp \
- arithmetic-3/pass1/expt.lisp \
- arithmetic-3/pass1/inequalities.lisp \
- arithmetic-3/pass1/mini-theories.lisp \
- arithmetic-3/pass1/non-linear.lisp \
- arithmetic-3/pass1/num-and-denom-helper.lisp \
- arithmetic-3/pass1/numerator-and-denominator.lisp \
- arithmetic-3/pass1/prefer-times.lisp \
- arithmetic-3/pass1/top.lisp \
- arithmetic-3/top.lisp \
- arithmetic-5/lib/basic-ops/arithmetic-theory.lisp \
- arithmetic-5/lib/basic-ops/banner.lisp \
- arithmetic-5/lib/basic-ops/basic.lisp \
- arithmetic-5/lib/basic-ops/building-blocks-helper.lisp \
- arithmetic-5/lib/basic-ops/building-blocks.lisp \
- arithmetic-5/lib/basic-ops/collect.lisp \
- arithmetic-5/lib/basic-ops/common.lisp \
- arithmetic-5/lib/basic-ops/default-hint.lisp \
- arithmetic-5/lib/basic-ops/distributivity.lisp \
- arithmetic-5/lib/basic-ops/dynamic-e-d.lisp \
- arithmetic-5/lib/basic-ops/elim-hint.acl2 \
- arithmetic-5/lib/basic-ops/elim-hint.lisp \
- arithmetic-5/lib/basic-ops/expt-helper.lisp \
- arithmetic-5/lib/basic-ops/expt.lisp \
- arithmetic-5/lib/basic-ops/forcing-types.lisp \
- arithmetic-5/lib/basic-ops/if-normalization.lisp \
- arithmetic-5/lib/basic-ops/integerp-helper.lisp \
- arithmetic-5/lib/basic-ops/integerp-meta.lisp \
- arithmetic-5/lib/basic-ops/integerp.lisp \
- arithmetic-5/lib/basic-ops/mini-theories.lisp \
- arithmetic-5/lib/basic-ops/natp-posp.lisp \
- arithmetic-5/lib/basic-ops/normalize.lisp \
- arithmetic-5/lib/basic-ops/numerator-and-denominator.lisp \
- arithmetic-5/lib/basic-ops/remove-weak-inequalities.lisp \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.lisp \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.lisp \
- arithmetic-5/lib/basic-ops/simplify-helper.lisp \
- arithmetic-5/lib/basic-ops/simplify.lisp \
- arithmetic-5/lib/basic-ops/top.lisp \
- arithmetic-5/lib/basic-ops/types-helper.lisp \
- arithmetic-5/lib/basic-ops/types.lisp \
- arithmetic-5/lib/basic-ops/we-are-here.lisp \
- arithmetic-5/lib/floor-mod/floor-mod-basic-helper.lisp \
- arithmetic-5/lib/floor-mod/floor-mod-basic.lisp \
- arithmetic-5/lib/floor-mod/floor-mod-helper.lisp \
- arithmetic-5/lib/floor-mod/floor-mod.lisp \
- arithmetic-5/lib/floor-mod/forcing-types.lisp \
- arithmetic-5/lib/floor-mod/if-normalization.lisp \
- arithmetic-5/lib/floor-mod/logand-helper.lisp \
- arithmetic-5/lib/floor-mod/logand.lisp \
- arithmetic-5/lib/floor-mod/mod-expt-fast.lisp \
- arithmetic-5/lib/floor-mod/more-floor-mod.lisp \
- arithmetic-5/lib/floor-mod/top.lisp \
- arithmetic-5/lib/floor-mod/truncate-rem.lisp \
- arithmetic-5/support/basic-arithmetic-helper.lisp \
- arithmetic-5/support/basic-arithmetic.lisp \
- arithmetic-5/support/expt-helper.lisp \
- arithmetic-5/support/expt.lisp \
- arithmetic-5/support/inequalities.lisp \
- arithmetic-5/support/mini-theories.lisp \
- arithmetic-5/support/non-linear.lisp \
- arithmetic-5/support/num-and-denom-helper.lisp \
- arithmetic-5/support/numerator-and-denominator.lisp \
- arithmetic-5/support/prefer-times.lisp \
- arithmetic-5/support/top.lisp \
- arithmetic-5/top.lisp \
- arithmetic/abs.lisp \
- arithmetic/binomial.lisp \
- arithmetic/equalities.acl2 \
- arithmetic/equalities.lisp \
- arithmetic/factorial.lisp \
- arithmetic/idiv.lisp \
- arithmetic/inequalities.lisp \
- arithmetic/mod-gcd.lisp \
- arithmetic/nat-listp.lisp \
- arithmetic/natp-posp.lisp \
- arithmetic/rational-listp.lisp \
- arithmetic/rationals.lisp \
- arithmetic/sumlist.lisp \
- arithmetic/top-with-meta.lisp \
- arithmetic/top.lisp \
- bdd/alu-proofs.lisp \
- bdd/alu.lisp \
- bdd/bdd-primitives.lisp \
- bdd/bool-ops.lisp \
- bdd/cbf.lisp \
- bdd/hamming.lisp \
- bdd/pg-theory.lisp \
- centaur/4v-sexpr/4v-logic.lisp \
- centaur/4v-sexpr/bitspecs.lisp \
- centaur/4v-sexpr/cert.acl2 \
- centaur/4v-sexpr/compose-sexpr.lisp \
- centaur/4v-sexpr/g-sexpr-eval.acl2 \
- centaur/4v-sexpr/g-sexpr-eval.lisp \
- centaur/4v-sexpr/nsexprs.lisp \
- centaur/4v-sexpr/onehot-rewrite.lisp \
- centaur/4v-sexpr/portcullis.acl2 \
- centaur/4v-sexpr/portcullis.lisp \
- centaur/4v-sexpr/sexpr-3v.lisp \
- centaur/4v-sexpr/sexpr-advanced.lisp \
- centaur/4v-sexpr/sexpr-building.lisp \
- centaur/4v-sexpr/sexpr-equivs.lisp \
- centaur/4v-sexpr/sexpr-eval.lisp \
- centaur/4v-sexpr/sexpr-fixpoint-correct.lisp \
- centaur/4v-sexpr/sexpr-fixpoint-rewriting.lisp \
- centaur/4v-sexpr/sexpr-fixpoint-spec.lisp \
- centaur/4v-sexpr/sexpr-fixpoint-top.lisp \
- centaur/4v-sexpr/sexpr-fixpoint.lisp \
- centaur/4v-sexpr/sexpr-loop-debug.lisp \
- centaur/4v-sexpr/sexpr-rewrites.lisp \
- centaur/4v-sexpr/sexpr-to-faig.lisp \
- centaur/4v-sexpr/sexpr-vars-1pass.lisp \
- centaur/4v-sexpr/sexpr-vars.lisp \
- centaur/4v-sexpr/svarmap.lisp \
- centaur/4v-sexpr/top.lisp \
- centaur/aig/aig-equivs.lisp \
- centaur/aig/aig-vars-ext.lisp \
- centaur/aig/aig-vars.lisp \
- centaur/aig/aiger.lisp \
- centaur/aig/base.lisp \
- centaur/aig/bddify-correct.lisp \
- centaur/aig/bddify.lisp \
- centaur/aig/cert.acl2 \
- centaur/aig/eval-restrict.lisp \
- centaur/aig/fsm-pkg.lsp \
- centaur/aig/g-aig-eval.acl2 \
- centaur/aig/g-aig-eval.lisp \
- centaur/aig/induction.lisp \
- centaur/aig/misc.lisp \
- centaur/aig/portcullis.acl2 \
- centaur/aig/portcullis.lisp \
- centaur/aig/three-four.lisp \
- centaur/aig/vuaig.lisp \
- centaur/aig/witness.acl2 \
- centaur/aig/witness.lisp \
- centaur/aignet/package.lsp \
- centaur/bitops/bits-between.lisp \
- centaur/bitops/bitsets-opt.lisp \
- centaur/bitops/bitsets.lisp \
- centaur/bitops/cert.acl2 \
- centaur/bitops/congruences.lisp \
- centaur/bitops/equal-by-logbitp.lisp \
- centaur/bitops/extra-defs.lisp \
- centaur/bitops/ihs-extensions.lisp \
- centaur/bitops/ihsext-basics.lisp \
- centaur/bitops/install-bit.lisp \
- centaur/bitops/integer-length.lisp \
- centaur/bitops/part-select.lisp \
- centaur/bitops/rotate.lisp \
- centaur/bitops/sbitsets.lisp \
- centaur/bitops/sign-extend.lisp \
- centaur/bitops/top.lisp \
- centaur/bridge/cert.acl2 \
- centaur/bridge/package.lsp \
- centaur/bridge/portcullis.acl2 \
- centaur/bridge/portcullis.lisp \
- centaur/bridge/to-json.lisp \
- centaur/bridge/top.lisp \
- centaur/defrstobj/array-lemmas.lisp \
- centaur/defrstobj/basic-tests.lisp \
- centaur/defrstobj/cert.acl2 \
- centaur/defrstobj/def-typed-record.lisp \
- centaur/defrstobj/defrstobj.lisp \
- centaur/defrstobj/fancy-worseguy.lisp \
- centaur/defrstobj/g-delete-keys.lisp \
- centaur/defrstobj/groundwork/array-rec.lisp \
- centaur/defrstobj/groundwork/cert.acl2 \
- centaur/defrstobj/groundwork/demo1.lisp \
- centaur/defrstobj/groundwork/demo2.lisp \
- centaur/defrstobj/groundwork/demo3.lisp \
- centaur/defrstobj/groundwork/demo4.lisp \
- centaur/defrstobj/groundwork/demo5.lisp \
- centaur/defrstobj/groundwork/local.lisp \
- centaur/defrstobj/package.lsp \
- centaur/defrstobj/portcullis.acl2 \
- centaur/defrstobj/portcullis.lisp \
- centaur/defrstobj/typed-record-tests.lisp \
- centaur/defrstobj/typed-records.lisp \
- centaur/esim/cert.acl2 \
- centaur/esim/esim-paths.lisp \
- centaur/esim/esim-primitives.lisp \
- centaur/esim/esim-sexpr-correct.lisp \
- centaur/esim/esim-sexpr-support-thms.lisp \
- centaur/esim/esim-sexpr-support.lisp \
- centaur/esim/esim-sexpr.lisp \
- centaur/esim/esim-spec.lisp \
- centaur/esim/esim-vcd.lisp \
- centaur/esim/esim-vl.lisp \
- centaur/esim/follow-backwards.lisp \
- centaur/esim/local-theory.lisp \
- centaur/esim/packages.lsp \
- centaur/esim/plist.lisp \
- centaur/esim/portcullis.acl2 \
- centaur/esim/portcullis.lisp \
- centaur/esim/steps.lisp \
- centaur/esim/stv/cert.acl2 \
- centaur/esim/stv/stv-compile.lisp \
- centaur/esim/stv/stv-debug.lisp \
- centaur/esim/stv/stv-doc.lisp \
- centaur/esim/stv/stv-expand.lisp \
- centaur/esim/stv/stv-run.lisp \
- centaur/esim/stv/stv-sim.lisp \
- centaur/esim/stv/stv-top.lisp \
- centaur/esim/stv/stv-util.lisp \
- centaur/esim/stv/stv-widen.lisp \
- centaur/gl/always-equal-prep.lisp \
- centaur/gl/auto-bindings.lisp \
- centaur/gl/bfr-aig-bddify.lisp \
- centaur/gl/bfr-sat.lisp \
- centaur/gl/bfr.lisp \
- centaur/gl/bvec-ite.lisp \
- centaur/gl/bvecs.lisp \
- centaur/gl/cert.acl2 \
- centaur/gl/def-gl-clause-proc.lisp \
- centaur/gl/defagg.lisp \
- centaur/gl/defapply.lisp \
- centaur/gl/eval-f-i-cp.lisp \
- centaur/gl/eval-g-base-help.lisp \
- centaur/gl/eval-g-base.lisp \
- centaur/gl/factor-fns.lisp \
- centaur/gl/g-always-equal.lisp \
- centaur/gl/g-ash.lisp \
- centaur/gl/g-binary-+.lisp \
- centaur/gl/g-binary-mult.lisp \
- centaur/gl/g-code-char.lisp \
- centaur/gl/g-coerce.lisp \
- centaur/gl/g-cons.lisp \
- centaur/gl/g-equal.lisp \
- centaur/gl/g-floor.lisp \
- centaur/gl/g-gl-mbe.lisp \
- centaur/gl/g-hide.lisp \
- centaur/gl/g-if.lisp \
- centaur/gl/g-integer-length.lisp \
- centaur/gl/g-intern.lisp \
- centaur/gl/g-lessthan.lisp \
- centaur/gl/g-logand.lisp \
- centaur/gl/g-logbitp.lisp \
- centaur/gl/g-logior.lisp \
- centaur/gl/g-lognot.lisp \
- centaur/gl/g-make-fast-alist.lisp \
- centaur/gl/g-mod.lisp \
- centaur/gl/g-predicates.lisp \
- centaur/gl/g-primitives-help.lisp \
- centaur/gl/g-rem.lisp \
- centaur/gl/g-truncate.lisp \
- centaur/gl/g-unary--.lisp \
- centaur/gl/g-unary-concrete.lisp \
- centaur/gl/general-object-thms.lisp \
- centaur/gl/general-objects.lisp \
- centaur/gl/generic-geval.lisp \
- centaur/gl/gify-clause-proc.lisp \
- centaur/gl/gify-thms.lisp \
- centaur/gl/gify.lisp \
- centaur/gl/gl-doc-string.lisp \
- centaur/gl/gl-generic-clause-proc.lisp \
- centaur/gl/gl-mbe.lisp \
- centaur/gl/gl-misc-defs.lisp \
- centaur/gl/gl-misc-doc.lisp \
- centaur/gl/gl-util.lisp \
- centaur/gl/gl.lisp \
- centaur/gl/glcp-templates.lisp \
- centaur/gl/gobject-type-thms.lisp \
- centaur/gl/gobject-types.lisp \
- centaur/gl/gobjectp-thms.lisp \
- centaur/gl/gobjectp.lisp \
- centaur/gl/gtests.lisp \
- centaur/gl/gtype-thms.lisp \
- centaur/gl/gtypes.lisp \
- centaur/gl/hyp-fix-logic.lisp \
- centaur/gl/hyp-fix.lisp \
- centaur/gl/ite-merge.lisp \
- centaur/gl/package.lsp \
- centaur/gl/param.lisp \
- centaur/gl/portcullis.acl2 \
- centaur/gl/portcullis.lisp \
- centaur/gl/run-gified-cp.lisp \
- centaur/gl/rws.lisp \
- centaur/gl/shape-spec.lisp \
- centaur/gl/symbolic-arithmetic-fns.lisp \
- centaur/gl/symbolic-arithmetic.lisp \
- centaur/misc/absstobjs.lisp \
- centaur/misc/alist-defs.lisp \
- centaur/misc/alist-equiv.lisp \
- centaur/misc/alist-witness.lisp \
- centaur/misc/ap.lisp \
- centaur/misc/arith-equivs.lisp \
- centaur/misc/context-rw.acl2 \
- centaur/misc/context-rw.lisp \
- centaur/misc/defapply.lisp \
- centaur/misc/dfs-measure.lisp \
- centaur/misc/equal-by-nths.lisp \
- centaur/misc/equal-sets.acl2 \
- centaur/misc/equal-sets.lisp \
- centaur/misc/evaluator-metatheorems.lisp \
- centaur/misc/fal-graphs.lisp \
- centaur/misc/fast-alists.lisp \
- centaur/misc/filter-alist.lisp \
- centaur/misc/hons-alphorder-merge.acl2 \
- centaur/misc/hons-alphorder-merge.lisp \
- centaur/misc/hons-extra.lisp \
- centaur/misc/hons-remove-dups.lisp \
- centaur/misc/hons-sets.lisp \
- centaur/misc/interp-function-lookup.lisp \
- centaur/misc/introduce-var.acl2 \
- centaur/misc/introduce-var.lisp \
- centaur/misc/lists.lisp \
- centaur/misc/load-stobj-tests.lisp \
- centaur/misc/load-stobj.lisp \
- centaur/misc/memory-mgmt-logic.lisp \
- centaur/misc/memory-mgmt-raw.lisp \
- centaur/misc/mfc-utils.lisp \
- centaur/misc/nat-list-duplicates.lisp \
- centaur/misc/numlist.lisp \
- centaur/misc/osets-witnessing.acl2 \
- centaur/misc/osets-witnessing.lisp \
- centaur/misc/patterns.lisp \
- centaur/misc/seed-random.lisp \
- centaur/misc/smm-impl.lisp \
- centaur/misc/smm.lisp \
- centaur/misc/sneaky-load.lisp \
- centaur/misc/suffixp.lisp \
- centaur/misc/tailrec.acl2 \
- centaur/misc/tailrec.lisp \
- centaur/misc/top.lisp \
- centaur/misc/tshell.lisp \
- centaur/misc/tuplep.lisp \
- centaur/misc/u32-listp.lisp \
- centaur/misc/universal-equiv.lisp \
- centaur/misc/vecs-ints.lisp \
- centaur/misc/witness-cp.lisp \
- centaur/satlink/package.lsp \
- centaur/ubdds/cert.acl2 \
- centaur/ubdds/core.lisp \
- centaur/ubdds/extra-operations.lisp \
- centaur/ubdds/lite.lisp \
- centaur/ubdds/param.lisp \
- centaur/ubdds/sanity-check-macros.lisp \
- centaur/ubdds/subset.lisp \
- centaur/ubdds/witness.acl2 \
- centaur/ubdds/witness.lisp \
- centaur/vl/cert.acl2 \
- centaur/vl/checkers/cert.acl2 \
- centaur/vl/checkers/checkers.lisp \
- centaur/vl/checkers/condcheck.lisp \
- centaur/vl/checkers/dupeinst-check.lisp \
- centaur/vl/checkers/duperhs.lisp \
- centaur/vl/checkers/duplicate-detect.lisp \
- centaur/vl/checkers/leftright.lisp \
- centaur/vl/checkers/multidrive-detect.lisp \
- centaur/vl/checkers/oddexpr.lisp \
- centaur/vl/checkers/portcheck.lisp \
- centaur/vl/checkers/qmarksize-check.lisp \
- centaur/vl/checkers/selfassigns.lisp \
- centaur/vl/checkers/skip-detect.lisp \
- centaur/vl/checkers/typo-detect.lisp \
- centaur/vl/checkers/use-set-report.lisp \
- centaur/vl/checkers/use-set-tool.lisp \
- centaur/vl/checkers/use-set.lisp \
- centaur/vl/lint/bit-use-set.lisp \
- centaur/vl/lint/cert.acl2 \
- centaur/vl/lint/check-case.lisp \
- centaur/vl/lint/check-namespace.lisp \
- centaur/vl/lint/disconnected.lisp \
- centaur/vl/lint/lint.acl2 \
- centaur/vl/lint/lint.lisp \
- centaur/vl/lint/use-set-ignore.lisp \
- centaur/vl/lint/xf-drop-missing-submodules.lisp \
- centaur/vl/lint/xf-drop-unresolved-submodules.lisp \
- centaur/vl/lint/xf-lint-stmt-rewrite.lisp \
- centaur/vl/lint/xf-remove-toohard.lisp \
- centaur/vl/lint/xf-suppress-warnings.lisp \
- centaur/vl/lint/xf-undefined-names.lisp \
- centaur/vl/loader/cert.acl2 \
- centaur/vl/loader/defines.lisp \
- centaur/vl/loader/filemap.lisp \
- centaur/vl/loader/find-file.lisp \
- centaur/vl/loader/inject-comments.lisp \
- centaur/vl/loader/lexer-tests.lisp \
- centaur/vl/loader/lexer-tokens.lisp \
- centaur/vl/loader/lexer-utils.lisp \
- centaur/vl/loader/lexer.lisp \
- centaur/vl/loader/loader.lisp \
- centaur/vl/loader/make-implicit-wires.lisp \
- centaur/vl/loader/overrides.lisp \
- centaur/vl/loader/parse-blockitems.lisp \
- centaur/vl/loader/parse-delays.lisp \
- centaur/vl/loader/parse-error.lisp \
- centaur/vl/loader/parse-eventctrl.lisp \
- centaur/vl/loader/parse-expressions-def.lisp \
- centaur/vl/loader/parse-expressions-eof.lisp \
- centaur/vl/loader/parse-expressions-error.lisp \
- centaur/vl/loader/parse-expressions-progress.lisp \
- centaur/vl/loader/parse-expressions-result.lisp \
- centaur/vl/loader/parse-expressions-tokenlist.lisp \
- centaur/vl/loader/parse-expressions-warnings.lisp \
- centaur/vl/loader/parse-expressions.lisp \
- centaur/vl/loader/parse-functions.lisp \
- centaur/vl/loader/parse-gates.lisp \
- centaur/vl/loader/parse-insts.lisp \
- centaur/vl/loader/parse-lvalues.lisp \
- centaur/vl/loader/parse-modules.lisp \
- centaur/vl/loader/parse-nets.lisp \
- centaur/vl/loader/parse-ports.lisp \
- centaur/vl/loader/parse-ranges.lisp \
- centaur/vl/loader/parse-statements-def.lisp \
- centaur/vl/loader/parse-statements-error.lisp \
- centaur/vl/loader/parse-statements-progress.lisp \
- centaur/vl/loader/parse-statements-result.lisp \
- centaur/vl/loader/parse-statements-tokenlist.lisp \
- centaur/vl/loader/parse-statements-warninglist.lisp \
- centaur/vl/loader/parse-statements.lisp \
- centaur/vl/loader/parse-strengths.lisp \
- centaur/vl/loader/parse-utils.lisp \
- centaur/vl/loader/parser.lisp \
- centaur/vl/loader/preprocessor-tests.lisp \
- centaur/vl/loader/preprocessor.lisp \
- centaur/vl/loader/read-file.lisp \
- centaur/vl/mlib/allexprs.lisp \
- centaur/vl/mlib/atts.lisp \
- centaur/vl/mlib/cert.acl2 \
- centaur/vl/mlib/clean-concats.lisp \
- centaur/vl/mlib/comment-writer.lisp \
- centaur/vl/mlib/context.lisp \
- centaur/vl/mlib/ctxexprs.lisp \
- centaur/vl/mlib/delta.lisp \
- centaur/vl/mlib/expr-building.lisp \
- centaur/vl/mlib/expr-parse.lisp \
- centaur/vl/mlib/expr-slice.lisp \
- centaur/vl/mlib/expr-tools.lisp \
- centaur/vl/mlib/filter.lisp \
- centaur/vl/mlib/find-item.lisp \
- centaur/vl/mlib/find-module.lisp \
- centaur/vl/mlib/fmt.lisp \
- centaur/vl/mlib/hid-tools.lisp \
- centaur/vl/mlib/hierarchy.lisp \
- centaur/vl/mlib/lvalues-mentioning.lisp \
- centaur/vl/mlib/lvalues.lisp \
- centaur/vl/mlib/modname-sets.lisp \
- centaur/vl/mlib/modnamespace.lisp \
- centaur/vl/mlib/namefactory.lisp \
- centaur/vl/mlib/namemangle.lisp \
- centaur/vl/mlib/port-tools.lisp \
- centaur/vl/mlib/print-context.lisp \
- centaur/vl/mlib/print-warnings.lisp \
- centaur/vl/mlib/range-tools.lisp \
- centaur/vl/mlib/relocate.lisp \
- centaur/vl/mlib/remove-bad.lisp \
- centaur/vl/mlib/rvalues.lisp \
- centaur/vl/mlib/stmt-tools.lisp \
- centaur/vl/mlib/sub-counts.lisp \
- centaur/vl/mlib/warnings.lisp \
- centaur/vl/mlib/welltyped.lisp \
- centaur/vl/mlib/writer.lisp \
- centaur/vl/onehot.lisp \
- centaur/vl/other-packages.lsp \
- centaur/vl/package.lsp \
- centaur/vl/parsetree.lisp \
- centaur/vl/portcullis.acl2 \
- centaur/vl/portcullis.lisp \
- centaur/vl/primitives.lisp \
- centaur/vl/toe/cert.acl2 \
- centaur/vl/toe/toe-add-res-modules.lisp \
- centaur/vl/toe/toe-add-zdrivers.lisp \
- centaur/vl/toe/toe-emodwire.lisp \
- centaur/vl/toe/toe-eocc-allnames.lisp \
- centaur/vl/toe/toe-preliminary.lisp \
- centaur/vl/toe/toe-top.lisp \
- centaur/vl/toe/toe-verilogify.lisp \
- centaur/vl/toe/toe-wirealist.lisp \
- centaur/vl/top.acl2 \
- centaur/vl/top.lisp \
- centaur/vl/transforms/always/cert.acl2 \
- centaur/vl/transforms/always/conditions.lisp \
- centaur/vl/transforms/always/elimalways.lisp \
- centaur/vl/transforms/always/eliminitial.lisp \
- centaur/vl/transforms/always/elimnegedge.lisp \
- centaur/vl/transforms/always/flopcode-debug.lisp \
- centaur/vl/transforms/always/flopcode-prog.lisp \
- centaur/vl/transforms/always/flopcode-synth.lisp \
- centaur/vl/transforms/always/ifmerge.lisp \
- centaur/vl/transforms/always/latchcode.lisp \
- centaur/vl/transforms/always/make-flop.lisp \
- centaur/vl/transforms/always/make-latch.lisp \
- centaur/vl/transforms/always/stmtrewrite.lisp \
- centaur/vl/transforms/always/stmttemps.lisp \
- centaur/vl/transforms/always/synthalways.lisp \
- centaur/vl/transforms/always/top.lisp \
- centaur/vl/transforms/always/unelse.lisp \
- centaur/vl/transforms/always/util.lisp \
- centaur/vl/transforms/cert.acl2 \
- centaur/vl/transforms/cn-hooks.lisp \
- centaur/vl/transforms/occform/add.lisp \
- centaur/vl/transforms/occform/cert.acl2 \
- centaur/vl/transforms/occform/compare.lisp \
- centaur/vl/transforms/occform/div.lisp \
- centaur/vl/transforms/occform/mul.lisp \
- centaur/vl/transforms/occform/select.lisp \
- centaur/vl/transforms/occform/shl.lisp \
- centaur/vl/transforms/occform/shr.lisp \
- centaur/vl/transforms/occform/simple.lisp \
- centaur/vl/transforms/occform/top.lisp \
- centaur/vl/transforms/occform/util.lisp \
- centaur/vl/transforms/occform/xdet.lisp \
- centaur/vl/transforms/xf-addinstnames.lisp \
- centaur/vl/transforms/xf-annotate-mods.lisp \
- centaur/vl/transforms/xf-argresolve.lisp \
- centaur/vl/transforms/xf-array-indexing.lisp \
- centaur/vl/transforms/xf-assign-trunc.lisp \
- centaur/vl/transforms/xf-blankargs.lisp \
- centaur/vl/transforms/xf-clean-params.lisp \
- centaur/vl/transforms/xf-clean-selects.lisp \
- centaur/vl/transforms/xf-delayredux.lisp \
- centaur/vl/transforms/xf-designregs.lisp \
- centaur/vl/transforms/xf-designwires.lisp \
- centaur/vl/transforms/xf-drop-blankports.lisp \
- centaur/vl/transforms/xf-elim-supply.lisp \
- centaur/vl/transforms/xf-expand-functions.lisp \
- centaur/vl/transforms/xf-expr-simp.lisp \
- centaur/vl/transforms/xf-expr-split.lisp \
- centaur/vl/transforms/xf-follow-hids.lisp \
- centaur/vl/transforms/xf-gate-elim.lisp \
- centaur/vl/transforms/xf-gateredux.lisp \
- centaur/vl/transforms/xf-gatesplit.lisp \
- centaur/vl/transforms/xf-hid-elim.lisp \
- centaur/vl/transforms/xf-inline.lisp \
- centaur/vl/transforms/xf-oprewrite.lisp \
- centaur/vl/transforms/xf-optimize-rw.lisp \
- centaur/vl/transforms/xf-orig.lisp \
- centaur/vl/transforms/xf-portdecl-sign.lisp \
- centaur/vl/transforms/xf-propagate.lisp \
- centaur/vl/transforms/xf-replicate-insts.lisp \
- centaur/vl/transforms/xf-resolve-ranges.lisp \
- centaur/vl/transforms/xf-sizing.lisp \
- centaur/vl/transforms/xf-subst.lisp \
- centaur/vl/transforms/xf-unparameterize.lisp \
- centaur/vl/transforms/xf-unused-reg.lisp \
- centaur/vl/transforms/xf-weirdint-elim.lisp \
- centaur/vl/translation.lisp \
- centaur/vl/util/arithmetic.lisp \
- centaur/vl/util/bits.lisp \
- centaur/vl/util/cert.acl2 \
- centaur/vl/util/character-list-listp.lisp \
- centaur/vl/util/clean-alist.lisp \
- centaur/vl/util/commentmap.lisp \
- centaur/vl/util/cw-unformatted.lisp \
- centaur/vl/util/cwtime.lisp \
- centaur/vl/util/defs.lisp \
- centaur/vl/util/defwellformed.lisp \
- centaur/vl/util/echars.lisp \
- centaur/vl/util/esim-lemmas.lisp \
- centaur/vl/util/gc.lisp \
- centaur/vl/util/intersectp-equal.lisp \
- centaur/vl/util/namedb.lisp \
- centaur/vl/util/nat-alists.lisp \
- centaur/vl/util/next-power-of-2.lisp \
- centaur/vl/util/osets.lisp \
- centaur/vl/util/position.lisp \
- centaur/vl/util/prefix-hash.lisp \
- centaur/vl/util/prefixp.lisp \
- centaur/vl/util/print-htmlencode.lisp \
- centaur/vl/util/print-urlencode.lisp \
- centaur/vl/util/print.lisp \
- centaur/vl/util/string-alists.lisp \
- centaur/vl/util/subsetp-equal.lisp \
- centaur/vl/util/sum-nats.lisp \
- centaur/vl/util/toposort.lisp \
- centaur/vl/util/warnings.lisp \
- centaur/vl/wf-ranges-resolved-p.lisp \
- centaur/vl/wf-reasonable-p.lisp \
- centaur/vl/wf-widthsfixed-p.lisp \
- clause-processors/SULFA/books/sat/sat-package.acl2 \
- clause-processors/autohide.acl2 \
- clause-processors/autohide.lisp \
- clause-processors/basic-examples.acl2 \
- clause-processors/basic-examples.lisp \
- clause-processors/bv-add-common.lisp \
- clause-processors/bv-add-tests.lisp \
- clause-processors/bv-add.lisp \
- clause-processors/decomp-hint.lisp \
- clause-processors/equality.acl2 \
- clause-processors/equality.lisp \
- clause-processors/ev-find-rules.lisp \
- clause-processors/ev-theoremp.lisp \
- clause-processors/find-subterms.lisp \
- clause-processors/generalize.acl2 \
- clause-processors/generalize.lisp \
- clause-processors/instantiate.lisp \
- clause-processors/join-thms.lisp \
- clause-processors/just-expand.lisp \
- clause-processors/meta-extract-simple-test.lisp \
- clause-processors/meta-extract-user.lisp \
- clause-processors/multi-env-trick.lisp \
- clause-processors/null-fail-hints.lisp \
- clause-processors/nvalues-thms.lisp \
- clause-processors/replace-defined-consts.acl2 \
- clause-processors/replace-defined-consts.lisp \
- clause-processors/replace-impl.lisp \
- clause-processors/stobj-preservation.lisp \
- clause-processors/sublis-var-meaning.lisp \
- clause-processors/term-patterns.acl2 \
- clause-processors/term-patterns.lisp \
- clause-processors/unify-subst.acl2 \
- clause-processors/unify-subst.lisp \
- clause-processors/use-by-hint.lisp \
- clause-processors/witness-cp.acl2 \
- clause-processors/witness-cp.lisp \
- coi/adviser/adviser-defpkg.lsp \
- coi/adviser/adviser-pkg.lisp \
- coi/adviser/adviser.lisp \
- coi/adviser/cert.acl2 \
- coi/adviser/test.lisp \
- coi/alists/alist-defpkg.lsp \
- coi/alists/alist-pkg.lisp \
- coi/alists/bindequiv.lisp \
- coi/alists/cert.acl2 \
- coi/alists/clearkey.lisp \
- coi/alists/deshadow.lisp \
- coi/alists/equiv.lisp \
- coi/alists/keyquiv.lisp \
- coi/alists/preimage.lisp \
- coi/alists/strip.lisp \
- coi/alists/subkeyquiv.lisp \
- coi/alists/top.lisp \
- coi/bags/bag-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/basic.lisp \
- coi/bags/bind-free-rules.lisp \
- coi/bags/cert.acl2 \
- coi/bags/cons.lisp \
- coi/bags/eric-meta.lisp \
- coi/bags/extras.lisp \
- coi/bags/meta.lisp \
- coi/bags/neq.lisp \
- coi/bags/pick-a-point.lisp \
- coi/bags/top.lisp \
- coi/bags/two-level-meta.lisp \
- coi/bags/two-level.lisp \
- coi/defpun/ack.lisp \
- coi/defpun/defminterm.lisp \
- coi/defpun/defpun.lisp \
- coi/defpun/defxch.lisp \
- coi/defstructure/cert.acl2 \
- coi/defstructure/defstructure-pkg.lisp \
- coi/defstructure/defstructure.lisp \
- coi/defstructure/structures-defpkg.lsp \
- coi/dtrees/base.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/child.lisp \
- coi/dtrees/deps.lisp \
- coi/dtrees/dtree-defpkg.lsp \
- coi/dtrees/equiv.lisp \
- coi/dtrees/erase.lisp \
- coi/dtrees/leafp.lisp \
- coi/dtrees/raw.lisp \
- coi/dtrees/royalp.lisp \
- coi/dtrees/set.lisp \
- coi/dtrees/top.lisp \
- coi/gacc/abstract-gacc.lisp \
- coi/gacc/addr-range.lisp \
- coi/gacc/bits.lisp \
- coi/gacc/block.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/finite.acl2 \
- coi/gacc/finite.lisp \
- coi/gacc/fr-path-connection.acl2 \
- coi/gacc/fr-path-connection.lisp \
- coi/gacc/gacc-defpkg.lsp \
- coi/gacc/gacc-exports.lisp \
- coi/gacc/gacc-pkg.lisp \
- coi/gacc/gacc.acl2 \
- coi/gacc/gacc.lisp \
- coi/gacc/gacc2.acl2 \
- coi/gacc/gacc2.lisp \
- coi/gacc/gacc3.acl2 \
- coi/gacc/gacc3.lisp \
- coi/gacc/gax.acl2 \
- coi/gacc/gax.lisp \
- coi/gacc/list-ops-common.lisp \
- coi/gacc/list-ops-fast.acl2 \
- coi/gacc/list-ops-fast.lisp \
- coi/gacc/list-ops.lisp \
- coi/gacc/mem-fast.acl2 \
- coi/gacc/mem-fast.lisp \
- coi/gacc/mem.lisp \
- coi/gacc/ram.lisp \
- coi/gacc/ram0.lisp \
- coi/gacc/ram2.acl2 \
- coi/gacc/ram2.lisp \
- coi/gacc/ram2b.acl2 \
- coi/gacc/ram2b.lisp \
- coi/gacc/ram3.acl2 \
- coi/gacc/ram3.lisp \
- coi/gacc/top.acl2 \
- coi/gacc/top.lisp \
- coi/gacc/tr-path-connection.acl2 \
- coi/gacc/tr-path-connection.lisp \
- coi/gacc/wrap.lisp \
- coi/generalize/cert.acl2 \
- coi/generalize/generalize.lisp \
- coi/gensym/cert.acl2 \
- coi/gensym/gensym-list.lisp \
- coi/gensym/gensym.lisp \
- coi/lists/acl2-count.lisp \
- coi/lists/basic.lisp \
- coi/lists/cert.acl2 \
- coi/lists/disjoint.lisp \
- coi/lists/find-index.lisp \
- coi/lists/list-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-top.lisp \
- coi/lists/listset-induction.lisp \
- coi/lists/map-cons.lisp \
- coi/lists/memberp.lisp \
- coi/lists/mixed.lisp \
- coi/lists/mv-nth.lisp \
- coi/lists/nth-and-update-nth.lisp \
- coi/lists/nth-meta.lisp \
- coi/lists/nth-meta2.lisp \
- coi/lists/remove-induction.lisp \
- coi/lists/remove.lisp \
- coi/lists/repeat.lisp \
- coi/lists/set.lisp \
- coi/lists/subsetp.lisp \
- coi/lists/update-nth-array.lisp \
- coi/maps/aliases.lisp \
- coi/maps/cert.acl2 \
- coi/maps/map-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/maps.lisp \
- coi/maps/typed-maps.lisp \
- coi/nary/cert.acl2 \
- coi/nary/example.lisp \
- coi/nary/nary.lisp \
- coi/nary/nth-rules.lisp \
- coi/nary/ordinal-order.lisp \
- coi/nary/rewrite-equal-hint.lisp \
- coi/osets/cert.acl2 \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/computed-hints.lisp \
- coi/osets/conversions.lisp \
- coi/osets/extras.lisp \
- coi/osets/fast.lisp \
- coi/osets/instance-defpkg.lsp \
- coi/osets/instance.lisp \
- coi/osets/listsets.lisp \
- coi/osets/map.lisp \
- coi/osets/membership.lisp \
- coi/osets/multiappend.lisp \
- coi/osets/multicons.lisp \
- coi/osets/outer.lisp \
- coi/osets/primitives.lisp \
- coi/osets/quantify.lisp \
- coi/osets/set-defpkg.lsp \
- coi/osets/set-order.lisp \
- coi/osets/set-processor.lisp \
- coi/osets/sets.lisp \
- coi/osets/sort.lisp \
- coi/paths/cert.acl2 \
- coi/paths/compatibility.lisp \
- coi/paths/cp-set.lisp \
- coi/paths/defs.lisp \
- coi/paths/diverge.lisp \
- coi/paths/dominates.lisp \
- coi/paths/equiv.lisp \
- coi/paths/hints.lisp \
- coi/paths/list-path-connection.lisp \
- coi/paths/meta.lisp \
- coi/paths/path-defpkg.lsp \
- coi/paths/path.lisp \
- coi/paths/pm.lisp \
- coi/quantification/cert.acl2 \
- coi/quantification/quant-defpkg.lsp \
- coi/quantification/quantification.acl2 \
- coi/quantification/quantification.lisp \
- coi/records/cert.acl2 \
- coi/records/defarray.acl2 \
- coi/records/defarray.lisp \
- coi/records/defrecord-fast.acl2 \
- coi/records/defrecord-fast.lisp \
- coi/records/defrecord.lisp \
- coi/records/domain.acl2 \
- coi/records/domain.lisp \
- coi/records/fixedpoint.acl2 \
- coi/records/fixedpoint.lisp \
- coi/records/mem-domain.lisp \
- coi/records/memory.lisp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lisp \
- coi/records/record-exports.lsp \
- coi/records/records.lisp \
- coi/records/set-domain.lisp \
- coi/super-ihs/arithmetic.lisp \
- coi/super-ihs/ash.lisp \
- coi/super-ihs/basics.lisp \
- coi/super-ihs/bit-functions.lisp \
- coi/super-ihs/bit-twiddling-logops.lisp \
- coi/super-ihs/byte-p.lisp \
- coi/super-ihs/c-functions.lisp \
- coi/super-ihs/carry.lisp \
- coi/super-ihs/cert.acl2 \
- coi/super-ihs/eric.lisp \
- coi/super-ihs/evenp.lisp \
- coi/super-ihs/fast.lisp \
- coi/super-ihs/from-rtl.lisp \
- coi/super-ihs/hacks.lisp \
- coi/super-ihs/inductions.lisp \
- coi/super-ihs/iter-sqrt.lisp \
- coi/super-ihs/logapp.lisp \
- coi/super-ihs/logbit.lisp \
- coi/super-ihs/logbitp.lisp \
- coi/super-ihs/logcar.lisp \
- coi/super-ihs/logcdr.lisp \
- coi/super-ihs/logcons.lisp \
- coi/super-ihs/logext.lisp \
- coi/super-ihs/loghead.lisp \
- coi/super-ihs/logical-logops.lisp \
- coi/super-ihs/logior-logapp-crock.lisp \
- coi/super-ihs/loglist.lisp \
- coi/super-ihs/logpair.lisp \
- coi/super-ihs/logtail.lisp \
- coi/super-ihs/lshu.lisp \
- coi/super-ihs/meta.lisp \
- coi/super-ihs/min-max.lisp \
- coi/super-ihs/plus-logapp-suck.lisp \
- coi/super-ihs/signed-byte-p-overflow.lisp \
- coi/super-ihs/super-ihs.lisp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/unsigned-byte-p.lisp \
- coi/symbol-fns/cert.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/symbol-fns/symbol-fns-exports.lisp \
- coi/symbol-fns/symbol-fns-exports.lsp \
- coi/symbol-fns/symbol-fns.lisp \
- coi/syntax/auxilary.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/defbinding.lisp \
- coi/syntax/defevaluator.lisp \
- coi/syntax/quine.lisp \
- coi/syntax/syn-defpkg.lsp \
- coi/syntax/syn-pkg.lisp \
- coi/syntax/syntax-extensions.lisp \
- coi/syntax/syntax.lisp \
- coi/termination/assuming/cert.acl2 \
- coi/termination/assuming/compiler-proof.lisp \
- coi/termination/assuming/compiler.lisp \
- coi/termination/assuming/zero.lisp \
- coi/util/cert.acl2 \
- coi/util/clause-processor.lisp \
- coi/util/debug-defpkg.lsp \
- coi/util/debug.acl2 \
- coi/util/debug.lisp \
- coi/util/def-defpkg.lsp \
- coi/util/defbinding.acl2 \
- coi/util/defbinding.lisp \
- coi/util/defdoc.acl2 \
- coi/util/defdoc.lisp \
- coi/util/deffix.acl2 \
- coi/util/deffix.lisp \
- coi/util/defsubtype.acl2 \
- coi/util/defsubtype.lisp \
- coi/util/defun-defpkg.lsp \
- coi/util/defun-support.acl2 \
- coi/util/defun-support.lisp \
- coi/util/defun.acl2 \
- coi/util/defun.lisp \
- coi/util/extra-info-test.lisp \
- coi/util/extra-info.lisp \
- coi/util/fixequiv.lisp \
- coi/util/gensym-defpkg.lsp \
- coi/util/good-rewrite-order.lisp \
- coi/util/ifdef.acl2 \
- coi/util/ifdef.lisp \
- coi/util/iff.lisp \
- coi/util/ifixequiv.lisp \
- coi/util/implies.lisp \
- coi/util/in-conclusion.lisp \
- coi/util/ith.lisp \
- coi/util/mv-nth.acl2 \
- coi/util/mv-nth.lisp \
- coi/util/nfixequiv.lisp \
- coi/util/ordinal-order.lisp \
- coi/util/pseudo-translate.lisp \
- coi/util/recursion-support.acl2 \
- coi/util/recursion-support.lisp \
- coi/util/rewrite-equiv.lisp \
- coi/util/rule-sets-defpkg.lsp \
- coi/util/rule-sets-documentation.acl2 \
- coi/util/rule-sets-documentation.lisp \
- coi/util/rule-sets-support.acl2 \
- coi/util/rule-sets-support.lisp \
- coi/util/rule-sets.acl2 \
- coi/util/rule-sets.lisp \
- coi/util/skip-rewrite.lisp \
- coi/util/syntaxp.lisp \
- coi/util/table-defpkg.lsp \
- coi/util/table.acl2 \
- coi/util/table.lisp \
- coi/util/util-exports.lsp \
- concurrent-programs/bakery/apply-total-order.lisp \
- concurrent-programs/bakery/fairenv.lisp \
- concurrent-programs/bakery/final-theorems.lisp \
- concurrent-programs/bakery/initial-state.lisp \
- concurrent-programs/bakery/inv-persists.lisp \
- concurrent-programs/bakery/inv-sufficient.lisp \
- concurrent-programs/bakery/labels.lisp \
- concurrent-programs/bakery/lexicographic-pos.lisp \
- concurrent-programs/bakery/lexicographic.lisp \
- concurrent-programs/bakery/measures.lisp \
- concurrent-programs/bakery/pos-temp.lisp \
- concurrent-programs/bakery/programs.lisp \
- concurrent-programs/bakery/properties-of-sets.lisp \
- concurrent-programs/bakery/properties.lisp \
- concurrent-programs/bakery/records.lisp \
- concurrent-programs/bakery/stutter1-match.lisp \
- concurrent-programs/bakery/stutter2.lisp \
- concurrent-programs/bakery/variables.lisp \
- concurrent-programs/german-protocol/german.lisp \
- countereg-gen/acl2s-parameter.lisp \
- countereg-gen/base.lisp \
- countereg-gen/basis.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/data.lisp \
- countereg-gen/graph.lisp \
- countereg-gen/library-support.lisp \
- countereg-gen/main.lisp \
- countereg-gen/mv-proof.lisp \
- countereg-gen/num-list-fns.lisp \
- countereg-gen/num-list-thms.lisp \
- countereg-gen/package.lsp \
- countereg-gen/random-state-basis1.lisp \
- countereg-gen/random-state.lisp \
- countereg-gen/random.lisp \
- countereg-gen/rem-and-floor.lisp \
- countereg-gen/simple-graph-array.lisp \
- countereg-gen/splitnat.lisp \
- countereg-gen/switchnat.lisp \
- countereg-gen/top.lisp \
- countereg-gen/type.lisp \
- countereg-gen/utilities.lisp \
- countereg-gen/with-timeout.lisp \
- cowles/acl2-agp.lisp \
- cowles/acl2-asg.lisp \
- cowles/acl2-crg.lisp \
- cowles/cert.acl2 \
- cowles/packages.lsp \
- cutil/cert.acl2 \
- cutil/da-base.lisp \
- cutil/defaggregate-tests.lisp \
- cutil/defaggregate.lisp \
- cutil/defalist-tests.lisp \
- cutil/defalist.lisp \
- cutil/defenum.lisp \
- cutil/define-tests.acl2 \
- cutil/define-tests.lisp \
- cutil/define.lisp \
- cutil/deflist-aux.lisp \
- cutil/deflist-tests.lisp \
- cutil/deflist.lisp \
- cutil/defmapappend-tests.lisp \
- cutil/defmapappend.lisp \
- cutil/defmvtypes.lisp \
- cutil/defprojection-tests.acl2 \
- cutil/defprojection-tests.lisp \
- cutil/defprojection.lisp \
- cutil/defsection.lisp \
- cutil/formals.lisp \
- cutil/look-up.lisp \
- cutil/maybe-defthm.lisp \
- cutil/package.lsp \
- cutil/portcullis.acl2 \
- cutil/portcullis.lisp \
- cutil/returnspecs.lisp \
- cutil/support.lisp \
- cutil/top.acl2 \
- cutil/top.lisp \
- cutil/wizard.lisp \
- data-structures/alist-defthms.lisp \
- data-structures/alist-defuns.lisp \
- data-structures/alist-theory.lisp \
- data-structures/array1.lisp \
- data-structures/defalist.acl2 \
- data-structures/defalist.lisp \
- data-structures/define-structures-package.lsp \
- data-structures/define-u-package.lsp \
- data-structures/deflist.acl2 \
- data-structures/deflist.lisp \
- data-structures/doc-section.lisp \
- data-structures/list-defthms.lisp \
- data-structures/list-defuns.lisp \
- data-structures/list-theory.lisp \
- data-structures/memories/cert.acl2 \
- data-structures/memories/log2.lisp \
- data-structures/memories/memory-impl.lisp \
- data-structures/memories/memory.lisp \
- data-structures/memories/memtree.lisp \
- data-structures/memories/package.lsp \
- data-structures/memories/private.lisp \
- data-structures/no-duplicates.lisp \
- data-structures/number-list-defthms.lisp \
- data-structures/number-list-defuns.lisp \
- data-structures/number-list-theory.lisp \
- data-structures/set-defthms.lisp \
- data-structures/set-defuns.lisp \
- data-structures/set-theory.lisp \
- data-structures/structures.acl2 \
- data-structures/structures.lisp \
- data-structures/utilities.acl2 \
- data-structures/utilities.lisp \
- deduction/passmore/bewijs.lisp \
- deduction/passmore/general.lisp \
- deduction/passmore/paramod.lisp \
- deduction/passmore/prover.lisp \
- deduction/passmore/resolution.lisp \
- deduction/passmore/unification.lisp \
- deduction/passmore/weighting.lisp \
- defexec/dag-unification/basic.lisp \
- defexec/dag-unification/dag-unification-l.lisp \
- defexec/dag-unification/dag-unification-rules.lisp \
- defexec/dag-unification/dag-unification-st.lisp \
- defexec/dag-unification/dags.lisp \
- defexec/dag-unification/list-unification-rules.lisp \
- defexec/dag-unification/matching.lisp \
- defexec/dag-unification/subsumption-subst.lisp \
- defexec/dag-unification/subsumption.lisp \
- defexec/dag-unification/terms-as-dag.lisp \
- defexec/dag-unification/terms-dag-stobj.lisp \
- defexec/dag-unification/terms.lisp \
- defexec/defpun-exec/defpun-exec.lisp \
- defexec/find-path/fpst.lisp \
- defexec/find-path/graph/find-path1.lisp \
- defexec/find-path/graph/find-path2.lisp \
- defexec/find-path/graph/find-path3.lisp \
- defexec/find-path/graph/helpers.lisp \
- defexec/find-path/graph/linear-find-path.lisp \
- defexec/find-path/run-fpst.lisp \
- defexec/ordinals/supporting-ordinals.lisp \
- defexec/other-apps/misc/memos.lisp \
- defexec/other-apps/misc/stobjsim.lisp \
- defexec/other-apps/qsort/extraction.lisp \
- defexec/other-apps/qsort/final-theorem.lisp \
- defexec/other-apps/qsort/first-last.lisp \
- defexec/other-apps/qsort/intermediate-program.lisp \
- defexec/other-apps/qsort/intermediate-to-spec.lisp \
- defexec/other-apps/qsort/load-extract.lisp \
- defexec/other-apps/qsort/merge-intermediate.lisp \
- defexec/other-apps/qsort/nth-update-nth.lisp \
- defexec/other-apps/qsort/permutations.lisp \
- defexec/other-apps/qsort/programs.lisp \
- defexec/other-apps/qsort/sort-qs-properties.lisp \
- defexec/other-apps/qsort/spec-properties.lisp \
- defexec/other-apps/qsort/split-qs-properties.lisp \
- defexec/other-apps/qsort/total-order.lisp \
- defexec/other-apps/records/inline.lisp \
- defexec/other-apps/records/records-bsd.lisp \
- defexec/other-apps/records/records.lisp \
- defexec/other-apps/records/recordsim.lisp \
- defexec/reflexive/reflexive.lisp \
- defsort/defsort.lisp \
- defsort/duplicated-members.lisp \
- defsort/duplicity.lisp \
- defsort/examples.lisp \
- defsort/generic-impl.lisp \
- defsort/generic.lisp \
- defsort/remove-dups.lisp \
- defsort/uniquep.lisp \
- demos/list-theory.lisp \
- demos/modeling/cert.acl2 \
- demos/modeling/memories.lisp \
- demos/modeling/network-state-basic.lisp \
- demos/modeling/network-state.lisp \
- demos/modeling/nondeterminism.lisp \
- finite-set-theory/osets/cardinality.lisp \
- finite-set-theory/osets/cert.acl2 \
- finite-set-theory/osets/computed-hints.lisp \
- finite-set-theory/osets/delete.lisp \
- finite-set-theory/osets/difference.lisp \
- finite-set-theory/osets/instance.lisp \
- finite-set-theory/osets/intersect.lisp \
- finite-set-theory/osets/map-tests.lisp \
- finite-set-theory/osets/map.lisp \
- finite-set-theory/osets/membership.lisp \
- finite-set-theory/osets/outer.lisp \
- finite-set-theory/osets/portcullis.acl2 \
- finite-set-theory/osets/portcullis.lisp \
- finite-set-theory/osets/primitives.lisp \
- finite-set-theory/osets/quantify.lisp \
- finite-set-theory/osets/sets.defpkg \
- finite-set-theory/osets/sets.lisp \
- finite-set-theory/osets/sort.lisp \
- finite-set-theory/osets/under-set-equiv.lisp \
- finite-set-theory/osets/union.lisp \
- finite-set-theory/set-theory.acl2 \
- finite-set-theory/set-theory.lisp \
- finite-set-theory/total-ordering.lisp \
- hacking/all.acl2 \
- hacking/all.lisp \
- hacking/bridge.acl2 \
- hacking/bridge.lisp \
- hacking/defcode.acl2 \
- hacking/defcode.lisp \
- hacking/defstruct-parsing.acl2 \
- hacking/defstruct-parsing.lisp \
- hacking/doc-section.lisp \
- hacking/dynamic-make-event-test.acl2 \
- hacking/dynamic-make-event-test.lisp \
- hacking/dynamic-make-event.acl2 \
- hacking/dynamic-make-event.lisp \
- hacking/evalable-ld-printing.acl2 \
- hacking/evalable-ld-printing.lisp \
- hacking/hacker-pkg.lsp \
- hacking/hacker.acl2 \
- hacking/hacker.lisp \
- hacking/progn-bang-enh.acl2 \
- hacking/progn-bang-enh.lisp \
- hacking/raw.acl2 \
- hacking/raw.lisp \
- hacking/redefun.acl2 \
- hacking/redefun.lisp \
- hacking/rewrite-code-pkg.lsp \
- hacking/rewrite-code.acl2 \
- hacking/rewrite-code.lisp \
- hacking/subsumption.acl2 \
- hacking/subsumption.lisp \
- hacking/table-guard.acl2 \
- hacking/table-guard.lisp \
- hints/basic-tests.acl2 \
- hints/basic-tests.lisp \
- hints/consider-hint-tests.acl2 \
- hints/consider-hint-tests.lisp \
- hints/consider-hint.lisp \
- hints/huet-lang-algorithm-tests.lisp \
- hints/huet-lang-algorithm.lisp \
- hints/merge-hint.lisp \
- ihs/@logops.lisp \
- ihs/basic-definitions.lisp \
- ihs/ihs-definitions.lisp \
- ihs/ihs-doc-topic.lisp \
- ihs/ihs-init.acl2 \
- ihs/ihs-init.lisp \
- ihs/ihs-lemmas.lisp \
- ihs/ihs-theories.lisp \
- ihs/logops-definitions.lisp \
- ihs/logops-lemmas.lisp \
- ihs/math-lemmas.lisp \
- ihs/quotient-remainder-lemmas.lisp \
- leftist-trees/leftist-tree-defthms.lisp \
- leftist-trees/leftist-tree-defuns.lisp \
- leftist-trees/leftist-tree-sort-equivalent.lisp \
- leftist-trees/leftist-tree-sort-equivalent2.lisp \
- leftist-trees/leftist-tree-sort-equivalent3.lisp \
- leftist-trees/leftist-tree-sort.lisp \
- leftist-trees/top.lisp \
- make-event/acl2x-help.lisp \
- make-event/assert-check-include-1.acl2 \
- make-event/assert-check-include-1.lisp \
- make-event/assert-check-include.lisp \
- make-event/assert-check.lisp \
- make-event/assert-include.acl2 \
- make-event/assert-include.lisp \
- make-event/assert.lisp \
- make-event/basic-check.lisp \
- make-event/basic-pkg-check.acl2 \
- make-event/basic-pkg-check.lisp \
- make-event/basic-pkg.acl2 \
- make-event/basic-pkg.lisp \
- make-event/basic.lisp \
- make-event/defconst-fast-examples.lisp \
- make-event/defconst-fast.lisp \
- make-event/defrefine.lisp \
- make-event/defrule.lisp \
- make-event/defspec.lisp \
- make-event/dotimes.lisp \
- make-event/embeddable-event-forms.lisp \
- make-event/eval-check-tests.lisp \
- make-event/eval-check.lisp \
- make-event/eval-tests.lisp \
- make-event/eval.lisp \
- make-event/gen-defthm-check.lisp \
- make-event/gen-defthm.lisp \
- make-event/gen-defun-check.lisp \
- make-event/gen-defun.lisp \
- make-event/inline-book.lisp \
- make-event/local-elided-include.lisp \
- make-event/local-elided.lisp \
- make-event/local-requires-skip-check-include.lisp \
- make-event/local-requires-skip-check.lisp \
- make-event/logical-tangent.lisp \
- make-event/macros-include.lisp \
- make-event/macros-skip-proofs-include.acl2 \
- make-event/macros-skip-proofs-include.lisp \
- make-event/macros-skip-proofs.acl2 \
- make-event/macros-skip-proofs.lisp \
- make-event/macros.lisp \
- make-event/make-redundant.lisp \
- make-event/nested-check.lisp \
- make-event/nested.lisp \
- make-event/portcullis-expansion-include.acl2 \
- make-event/portcullis-expansion-include.lisp \
- make-event/portcullis-expansion.acl2 \
- make-event/portcullis-expansion.lisp \
- make-event/proof-by-arith.lisp \
- make-event/read-from-file.lisp \
- make-event/require-book.lisp \
- make-event/test-case-check.lisp \
- make-event/test-case.lisp \
- meta/meta-plus-equal.lisp \
- meta/meta-plus-lessp.lisp \
- meta/meta-times-equal.lisp \
- meta/meta.lisp \
- meta/pseudo-termp-lemmas.lisp \
- meta/term-defuns.lisp \
- meta/term-lemmas.lisp \
- misc/assert.lisp \
- misc/bash.lisp \
- misc/beta-reduce.lisp \
- misc/callers-and-ancestors.lisp \
- misc/character-encoding-test.lisp \
- misc/check-acl2-exports.lisp \
- misc/check-state.lisp \
- misc/computed-hint-rewrite.lisp \
- misc/computed-hint.lisp \
- misc/congruent-stobjs-test.lisp \
- misc/csort.lisp \
- misc/dead-events.lisp \
- misc/defabsstobj-example-1.lisp \
- misc/defabsstobj-example-2.lisp \
- misc/defabsstobj-example-3.lisp \
- misc/defabsstobj-example-4.acl2 \
- misc/defabsstobj-example-4.lisp \
- misc/defattach-bang.lisp \
- misc/defattach-example.lisp \
- misc/definline.lisp \
- misc/defmac.lisp \
- misc/defopener.lisp \
- misc/defp.lisp \
- misc/defproxy-test.acl2 \
- misc/defproxy-test.lisp \
- misc/defpun.lisp \
- misc/defun-plus.lisp \
- misc/dft-ex.acl2 \
- misc/dft-ex.lisp \
- misc/dft.lisp \
- misc/dijkstra-shortest-path.lisp \
- misc/disassemble.acl2 \
- misc/disassemble.lisp \
- misc/doc-section.lisp \
- misc/dump-events.lisp \
- misc/equal-by-g-help.lisp \
- misc/equal-by-g.lisp \
- misc/eval.lisp \
- misc/evalable-printing.lisp \
- misc/expander.lisp \
- misc/fast-coerce.lisp \
- misc/fibonacci.lisp \
- misc/file-io.lisp \
- misc/find-lemmas.lisp \
- misc/gentle.lisp \
- misc/getprop.lisp \
- misc/goodstein.lisp \
- misc/grcd.lisp \
- misc/hanoi.acl2 \
- misc/hanoi.lisp \
- misc/hons-help.lisp \
- misc/hons-help2.lisp \
- misc/hons-tests.lisp \
- misc/how-to-prove-thms.lisp \
- misc/int-division.lisp \
- misc/integer-type-set-test.lisp \
- misc/invariants.lisp \
- misc/meta-lemmas.lisp \
- misc/misc2/defpun-exec-domain-example.lisp \
- misc/misc2/misc.lisp \
- misc/misc2/reverse-by-separation.acl2 \
- misc/misc2/reverse-by-separation.lisp \
- misc/misc2/ruler-extenders-tests.acl2 \
- misc/misc2/ruler-extenders-tests.lisp \
- misc/misc2/step-limits.lisp \
- misc/mult.lisp \
- misc/oprof.acl2 \
- misc/oprof.lisp \
- misc/priorities.lisp \
- misc/problem13.lisp \
- misc/process-book-readme.lisp \
- misc/profiling.acl2 \
- misc/profiling.lisp \
- misc/qi-correct.acl2 \
- misc/qi-correct.lisp \
- misc/qi.acl2 \
- misc/qi.lisp \
- misc/radix.acl2 \
- misc/radix.lisp \
- misc/random.lisp \
- misc/records-bsd.lisp \
- misc/records.lisp \
- misc/records0.lisp \
- misc/redef-pkg.acl2 \
- misc/redef-pkg.lisp \
- misc/rtl-untranslate.lisp \
- misc/save-time.lisp \
- misc/seq.lisp \
- misc/seqw.lisp \
- misc/simplify-defuns.lisp \
- misc/simplify-thm.lisp \
- misc/sin-cos.lisp \
- misc/sort-symbols.lisp \
- misc/sticky-disable.lisp \
- misc/symbol-btree.lisp \
- misc/total-order-bsd.lisp \
- misc/total-order.lisp \
- misc/trace-star.lisp \
- misc/transfinite.lisp \
- misc/untranslate-patterns.lisp \
- misc/wet.lisp \
- models/jvm/m1-original/m1-story.acl2 \
- models/jvm/m1-original/m1-story.lisp \
- models/jvm/m1-original/problem-set-1-answers.acl2 \
- models/jvm/m1-original/problem-set-1-answers.lisp \
- models/jvm/m1/alternating-sum-variant.lisp \
- models/jvm/m1/alternating-sum.lisp \
- models/jvm/m1/bexpt.lisp \
- models/jvm/m1/cert.acl2 \
- models/jvm/m1/defsys-utilities.lisp \
- models/jvm/m1/defsys.acl2 \
- models/jvm/m1/defsys.lisp \
- models/jvm/m1/div.lisp \
- models/jvm/m1/even-solution-1.lisp \
- models/jvm/m1/even-solution-2.lisp \
- models/jvm/m1/expt.lisp \
- models/jvm/m1/fact.lisp \
- models/jvm/m1/fib.lisp \
- models/jvm/m1/find-k!.acl2 \
- models/jvm/m1/find-k!.lisp \
- models/jvm/m1/funny-fact.lisp \
- models/jvm/m1/implementation.acl2 \
- models/jvm/m1/implementation.lisp \
- models/jvm/m1/lessp.lisp \
- models/jvm/m1/low-seven.acl2 \
- models/jvm/m1/low-seven.lisp \
- models/jvm/m1/m1.acl2 \
- models/jvm/m1/m1.lisp \
- models/jvm/m1/magic.lisp \
- models/jvm/m1/power.lisp \
- models/jvm/m1/sign.lisp \
- models/jvm/m1/sum.lisp \
- models/jvm/m1/sumsq.lisp \
- models/jvm/m1/template.lisp \
- models/jvm/m1/theorems-a-and-b.lisp \
- models/jvm/m1/tmi-reductions.lisp \
- models/jvm/m1/wormhole-abstraction.lisp \
- models/jvm/m5/apprentice-state.acl2 \
- models/jvm/m5/apprentice-state.lisp \
- models/jvm/m5/demo.acl2 \
- models/jvm/m5/demo.lisp \
- models/jvm/m5/idemo.acl2 \
- models/jvm/m5/idemo.lisp \
- models/jvm/m5/infinite-fair-schedule.lisp \
- models/jvm/m5/isort.acl2 \
- models/jvm/m5/isort.lisp \
- models/jvm/m5/jvm-fact-setup.acl2 \
- models/jvm/m5/jvm-fact-setup.lisp \
- models/jvm/m5/m5.acl2 \
- models/jvm/m5/m5.lisp \
- models/jvm/m5/partial.acl2 \
- models/jvm/m5/partial.lisp \
- models/jvm/m5/perm.lisp \
- models/jvm/m5/universal-never-returns.acl2 \
- models/jvm/m5/universal-never-returns.lisp \
- models/jvm/m5/universal.acl2 \
- models/jvm/m5/universal.lisp \
- models/jvm/m5/utilities.acl2 \
- models/jvm/m5/utilities.lisp \
- ordinals/e0-ordinal.lisp \
- ordinals/lexicographic-book.lisp \
- ordinals/lexicographic-ordering-without-arithmetic.lisp \
- ordinals/lexicographic-ordering.lisp \
- ordinals/limits.lisp \
- ordinals/ordinal-addition.lisp \
- ordinals/ordinal-basic-thms.lisp \
- ordinals/ordinal-counter-examples.lisp \
- ordinals/ordinal-definitions.lisp \
- ordinals/ordinal-exponentiation.lisp \
- ordinals/ordinal-isomorphism.lisp \
- ordinals/ordinal-multiplication.lisp \
- ordinals/ordinal-total-order.lisp \
- ordinals/ordinals-without-arithmetic.lisp \
- ordinals/ordinals.lisp \
- ordinals/proof-of-well-foundedness.acl2 \
- ordinals/proof-of-well-foundedness.lisp \
- ordinals/top-with-meta.lisp \
- oslib/catpath.lisp \
- oslib/cert.acl2 \
- oslib/date.lisp \
- oslib/getpid.lisp \
- oslib/ls.lisp \
- oslib/package.lsp \
- oslib/portcullis.acl2 \
- oslib/portcullis.lisp \
- oslib/read-acl2-oracle.lisp \
- oslib/tempfile.lisp \
- oslib/top.lisp \
- paco/acl2-customization.lsp \
- paco/database.acl2 \
- paco/database.lisp \
- paco/elim-dest.acl2 \
- paco/elim-dest.lisp \
- paco/foundations.acl2 \
- paco/foundations.lisp \
- paco/induct.acl2 \
- paco/induct.lisp \
- paco/output-module.acl2 \
- paco/output-module.lisp \
- paco/paco.acl2 \
- paco/paco.lisp \
- paco/prove.acl2 \
- paco/prove.lisp \
- paco/rewrite.acl2 \
- paco/rewrite.lisp \
- paco/simplify.acl2 \
- paco/simplify.lisp \
- paco/type-set.acl2 \
- paco/type-set.lisp \
- paco/utilities.acl2 \
- paco/utilities.lisp \
- parallel/fibonacci.lisp \
- parallel/hint-tests.acl2 \
- parallel/hint-tests.lisp \
- parallel/matrix-multiplication-parallel.lisp \
- parallel/matrix-multiplication-serial.lisp \
- parallel/matrix-multiplication-setup.lisp \
- parallel/spec-mv-let.lisp \
- parallel/stress-tests.lisp \
- parallel/syntax-tests.lisp \
- parallel/with-waterfall-parallelism.lisp \
- parallel/without-waterfall-parallelism.lisp \
- powerlists/algebra.lisp \
- powerlists/batcher-sort.lisp \
- powerlists/bitonic-sort.lisp \
- powerlists/cert.acl2 \
- powerlists/cla-adder.lisp \
- powerlists/defpkg.lsp \
- powerlists/gray-code.lisp \
- powerlists/merge-sort.lisp \
- powerlists/prefix-sum.lisp \
- powerlists/simple.lisp \
- powerlists/sort.lisp \
- proofstyles/completeness/assertions-partial.lisp \
- proofstyles/completeness/assertions-total.lisp \
- proofstyles/completeness/clock-partial.lisp \
- proofstyles/completeness/clock-total.lisp \
- proofstyles/completeness/generic-partial.lisp \
- proofstyles/completeness/generic-total.lisp \
- proofstyles/completeness/stepwise-invariants-partial.lisp \
- proofstyles/completeness/stepwise-invariants-total.lisp \
- proofstyles/counterexamples/halt-flg.lisp \
- proofstyles/counterexamples/memory-clearing.lisp \
- proofstyles/counterexamples/realistic.lisp \
- proofstyles/invclock/c2i/c2i-partial.lisp \
- proofstyles/invclock/c2i/c2i-total.lisp \
- proofstyles/invclock/c2i/clock-to-inv.lisp \
- proofstyles/invclock/compose/compose-c-c-partial.lisp \
- proofstyles/invclock/compose/compose-c-c-total.lisp \
- proofstyles/invclock/i2c/i2c-partial.lisp \
- proofstyles/invclock/i2c/i2c-total.lisp \
- proofstyles/invclock/i2c/inv-to-clock.lisp \
- proofstyles/soundness/assertions-partial.lisp \
- proofstyles/soundness/assertions-total.lisp \
- proofstyles/soundness/clock-partial.lisp \
- proofstyles/soundness/clock-total.lisp \
- proofstyles/soundness/stepwise-invariants-partial.lisp \
- proofstyles/soundness/stepwise-invariants-total.lisp \
- quadratic-reciprocity/eisenstein.lisp \
- quadratic-reciprocity/euclid.lisp \
- quadratic-reciprocity/euler.lisp \
- quadratic-reciprocity/fermat.lisp \
- quadratic-reciprocity/gauss.lisp \
- quadratic-reciprocity/mersenne.lisp \
- regex/cert.acl2 \
- regex/defset-encapsulates.lisp \
- regex/defset-macros.lisp \
- regex/equal-based-set.lisp \
- regex/grep-command-line.lisp \
- regex/input-list.lisp \
- regex/portcullis.acl2 \
- regex/portcullis.lisp \
- regex/regex-chartrans.lisp \
- regex/regex-defs.lisp \
- regex/regex-exec.lisp \
- regex/regex-fileio.lisp \
- regex/regex-parse-brace.lisp \
- regex/regex-parse-bracket.lisp \
- regex/regex-parse.lisp \
- regex/regex-tests.lisp \
- regex/regex-ui.lisp \
- rtl/rel1/lib1/basic.lisp \
- rtl/rel1/lib1/bits.lisp \
- rtl/rel1/lib1/brat.lisp \
- rtl/rel1/lib1/float.lisp \
- rtl/rel1/lib1/reps.lisp \
- rtl/rel1/lib1/round.lisp \
- rtl/rel1/lib1/top.lisp \
- rtl/rel1/lib3/basic.lisp \
- rtl/rel1/lib3/bits.lisp \
- rtl/rel1/lib3/brat.lisp \
- rtl/rel1/lib3/fadd.lisp \
- rtl/rel1/lib3/float.lisp \
- rtl/rel1/lib3/reps.lisp \
- rtl/rel1/lib3/round.lisp \
- rtl/rel1/lib3/top.lisp \
- rtl/rel1/support/add.lisp \
- rtl/rel1/support/away.lisp \
- rtl/rel1/support/basic.lisp \
- rtl/rel1/support/divsqrt.lisp \
- rtl/rel1/support/fadd/add3.lisp \
- rtl/rel1/support/fadd/lop1.lisp \
- rtl/rel1/support/fadd/lop2.lisp \
- rtl/rel1/support/fadd/lop3.lisp \
- rtl/rel1/support/fadd/stick.lisp \
- rtl/rel1/support/fadd/top.lisp \
- rtl/rel1/support/float.lisp \
- rtl/rel1/support/floor.lisp \
- rtl/rel1/support/fp.lisp \
- rtl/rel1/support/logdefs.lisp \
- rtl/rel1/support/loglemmas.lisp \
- rtl/rel1/support/logxor-def.lisp \
- rtl/rel1/support/logxor-lemmas.lisp \
- rtl/rel1/support/merge.lisp \
- rtl/rel1/support/near.lisp \
- rtl/rel1/support/odd.lisp \
- rtl/rel1/support/proofs.lisp \
- rtl/rel1/support/reps.lisp \
- rtl/rel1/support/rewrite-theory.lisp \
- rtl/rel1/support/rnd.lisp \
- rtl/rel1/support/sticky.lisp \
- rtl/rel1/support/trunc.lisp \
- rtl/rel1/support/x-2xx.lisp \
- rtl/rel4/arithmetic/arith.lisp \
- rtl/rel4/arithmetic/arith2.lisp \
- rtl/rel4/arithmetic/basic.lisp \
- rtl/rel4/arithmetic/cg.lisp \
- rtl/rel4/arithmetic/common-factor-defuns.lisp \
- rtl/rel4/arithmetic/common-factor.lisp \
- rtl/rel4/arithmetic/complex-rationalp.lisp \
- rtl/rel4/arithmetic/denominator.lisp \
- rtl/rel4/arithmetic/even-odd.lisp \
- rtl/rel4/arithmetic/even-odd2-proofs.lisp \
- rtl/rel4/arithmetic/even-odd2.lisp \
- rtl/rel4/arithmetic/expo-proofs.lisp \
- rtl/rel4/arithmetic/expo.lisp \
- rtl/rel4/arithmetic/expt-proofs.lisp \
- rtl/rel4/arithmetic/expt.lisp \
- rtl/rel4/arithmetic/extra-rules.lisp \
- rtl/rel4/arithmetic/fl-expt.lisp \
- rtl/rel4/arithmetic/fl-hacks.lisp \
- rtl/rel4/arithmetic/fl-proofs.lisp \
- rtl/rel4/arithmetic/fl.lisp \
- rtl/rel4/arithmetic/floor-proofs.lisp \
- rtl/rel4/arithmetic/floor.lisp \
- rtl/rel4/arithmetic/fp.lisp \
- rtl/rel4/arithmetic/fp2.lisp \
- rtl/rel4/arithmetic/ground-zero.lisp \
- rtl/rel4/arithmetic/hacks.lisp \
- rtl/rel4/arithmetic/induct.lisp \
- rtl/rel4/arithmetic/integerp.lisp \
- rtl/rel4/arithmetic/inverted-factor.lisp \
- rtl/rel4/arithmetic/mod-expt.lisp \
- rtl/rel4/arithmetic/mod-proofs.lisp \
- rtl/rel4/arithmetic/mod.lisp \
- rtl/rel4/arithmetic/negative-syntaxp.lisp \
- rtl/rel4/arithmetic/nniq.lisp \
- rtl/rel4/arithmetic/numerator.lisp \
- rtl/rel4/arithmetic/power2p.lisp \
- rtl/rel4/arithmetic/predicate.lisp \
- rtl/rel4/arithmetic/product-proofs.lisp \
- rtl/rel4/arithmetic/product.lisp \
- rtl/rel4/arithmetic/rationalp.lisp \
- rtl/rel4/arithmetic/top.lisp \
- rtl/rel4/arithmetic/unary-divide.lisp \
- rtl/rel4/arithmetic/x-2xx.lisp \
- rtl/rel4/lib/arith.lisp \
- rtl/rel4/lib/basic.lisp \
- rtl/rel4/lib/bits.lisp \
- rtl/rel4/lib/bvecp-helpers.lisp \
- rtl/rel4/lib/bvecp-raw-helpers.lisp \
- rtl/rel4/lib/clocks.lisp \
- rtl/rel4/lib/fadd.lisp \
- rtl/rel4/lib/float.lisp \
- rtl/rel4/lib/openers.lisp \
- rtl/rel4/lib/package-defs.lisp \
- rtl/rel4/lib/reps.lisp \
- rtl/rel4/lib/rom-helpers.lisp \
- rtl/rel4/lib/round.lisp \
- rtl/rel4/lib/rtl.lisp \
- rtl/rel4/lib/rtlarr.lisp \
- rtl/rel4/lib/simple-loop-helpers.lisp \
- rtl/rel4/lib/simplify-model-helpers.lisp \
- rtl/rel4/lib/top.lisp \
- rtl/rel4/lib/util.lisp \
- rtl/rel4/support/add3-proofs.lisp \
- rtl/rel4/support/add3.lisp \
- rtl/rel4/support/all-ones.lisp \
- rtl/rel4/support/ash.lisp \
- rtl/rel4/support/away-proofs.lisp \
- rtl/rel4/support/away.lisp \
- rtl/rel4/support/badguys.lisp \
- rtl/rel4/support/bias-proofs.lisp \
- rtl/rel4/support/bias.lisp \
- rtl/rel4/support/bitn-proofs.lisp \
- rtl/rel4/support/bitn.lisp \
- rtl/rel4/support/bits-extra.lisp \
- rtl/rel4/support/bits-proofs.lisp \
- rtl/rel4/support/bits-trunc-proofs.lisp \
- rtl/rel4/support/bits-trunc.lisp \
- rtl/rel4/support/bits.lisp \
- rtl/rel4/support/bvecp-helpers.lisp \
- rtl/rel4/support/bvecp-lemmas.lisp \
- rtl/rel4/support/bvecp-proofs.lisp \
- rtl/rel4/support/bvecp.lisp \
- rtl/rel4/support/cat-def.lisp \
- rtl/rel4/support/cat-proofs.lisp \
- rtl/rel4/support/cat.lisp \
- rtl/rel4/support/clocks.lisp \
- rtl/rel4/support/decode-proofs.lisp \
- rtl/rel4/support/decode.lisp \
- rtl/rel4/support/drnd.lisp \
- rtl/rel4/support/encode.lisp \
- rtl/rel4/support/ereps-proofs.lisp \
- rtl/rel4/support/ereps.lisp \
- rtl/rel4/support/fadd.lisp \
- rtl/rel4/support/fast-and.lisp \
- rtl/rel4/support/float.lisp \
- rtl/rel4/support/ground-zero.lisp \
- rtl/rel4/support/guards.lisp \
- rtl/rel4/support/ireps.lisp \
- rtl/rel4/support/land-proofs.lisp \
- rtl/rel4/support/land.lisp \
- rtl/rel4/support/lextra-proofs.lisp \
- rtl/rel4/support/lextra.lisp \
- rtl/rel4/support/lior-proofs.lisp \
- rtl/rel4/support/lior.lisp \
- rtl/rel4/support/lnot-proofs.lisp \
- rtl/rel4/support/lnot.lisp \
- rtl/rel4/support/log-equal.lisp \
- rtl/rel4/support/log-proofs.lisp \
- rtl/rel4/support/log.lisp \
- rtl/rel4/support/logand-proofs.lisp \
- rtl/rel4/support/logand.lisp \
- rtl/rel4/support/logeqv.lisp \
- rtl/rel4/support/logior-proofs.lisp \
- rtl/rel4/support/logior.lisp \
- rtl/rel4/support/logior1-proofs.lisp \
- rtl/rel4/support/logior1.lisp \
- rtl/rel4/support/lognot.lisp \
- rtl/rel4/support/logorc1.lisp \
- rtl/rel4/support/logs.lisp \
- rtl/rel4/support/logxor.lisp \
- rtl/rel4/support/lop1-proofs.lisp \
- rtl/rel4/support/lop1.lisp \
- rtl/rel4/support/lop2-proofs.lisp \
- rtl/rel4/support/lop2.lisp \
- rtl/rel4/support/lop3-proofs.lisp \
- rtl/rel4/support/lop3.lisp \
- rtl/rel4/support/lxor-proofs.lisp \
- rtl/rel4/support/lxor.lisp \
- rtl/rel4/support/merge.lisp \
- rtl/rel4/support/merge2.lisp \
- rtl/rel4/support/mod4.lisp \
- rtl/rel4/support/model-helpers.lisp \
- rtl/rel4/support/mulcat-proofs.lisp \
- rtl/rel4/support/mulcat.lisp \
- rtl/rel4/support/near+-proofs.lisp \
- rtl/rel4/support/near+.lisp \
- rtl/rel4/support/near-proofs.lisp \
- rtl/rel4/support/near.lisp \
- rtl/rel4/support/ocat.lisp \
- rtl/rel4/support/oddr-proofs.lisp \
- rtl/rel4/support/oddr.lisp \
- rtl/rel4/support/openers.lisp \
- rtl/rel4/support/package-defs.lisp \
- rtl/rel4/support/rewrite-theory.lisp \
- rtl/rel4/support/rnd.lisp \
- rtl/rel4/support/rom-helpers.lisp \
- rtl/rel4/support/rtl.lisp \
- rtl/rel4/support/rtlarr.lisp \
- rtl/rel4/support/setbitn-proofs.lisp \
- rtl/rel4/support/setbitn.lisp \
- rtl/rel4/support/setbits-proofs.lisp \
- rtl/rel4/support/setbits.lisp \
- rtl/rel4/support/sgn.lisp \
- rtl/rel4/support/shft.lisp \
- rtl/rel4/support/simple-loop-helpers.lisp \
- rtl/rel4/support/simplify-model-helpers.lisp \
- rtl/rel4/support/stick-proofs.lisp \
- rtl/rel4/support/stick.lisp \
- rtl/rel4/support/sticky-proofs.lisp \
- rtl/rel4/support/sticky.lisp \
- rtl/rel4/support/sumbits.lisp \
- rtl/rel4/support/top.lisp \
- rtl/rel4/support/top1.lisp \
- rtl/rel4/support/trunc-proofs.lisp \
- rtl/rel4/support/trunc.lisp \
- rtl/rel4/support/util.lisp \
- rtl/rel4/user/away.lisp \
- rtl/rel4/user/bias.lisp \
- rtl/rel4/user/bitn.lisp \
- rtl/rel4/user/bits-trunc.lisp \
- rtl/rel4/user/bits.lisp \
- rtl/rel4/user/brat.lisp \
- rtl/rel4/user/bvecp.lisp \
- rtl/rel4/user/cat.lisp \
- rtl/rel4/user/decode.lisp \
- rtl/rel4/user/ereps.lisp \
- rtl/rel4/user/land.lisp \
- rtl/rel4/user/lextra.lisp \
- rtl/rel4/user/lior.lisp \
- rtl/rel4/user/lnot.lisp \
- rtl/rel4/user/logior1.lisp \
- rtl/rel4/user/lxor.lisp \
- rtl/rel4/user/mulcat.lisp \
- rtl/rel4/user/near.lisp \
- rtl/rel4/user/setbitn.lisp \
- rtl/rel4/user/setbits.lisp \
- rtl/rel4/user/stick.lisp \
- rtl/rel4/user/sumbits.lisp \
- rtl/rel4/user/top.lisp \
- rtl/rel4/user/trunc.lisp \
- rtl/rel5/arithmetic/arith.lisp \
- rtl/rel5/arithmetic/arith2.lisp \
- rtl/rel5/arithmetic/basic.lisp \
- rtl/rel5/arithmetic/cg.lisp \
- rtl/rel5/arithmetic/common-factor-defuns.lisp \
- rtl/rel5/arithmetic/common-factor.lisp \
- rtl/rel5/arithmetic/complex-rationalp.lisp \
- rtl/rel5/arithmetic/denominator.lisp \
- rtl/rel5/arithmetic/even-odd.lisp \
- rtl/rel5/arithmetic/even-odd2-proofs.lisp \
- rtl/rel5/arithmetic/even-odd2.lisp \
- rtl/rel5/arithmetic/expo-proofs.lisp \
- rtl/rel5/arithmetic/expo.lisp \
- rtl/rel5/arithmetic/expt-proofs.lisp \
- rtl/rel5/arithmetic/expt.lisp \
- rtl/rel5/arithmetic/extra-rules.lisp \
- rtl/rel5/arithmetic/fl-expt.lisp \
- rtl/rel5/arithmetic/fl-hacks.lisp \
- rtl/rel5/arithmetic/fl-proofs.lisp \
- rtl/rel5/arithmetic/fl.lisp \
- rtl/rel5/arithmetic/floor-proofs.lisp \
- rtl/rel5/arithmetic/floor.lisp \
- rtl/rel5/arithmetic/fp.lisp \
- rtl/rel5/arithmetic/fp2.lisp \
- rtl/rel5/arithmetic/ground-zero.lisp \
- rtl/rel5/arithmetic/hacks.lisp \
- rtl/rel5/arithmetic/induct.lisp \
- rtl/rel5/arithmetic/integerp.lisp \
- rtl/rel5/arithmetic/inverted-factor.lisp \
- rtl/rel5/arithmetic/mod-expt.lisp \
- rtl/rel5/arithmetic/mod-proofs.lisp \
- rtl/rel5/arithmetic/mod.lisp \
- rtl/rel5/arithmetic/negative-syntaxp.lisp \
- rtl/rel5/arithmetic/nniq.lisp \
- rtl/rel5/arithmetic/numerator.lisp \
- rtl/rel5/arithmetic/power2p.lisp \
- rtl/rel5/arithmetic/predicate.lisp \
- rtl/rel5/arithmetic/product-proofs.lisp \
- rtl/rel5/arithmetic/product.lisp \
- rtl/rel5/arithmetic/rationalp.lisp \
- rtl/rel5/arithmetic/top.lisp \
- rtl/rel5/arithmetic/unary-divide.lisp \
- rtl/rel5/arithmetic/x-2xx.lisp \
- rtl/rel5/lib/add.lisp \
- rtl/rel5/lib/arith.lisp \
- rtl/rel5/lib/basic.lisp \
- rtl/rel5/lib/bits.lisp \
- rtl/rel5/lib/bvecp-helpers.lisp \
- rtl/rel5/lib/bvecp-raw-helpers.lisp \
- rtl/rel5/lib/clocks.lisp \
- rtl/rel5/lib/float.lisp \
- rtl/rel5/lib/log.lisp \
- rtl/rel5/lib/openers.lisp \
- rtl/rel5/lib/package-defs.lisp \
- rtl/rel5/lib/reps.lisp \
- rtl/rel5/lib/rom-helpers.lisp \
- rtl/rel5/lib/round.lisp \
- rtl/rel5/lib/rtl.lisp \
- rtl/rel5/lib/rtlarr.lisp \
- rtl/rel5/lib/simple-loop-helpers.lisp \
- rtl/rel5/lib/simplify-model-helpers.lisp \
- rtl/rel5/lib/top.lisp \
- rtl/rel5/lib/util.lisp \
- rtl/rel5/support/add3-proofs.lisp \
- rtl/rel5/support/add3.lisp \
- rtl/rel5/support/all-ones.lisp \
- rtl/rel5/support/ash.lisp \
- rtl/rel5/support/away-proofs.lisp \
- rtl/rel5/support/away.lisp \
- rtl/rel5/support/badguys.lisp \
- rtl/rel5/support/bias-proofs.lisp \
- rtl/rel5/support/bias.lisp \
- rtl/rel5/support/bitn-proofs.lisp \
- rtl/rel5/support/bitn.lisp \
- rtl/rel5/support/bits-proofs.lisp \
- rtl/rel5/support/bits-trunc-proofs.lisp \
- rtl/rel5/support/bits-trunc.lisp \
- rtl/rel5/support/bits.lisp \
- rtl/rel5/support/bvecp-helpers.lisp \
- rtl/rel5/support/bvecp-lemmas.lisp \
- rtl/rel5/support/bvecp-proofs.lisp \
- rtl/rel5/support/bvecp.lisp \
- rtl/rel5/support/cat-def.lisp \
- rtl/rel5/support/cat-proofs.lisp \
- rtl/rel5/support/cat.lisp \
- rtl/rel5/support/clocks.lisp \
- rtl/rel5/support/decode-proofs.lisp \
- rtl/rel5/support/decode.lisp \
- rtl/rel5/support/drnd.lisp \
- rtl/rel5/support/encode.lisp \
- rtl/rel5/support/ereps-proofs.lisp \
- rtl/rel5/support/ereps.lisp \
- rtl/rel5/support/fadd-extra.lisp \
- rtl/rel5/support/fadd-extra0.lisp \
- rtl/rel5/support/fadd.lisp \
- rtl/rel5/support/fast-and.lisp \
- rtl/rel5/support/float-extra.lisp \
- rtl/rel5/support/float.lisp \
- rtl/rel5/support/ground-zero.lisp \
- rtl/rel5/support/guards.lisp \
- rtl/rel5/support/ireps.lisp \
- rtl/rel5/support/land.lisp \
- rtl/rel5/support/land0-proofs.lisp \
- rtl/rel5/support/land0.lisp \
- rtl/rel5/support/lextra-proofs.lisp \
- rtl/rel5/support/lextra.lisp \
- rtl/rel5/support/lextra0.lisp \
- rtl/rel5/support/lior.lisp \
- rtl/rel5/support/lior0-proofs.lisp \
- rtl/rel5/support/lior0.lisp \
- rtl/rel5/support/lnot-proofs.lisp \
- rtl/rel5/support/lnot.lisp \
- rtl/rel5/support/log-equal.lisp \
- rtl/rel5/support/log-proofs.lisp \
- rtl/rel5/support/log.lisp \
- rtl/rel5/support/logand-proofs.lisp \
- rtl/rel5/support/logand.lisp \
- rtl/rel5/support/logeqv.lisp \
- rtl/rel5/support/logior-proofs.lisp \
- rtl/rel5/support/logior.lisp \
- rtl/rel5/support/logior1-proofs.lisp \
- rtl/rel5/support/logior1.lisp \
- rtl/rel5/support/lognot.lisp \
- rtl/rel5/support/logorc1.lisp \
- rtl/rel5/support/logs.lisp \
- rtl/rel5/support/logxor.lisp \
- rtl/rel5/support/lop1-proofs.lisp \
- rtl/rel5/support/lop1.lisp \
- rtl/rel5/support/lop2-proofs.lisp \
- rtl/rel5/support/lop2.lisp \
- rtl/rel5/support/lop3-proofs.lisp \
- rtl/rel5/support/lop3.lisp \
- rtl/rel5/support/lxor.lisp \
- rtl/rel5/support/lxor0-proofs.lisp \
- rtl/rel5/support/lxor0.lisp \
- rtl/rel5/support/merge.lisp \
- rtl/rel5/support/merge2.lisp \
- rtl/rel5/support/mod4.lisp \
- rtl/rel5/support/model-helpers.lisp \
- rtl/rel5/support/mulcat-proofs.lisp \
- rtl/rel5/support/mulcat.lisp \
- rtl/rel5/support/near+-proofs.lisp \
- rtl/rel5/support/near+.lisp \
- rtl/rel5/support/near-proofs.lisp \
- rtl/rel5/support/near.lisp \
- rtl/rel5/support/ocat.lisp \
- rtl/rel5/support/oddr-proofs.lisp \
- rtl/rel5/support/oddr.lisp \
- rtl/rel5/support/openers.lisp \
- rtl/rel5/support/package-defs.lisp \
- rtl/rel5/support/rewrite-theory.lisp \
- rtl/rel5/support/rnd.lisp \
- rtl/rel5/support/rom-helpers.lisp \
- rtl/rel5/support/round-extra.lisp \
- rtl/rel5/support/rtl.lisp \
- rtl/rel5/support/rtlarr.lisp \
- rtl/rel5/support/setbitn-proofs.lisp \
- rtl/rel5/support/setbitn.lisp \
- rtl/rel5/support/setbits-proofs.lisp \
- rtl/rel5/support/setbits.lisp \
- rtl/rel5/support/sgn.lisp \
- rtl/rel5/support/shft.lisp \
- rtl/rel5/support/simple-loop-helpers.lisp \
- rtl/rel5/support/simplify-model-helpers.lisp \
- rtl/rel5/support/stick-proofs.lisp \
- rtl/rel5/support/stick.lisp \
- rtl/rel5/support/sticky-proofs.lisp \
- rtl/rel5/support/sticky.lisp \
- rtl/rel5/support/sumbits.lisp \
- rtl/rel5/support/top.lisp \
- rtl/rel5/support/top1.lisp \
- rtl/rel5/support/trunc-proofs.lisp \
- rtl/rel5/support/trunc.lisp \
- rtl/rel5/support/util.lisp \
- rtl/rel5/user/away.lisp \
- rtl/rel5/user/bias.lisp \
- rtl/rel5/user/bitn.lisp \
- rtl/rel5/user/bits-trunc.lisp \
- rtl/rel5/user/bits.lisp \
- rtl/rel5/user/brat.lisp \
- rtl/rel5/user/bvecp.lisp \
- rtl/rel5/user/cat.lisp \
- rtl/rel5/user/decode.lisp \
- rtl/rel5/user/ereps.lisp \
- rtl/rel5/user/land.lisp \
- rtl/rel5/user/lextra.lisp \
- rtl/rel5/user/lior.lisp \
- rtl/rel5/user/lnot.lisp \
- rtl/rel5/user/logior1.lisp \
- rtl/rel5/user/lxor.lisp \
- rtl/rel5/user/mulcat.lisp \
- rtl/rel5/user/near.lisp \
- rtl/rel5/user/setbitn.lisp \
- rtl/rel5/user/setbits.lisp \
- rtl/rel5/user/stick.lisp \
- rtl/rel5/user/sumbits.lisp \
- rtl/rel5/user/top.lisp \
- rtl/rel5/user/trunc.lisp \
- rtl/rel8/arithmetic/arith.lisp \
- rtl/rel8/arithmetic/arith2.lisp \
- rtl/rel8/arithmetic/basic.lisp \
- rtl/rel8/arithmetic/cg.lisp \
- rtl/rel8/arithmetic/common-factor-defuns.lisp \
- rtl/rel8/arithmetic/common-factor.lisp \
- rtl/rel8/arithmetic/complex-rationalp.lisp \
- rtl/rel8/arithmetic/denominator.lisp \
- rtl/rel8/arithmetic/even-odd.lisp \
- rtl/rel8/arithmetic/even-odd2-proofs.lisp \
- rtl/rel8/arithmetic/even-odd2.lisp \
- rtl/rel8/arithmetic/expo-proofs.lisp \
- rtl/rel8/arithmetic/expo.lisp \
- rtl/rel8/arithmetic/expt-proofs.lisp \
- rtl/rel8/arithmetic/expt.lisp \
- rtl/rel8/arithmetic/extra-rules.lisp \
- rtl/rel8/arithmetic/fl-expt.lisp \
- rtl/rel8/arithmetic/fl-hacks.lisp \
- rtl/rel8/arithmetic/fl-proofs.lisp \
- rtl/rel8/arithmetic/fl.lisp \
- rtl/rel8/arithmetic/floor-proofs.lisp \
- rtl/rel8/arithmetic/floor.lisp \
- rtl/rel8/arithmetic/fp.lisp \
- rtl/rel8/arithmetic/fp2.lisp \
- rtl/rel8/arithmetic/ground-zero.lisp \
- rtl/rel8/arithmetic/hacks.lisp \
- rtl/rel8/arithmetic/induct.lisp \
- rtl/rel8/arithmetic/integerp.lisp \
- rtl/rel8/arithmetic/inverted-factor.lisp \
- rtl/rel8/arithmetic/mod-expt.lisp \
- rtl/rel8/arithmetic/mod-proofs.lisp \
- rtl/rel8/arithmetic/mod.lisp \
- rtl/rel8/arithmetic/negative-syntaxp.lisp \
- rtl/rel8/arithmetic/nniq.lisp \
- rtl/rel8/arithmetic/numerator.lisp \
- rtl/rel8/arithmetic/power2p.lisp \
- rtl/rel8/arithmetic/predicate.lisp \
- rtl/rel8/arithmetic/product-proofs.lisp \
- rtl/rel8/arithmetic/product.lisp \
- rtl/rel8/arithmetic/rationalp.lisp \
- rtl/rel8/arithmetic/top.lisp \
- rtl/rel8/arithmetic/unary-divide.lisp \
- rtl/rel8/arithmetic/x-2xx.lisp \
- rtl/rel8/lib/add.lisp \
- rtl/rel8/lib/arith.lisp \
- rtl/rel8/lib/basic.lisp \
- rtl/rel8/lib/bits.lisp \
- rtl/rel8/lib/bvecp-helpers.lisp \
- rtl/rel8/lib/bvecp-raw-helpers.lisp \
- rtl/rel8/lib/clocks.lisp \
- rtl/rel8/lib/float.lisp \
- rtl/rel8/lib/log.lisp \
- rtl/rel8/lib/logn.lisp \
- rtl/rel8/lib/logn2log.lisp \
- rtl/rel8/lib/mult.lisp \
- rtl/rel8/lib/openers.lisp \
- rtl/rel8/lib/package-defs.lisp \
- rtl/rel8/lib/reps.lisp \
- rtl/rel8/lib/rom-helpers.lisp \
- rtl/rel8/lib/round.lisp \
- rtl/rel8/lib/rtl.lisp \
- rtl/rel8/lib/rtlarr.lisp \
- rtl/rel8/lib/simple-loop-helpers.lisp \
- rtl/rel8/lib/simplify-model-helpers.lisp \
- rtl/rel8/lib/top.lisp \
- rtl/rel8/lib/util.lisp \
- rtl/rel8/support/lib1.delta1/arith-extra.lisp \
- rtl/rel8/support/lib1.delta1/arith.lisp \
- rtl/rel8/support/lib1.delta1/basic-extra.lisp \
- rtl/rel8/support/lib1.delta1/basic.lisp \
- rtl/rel8/support/lib1.delta1/bits-extra.lisp \
- rtl/rel8/support/lib1.delta1/bits.lisp \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.lisp \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.lisp \
- rtl/rel8/support/lib1.delta1/float-extra2.lisp \
- rtl/rel8/support/lib1.delta1/float.lisp \
- rtl/rel8/support/lib1.delta1/mult-proofs.acl2 \
- rtl/rel8/support/lib1.delta1/mult-proofs.lisp \
- rtl/rel8/support/lib1.delta1/mult.lisp \
- rtl/rel8/support/lib1.delta1/round-extra2.lisp \
- rtl/rel8/support/lib1.delta1/round.lisp \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.lisp \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers.lisp \
- rtl/rel8/support/lib1.delta2/float-extra.lisp \
- rtl/rel8/support/lib1.delta2/float.lisp \
- rtl/rel8/support/lib1/add.lisp \
- rtl/rel8/support/lib1/arith.lisp \
- rtl/rel8/support/lib1/basic.lisp \
- rtl/rel8/support/lib1/bits.lisp \
- rtl/rel8/support/lib1/bvecp-helpers.lisp \
- rtl/rel8/support/lib1/bvecp-raw-helpers.lisp \
- rtl/rel8/support/lib1/clocks.lisp \
- rtl/rel8/support/lib1/float.lisp \
- rtl/rel8/support/lib1/log.lisp \
- rtl/rel8/support/lib1/openers.lisp \
- rtl/rel8/support/lib1/package-defs.lisp \
- rtl/rel8/support/lib1/reps.lisp \
- rtl/rel8/support/lib1/rom-helpers.lisp \
- rtl/rel8/support/lib1/round.lisp \
- rtl/rel8/support/lib1/rtl.lisp \
- rtl/rel8/support/lib1/rtlarr.lisp \
- rtl/rel8/support/lib1/simple-loop-helpers.lisp \
- rtl/rel8/support/lib1/simplify-model-helpers.lisp \
- rtl/rel8/support/lib1/top.lisp \
- rtl/rel8/support/lib1/util.lisp \
- rtl/rel8/support/lib2.delta1/add-new-proofs.lisp \
- rtl/rel8/support/lib2.delta1/add-new.lisp \
- rtl/rel8/support/lib2.delta1/add-proofs.lisp \
- rtl/rel8/support/lib2.delta1/add.lisp \
- rtl/rel8/support/lib2.delta1/arith.lisp \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.lisp \
- rtl/rel8/support/lib2.delta1/bits-new.lisp \
- rtl/rel8/support/lib2.delta1/bits-proofs.lisp \
- rtl/rel8/support/lib2.delta1/bits.lisp \
- rtl/rel8/support/lib2.delta1/bvecp-helpers.lisp \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.lisp \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.lisp \
- rtl/rel8/support/lib2.delta1/float-new-proofs.lisp \
- rtl/rel8/support/lib2.delta1/float-new.lisp \
- rtl/rel8/support/lib2.delta1/float-proofs.lisp \
- rtl/rel8/support/lib2.delta1/float.lisp \
- rtl/rel8/support/lib2.delta1/log-new-proofs.lisp \
- rtl/rel8/support/lib2.delta1/log-new.lisp \
- rtl/rel8/support/lib2.delta1/log-proofs.lisp \
- rtl/rel8/support/lib2.delta1/log-support-proofs.lisp \
- rtl/rel8/support/lib2.delta1/log-support.lisp \
- rtl/rel8/support/lib2.delta1/log.lisp \
- rtl/rel8/support/lib2.delta1/logn-new-proofs.lisp \
- rtl/rel8/support/lib2.delta1/logn-new.lisp \
- rtl/rel8/support/lib2.delta1/logn-proofs.lisp \
- rtl/rel8/support/lib2.delta1/logn.lisp \
- rtl/rel8/support/lib2.delta1/logn2log-proofs.lisp \
- rtl/rel8/support/lib2.delta1/logn2log.lisp \
- rtl/rel8/support/lib2.delta1/mult-new-proofs.lisp \
- rtl/rel8/support/lib2.delta1/mult-new.lisp \
- rtl/rel8/support/lib2.delta1/mult-proofs.lisp \
- rtl/rel8/support/lib2.delta1/mult.lisp \
- rtl/rel8/support/lib2.delta1/reps-new-proofs.lisp \
- rtl/rel8/support/lib2.delta1/reps-new.lisp \
- rtl/rel8/support/lib2.delta1/reps-proofs.lisp \
- rtl/rel8/support/lib2.delta1/reps.lisp \
- rtl/rel8/support/lib2.delta1/round-new-proofs.lisp \
- rtl/rel8/support/lib2.delta1/round-new.lisp \
- rtl/rel8/support/lib2.delta1/round-proofs.lisp \
- rtl/rel8/support/lib2.delta1/round.lisp \
- rtl/rel8/support/lib2.delta1/rtl-new-proofs.lisp \
- rtl/rel8/support/lib2.delta1/rtl-new.lisp \
- rtl/rel8/support/lib2.delta1/rtl-proofs.lisp \
- rtl/rel8/support/lib2.delta1/rtl.lisp \
- rtl/rel8/support/lib2.delta1/rtlarr-new.lisp \
- rtl/rel8/support/lib2.delta1/rtlarr.lisp \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.lisp \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers.lisp \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.lisp \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.lisp \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.lisp \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers.lisp \
- rtl/rel8/support/lib2.delta1/top.lisp \
- rtl/rel8/support/lib2.delta1/util.lisp \
- rtl/rel8/support/lib2.delta2/add-lib.lisp \
- rtl/rel8/support/lib2.delta2/add.lisp \
- rtl/rel8/support/lib2.delta2/base.lisp \
- rtl/rel8/support/lib2.delta2/bits.lisp \
- rtl/rel8/support/lib2.delta2/log.lisp \
- rtl/rel8/support/lib2/add.lisp \
- rtl/rel8/support/lib2/arith.lisp \
- rtl/rel8/support/lib2/base.lisp \
- rtl/rel8/support/lib2/basic.lisp \
- rtl/rel8/support/lib2/bits.lisp \
- rtl/rel8/support/lib2/bvecp-helpers.lisp \
- rtl/rel8/support/lib2/bvecp-raw-helpers.lisp \
- rtl/rel8/support/lib2/clocks.lisp \
- rtl/rel8/support/lib2/float.lisp \
- rtl/rel8/support/lib2/log.lisp \
- rtl/rel8/support/lib2/mult.lisp \
- rtl/rel8/support/lib2/openers.lisp \
- rtl/rel8/support/lib2/package-defs.lisp \
- rtl/rel8/support/lib2/reps.lisp \
- rtl/rel8/support/lib2/rom-helpers.lisp \
- rtl/rel8/support/lib2/round.lisp \
- rtl/rel8/support/lib2/rtl.lisp \
- rtl/rel8/support/lib2/rtlarr.lisp \
- rtl/rel8/support/lib2/simple-loop-helpers.lisp \
- rtl/rel8/support/lib2/simplify-model-helpers.lisp \
- rtl/rel8/support/lib2/top.lisp \
- rtl/rel8/support/lib2/util.lisp \
- rtl/rel8/support/support/add3-proofs.lisp \
- rtl/rel8/support/support/add3.lisp \
- rtl/rel8/support/support/all-ones.lisp \
- rtl/rel8/support/support/ash.lisp \
- rtl/rel8/support/support/away-proofs.lisp \
- rtl/rel8/support/support/away.lisp \
- rtl/rel8/support/support/badguys.lisp \
- rtl/rel8/support/support/bias-proofs.lisp \
- rtl/rel8/support/support/bias.lisp \
- rtl/rel8/support/support/bitn-proofs.lisp \
- rtl/rel8/support/support/bitn.lisp \
- rtl/rel8/support/support/bits-proofs.lisp \
- rtl/rel8/support/support/bits-trunc-proofs.lisp \
- rtl/rel8/support/support/bits-trunc.lisp \
- rtl/rel8/support/support/bits.lisp \
- rtl/rel8/support/support/bvecp-helpers.lisp \
- rtl/rel8/support/support/bvecp-lemmas.lisp \
- rtl/rel8/support/support/bvecp-proofs.lisp \
- rtl/rel8/support/support/bvecp.lisp \
- rtl/rel8/support/support/cat-def.lisp \
- rtl/rel8/support/support/cat-proofs.lisp \
- rtl/rel8/support/support/cat.lisp \
- rtl/rel8/support/support/clocks.lisp \
- rtl/rel8/support/support/decode-proofs.lisp \
- rtl/rel8/support/support/decode.lisp \
- rtl/rel8/support/support/drnd-original.lisp \
- rtl/rel8/support/support/encode.lisp \
- rtl/rel8/support/support/ereps-proofs.lisp \
- rtl/rel8/support/support/ereps.lisp \
- rtl/rel8/support/support/fadd-extra.lisp \
- rtl/rel8/support/support/fadd-extra0.lisp \
- rtl/rel8/support/support/fadd.lisp \
- rtl/rel8/support/support/fast-and.lisp \
- rtl/rel8/support/support/float-extra.lisp \
- rtl/rel8/support/support/float.lisp \
- rtl/rel8/support/support/ground-zero.lisp \
- rtl/rel8/support/support/guards.lisp \
- rtl/rel8/support/support/ireps.lisp \
- rtl/rel8/support/support/land.lisp \
- rtl/rel8/support/support/land0-proofs.lisp \
- rtl/rel8/support/support/land0.lisp \
- rtl/rel8/support/support/lextra-proofs.lisp \
- rtl/rel8/support/support/lextra.lisp \
- rtl/rel8/support/support/lextra0.lisp \
- rtl/rel8/support/support/lior.lisp \
- rtl/rel8/support/support/lior0-proofs.lisp \
- rtl/rel8/support/support/lior0.lisp \
- rtl/rel8/support/support/lnot-proofs.lisp \
- rtl/rel8/support/support/lnot.lisp \
- rtl/rel8/support/support/log-equal.lisp \
- rtl/rel8/support/support/log-proofs.lisp \
- rtl/rel8/support/support/log.lisp \
- rtl/rel8/support/support/logand-proofs.lisp \
- rtl/rel8/support/support/logand.lisp \
- rtl/rel8/support/support/logeqv.lisp \
- rtl/rel8/support/support/logior-proofs.lisp \
- rtl/rel8/support/support/logior.lisp \
- rtl/rel8/support/support/logior1-proofs.lisp \
- rtl/rel8/support/support/logior1.lisp \
- rtl/rel8/support/support/lognot.lisp \
- rtl/rel8/support/support/logorc1.lisp \
- rtl/rel8/support/support/logs.lisp \
- rtl/rel8/support/support/logxor.lisp \
- rtl/rel8/support/support/lop1-proofs.lisp \
- rtl/rel8/support/support/lop1.lisp \
- rtl/rel8/support/support/lop2-proofs.lisp \
- rtl/rel8/support/support/lop2.lisp \
- rtl/rel8/support/support/lop3-proofs.lisp \
- rtl/rel8/support/support/lop3.lisp \
- rtl/rel8/support/support/lxor.lisp \
- rtl/rel8/support/support/lxor0-proofs.lisp \
- rtl/rel8/support/support/lxor0.lisp \
- rtl/rel8/support/support/merge.lisp \
- rtl/rel8/support/support/merge2.lisp \
- rtl/rel8/support/support/mod4.lisp \
- rtl/rel8/support/support/model-helpers.lisp \
- rtl/rel8/support/support/mulcat-proofs.lisp \
- rtl/rel8/support/support/mulcat.lisp \
- rtl/rel8/support/support/near+-proofs.lisp \
- rtl/rel8/support/support/near+.lisp \
- rtl/rel8/support/support/near-proofs.lisp \
- rtl/rel8/support/support/near.lisp \
- rtl/rel8/support/support/ocat.lisp \
- rtl/rel8/support/support/oddr-proofs.lisp \
- rtl/rel8/support/support/oddr.lisp \
- rtl/rel8/support/support/openers.lisp \
- rtl/rel8/support/support/package-defs.lisp \
- rtl/rel8/support/support/rewrite-theory.lisp \
- rtl/rel8/support/support/rnd.lisp \
- rtl/rel8/support/support/rom-helpers.lisp \
- rtl/rel8/support/support/round-extra.lisp \
- rtl/rel8/support/support/rtl.lisp \
- rtl/rel8/support/support/rtlarr.lisp \
- rtl/rel8/support/support/setbitn-proofs.lisp \
- rtl/rel8/support/support/setbitn.lisp \
- rtl/rel8/support/support/setbits-proofs.lisp \
- rtl/rel8/support/support/setbits.lisp \
- rtl/rel8/support/support/sgn.lisp \
- rtl/rel8/support/support/shft.lisp \
- rtl/rel8/support/support/simple-loop-helpers.lisp \
- rtl/rel8/support/support/simplify-model-helpers.lisp \
- rtl/rel8/support/support/stick-proofs.lisp \
- rtl/rel8/support/support/stick.lisp \
- rtl/rel8/support/support/sticky-proofs.lisp \
- rtl/rel8/support/support/sticky.lisp \
- rtl/rel8/support/support/sumbits.lisp \
- rtl/rel8/support/support/top.lisp \
- rtl/rel8/support/support/top1.lisp \
- rtl/rel8/support/support/trunc-proofs.lisp \
- rtl/rel8/support/support/trunc.lisp \
- rtl/rel8/support/support/util.lisp \
- rtl/rel8/support/top/top.lisp \
- security/jfkr/cert.acl2 \
- security/jfkr/diffie-helman.lisp \
- security/jfkr/encryption.lisp \
- security/jfkr/jfkr.lisp \
- security/jfkr/package.lsp \
- security/jfkr/random.lisp \
- security/suite-b/sha-2.lisp \
- security/util/byte-operations.lisp \
- serialize/serialize-tests.acl2 \
- serialize/serialize-tests.lisp \
- serialize/serialize-tests2.acl2 \
- serialize/serialize-tests2.lisp \
- serialize/unsound-read.acl2 \
- serialize/unsound-read.lisp \
- sorting/bsort.lisp \
- sorting/convert-perm-to-how-many.lisp \
- sorting/equisort.lisp \
- sorting/equisort2.lisp \
- sorting/equisort3.lisp \
- sorting/isort.lisp \
- sorting/msort.lisp \
- sorting/no-dups-qsort.lisp \
- sorting/ordered-perms.lisp \
- sorting/perm.lisp \
- sorting/qsort.lisp \
- sorting/sorts-equivalent.lisp \
- sorting/sorts-equivalent2.lisp \
- sorting/sorts-equivalent3.lisp \
- std/io/base.lisp \
- std/io/close-input-channel.lisp \
- std/io/combine.lisp \
- std/io/file-measure.lisp \
- std/io/nthcdr-bytes.lisp \
- std/io/open-input-channel.lisp \
- std/io/open-input-channels.lisp \
- std/io/peek-char.lisp \
- std/io/read-byte.lisp \
- std/io/read-char.lisp \
- std/io/read-file-bytes.lisp \
- std/io/read-file-characters-no-error.acl2 \
- std/io/read-file-characters-no-error.lisp \
- std/io/read-file-characters.lisp \
- std/io/read-file-lines.lisp \
- std/io/read-file-objects.lisp \
- std/io/read-ints.lisp \
- std/io/read-object.lisp \
- std/io/sign-byte.lisp \
- std/io/signed-byte-listp.lisp \
- std/io/take-bytes.lisp \
- std/io/unsigned-byte-listp.lisp \
- std/ks/base10-digit-charp.lisp \
- std/ks/explode-atom.lisp \
- std/ks/explode-nonnegative-integer.lisp \
- std/ks/intern-in-package-of-symbol.lisp \
- std/ks/string-append.lisp \
- std/ks/two-nats-measure.lisp \
- std/lists/app.lisp \
- std/lists/append.lisp \
- std/lists/coerce.lisp \
- std/lists/consless-listp.lisp \
- std/lists/equiv.lisp \
- std/lists/final-cdr.lisp \
- std/lists/flatten.lisp \
- std/lists/list-defuns.lisp \
- std/lists/list-fix.lisp \
- std/lists/make-character-list.lisp \
- std/lists/mfc-utils.lisp \
- std/lists/nat-listp.lisp \
- std/lists/nthcdr.lisp \
- std/lists/prefixp.lisp \
- std/lists/repeat.lisp \
- std/lists/rev.lisp \
- std/lists/revappend.lisp \
- std/lists/reverse.lisp \
- std/lists/sets.lisp \
- std/lists/take.lisp \
- str/abbrevs.lisp \
- str/arithmetic.lisp \
- str/case-conversion.lisp \
- str/cat.lisp \
- str/cert.acl2 \
- str/char-case.lisp \
- str/digitp.lisp \
- str/eqv.lisp \
- str/fast-cat.acl2 \
- str/fast-cat.lisp \
- str/firstn-chars.lisp \
- str/hexify.lisp \
- str/html-encode.lisp \
- str/ieqv.lisp \
- str/iless.lisp \
- str/iprefixp.lisp \
- str/isort.lisp \
- str/istrpos.lisp \
- str/istrprefixp.lisp \
- str/isubstrp.lisp \
- str/natstr.lisp \
- str/package.lsp \
- str/pad.lisp \
- str/portcullis.acl2 \
- str/portcullis.lisp \
- str/prefix-lines.lisp \
- str/stringify.lisp \
- str/strline.lisp \
- str/strnatless.lisp \
- str/strpos.lisp \
- str/strprefixp.lisp \
- str/strrpos.lisp \
- str/strsplit.lisp \
- str/strsubst.lisp \
- str/strtok.lisp \
- str/strval.lisp \
- str/subseq.lisp \
- str/substrp.lisp \
- str/suffixp.lisp \
- str/top.lisp \
- symbolic/generic/assertions.lisp \
- symbolic/generic/defsimulate.lisp \
- symbolic/generic/factorial-jvm-correct.acl2 \
- symbolic/generic/factorial-jvm-correct.lisp \
- symbolic/generic/measures.lisp \
- symbolic/generic/partial-correctness.lisp \
- symbolic/generic/tiny-fib-correct.lisp \
- symbolic/generic/total-correctness.lisp \
- symbolic/m5/demo.acl2 \
- symbolic/m5/demo.lisp \
- symbolic/m5/utilities.acl2 \
- symbolic/m5/utilities.lisp \
- symbolic/tiny-fib/defstobj+.lisp \
- symbolic/tiny-fib/fib-def.lisp \
- symbolic/tiny-fib/tiny-rewrites.lisp \
- symbolic/tiny-fib/tiny.lisp \
- symbolic/tiny-triangle/tiny-triangle-correct.lisp \
- symbolic/tiny-triangle/triangle-def.lisp \
- system/compare-out-files.lisp \
- system/convert-normalized-term-to-pairs.lisp \
- system/extend-pathname.lisp \
- system/f-put-global.lisp \
- system/gather-dcls.lisp \
- system/hl-addr-combine.lisp \
- system/io.lisp \
- system/legal-variablep.lisp \
- system/meta-extract.lisp \
- system/pseudo-good-worldp.lisp \
- system/pseudo-termp-lemmas.lisp \
- system/subcor-var.lisp \
- system/sublis-var.lisp \
- system/subst-expr.lisp \
- system/subst-var.lisp \
- system/too-many-ifs.acl2 \
- system/too-many-ifs.lisp \
- system/top.lisp \
- system/update-state.lisp \
- system/verified-termination-and-guards.lisp \
- system/worldp-check.acl2 \
- system/worldp-check.lisp \
- taspi/code/brlens/brlens.lisp \
- taspi/code/brlens/trees-with-brlens.lisp \
- taspi/code/build/build-term-guards.lisp \
- taspi/code/build/build-term.lisp \
- taspi/code/fringes/fringes-guards.lisp \
- taspi/code/fringes/fringes-props.lisp \
- taspi/code/fringes/fringes.lisp \
- taspi/code/gen-helper/bdd-functions.lisp \
- taspi/code/gen-helper/extra.lisp \
- taspi/code/gen-helper/fast-lists.lisp \
- taspi/code/gen-helper/sets.lisp \
- taspi/code/gen-helper/top.lisp \
- taspi/code/gen-trees/app-rev-lists.lisp \
- taspi/code/gen-trees/btrees-bdds-sets.lisp \
- taspi/code/gen-trees/btrees-bdds.lisp \
- taspi/code/gen-trees/btrees.lisp \
- taspi/code/gen-trees/sets-lists-trees.lisp \
- taspi/code/gen-trees/top.lisp \
- taspi/code/gen-trees/tree-predicates.lisp \
- taspi/code/replete/replete-guards.lisp \
- taspi/code/replete/replete-helper.lisp \
- taspi/code/replete/replete.lisp \
- taspi/code/sequences/align.lisp \
- taspi/code/sequences/p-inform.lisp \
- taspi/code/sequences/seqs.lisp \
- taspi/code/tree-manip/insertion-based-sort.lisp \
- taspi/code/tree-manip/merge-based-sort.lisp \
- taspi/code/tree-manip/mv-root.lisp \
- taspi/code/tree-manip/quicksort.lisp \
- taspi/code/tree-manip/sort-help.lisp \
- taspi/code/tree-manip/top.lisp \
- taspi/database/db-from-list.lisp \
- taspi/database/db.lisp \
- taspi/database/entry.lisp \
- taspi/database/filters.lisp \
- taspi/database/props.lisp \
- taspi/proofs/fringes-taspi.acl2 \
- taspi/proofs/fringes-taspi.lisp \
- taspi/proofs/omerge-good-order.acl2 \
- taspi/proofs/omerge-good-order.lisp \
- taspi/proofs/sets.acl2 \
- taspi/proofs/sets.lisp \
- taspi/sets-input/consensus.lisp \
- taspi/sets-input/greedy.lisp \
- taspi/sets-input/mast.lisp \
- taspi/sets-input/mct.lisp \
- taspi/sets-input/multipolar-loose.lisp \
- taspi/sets-input/top.lisp \
- taspi/sets-input/tree-compat.lisp \
- taspi/sets-input/tree-support-in-set.lisp \
- taspi/single-input/taxa-based.lisp \
- taspi/single-input/tree-stats.lisp \
- taspi/tree-distance/rf.lisp \
- taspi/tree-distance/symm-diff.lisp \
- taspi/tree-generation/branch-and-bound/bandb.lisp \
- taspi/tree-generation/distance-based/naive-quartet-method.lisp \
- taspi/tree-generation/heuristics/do-search.lisp \
- taspi/tree-generation/heuristics/spr.lisp \
- taspi/tree-generation/heuristics/tbr.lisp \
- taspi/tree-generation/tree-gen-helper/basics.lisp \
- taspi/tree-score/ambig-score.lisp \
- taspi/tree-score/circle-scoring.lisp \
- taspi/tree-score/costs.lisp \
- taspi/tree-score/efficient-pscores-help.lisp \
- taspi/tree-score/efficient-pscores.lisp \
- taspi/tree-score/fitch-scoring.lisp \
- taspi/tree-score/min-length.lisp \
- taspi/tree-score/opt-pairwise.lisp \
- taspi/tree-score/pscores.lisp \
- tau/bounders/elementary-bounders.lisp \
- tau/bounders/find-maximal-1d.lisp \
- tau/bounders/find-maximal-2d.lisp \
- tau/bounders/find-minimal-1d.lisp \
- tau/bounders/find-minimal-2d.lisp \
- textbook/chap10/ac-example.lisp \
- textbook/chap10/adder.lisp \
- textbook/chap10/compiler.acl2 \
- textbook/chap10/compiler.lisp \
- textbook/chap10/fact.lisp \
- textbook/chap10/insertion-sort.lisp \
- textbook/chap10/tree.lisp \
- textbook/chap11/compress.lisp \
- textbook/chap11/encap.lisp \
- textbook/chap11/finite-sets.lisp \
- textbook/chap11/how-many-soln1.lisp \
- textbook/chap11/how-many-soln2.lisp \
- textbook/chap11/mergesort.lisp \
- textbook/chap11/perm-append.lisp \
- textbook/chap11/perm.lisp \
- textbook/chap11/qsort.lisp \
- textbook/chap11/starters.lisp \
- textbook/chap11/summations-book.lisp \
- textbook/chap11/summations.lisp \
- textbook/chap11/tautology.lisp \
- textbook/chap11/xtr.lisp \
- textbook/chap11/xtr2.lisp \
- textbook/chap3/programs.lisp \
- textbook/chap4/solutions-logic-mode.lisp \
- textbook/chap4/solutions-program-mode.lisp \
- textbook/chap5/solutions.lisp \
- textbook/chap6/selected-solutions.lisp \
- tools/bstar.lisp \
- tools/case-splitting-rules.lisp \
- tools/clone-stobj.lisp \
- tools/cws.lisp \
- tools/def-functional-instance.lisp \
- tools/defconsts.lisp \
- tools/defevaluator-fast.lisp \
- tools/define-keyed-function.lisp \
- tools/defined-const.lisp \
- tools/defmacfun.lisp \
- tools/defredundant.lisp \
- tools/defsum.lisp \
- tools/deftuple.lisp \
- tools/do-not.lisp \
- tools/easy-simplify.lisp \
- tools/fake-event.lisp \
- tools/flag-package.lsp \
- tools/flag.acl2 \
- tools/flag.lisp \
- tools/in-raw-mode.acl2 \
- tools/in-raw-mode.lisp \
- tools/include-raw.lisp \
- tools/mv-nth.lisp \
- tools/oracle-eval-real.acl2 \
- tools/oracle-eval-real.lisp \
- tools/oracle-eval.lisp \
- tools/pack.lisp \
- tools/pattern-match.lisp \
- tools/plev-ccl.acl2 \
- tools/plev-ccl.lisp \
- tools/plev.lisp \
- tools/rulesets.lisp \
- tools/safe-case.lisp \
- tools/saved-errors.lisp \
- tools/stobj-frame.lisp \
- tools/stobj-help.lisp \
- tools/templates.lisp \
- tools/theory-tools.lisp \
- tools/time-dollar-with-gc.acl2 \
- tools/time-dollar-with-gc.lisp \
- tools/types-misc.lisp \
- tools/with-arith5-help.lisp \
- tools/with-quoted-forms.lisp \
- tutorial-problems/introductory-challenge-problem-4-athena.lisp \
- tutorial-problems/introductory-challenge-problem-4.lisp \
- unicode/partition.lisp \
- unicode/read-utf8.lisp \
- unicode/sum-list.lisp \
- unicode/uchar.lisp \
- unicode/utf8-decode.lisp \
- unicode/utf8-encode.lisp \
- unicode/utf8-table35.lisp \
- unicode/utf8-table36.lisp \
- unicode/z-listp.lisp \
- workshops/1999/calculus/solutions/mesh-append.lisp \
- workshops/1999/calculus/solutions/mesh-make-partition.lisp \
- workshops/1999/calculus/solutions/partition-defuns.lisp \
- workshops/1999/calculus/solutions/partitionp-make-partition-rec.lisp \
- workshops/1999/calculus/solutions/partitionp-make-partition.lisp \
- workshops/1999/calculus/solutions/riemann-rcfn-helpers.lisp \
- workshops/1999/compiler/compiler.lisp \
- workshops/1999/compiler/evaluator.lisp \
- workshops/1999/compiler/exercises.lisp \
- workshops/1999/compiler/machine.lisp \
- workshops/1999/compiler/proof.lisp \
- workshops/1999/compiler/proof1.lisp \
- workshops/1999/de-hdl/arity.lisp \
- workshops/1999/de-hdl/de4.lisp \
- workshops/1999/de-hdl/examples.lisp \
- workshops/1999/de-hdl/help-defuns.lisp \
- workshops/1999/de-hdl/measure.lisp \
- workshops/1999/de-hdl/primitives.lisp \
- workshops/1999/de-hdl/sts-okp.lisp \
- workshops/1999/de-hdl/syntax.lisp \
- workshops/1999/de-hdl/thm-example.lisp \
- workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.lisp \
- workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.lisp \
- workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.lisp \
- workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.lisp \
- workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.lisp \
- workshops/1999/embedded/Proof-Of-Contribution/CRT.lisp \
- workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.lisp \
- workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.lisp \
- workshops/1999/embedded/Proof-Of-Contribution/Generic.lisp \
- workshops/1999/embedded/Proof-Of-Contribution/Mapping.lisp \
- workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.lisp \
- workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.lisp \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.lisp \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.lisp \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.lisp \
- workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.lisp \
- workshops/1999/graph/find-path1.lisp \
- workshops/1999/graph/find-path2.lisp \
- workshops/1999/graph/find-path3.lisp \
- workshops/1999/graph/helpers.lisp \
- workshops/1999/graph/linear-find-path.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/alls.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/cnf.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/derive.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/flip.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/keval.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/modeler.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/nnf.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/paramod.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/prover.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/resolve.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/sets.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/simplify.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/substitution.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/sugar.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/top.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/variables.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.lisp \
- workshops/1999/ivy/ivy-v2/ivy-sources/xeval.lisp \
- workshops/1999/knuth-91/aof.acl2 \
- workshops/1999/knuth-91/aof.lisp \
- workshops/1999/knuth-91/exercise1.acl2 \
- workshops/1999/knuth-91/exercise1.lisp \
- workshops/1999/knuth-91/exercise2.lisp \
- workshops/1999/knuth-91/exercise3.lisp \
- workshops/1999/knuth-91/exercise4a.lisp \
- workshops/1999/knuth-91/exercise4b.lisp \
- workshops/1999/knuth-91/exercise5.lisp \
- workshops/1999/knuth-91/exercise6a.lisp \
- workshops/1999/knuth-91/exercise6b.lisp \
- workshops/1999/knuth-91/exercise7a.lisp \
- workshops/1999/knuth-91/exercise7b.lisp \
- workshops/1999/knuth-91/knuth-arch.lisp \
- workshops/1999/mu-calculus/book/fast-sets.acl2 \
- workshops/1999/mu-calculus/book/fast-sets.lisp \
- workshops/1999/mu-calculus/book/fixpoints.acl2 \
- workshops/1999/mu-calculus/book/fixpoints.lisp \
- workshops/1999/mu-calculus/book/models.acl2 \
- workshops/1999/mu-calculus/book/models.lisp \
- workshops/1999/mu-calculus/book/relations.acl2 \
- workshops/1999/mu-calculus/book/relations.lisp \
- workshops/1999/mu-calculus/book/semantics.acl2 \
- workshops/1999/mu-calculus/book/semantics.lisp \
- workshops/1999/mu-calculus/book/sets.acl2 \
- workshops/1999/mu-calculus/book/sets.lisp \
- workshops/1999/mu-calculus/book/syntax.acl2 \
- workshops/1999/mu-calculus/book/syntax.lisp \
- workshops/1999/mu-calculus/solutions/ctl.acl2 \
- workshops/1999/mu-calculus/solutions/ctl.lisp \
- workshops/1999/mu-calculus/solutions/defung.lisp \
- workshops/1999/mu-calculus/solutions/fast-sets.acl2 \
- workshops/1999/mu-calculus/solutions/fast-sets.lisp \
- workshops/1999/mu-calculus/solutions/fixpoints.acl2 \
- workshops/1999/mu-calculus/solutions/fixpoints.lisp \
- workshops/1999/mu-calculus/solutions/meta.lisp \
- workshops/1999/mu-calculus/solutions/models.acl2 \
- workshops/1999/mu-calculus/solutions/models.lisp \
- workshops/1999/mu-calculus/solutions/perm.lisp \
- workshops/1999/mu-calculus/solutions/relations.acl2 \
- workshops/1999/mu-calculus/solutions/relations.lisp \
- workshops/1999/mu-calculus/solutions/semantics.acl2 \
- workshops/1999/mu-calculus/solutions/semantics.lisp \
- workshops/1999/mu-calculus/solutions/sets.acl2 \
- workshops/1999/mu-calculus/solutions/sets.lisp \
- workshops/1999/mu-calculus/solutions/syntax.acl2 \
- workshops/1999/mu-calculus/solutions/syntax.lisp \
- workshops/1999/pipeline/b-ops-aux-def.lisp \
- workshops/1999/pipeline/b-ops-aux.lisp \
- workshops/1999/pipeline/basic-def.acl2 \
- workshops/1999/pipeline/basic-def.lisp \
- workshops/1999/pipeline/basic-lemmas.lisp \
- workshops/1999/pipeline/define-u-package.lsp \
- workshops/1999/pipeline/exercise.lisp \
- workshops/1999/pipeline/ihs.lisp \
- workshops/1999/pipeline/model.lisp \
- workshops/1999/pipeline/proof.lisp \
- workshops/1999/pipeline/table-def.lisp \
- workshops/1999/pipeline/trivia.lisp \
- workshops/1999/pipeline/utils.acl2 \
- workshops/1999/pipeline/utils.lisp \
- workshops/1999/simulator/exercises.lisp \
- workshops/1999/simulator/tiny.lisp \
- workshops/1999/ste/assertion.lisp \
- workshops/1999/ste/boolean.lisp \
- workshops/1999/ste/circuit.lisp \
- workshops/1999/ste/example.lisp \
- workshops/1999/ste/expression.lisp \
- workshops/1999/ste/fundamental.lisp \
- workshops/1999/ste/inference.lisp \
- workshops/1999/ste/lemma-4.lisp \
- workshops/1999/ste/run.lisp \
- workshops/1999/ste/state.lisp \
- workshops/1999/ste/trajectory.lisp \
- workshops/1999/ste/util.lisp \
- workshops/1999/vhdl/exercises.lisp \
- workshops/1999/vhdl/fact-proof.lisp \
- workshops/1999/vhdl/fact.lisp \
- workshops/1999/vhdl/vhdl.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/base.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/compile.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/cstate.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/expr.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/lstate.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/mstate.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/pstate.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/setup.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/simulator.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.lisp \
- workshops/2000/lusk-mccune/lusk-mccune-final/util.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.lisp \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.lisp \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.lisp \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.lisp \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.lisp \
- workshops/2000/manolios/pipeline/pipeline/top/ihs.lisp \
- workshops/2000/manolios/pipeline/pipeline/top/meta.lisp \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.lisp \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.lisp \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux.lisp \
- workshops/2000/manolios/pipeline/trivial/basic-def.acl2 \
- workshops/2000/manolios/pipeline/trivial/basic-def.lisp \
- workshops/2000/manolios/pipeline/trivial/basic-lemmas.lisp \
- workshops/2000/manolios/pipeline/trivial/define-u-package.lsp \
- workshops/2000/manolios/pipeline/trivial/ihs.lisp \
- workshops/2000/manolios/pipeline/trivial/model.lisp \
- workshops/2000/manolios/pipeline/trivial/proof.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.acl2 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/define-u-package.lsp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/model.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/proof.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/utils.acl2 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/utils.lisp \
- workshops/2000/manolios/pipeline/trivial/table-def.lisp \
- workshops/2000/manolios/pipeline/trivial/trivia.lisp \
- workshops/2000/manolios/pipeline/trivial/utils.acl2 \
- workshops/2000/manolios/pipeline/trivial/utils.lisp \
- workshops/2000/medina/polynomials/addition.acl2 \
- workshops/2000/medina/polynomials/addition.lisp \
- workshops/2000/medina/polynomials/certification.acl2 \
- workshops/2000/medina/polynomials/congruences-1.acl2 \
- workshops/2000/medina/polynomials/congruences-1.lisp \
- workshops/2000/medina/polynomials/congruences-2.acl2 \
- workshops/2000/medina/polynomials/congruences-2.lisp \
- workshops/2000/medina/polynomials/examples.acl2 \
- workshops/2000/medina/polynomials/examples.lisp \
- workshops/2000/medina/polynomials/lexicographical-ordering.acl2 \
- workshops/2000/medina/polynomials/lexicographical-ordering.lisp \
- workshops/2000/medina/polynomials/monomial.acl2 \
- workshops/2000/medina/polynomials/monomial.lisp \
- workshops/2000/medina/polynomials/multiplication.acl2 \
- workshops/2000/medina/polynomials/multiplication.lisp \
- workshops/2000/medina/polynomials/negation.acl2 \
- workshops/2000/medina/polynomials/negation.lisp \
- workshops/2000/medina/polynomials/normal-form.acl2 \
- workshops/2000/medina/polynomials/normal-form.lisp \
- workshops/2000/medina/polynomials/polynomial.acl2 \
- workshops/2000/medina/polynomials/polynomial.lisp \
- workshops/2000/medina/polynomials/term.acl2 \
- workshops/2000/medina/polynomials/term.lisp \
- workshops/2000/moore-manolios/partial-functions/defpun-original.lisp \
- workshops/2000/moore-manolios/partial-functions/defpun.lisp \
- workshops/2000/moore-manolios/partial-functions/examples.acl2 \
- workshops/2000/moore-manolios/partial-functions/examples.lisp \
- workshops/2000/moore-manolios/partial-functions/mod-1-property.lisp \
- workshops/2000/moore-manolios/partial-functions/report.lisp \
- workshops/2000/moore-manolios/partial-functions/tjvm-examples.acl2 \
- workshops/2000/moore-manolios/partial-functions/tjvm-examples.lisp \
- workshops/2000/moore-manolios/partial-functions/tjvm.acl2 \
- workshops/2000/moore-manolios/partial-functions/tjvm.lisp \
- workshops/2000/ruiz/multiset/defmul.acl2 \
- workshops/2000/ruiz/multiset/defmul.lisp \
- workshops/2000/ruiz/multiset/examples/ackermann/ackermann.lisp \
- workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.lisp \
- workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.lisp \
- workshops/2000/ruiz/multiset/examples/newman/confluence-v0.acl2 \
- workshops/2000/ruiz/multiset/examples/newman/confluence-v0.lisp \
- workshops/2000/ruiz/multiset/examples/newman/confluence.acl2 \
- workshops/2000/ruiz/multiset/examples/newman/confluence.lisp \
- workshops/2000/ruiz/multiset/examples/newman/local-confluence.acl2 \
- workshops/2000/ruiz/multiset/examples/newman/local-confluence.lisp \
- workshops/2000/ruiz/multiset/examples/newman/newman.acl2 \
- workshops/2000/ruiz/multiset/examples/newman/newman.lisp \
- workshops/2000/ruiz/multiset/multiset.acl2 \
- workshops/2000/ruiz/multiset/multiset.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/constants.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/constants.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/declarations.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/declarations.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/exec.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/exec.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/inputs.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/inputs.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/main.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/main.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/model.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/model.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp \
- workshops/2000/russinoff-kaufmann/supporting-materials/pipe.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/pipe.lisp \
- workshops/2000/russinoff-short/crt.lisp \
- workshops/2000/russinoff-short/summary.lisp \
- workshops/2000/sumners1/cdeq/cdeq-defs.lisp \
- workshops/2000/sumners1/cdeq/cdeq-phase1.lisp \
- workshops/2000/sumners1/cdeq/cdeq-phase2.lisp \
- workshops/2000/sumners1/cdeq/cdeq-phase3.lisp \
- workshops/2000/sumners1/cdeq/cdeq-phase4.lisp \
- workshops/2000/sumners1/cdeq/records.lisp \
- workshops/2000/sumners2/bdds/bdd-mgr.lisp \
- workshops/2000/sumners2/bdds/bdd-prf.lisp \
- workshops/2000/sumners2/bdds/bdd-spec.lisp \
- workshops/2002/cowles-flat/support/flat-ackermann.acl2 \
- workshops/2002/cowles-flat/support/flat-ackermann.lisp \
- workshops/2002/cowles-flat/support/flat-nested.acl2 \
- workshops/2002/cowles-flat/support/flat-nested.lisp \
- workshops/2002/cowles-flat/support/flat-primitive.acl2 \
- workshops/2002/cowles-flat/support/flat-primitive.lisp \
- workshops/2002/cowles-flat/support/flat-reverse.acl2 \
- workshops/2002/cowles-flat/support/flat-reverse.lisp \
- workshops/2002/cowles-flat/support/flat-tail.acl2 \
- workshops/2002/cowles-flat/support/flat-tail.lisp \
- workshops/2002/cowles-flat/support/flat-z.acl2 \
- workshops/2002/cowles-flat/support/flat-z.lisp \
- workshops/2002/cowles-flat/support/flat.acl2 \
- workshops/2002/cowles-flat/support/flat.lisp \
- workshops/2002/cowles-primrec/support/bad-def.acl2 \
- workshops/2002/cowles-primrec/support/bad-def.lisp \
- workshops/2002/cowles-primrec/support/bad-def1.acl2 \
- workshops/2002/cowles-primrec/support/bad-def1.lisp \
- workshops/2002/cowles-primrec/support/defpr.lisp \
- workshops/2002/cowles-primrec/support/fix.lisp \
- workshops/2002/cowles-primrec/support/primitive.lisp \
- workshops/2002/cowles-primrec/support/tail.lisp \
- workshops/2002/georgelin-borrione-ostier/support/acl2-transl.lisp \
- workshops/2002/georgelin-borrione-ostier/support/generates-functions.lisp \
- workshops/2002/georgelin-borrione-ostier/support/generates-theorems.lisp \
- workshops/2002/georgelin-borrione-ostier/support/utils.lisp \
- workshops/2002/kaufmann-sumners/support/records.lisp \
- workshops/2002/kaufmann-sumners/support/records0.lisp \
- workshops/2002/kaufmann-sumners/support/sets.lisp \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.acl2 \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.lisp \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.acl2 \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.lisp \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.lisp \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.lisp \
- workshops/2002/manolios-kaufmann/support/records/records-original.lisp \
- workshops/2002/manolios-kaufmann/support/records/records.lisp \
- workshops/2002/manolios-kaufmann/support/records/total-order.lisp \
- workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.lisp \
- workshops/2002/manolios-kaufmann/support/sorting/perm-order.lisp \
- workshops/2002/manolios-kaufmann/support/sorting/perm.lisp \
- workshops/2002/manolios-kaufmann/support/sorting/quicksort.lisp \
- workshops/2002/manolios-kaufmann/support/sorting/total-order.lisp \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.lisp \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.lisp \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.lisp \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.lisp \
- workshops/2002/martin-alonso-perez-sancho/support/Adleman.lisp \
- workshops/2002/medina-palomo-alonso/support/section-2/npol.acl2 \
- workshops/2002/medina-palomo-alonso/support/section-2/npol.lisp \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-1.acl2 \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-1.lisp \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-2.acl2 \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-2.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/monomial.acl2 \
- workshops/2002/medina-palomo-alonso/support/section-3/monomial.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.acl2 \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.acl2 \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.acl2 \
- workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/term.acl2 \
- workshops/2002/medina-palomo-alonso/support/section-3/term.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/upol.acl2 \
- workshops/2002/medina-palomo-alonso/support/section-3/upol.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.lisp \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.lisp \
- workshops/2003/austel/support/abs-type.lisp \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.lisp \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.lisp \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.lisp \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.lisp \
- workshops/2003/gamboa-cowles-van-baalen/support/defpkg.lsp \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.acl2 \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.lisp \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.acl2 \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.lisp \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.acl2 \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.lisp \
- workshops/2003/gamboa-cowles-van-baalen/support/linalg.lisp \
- workshops/2003/greve-wilding_defrecord/support/defrecord.lisp \
- workshops/2003/greve-wilding_mbe/support/fpst.lisp \
- workshops/2003/greve-wilding_mbe/support/run-fpst.lisp \
- workshops/2003/hbl/support/sol1.lisp \
- workshops/2003/hbl/support/sol2.lisp \
- workshops/2003/hendrix/support/madd.lisp \
- workshops/2003/hendrix/support/matrices.lisp \
- workshops/2003/hendrix/support/mdefthms.lisp \
- workshops/2003/hendrix/support/mdefuns.lisp \
- workshops/2003/hendrix/support/mentry.lisp \
- workshops/2003/hendrix/support/mid.lisp \
- workshops/2003/hendrix/support/mmult.lisp \
- workshops/2003/hendrix/support/mscal.lisp \
- workshops/2003/hendrix/support/msub.lisp \
- workshops/2003/hendrix/support/mtrans.lisp \
- workshops/2003/hendrix/support/mzero.lisp \
- workshops/2003/hendrix/support/vector.lisp \
- workshops/2003/matlin-mccune/support/simp.lisp \
- workshops/2003/moore_rockwell/support/memory-taggings.lisp \
- workshops/2003/moore_vcg/support/demo.acl2 \
- workshops/2003/moore_vcg/support/demo.lisp \
- workshops/2003/moore_vcg/support/m5.acl2 \
- workshops/2003/moore_vcg/support/m5.lisp \
- workshops/2003/moore_vcg/support/utilities.acl2 \
- workshops/2003/moore_vcg/support/utilities.lisp \
- workshops/2003/moore_vcg/support/vcg-examples.acl2 \
- workshops/2003/moore_vcg/support/vcg-examples.lisp \
- workshops/2003/ray-matthews-tuttle/support/apply-total-order.lisp \
- workshops/2003/ray-matthews-tuttle/support/bisimilarity.lisp \
- workshops/2003/ray-matthews-tuttle/support/circuit-bisim.lisp \
- workshops/2003/ray-matthews-tuttle/support/circuits.lisp \
- workshops/2003/ray-matthews-tuttle/support/concrete-ltl.lisp \
- workshops/2003/ray-matthews-tuttle/support/cone-of-influence.lisp \
- workshops/2003/ray-matthews-tuttle/support/conjunction.lisp \
- workshops/2003/ray-matthews-tuttle/support/impl-hack.acl2 \
- workshops/2003/ray-matthews-tuttle/support/impl-hack.lisp \
- workshops/2003/ray-matthews-tuttle/support/ltl.lisp \
- workshops/2003/ray-matthews-tuttle/support/records.lisp \
- workshops/2003/ray-matthews-tuttle/support/reductions.lisp \
- workshops/2003/ray-matthews-tuttle/support/sets.lisp \
- workshops/2003/ray-matthews-tuttle/support/total-order.lisp \
- workshops/2003/schmaltz-al-sammane-et-al/support/consistency.lisp \
- workshops/2003/schmaltz-borrione/support/arbiter.lisp \
- workshops/2003/schmaltz-borrione/support/decoder.lisp \
- workshops/2003/schmaltz-borrione/support/inequalities.lisp \
- workshops/2003/schmaltz-borrione/support/predicates.lisp \
- workshops/2003/schmaltz-borrione/support/transfers.lisp \
- workshops/2003/sumners/support/cfair.lisp \
- workshops/2003/sumners/support/example1.lisp \
- workshops/2003/sumners/support/example2.lisp \
- workshops/2003/sumners/support/example3.lisp \
- workshops/2003/sumners/support/fair1.lisp \
- workshops/2003/sumners/support/fair2.lisp \
- workshops/2003/sumners/support/n2n.lisp \
- workshops/2003/sumners/support/simple.lisp \
- workshops/2003/sustik/support/dickson.lisp \
- workshops/2003/toma-borrione/support/bv-op-defthms.lisp \
- workshops/2003/toma-borrione/support/bv-op-defuns.lisp \
- workshops/2003/toma-borrione/support/misc.lisp \
- workshops/2003/toma-borrione/support/padding-1-256.lisp \
- workshops/2003/toma-borrione/support/padding-384-512.lisp \
- workshops/2003/toma-borrione/support/parsing.lisp \
- workshops/2003/toma-borrione/support/sha-1.lisp \
- workshops/2003/toma-borrione/support/sha-256.lisp \
- workshops/2003/toma-borrione/support/sha-384-512.lisp \
- workshops/2003/toma-borrione/support/sha-functions.lisp \
- workshops/2003/tsong/support/shim.lisp \
- workshops/2004/cowles-gamboa/support/WyoM1-correct.acl2 \
- workshops/2004/cowles-gamboa/support/WyoM1-correct.lisp \
- workshops/2004/cowles-gamboa/support/WyoM1-utilities.acl2 \
- workshops/2004/cowles-gamboa/support/WyoM1-utilities.lisp \
- workshops/2004/cowles-gamboa/support/WyoM1.acl2 \
- workshops/2004/cowles-gamboa/support/WyoM1.lisp \
- workshops/2004/cowles-gamboa/support/knuth.lisp \
- workshops/2004/cowles-gamboa/support/tail-rec.acl2 \
- workshops/2004/cowles-gamboa/support/tail-rec.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/computed-hints.lisp \
- workshops/2004/davis/support/fast.lisp \
- workshops/2004/davis/support/instance.lisp \
- workshops/2004/davis/support/map.lisp \
- workshops/2004/davis/support/membership.lisp \
- workshops/2004/davis/support/outer.lisp \
- workshops/2004/davis/support/package.lsp \
- workshops/2004/davis/support/primitives.lisp \
- workshops/2004/davis/support/quantify.lisp \
- workshops/2004/davis/support/set-order.lisp \
- workshops/2004/davis/support/sets.lisp \
- workshops/2004/davis/support/sort.lisp \
- workshops/2004/gameiro-manolios/support/interval.lisp \
- workshops/2004/gameiro-manolios/support/nth-thms.lisp \
- workshops/2004/gameiro-manolios/support/top-with-meta.lisp \
- workshops/2004/gameiro-manolios/support/transversality.lisp \
- workshops/2004/greve/support/defrecord.lisp \
- workshops/2004/greve/support/mark.lisp \
- workshops/2004/legato/support/generic-theories.lisp \
- workshops/2004/legato/support/generic-theory-alternative-induction-mult.lisp \
- workshops/2004/legato/support/generic-theory-alternative-induction-sum.lisp \
- workshops/2004/legato/support/generic-theory-loop-invariant-mult.lisp \
- workshops/2004/legato/support/generic-theory-loop-invariant-sum.lisp \
- workshops/2004/legato/support/generic-theory-tail-recursion-mult.lisp \
- workshops/2004/legato/support/generic-theory-tail-recursion-sum.lisp \
- workshops/2004/legato/support/proof-by-generalization-mult.lisp \
- workshops/2004/legato/support/proof-by-generalization-sum.lisp \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.lisp \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.lisp \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/records.lisp \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.lisp \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.lisp \
- workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.lisp \
- workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.lisp \
- workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.lisp \
- workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.lisp \
- workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.lisp \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.lisp \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.lisp \
- workshops/2004/ray/support/defcoerce.lisp \
- workshops/2004/ray/support/defpun-exec.lisp \
- workshops/2004/ray/support/generic.lisp \
- workshops/2004/roach-fraij/support/roach-fraij-script.lisp \
- workshops/2004/ruiz-et-al/support/basic.lisp \
- workshops/2004/ruiz-et-al/support/dag-unification-rules.lisp \
- workshops/2004/ruiz-et-al/support/dags.lisp \
- workshops/2004/ruiz-et-al/support/lists.lisp \
- workshops/2004/ruiz-et-al/support/matching.lisp \
- workshops/2004/ruiz-et-al/support/prefix-unification-rules.lisp \
- workshops/2004/ruiz-et-al/support/q-dag-unification-rules.lisp \
- workshops/2004/ruiz-et-al/support/q-dag-unification-st.lisp \
- workshops/2004/ruiz-et-al/support/q-dag-unification.lisp \
- workshops/2004/ruiz-et-al/support/subsumption-subst.lisp \
- workshops/2004/ruiz-et-al/support/subsumption.lisp \
- workshops/2004/ruiz-et-al/support/terms-as-dag.lisp \
- workshops/2004/ruiz-et-al/support/terms.lisp \
- workshops/2004/sawada/support/bv.acl2 \
- workshops/2004/sawada/support/bv.lisp \
- workshops/2004/sawada/support/defpkg.lsp \
- workshops/2004/sawada/support/ihs.lisp \
- workshops/2004/schmaltz-borrione/support/collect_msg_book.lisp \
- workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.lisp \
- workshops/2004/schmaltz-borrione/support/intersect.lisp \
- workshops/2004/schmaltz-borrione/support/local_trip_book.lisp \
- workshops/2004/schmaltz-borrione/support/make_travel_list_book.lisp \
- workshops/2004/schmaltz-borrione/support/mod_lemmas.lisp \
- workshops/2004/schmaltz-borrione/support/node.lisp \
- workshops/2004/schmaltz-borrione/support/octagon_book.lisp \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.lisp \
- workshops/2004/schmaltz-borrione/support/routing_defuns.lisp \
- workshops/2004/schmaltz-borrione/support/routing_local_lemmas.lisp \
- workshops/2004/schmaltz-borrione/support/routing_main.lisp \
- workshops/2004/schmaltz-borrione/support/scheduler_book.lisp \
- workshops/2004/schmaltz-borrione/support/switch.lisp \
- workshops/2004/schmaltz-borrione/support/trip_book.lisp \
- workshops/2004/schmaltz-borrione/support/trip_thms.lisp \
- workshops/2004/smith-et-al/support/bags/bag-exports.acl2 \
- workshops/2004/smith-et-al/support/bags/bag-exports.lisp \
- workshops/2004/smith-et-al/support/bags/bag-pkg.acl2 \
- workshops/2004/smith-et-al/support/bags/bag-pkg.lisp \
- workshops/2004/smith-et-al/support/bags/basic.acl2 \
- workshops/2004/smith-et-al/support/bags/basic.lisp \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.acl2 \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.lisp \
- workshops/2004/smith-et-al/support/bags/cons.lisp \
- workshops/2004/smith-et-al/support/bags/eric-meta.acl2 \
- workshops/2004/smith-et-al/support/bags/eric-meta.lisp \
- workshops/2004/smith-et-al/support/bags/meta.acl2 \
- workshops/2004/smith-et-al/support/bags/meta.lisp \
- workshops/2004/smith-et-al/support/bags/neq.acl2 \
- workshops/2004/smith-et-al/support/bags/neq.lisp \
- workshops/2004/smith-et-al/support/bags/top.acl2 \
- workshops/2004/smith-et-al/support/bags/top.lisp \
- workshops/2004/smith-et-al/support/bags/two-level-meta.acl2 \
- workshops/2004/smith-et-al/support/bags/two-level-meta.lisp \
- workshops/2004/smith-et-al/support/bags/two-level.acl2 \
- workshops/2004/smith-et-al/support/bags/two-level.lisp \
- workshops/2004/smith-et-al/support/lists/cert.acl2 \
- workshops/2004/smith-et-al/support/lists/list-exports.lisp \
- workshops/2004/smith-et-al/support/lists/list-top.acl2 \
- workshops/2004/smith-et-al/support/lists/list-top.lisp \
- workshops/2004/smith-et-al/support/lists/lists.lisp \
- workshops/2004/smith-et-al/support/lists/mv-nth.lisp \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.acl2 \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.lisp \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.acl2 \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.lisp \
- workshops/2004/smith-et-al/support/syntax/auxilary.acl2 \
- workshops/2004/smith-et-al/support/syntax/auxilary.lisp \
- workshops/2004/smith-et-al/support/syntax/syn-pkg.acl2 \
- workshops/2004/smith-et-al/support/syntax/syn-pkg.lisp \
- workshops/2004/smith-et-al/support/syntax/syntax-extensions.acl2 \
- workshops/2004/smith-et-al/support/syntax/syntax-extensions.lisp \
- workshops/2004/smith-et-al/support/syntax/syntax.acl2 \
- workshops/2004/smith-et-al/support/syntax/syntax.lisp \
- workshops/2004/sumners-ray/support/basis.lisp \
- workshops/2004/sumners-ray/support/crit.lisp \
- workshops/2004/sumners-ray/support/mesi.lisp \
- workshops/2004/sumners-ray/support/records.lisp \
- workshops/2004/sumners-ray/support/sets.lisp \
- workshops/2004/sumners-ray/support/total-order.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed1.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed1.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.acl2 \
- workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.lisp \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.lisp \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.lisp \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.lisp \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.lisp \
- workshops/2006/greve/nary/example.lisp \
- workshops/2006/greve/nary/nary.lisp \
- workshops/2006/greve/nary/nth-rules.lisp \
- workshops/2006/hunt-reeber/support/acl2.lisp \
- workshops/2006/hunt-reeber/support/bdd.lisp \
- workshops/2006/hunt-reeber/support/sat.lisp \
- workshops/2006/kaufmann-moore/support/austel.lisp \
- workshops/2006/kaufmann-moore/support/greve1.lisp \
- workshops/2006/kaufmann-moore/support/greve2.lisp \
- workshops/2006/kaufmann-moore/support/greve3.lisp \
- workshops/2006/kaufmann-moore/support/mini-proveall-plus.lisp \
- workshops/2006/kaufmann-moore/support/mini-proveall.lisp \
- workshops/2006/kaufmann-moore/support/rhs1-iff.acl2 \
- workshops/2006/kaufmann-moore/support/rhs1-iff.lisp \
- workshops/2006/kaufmann-moore/support/rhs1.acl2 \
- workshops/2006/kaufmann-moore/support/rhs1.lisp \
- workshops/2006/kaufmann-moore/support/rhs2.acl2 \
- workshops/2006/kaufmann-moore/support/rhs2.lisp \
- workshops/2006/kaufmann-moore/support/smith1.lisp \
- workshops/2006/kaufmann-moore/support/sumners1.lisp \
- workshops/2006/kaufmann-moore/support/warnings.acl2 \
- workshops/2006/kaufmann-moore/support/warnings.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/AES/cert.acl2 \
- workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/cert.acl2 \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/cert.acl2 \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/cert.acl2 \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/cert.acl2 \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.lisp \
- workshops/2006/rager/support/ptest-fib.lisp \
- workshops/2006/rager/support/ptest-if-normalization.lisp \
- workshops/2006/rager/support/ptest-mergesort.acl2 \
- workshops/2006/rager/support/ptest-mergesort.lisp \
- workshops/2006/ray/tail/exists.lisp \
- workshops/2006/ray/tail/forall.lisp \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.lisp \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.lisp \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.lisp \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.lisp \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.lisp \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.lisp \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.lisp \
- workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.lisp \
- workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.lisp \
- workshops/2006/swords-cook/lcsoundness/defsum-thms.lisp \
- workshops/2006/swords-cook/lcsoundness/defsum.lisp \
- workshops/2006/swords-cook/lcsoundness/pattern-match.lisp \
- workshops/2007/cowles-et-al/support/cowles/while-loop.lisp \
- workshops/2007/cowles-et-al/support/greve/ack.lisp \
- workshops/2007/cowles-et-al/support/greve/defminterm.lisp \
- workshops/2007/cowles-et-al/support/greve/defpun.lisp \
- workshops/2007/cowles-et-al/support/greve/defxch.lisp \
- workshops/2007/cowles-et-al/support/greve/while.lisp \
- workshops/2007/cowles-et-al/support/ray/reflexive-macros.lisp \
- workshops/2007/cowles-et-al/support/ray/reflexive.lisp \
- workshops/2007/dillinger-et-al/code/all.acl2 \
- workshops/2007/dillinger-et-al/code/all.lisp \
- workshops/2007/dillinger-et-al/code/bridge.acl2 \
- workshops/2007/dillinger-et-al/code/bridge.lisp \
- workshops/2007/dillinger-et-al/code/defcode-macro.acl2 \
- workshops/2007/dillinger-et-al/code/defcode-macro.lisp \
- workshops/2007/dillinger-et-al/code/defcode.acl2 \
- workshops/2007/dillinger-et-al/code/defcode.lisp \
- workshops/2007/dillinger-et-al/code/defstruct-parsing.acl2 \
- workshops/2007/dillinger-et-al/code/defstruct-parsing.lisp \
- workshops/2007/dillinger-et-al/code/hacker-pkg.lsp \
- workshops/2007/dillinger-et-al/code/hacker.acl2 \
- workshops/2007/dillinger-et-al/code/hacker.lisp \
- workshops/2007/dillinger-et-al/code/raw.acl2 \
- workshops/2007/dillinger-et-al/code/raw.lisp \
- workshops/2007/dillinger-et-al/code/redefun.acl2 \
- workshops/2007/dillinger-et-al/code/redefun.lisp \
- workshops/2007/dillinger-et-al/code/rewrite-code.acl2 \
- workshops/2007/dillinger-et-al/code/rewrite-code.lisp \
- workshops/2007/dillinger-et-al/code/subsumption.acl2 \
- workshops/2007/dillinger-et-al/code/subsumption.lisp \
- workshops/2007/dillinger-et-al/code/table-guard.acl2 \
- workshops/2007/dillinger-et-al/code/table-guard.lisp \
- workshops/2007/erickson/bprove/bash.lisp \
- workshops/2007/erickson/bprove/exdefs.lisp \
- workshops/2007/erickson/bprove/gen.lisp \
- workshops/2007/erickson/bprove/lemgen.lisp \
- workshops/2007/erickson/bprove/refute.lisp \
- workshops/2007/rimlinger/support/Rimlinger.lisp \
- workshops/2007/rubio/support/abstract-reductions/abstract-proofs.lisp \
- workshops/2007/rubio/support/abstract-reductions/confluence.acl2 \
- workshops/2007/rubio/support/abstract-reductions/confluence.lisp \
- workshops/2007/rubio/support/abstract-reductions/convergent.acl2 \
- workshops/2007/rubio/support/abstract-reductions/convergent.lisp \
- workshops/2007/rubio/support/abstract-reductions/newman.acl2 \
- workshops/2007/rubio/support/abstract-reductions/newman.lisp \
- workshops/2007/rubio/support/multisets/defmul.acl2 \
- workshops/2007/rubio/support/multisets/defmul.lisp \
- workshops/2007/rubio/support/multisets/multiset.acl2 \
- workshops/2007/rubio/support/multisets/multiset.lisp \
- workshops/2007/rubio/support/simplicial-topology/generate-degenerate.acl2 \
- workshops/2007/rubio/support/simplicial-topology/generate-degenerate.lisp \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.lisp \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.lisp \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.lisp \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.lisp \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.lisp \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.lisp \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.lisp \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.lisp \
- workshops/2009/fraij-roach/support/functions.lisp \
- workshops/2009/fraij-roach/support/theorems.lisp \
- workshops/2009/hardin/deque-stobj/deque-stobj.lisp \
- workshops/2009/hardin/deque-stobj/deque-thms.lisp \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.acl2 \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.lisp \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.acl2 \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.lisp \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.lisp \
- workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.lisp \
- workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.acl2 \
- workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.lisp \
- workshops/2009/liu/support/error-analysis-tool3.lisp \
- workshops/2009/liu/support/mylet.lisp \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.lisp \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.lisp \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.lisp \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.lisp \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.lisp \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.lisp \
- workshops/2009/sumners/support/kas.acl2 \
- workshops/2009/sumners/support/kas.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.lisp \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.lisp \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.lisp \
- workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.lisp \
- workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.lisp \
- workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.lisp \
- workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.acl2 \
- workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.lisp \
- wp-gen/mutrec/mutrec.lisp \
- wp-gen/shared.lisp \
- wp-gen/wp-gen.acl2 \
- wp-gen/wp-gen.lisp \
- xdoc-impl/autolink.lisp \
- xdoc-impl/cert.acl2 \
- xdoc-impl/extra-packages.acl2 \
- xdoc-impl/extra-packages.lisp \
- xdoc-impl/fmt-to-str.lisp \
- xdoc-impl/import-acl2doc.lisp \
- xdoc-impl/mkdir-raw.acl2 \
- xdoc-impl/mkdir-raw.lisp \
- xdoc-impl/mkdir.lisp \
- xdoc-impl/parse-xml.lisp \
- xdoc-impl/portcullis.acl2 \
- xdoc-impl/portcullis.lisp \
- xdoc-impl/preprocess.lisp \
- xdoc-impl/save.lisp \
- xdoc-impl/sort.lisp \
- xdoc-impl/topics.lisp \
- xdoc-impl/write-acl2-xdoc.lisp \
- xdoc/base.lisp \
- xdoc/book-thms.lisp \
- xdoc/cert.acl2 \
- xdoc/defxdoc-raw.acl2 \
- xdoc/defxdoc-raw.lisp \
- xdoc/names.lisp \
- xdoc/package.lsp \
- xdoc/portcullis.acl2 \
- xdoc/portcullis.lisp \
- xdoc/top.lisp
-
-arithmetic-2/floor-mod/floor-mod-helper.cert : acl2x = 0
-arithmetic-2/floor-mod/floor-mod-helper.cert : no_pcert = 0
-
-arithmetic-2/floor-mod/floor-mod-helper.cert : \
- arithmetic-2/meta/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- arithmetic-2/floor-mod/floor-mod-helper.lisp
-
-
-arithmetic-2/floor-mod/floor-mod.cert : acl2x = 0
-arithmetic-2/floor-mod/floor-mod.cert : no_pcert = 0
-
-arithmetic-2/floor-mod/floor-mod.cert : \
- arithmetic-2/floor-mod/floor-mod-helper.cert \
- arithmetic-2/floor-mod/floor-mod.lisp
-
-
-arithmetic-2/meta/cancel-terms-helper.cert : acl2x = 0
-arithmetic-2/meta/cancel-terms-helper.cert : no_pcert = 0
-
-arithmetic-2/meta/cancel-terms-helper.cert : \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/cancel-terms-helper.lisp
-
-
-arithmetic-2/meta/cancel-terms-meta.cert : acl2x = 0
-arithmetic-2/meta/cancel-terms-meta.cert : no_pcert = 0
-
-arithmetic-2/meta/cancel-terms-meta.cert : \
- arithmetic-2/meta/common-meta.cert \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/cancel-terms-helper.cert \
- arithmetic-2/meta/cancel-terms-meta.lisp
-
-
-arithmetic-2/meta/collect-terms-meta.cert : acl2x = 0
-arithmetic-2/meta/collect-terms-meta.cert : no_pcert = 0
-
-arithmetic-2/meta/collect-terms-meta.cert : \
- arithmetic-2/meta/common-meta.cert \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/collect-terms-meta.lisp
-
-
-arithmetic-2/meta/common-meta.cert : acl2x = 0
-arithmetic-2/meta/common-meta.cert : no_pcert = 0
-
-arithmetic-2/meta/common-meta.cert : \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/common-meta.lisp
-
-
-arithmetic-2/meta/expt-helper.cert : acl2x = 0
-arithmetic-2/meta/expt-helper.cert : no_pcert = 0
-
-arithmetic-2/meta/expt-helper.cert : \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/expt-helper.lisp
-
-
-arithmetic-2/meta/expt.cert : acl2x = 0
-arithmetic-2/meta/expt.cert : no_pcert = 0
-
-arithmetic-2/meta/expt.cert : \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/expt-helper.cert \
- arithmetic-2/meta/expt.lisp
-
-
-arithmetic-2/meta/integerp-meta.cert : acl2x = 0
-arithmetic-2/meta/integerp-meta.cert : no_pcert = 0
-
-arithmetic-2/meta/integerp-meta.cert : \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/integerp-meta.lisp
-
-
-arithmetic-2/meta/integerp.cert : acl2x = 0
-arithmetic-2/meta/integerp.cert : no_pcert = 0
-
-arithmetic-2/meta/integerp.cert : \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/integerp.lisp
-
-
-arithmetic-2/meta/mini-theories.cert : acl2x = 0
-arithmetic-2/meta/mini-theories.cert : no_pcert = 0
-
-arithmetic-2/meta/mini-theories.cert : \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/mini-theories.lisp
-
-
-arithmetic-2/meta/non-linear.cert : acl2x = 0
-arithmetic-2/meta/non-linear.cert : no_pcert = 0
-
-arithmetic-2/meta/non-linear.cert : \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/cancel-terms-helper.cert \
- arithmetic-2/meta/non-linear.lisp
-
-
-arithmetic-2/meta/numerator-and-denominator.cert : acl2x = 0
-arithmetic-2/meta/numerator-and-denominator.cert : no_pcert = 0
-
-arithmetic-2/meta/numerator-and-denominator.cert : \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/numerator-and-denominator.lisp
-
-
-arithmetic-2/meta/post.cert : acl2x = 0
-arithmetic-2/meta/post.cert : no_pcert = 0
-
-arithmetic-2/meta/post.cert : \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/post.lisp
-
-
-arithmetic-2/meta/pre.cert : acl2x = 0
-arithmetic-2/meta/pre.cert : no_pcert = 0
-
-arithmetic-2/meta/pre.cert : \
- arithmetic-2/pass1/top.cert \
- arithmetic-2/meta/pre.lisp
-
-
-arithmetic-2/meta/top.cert : acl2x = 0
-arithmetic-2/meta/top.cert : no_pcert = 0
-
-arithmetic-2/meta/top.cert : \
- arithmetic-2/meta/pre.cert \
- arithmetic-2/meta/integerp.cert \
- arithmetic-2/meta/integerp-meta.cert \
- arithmetic-2/meta/cancel-terms-meta.cert \
- arithmetic-2/meta/collect-terms-meta.cert \
- arithmetic-2/meta/numerator-and-denominator.cert \
- arithmetic-2/meta/expt.cert \
- arithmetic-2/meta/non-linear.cert \
- arithmetic-2/meta/mini-theories.cert \
- arithmetic-2/meta/post.cert \
- arithmetic-2/meta/top.lisp
-
-
-arithmetic-2/pass1/basic-arithmetic-helper.cert : acl2x = 0
-arithmetic-2/pass1/basic-arithmetic-helper.cert : no_pcert = 0
-
-arithmetic-2/pass1/basic-arithmetic-helper.cert : \
- arithmetic-2/pass1/basic-arithmetic-helper.lisp
-
-
-arithmetic-2/pass1/basic-arithmetic.cert : acl2x = 0
-arithmetic-2/pass1/basic-arithmetic.cert : no_pcert = 0
-
-arithmetic-2/pass1/basic-arithmetic.cert : \
- arithmetic-2/pass1/basic-arithmetic-helper.cert \
- arithmetic-2/pass1/basic-arithmetic.lisp
-
-
-arithmetic-2/pass1/expt-helper.cert : acl2x = 0
-arithmetic-2/pass1/expt-helper.cert : no_pcert = 0
-
-arithmetic-2/pass1/expt-helper.cert : \
- arithmetic-2/pass1/basic-arithmetic.cert \
- arithmetic-2/pass1/inequalities.cert \
- arithmetic-2/pass1/prefer-times.cert \
- arithmetic-2/pass1/expt-helper.lisp
-
-
-arithmetic-2/pass1/expt.cert : acl2x = 0
-arithmetic-2/pass1/expt.cert : no_pcert = 0
-
-arithmetic-2/pass1/expt.cert : \
- arithmetic-2/pass1/basic-arithmetic.cert \
- arithmetic-2/pass1/inequalities.cert \
- arithmetic-2/pass1/prefer-times.cert \
- arithmetic-2/pass1/expt-helper.cert \
- arithmetic-2/pass1/expt.lisp
-
-
-arithmetic-2/pass1/inequalities.cert : acl2x = 0
-arithmetic-2/pass1/inequalities.cert : no_pcert = 0
-
-arithmetic-2/pass1/inequalities.cert : \
- arithmetic-2/pass1/basic-arithmetic.cert \
- arithmetic-2/pass1/inequalities.lisp
-
-
-arithmetic-2/pass1/mini-theories.cert : acl2x = 0
-arithmetic-2/pass1/mini-theories.cert : no_pcert = 0
-
-arithmetic-2/pass1/mini-theories.cert : \
- arithmetic-2/pass1/basic-arithmetic.cert \
- arithmetic-2/pass1/inequalities.cert \
- arithmetic-2/pass1/prefer-times.cert \
- arithmetic-2/pass1/expt.cert \
- arithmetic-2/pass1/mini-theories.lisp
-
-
-arithmetic-2/pass1/numerator-and-denominator-helper.cert : acl2x = 0
-arithmetic-2/pass1/numerator-and-denominator-helper.cert : no_pcert = 0
-
-arithmetic-2/pass1/numerator-and-denominator-helper.cert : \
- arithmetic-2/pass1/basic-arithmetic.cert \
- arithmetic-2/pass1/inequalities.cert \
- arithmetic-2/pass1/prefer-times.cert \
- arithmetic-2/pass1/numerator-and-denominator-helper.lisp
-
-
-arithmetic-2/pass1/numerator-and-denominator.cert : acl2x = 0
-arithmetic-2/pass1/numerator-and-denominator.cert : no_pcert = 0
-
-arithmetic-2/pass1/numerator-and-denominator.cert : \
- arithmetic-2/pass1/basic-arithmetic.cert \
- arithmetic-2/pass1/inequalities.cert \
- arithmetic-2/pass1/prefer-times.cert \
- arithmetic-2/pass1/numerator-and-denominator-helper.cert \
- arithmetic-2/pass1/numerator-and-denominator.lisp
-
-
-arithmetic-2/pass1/prefer-times.cert : acl2x = 0
-arithmetic-2/pass1/prefer-times.cert : no_pcert = 0
-
-arithmetic-2/pass1/prefer-times.cert : \
- arithmetic-2/pass1/basic-arithmetic.cert \
- arithmetic-2/pass1/inequalities.cert \
- arithmetic-2/pass1/prefer-times.lisp
-
-
-arithmetic-2/pass1/top.cert : acl2x = 0
-arithmetic-2/pass1/top.cert : no_pcert = 0
-
-arithmetic-2/pass1/top.cert : \
- arithmetic-2/pass1/basic-arithmetic.cert \
- arithmetic-2/pass1/inequalities.cert \
- arithmetic-2/pass1/expt.cert \
- arithmetic-2/pass1/prefer-times.cert \
- arithmetic-2/pass1/mini-theories.cert \
- arithmetic-2/pass1/numerator-and-denominator.cert \
- arithmetic-2/pass1/top.lisp
-
-
-arithmetic-3/bind-free/arithmetic-theory.cert : acl2x = 0
-arithmetic-3/bind-free/arithmetic-theory.cert : no_pcert = 0
-
-arithmetic-3/bind-free/arithmetic-theory.cert : \
- arithmetic-3/bind-free/basic.cert \
- arithmetic-3/bind-free/common.cert \
- arithmetic-3/bind-free/building-blocks.cert \
- arithmetic-3/bind-free/collect.cert \
- arithmetic-3/bind-free/arithmetic-theory.lisp
-
-
-arithmetic-3/bind-free/banner.cert : acl2x = 0
-arithmetic-3/bind-free/banner.cert : no_pcert = 0
-
-arithmetic-3/bind-free/banner.cert : \
- arithmetic-3/bind-free/banner.lisp
-
-
-arithmetic-3/bind-free/basic-helper.cert : acl2x = 0
-arithmetic-3/bind-free/basic-helper.cert : no_pcert = 0
-
-arithmetic-3/bind-free/basic-helper.cert : \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/bind-free/default-hint.cert \
- arithmetic-3/bind-free/basic-helper.lisp
-
-
-arithmetic-3/bind-free/basic.cert : acl2x = 0
-arithmetic-3/bind-free/basic.cert : no_pcert = 0
-
-arithmetic-3/bind-free/basic.cert : \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/bind-free/basic-helper.cert \
- arithmetic-3/bind-free/building-blocks.cert \
- arithmetic-3/bind-free/basic.lisp
-
-
-arithmetic-3/bind-free/building-blocks.cert : acl2x = 0
-arithmetic-3/bind-free/building-blocks.cert : no_pcert = 0
-
-arithmetic-3/bind-free/building-blocks.cert : \
- arithmetic-3/bind-free/building-blocks.lisp
-
-
-arithmetic-3/bind-free/collect.cert : acl2x = 0
-arithmetic-3/bind-free/collect.cert : no_pcert = 0
-
-arithmetic-3/bind-free/collect.cert : \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/bind-free/basic-helper.cert \
- arithmetic-3/bind-free/collect.lisp
-
-
-arithmetic-3/bind-free/common.cert : acl2x = 0
-arithmetic-3/bind-free/common.cert : no_pcert = 0
-
-arithmetic-3/bind-free/common.cert : \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/bind-free/building-blocks.cert \
- arithmetic-3/bind-free/common.lisp
-
-
-arithmetic-3/bind-free/default-hint.cert : acl2x = 0
-arithmetic-3/bind-free/default-hint.cert : no_pcert = 0
-
-arithmetic-3/bind-free/default-hint.cert : \
- arithmetic-3/bind-free/default-hint.lisp
-
-
-arithmetic-3/bind-free/integerp-meta.cert : acl2x = 0
-arithmetic-3/bind-free/integerp-meta.cert : no_pcert = 0
-
-arithmetic-3/bind-free/integerp-meta.cert : \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/bind-free/default-hint.cert \
- arithmetic-3/bind-free/integerp-meta.lisp
-
-
-arithmetic-3/bind-free/integerp.cert : acl2x = 0
-arithmetic-3/bind-free/integerp.cert : no_pcert = 0
-
-arithmetic-3/bind-free/integerp.cert : \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/bind-free/building-blocks.cert \
- arithmetic-3/bind-free/default-hint.cert \
- arithmetic-3/bind-free/integerp.lisp
-
-
-arithmetic-3/bind-free/mini-theories-helper.cert : acl2x = 0
-arithmetic-3/bind-free/mini-theories-helper.cert : no_pcert = 0
-
-arithmetic-3/bind-free/mini-theories-helper.cert : \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/bind-free/default-hint.cert \
- arithmetic-3/bind-free/mini-theories-helper.lisp
-
-
-arithmetic-3/bind-free/mini-theories.cert : acl2x = 0
-arithmetic-3/bind-free/mini-theories.cert : no_pcert = 0
-
-arithmetic-3/bind-free/mini-theories.cert : \
- arithmetic-3/bind-free/mini-theories-helper.cert \
- arithmetic-3/bind-free/mini-theories.lisp
-
-
-arithmetic-3/bind-free/normalize.cert : acl2x = 0
-arithmetic-3/bind-free/normalize.cert : no_pcert = 0
-
-arithmetic-3/bind-free/normalize.cert : \
- arithmetic-3/bind-free/basic.cert \
- arithmetic-3/bind-free/common.cert \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/bind-free/normalize.lisp
-
-
-arithmetic-3/bind-free/numerator-and-denominator.cert : acl2x = 0
-arithmetic-3/bind-free/numerator-and-denominator.cert : no_pcert = 0
-
-arithmetic-3/bind-free/numerator-and-denominator.cert : \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/bind-free/numerator-and-denominator.lisp
-
-
-arithmetic-3/bind-free/remove-weak-inequalities.cert : acl2x = 0
-arithmetic-3/bind-free/remove-weak-inequalities.cert : no_pcert = 0
-
-arithmetic-3/bind-free/remove-weak-inequalities.cert : \
- arithmetic-3/bind-free/building-blocks.cert \
- arithmetic-3/bind-free/remove-weak-inequalities.lisp
-
-
-arithmetic-3/bind-free/simplify-helper.cert : acl2x = 0
-arithmetic-3/bind-free/simplify-helper.cert : no_pcert = 0
-
-arithmetic-3/bind-free/simplify-helper.cert : \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/bind-free/default-hint.cert \
- arithmetic-3/bind-free/simplify-helper.lisp
-
-
-arithmetic-3/bind-free/simplify.cert : acl2x = 0
-arithmetic-3/bind-free/simplify.cert : no_pcert = 0
-
-arithmetic-3/bind-free/simplify.cert : \
- arithmetic-3/bind-free/simplify-helper.cert \
- arithmetic-3/bind-free/basic.cert \
- arithmetic-3/bind-free/common.cert \
- arithmetic-3/pass1/top.cert \
- arithmetic-3/bind-free/simplify.lisp
-
-
-arithmetic-3/bind-free/top.cert : acl2x = 0
-arithmetic-3/bind-free/top.cert : no_pcert = 0
-
-arithmetic-3/bind-free/top.cert : \
- arithmetic-3/bind-free/default-hint.cert \
- arithmetic-3/bind-free/building-blocks.cert \
- arithmetic-3/bind-free/mini-theories.cert \
- arithmetic-3/bind-free/common.cert \
- arithmetic-3/bind-free/normalize.cert \
- arithmetic-3/bind-free/simplify.cert \
- arithmetic-3/bind-free/numerator-and-denominator.cert \
- arithmetic-3/bind-free/integerp.cert \
- arithmetic-3/bind-free/integerp-meta.cert \
- arithmetic-3/bind-free/basic.cert \
- arithmetic-3/bind-free/collect.cert \
- arithmetic-3/bind-free/remove-weak-inequalities.cert \
- arithmetic-3/bind-free/arithmetic-theory.cert \
- arithmetic-3/bind-free/banner.cert \
- arithmetic-3/bind-free/top.lisp
-
-
-arithmetic-3/extra/ext.cert : acl2x = 0
-arithmetic-3/extra/ext.cert : no_pcert = 0
-
-arithmetic-3/extra/ext.cert : \
- arithmetic/top-with-meta.cert \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/arithmetic/extra-rules.cert \
- arithmetic-2/meta/expt.cert \
- arithmetic-2/meta/integerp.cert \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- arithmetic-3/extra/ext.lisp
-
-
-arithmetic-3/extra/top-ext.cert : acl2x = 0
-arithmetic-3/extra/top-ext.cert : no_pcert = 0
-
-arithmetic-3/extra/top-ext.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- arithmetic-3/extra/ext.cert \
- arithmetic-3/extra/top-ext.lisp
-
-
-arithmetic-3/floor-mod/floor-mod.cert : acl2x = 0
-arithmetic-3/floor-mod/floor-mod.cert : no_pcert = 0
-
-arithmetic-3/floor-mod/floor-mod.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/bind-free/building-blocks.cert \
- arithmetic-3/floor-mod/floor-mod.lisp
-
-
-arithmetic-3/floor-mod/mod-expt-fast.cert : acl2x = 0
-arithmetic-3/floor-mod/mod-expt-fast.cert : no_pcert = 0
-
-arithmetic-3/floor-mod/mod-expt-fast.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- arithmetic-3/floor-mod/mod-expt-fast.lisp
-
-
-arithmetic-3/pass1/basic-arithmetic-helper.cert : acl2x = 0
-arithmetic-3/pass1/basic-arithmetic-helper.cert : no_pcert = 0
-
-arithmetic-3/pass1/basic-arithmetic-helper.cert : \
- arithmetic-3/pass1/basic-arithmetic-helper.lisp
-
-
-arithmetic-3/pass1/basic-arithmetic.cert : acl2x = 0
-arithmetic-3/pass1/basic-arithmetic.cert : no_pcert = 0
-
-arithmetic-3/pass1/basic-arithmetic.cert : \
- arithmetic-3/pass1/basic-arithmetic-helper.cert \
- arithmetic-3/pass1/basic-arithmetic.lisp
-
-
-arithmetic-3/pass1/expt-helper.cert : acl2x = 0
-arithmetic-3/pass1/expt-helper.cert : no_pcert = 0
-
-arithmetic-3/pass1/expt-helper.cert : \
- arithmetic-3/pass1/basic-arithmetic.cert \
- arithmetic-3/pass1/inequalities.cert \
- arithmetic-3/pass1/prefer-times.cert \
- arithmetic-3/pass1/expt-helper.lisp
-
-
-arithmetic-3/pass1/expt.cert : acl2x = 0
-arithmetic-3/pass1/expt.cert : no_pcert = 0
-
-arithmetic-3/pass1/expt.cert : \
- arithmetic-3/pass1/basic-arithmetic.cert \
- arithmetic-3/pass1/inequalities.cert \
- arithmetic-3/pass1/prefer-times.cert \
- arithmetic-3/pass1/expt-helper.cert \
- arithmetic-3/pass1/expt.lisp
-
-
-arithmetic-3/pass1/inequalities.cert : acl2x = 0
-arithmetic-3/pass1/inequalities.cert : no_pcert = 0
-
-arithmetic-3/pass1/inequalities.cert : \
- arithmetic-3/pass1/basic-arithmetic.cert \
- arithmetic-3/pass1/inequalities.lisp
-
-
-arithmetic-3/pass1/mini-theories.cert : acl2x = 0
-arithmetic-3/pass1/mini-theories.cert : no_pcert = 0
-
-arithmetic-3/pass1/mini-theories.cert : \
- arithmetic-3/pass1/basic-arithmetic.cert \
- arithmetic-3/pass1/inequalities.cert \
- arithmetic-3/pass1/prefer-times.cert \
- arithmetic-3/pass1/expt.cert \
- arithmetic-3/pass1/mini-theories.lisp
-
-
-arithmetic-3/pass1/non-linear.cert : acl2x = 0
-arithmetic-3/pass1/non-linear.cert : no_pcert = 0
-
-arithmetic-3/pass1/non-linear.cert : \
- arithmetic-3/pass1/basic-arithmetic.cert \
- arithmetic-3/pass1/expt.cert \
- arithmetic-3/pass1/non-linear.lisp
-
-
-arithmetic-3/pass1/num-and-denom-helper.cert : acl2x = 0
-arithmetic-3/pass1/num-and-denom-helper.cert : no_pcert = 0
-
-arithmetic-3/pass1/num-and-denom-helper.cert : \
- arithmetic-3/pass1/basic-arithmetic.cert \
- arithmetic-3/pass1/inequalities.cert \
- arithmetic-3/pass1/prefer-times.cert \
- arithmetic-3/pass1/non-linear.cert \
- arithmetic-3/pass1/num-and-denom-helper.lisp
-
-
-arithmetic-3/pass1/numerator-and-denominator.cert : acl2x = 0
-arithmetic-3/pass1/numerator-and-denominator.cert : no_pcert = 0
-
-arithmetic-3/pass1/numerator-and-denominator.cert : \
- arithmetic-3/pass1/basic-arithmetic.cert \
- arithmetic-3/pass1/inequalities.cert \
- arithmetic-3/pass1/prefer-times.cert \
- arithmetic-3/pass1/non-linear.cert \
- arithmetic-3/pass1/num-and-denom-helper.cert \
- arithmetic-3/pass1/numerator-and-denominator.lisp
-
-
-arithmetic-3/pass1/prefer-times.cert : acl2x = 0
-arithmetic-3/pass1/prefer-times.cert : no_pcert = 0
-
-arithmetic-3/pass1/prefer-times.cert : \
- arithmetic-3/pass1/basic-arithmetic.cert \
- arithmetic-3/pass1/inequalities.cert \
- arithmetic-3/pass1/prefer-times.lisp
-
-
-arithmetic-3/pass1/top.cert : acl2x = 0
-arithmetic-3/pass1/top.cert : no_pcert = 0
-
-arithmetic-3/pass1/top.cert : \
- arithmetic-3/pass1/basic-arithmetic.cert \
- arithmetic-3/pass1/inequalities.cert \
- arithmetic-3/pass1/expt.cert \
- arithmetic-3/pass1/prefer-times.cert \
- arithmetic-3/pass1/mini-theories.cert \
- arithmetic-3/pass1/numerator-and-denominator.cert \
- arithmetic-3/pass1/non-linear.cert \
- arithmetic-3/pass1/top.lisp
-
-
-arithmetic-3/top.cert : acl2x = 0
-arithmetic-3/top.cert : no_pcert = 0
-
-arithmetic-3/top.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- arithmetic-3/floor-mod/mod-expt-fast.cert \
- arithmetic-3/top.lisp
-
-
-arithmetic-5/lib/basic-ops/arithmetic-theory.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/arithmetic-theory.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/arithmetic-theory.cert : \
- arithmetic-5/lib/basic-ops/common.cert \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/basic.cert \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.cert \
- arithmetic-5/lib/basic-ops/expt.cert \
- arithmetic-5/lib/basic-ops/collect.cert \
- arithmetic-5/lib/basic-ops/arithmetic-theory.lisp
-
-
-arithmetic-5/lib/basic-ops/banner.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/banner.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/banner.cert : \
- arithmetic-5/lib/basic-ops/banner.lisp
-
-
-arithmetic-5/lib/basic-ops/basic.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/basic.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/basic.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/basic.lisp
-
-
-arithmetic-5/lib/basic-ops/building-blocks-helper.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/building-blocks-helper.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/building-blocks-helper.cert : \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/building-blocks-helper.lisp
-
-
-arithmetic-5/lib/basic-ops/building-blocks.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/building-blocks.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/building-blocks.cert : \
- arithmetic-5/lib/basic-ops/building-blocks-helper.cert \
- arithmetic-5/lib/basic-ops/building-blocks.lisp
-
-
-arithmetic-5/lib/basic-ops/collect.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/collect.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/collect.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/expt-helper.cert \
- arithmetic-5/lib/basic-ops/collect.lisp
-
-
-arithmetic-5/lib/basic-ops/common.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/common.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/common.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/common.lisp
-
-
-arithmetic-5/lib/basic-ops/default-hint.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/default-hint.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/default-hint.cert : \
- arithmetic-5/lib/basic-ops/dynamic-e-d.cert \
- arithmetic-5/lib/basic-ops/default-hint.lisp
-
-
-arithmetic-5/lib/basic-ops/distributivity.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/distributivity.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/distributivity.cert : \
- arithmetic-5/lib/basic-ops/distributivity.lisp
-
-
-arithmetic-5/lib/basic-ops/dynamic-e-d.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/dynamic-e-d.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/dynamic-e-d.cert : \
- arithmetic-5/lib/basic-ops/dynamic-e-d.lisp
-
-
-arithmetic-5/lib/basic-ops/elim-hint.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/elim-hint.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/elim-hint.cert : \
- arithmetic-5/lib/basic-ops/default-hint.cert \
- arithmetic-5/lib/basic-ops/elim-hint.lisp \
- arithmetic-5/lib/basic-ops/elim-hint.acl2
-
-
-arithmetic-5/lib/basic-ops/expt-helper.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/expt-helper.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/expt-helper.cert : \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/default-hint.cert \
- arithmetic-5/lib/basic-ops/expt-helper.lisp
-
-
-arithmetic-5/lib/basic-ops/expt.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/expt.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/expt.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/expt-helper.cert \
- arithmetic-5/lib/basic-ops/types.cert \
- arithmetic-5/lib/basic-ops/expt.lisp
-
-
-arithmetic-5/lib/basic-ops/forcing-types.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/forcing-types.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/forcing-types.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/forcing-types.lisp
-
-
-arithmetic-5/lib/basic-ops/if-normalization.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/if-normalization.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/if-normalization.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/if-normalization.lisp
-
-
-arithmetic-5/lib/basic-ops/integerp-helper.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/integerp-helper.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/integerp-helper.cert : \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/default-hint.cert \
- arithmetic-5/lib/basic-ops/integerp-helper.lisp
-
-
-arithmetic-5/lib/basic-ops/integerp-meta.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/integerp-meta.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/integerp-meta.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/default-hint.cert \
- arithmetic-5/lib/basic-ops/integerp-meta.lisp
-
-
-arithmetic-5/lib/basic-ops/integerp.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/integerp.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/integerp.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/default-hint.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/integerp-helper.cert \
- arithmetic-5/lib/basic-ops/common.cert \
- arithmetic-5/lib/basic-ops/normalize.cert \
- arithmetic-5/lib/basic-ops/simplify.cert \
- arithmetic-5/lib/basic-ops/collect.cert \
- arithmetic-5/lib/basic-ops/integerp.lisp
-
-
-arithmetic-5/lib/basic-ops/mini-theories.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/mini-theories.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/mini-theories.cert : \
- arithmetic-5/lib/basic-ops/mini-theories.lisp
-
-
-arithmetic-5/lib/basic-ops/natp-posp.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/natp-posp.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/natp-posp.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/natp-posp.lisp
-
-
-arithmetic-5/lib/basic-ops/normalize.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/normalize.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/normalize.cert : \
- arithmetic-5/lib/basic-ops/common.cert \
- arithmetic-5/lib/basic-ops/basic.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/normalize.lisp
-
-
-arithmetic-5/lib/basic-ops/numerator-and-denominator.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/numerator-and-denominator.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/numerator-and-denominator.cert : \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/numerator-and-denominator.lisp
-
-
-arithmetic-5/lib/basic-ops/remove-weak-inequalities.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/remove-weak-inequalities.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/remove-weak-inequalities.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/remove-weak-inequalities.lisp
-
-
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.cert : \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.lisp
-
-
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/simplify-helper.cert \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.cert \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.lisp
-
-
-arithmetic-5/lib/basic-ops/simplify-helper.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/simplify-helper.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/simplify-helper.cert : \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/default-hint.cert \
- arithmetic-5/lib/basic-ops/simplify-helper.lisp
-
-
-arithmetic-5/lib/basic-ops/simplify.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/simplify.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/simplify.cert : \
- arithmetic-5/lib/basic-ops/common.cert \
- arithmetic-5/lib/basic-ops/simplify-helper.cert \
- arithmetic-5/lib/basic-ops/basic.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/simplify.lisp
-
-
-arithmetic-5/lib/basic-ops/top.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/top.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/top.cert : \
- arithmetic-5/lib/basic-ops/we-are-here.cert \
- arithmetic-5/lib/basic-ops/distributivity.cert \
- arithmetic-5/lib/basic-ops/default-hint.cert \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/common.cert \
- arithmetic-5/lib/basic-ops/normalize.cert \
- arithmetic-5/lib/basic-ops/simplify.cert \
- arithmetic-5/lib/basic-ops/mini-theories.cert \
- arithmetic-5/lib/basic-ops/numerator-and-denominator.cert \
- arithmetic-5/lib/basic-ops/natp-posp.cert \
- arithmetic-5/lib/basic-ops/integerp-meta.cert \
- arithmetic-5/lib/basic-ops/integerp.cert \
- arithmetic-5/lib/basic-ops/basic.cert \
- arithmetic-5/lib/basic-ops/expt.cert \
- arithmetic-5/lib/basic-ops/collect.cert \
- arithmetic-5/lib/basic-ops/remove-weak-inequalities.cert \
- arithmetic-5/lib/basic-ops/arithmetic-theory.cert \
- arithmetic-5/lib/basic-ops/types.cert \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.cert \
- arithmetic-5/lib/basic-ops/if-normalization.cert \
- arithmetic-5/lib/basic-ops/forcing-types.cert \
- arithmetic-5/lib/basic-ops/banner.cert \
- arithmetic-5/lib/basic-ops/top.lisp
-
-
-arithmetic-5/lib/basic-ops/types-helper.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/types-helper.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/types-helper.cert : \
- arithmetic-5/support/top.cert \
- arithmetic-5/lib/basic-ops/types-helper.lisp
-
-
-arithmetic-5/lib/basic-ops/types.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/types.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/types.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/types-helper.cert \
- arithmetic-5/lib/basic-ops/types.lisp
-
-
-arithmetic-5/lib/basic-ops/we-are-here.cert : acl2x = 0
-arithmetic-5/lib/basic-ops/we-are-here.cert : no_pcert = 0
-
-arithmetic-5/lib/basic-ops/we-are-here.cert : \
- arithmetic-5/lib/basic-ops/we-are-here.lisp
-
-
-arithmetic-5/lib/floor-mod/floor-mod-basic-helper.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod-basic-helper.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/floor-mod-basic-helper.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/floor-mod/forcing-types.cert \
- arithmetic-5/lib/basic-ops/top.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic-helper.lisp
-
-
-arithmetic-5/lib/floor-mod/floor-mod-basic.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod-basic.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/floor-mod-basic.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/floor-mod/forcing-types.cert \
- arithmetic-5/lib/basic-ops/top.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic-helper.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic.lisp
-
-
-arithmetic-5/lib/floor-mod/floor-mod-helper.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod-helper.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/floor-mod-helper.cert : \
- arithmetic-5/lib/basic-ops/top.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic.cert \
- arithmetic-5/lib/floor-mod/forcing-types.cert \
- arithmetic-5/lib/floor-mod/floor-mod-helper.lisp
-
-
-arithmetic-5/lib/floor-mod/floor-mod.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/floor-mod.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/common.cert \
- arithmetic-5/lib/basic-ops/top.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic.cert \
- arithmetic-5/lib/floor-mod/forcing-types.cert \
- arithmetic-5/lib/floor-mod/floor-mod-helper.cert \
- arithmetic-5/lib/floor-mod/floor-mod.lisp
-
-
-arithmetic-5/lib/floor-mod/forcing-types.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/forcing-types.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/forcing-types.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/floor-mod/forcing-types.lisp
-
-
-arithmetic-5/lib/floor-mod/if-normalization.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/if-normalization.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/if-normalization.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/floor-mod/if-normalization.lisp
-
-
-arithmetic-5/lib/floor-mod/logand-helper.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/logand-helper.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/logand-helper.cert : \
- arithmetic-5/lib/basic-ops/top.cert \
- arithmetic-5/lib/floor-mod/more-floor-mod.cert \
- arithmetic-5/lib/floor-mod/floor-mod.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic.cert \
- arithmetic-5/lib/floor-mod/truncate-rem.cert \
- arithmetic-5/lib/floor-mod/logand-helper.lisp
-
-
-arithmetic-5/lib/floor-mod/logand.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/logand.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/logand.cert : \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/basic-ops/top.cert \
- arithmetic-5/lib/floor-mod/more-floor-mod.cert \
- arithmetic-5/lib/floor-mod/floor-mod.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic.cert \
- arithmetic-5/lib/floor-mod/truncate-rem.cert \
- arithmetic-5/lib/floor-mod/logand-helper.cert \
- arithmetic-5/lib/floor-mod/logand.lisp
-
-
-arithmetic-5/lib/floor-mod/mod-expt-fast.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/mod-expt-fast.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/mod-expt-fast.cert : \
- arithmetic-5/lib/basic-ops/top.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic.cert \
- arithmetic-5/lib/floor-mod/floor-mod.cert \
- arithmetic-5/lib/floor-mod/more-floor-mod.cert \
- arithmetic-5/lib/floor-mod/truncate-rem.cert \
- arithmetic-5/lib/floor-mod/mod-expt-fast.lisp
-
-
-arithmetic-5/lib/floor-mod/more-floor-mod.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/more-floor-mod.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/more-floor-mod.cert : \
- arithmetic-5/lib/basic-ops/top.cert \
- arithmetic-5/lib/floor-mod/floor-mod.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic.cert \
- arithmetic-5/lib/floor-mod/if-normalization.cert \
- arithmetic-5/lib/floor-mod/forcing-types.cert \
- arithmetic-5/lib/floor-mod/more-floor-mod.lisp
-
-
-arithmetic-5/lib/floor-mod/top.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/top.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/top.cert : \
- arithmetic-5/lib/floor-mod/logand.cert \
- arithmetic-5/lib/floor-mod/truncate-rem.cert \
- arithmetic-5/lib/floor-mod/mod-expt-fast.cert \
- arithmetic-5/lib/floor-mod/more-floor-mod.cert \
- arithmetic-5/lib/floor-mod/floor-mod.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic.cert \
- arithmetic-5/lib/floor-mod/if-normalization.cert \
- arithmetic-5/lib/floor-mod/forcing-types.cert \
- arithmetic-5/lib/floor-mod/top.lisp
-
-
-arithmetic-5/lib/floor-mod/truncate-rem.cert : acl2x = 0
-arithmetic-5/lib/floor-mod/truncate-rem.cert : no_pcert = 0
-
-arithmetic-5/lib/floor-mod/truncate-rem.cert : \
- arithmetic-5/lib/basic-ops/top.cert \
- arithmetic-5/lib/floor-mod/floor-mod.cert \
- arithmetic-5/lib/floor-mod/floor-mod-basic.cert \
- arithmetic-5/lib/basic-ops/building-blocks.cert \
- arithmetic-5/lib/floor-mod/truncate-rem.lisp
-
-
-arithmetic-5/support/basic-arithmetic-helper.cert : acl2x = 0
-arithmetic-5/support/basic-arithmetic-helper.cert : no_pcert = 0
-
-arithmetic-5/support/basic-arithmetic-helper.cert : \
- arithmetic-5/support/basic-arithmetic-helper.lisp
-
-
-arithmetic-5/support/basic-arithmetic.cert : acl2x = 0
-arithmetic-5/support/basic-arithmetic.cert : no_pcert = 0
-
-arithmetic-5/support/basic-arithmetic.cert : \
- arithmetic-5/support/basic-arithmetic-helper.cert \
- arithmetic-5/support/basic-arithmetic.lisp
-
-
-arithmetic-5/support/expt-helper.cert : acl2x = 0
-arithmetic-5/support/expt-helper.cert : no_pcert = 0
-
-arithmetic-5/support/expt-helper.cert : \
- arithmetic-5/support/basic-arithmetic.cert \
- arithmetic-5/support/inequalities.cert \
- arithmetic-5/support/prefer-times.cert \
- arithmetic-5/support/expt-helper.lisp
-
-
-arithmetic-5/support/expt.cert : acl2x = 0
-arithmetic-5/support/expt.cert : no_pcert = 0
-
-arithmetic-5/support/expt.cert : \
- arithmetic-5/support/basic-arithmetic.cert \
- arithmetic-5/support/inequalities.cert \
- arithmetic-5/support/prefer-times.cert \
- arithmetic-5/support/expt-helper.cert \
- arithmetic-5/support/expt.lisp
-
-
-arithmetic-5/support/inequalities.cert : acl2x = 0
-arithmetic-5/support/inequalities.cert : no_pcert = 0
-
-arithmetic-5/support/inequalities.cert : \
- arithmetic-5/support/basic-arithmetic.cert \
- arithmetic-5/support/inequalities.lisp
-
-
-arithmetic-5/support/mini-theories.cert : acl2x = 0
-arithmetic-5/support/mini-theories.cert : no_pcert = 0
-
-arithmetic-5/support/mini-theories.cert : \
- arithmetic-5/support/basic-arithmetic.cert \
- arithmetic-5/support/inequalities.cert \
- arithmetic-5/support/prefer-times.cert \
- arithmetic-5/support/expt.cert \
- arithmetic-5/support/mini-theories.lisp
-
-
-arithmetic-5/support/non-linear.cert : acl2x = 0
-arithmetic-5/support/non-linear.cert : no_pcert = 0
-
-arithmetic-5/support/non-linear.cert : \
- arithmetic-5/support/basic-arithmetic.cert \
- arithmetic-5/support/expt.cert \
- arithmetic-5/support/non-linear.lisp
-
-
-arithmetic-5/support/num-and-denom-helper.cert : acl2x = 0
-arithmetic-5/support/num-and-denom-helper.cert : no_pcert = 0
-
-arithmetic-5/support/num-and-denom-helper.cert : \
- arithmetic-5/support/basic-arithmetic.cert \
- arithmetic-5/support/inequalities.cert \
- arithmetic-5/support/prefer-times.cert \
- arithmetic-5/support/non-linear.cert \
- arithmetic-5/support/num-and-denom-helper.lisp
-
-
-arithmetic-5/support/numerator-and-denominator.cert : acl2x = 0
-arithmetic-5/support/numerator-and-denominator.cert : no_pcert = 0
-
-arithmetic-5/support/numerator-and-denominator.cert : \
- arithmetic-5/support/basic-arithmetic.cert \
- arithmetic-5/support/inequalities.cert \
- arithmetic-5/support/prefer-times.cert \
- arithmetic-5/support/non-linear.cert \
- arithmetic-5/support/num-and-denom-helper.cert \
- arithmetic-5/support/numerator-and-denominator.lisp
-
-
-arithmetic-5/support/prefer-times.cert : acl2x = 0
-arithmetic-5/support/prefer-times.cert : no_pcert = 0
-
-arithmetic-5/support/prefer-times.cert : \
- arithmetic-5/support/basic-arithmetic.cert \
- arithmetic-5/support/inequalities.cert \
- arithmetic-5/support/prefer-times.lisp
-
-
-arithmetic-5/support/top.cert : acl2x = 0
-arithmetic-5/support/top.cert : no_pcert = 0
-
-arithmetic-5/support/top.cert : \
- arithmetic-5/support/basic-arithmetic.cert \
- arithmetic-5/support/inequalities.cert \
- arithmetic-5/support/expt.cert \
- arithmetic-5/support/prefer-times.cert \
- arithmetic-5/support/mini-theories.cert \
- arithmetic-5/support/numerator-and-denominator.cert \
- arithmetic-5/support/non-linear.cert \
- arithmetic-5/support/top.lisp
-
-
-arithmetic-5/top.cert : acl2x = 0
-arithmetic-5/top.cert : no_pcert = 0
-
-arithmetic-5/top.cert : \
- arithmetic-5/lib/basic-ops/top.cert \
- arithmetic-5/lib/floor-mod/top.cert \
- arithmetic-5/top.lisp
-
-
-arithmetic/abs.cert : acl2x = 0
-arithmetic/abs.cert : no_pcert = 0
-
-arithmetic/abs.cert : \
- arithmetic/top.cert \
- arithmetic/abs.lisp
-
-
-arithmetic/binomial.cert : acl2x = 0
-arithmetic/binomial.cert : no_pcert = 0
-
-arithmetic/binomial.cert : \
- arithmetic/top.cert \
- arithmetic/factorial.cert \
- arithmetic/sumlist.cert \
- arithmetic/binomial.lisp
-
-
-arithmetic/equalities.cert : acl2x = 0
-arithmetic/equalities.cert : no_pcert = 0
-
-arithmetic/equalities.cert : \
- cowles/acl2-crg.cert \
- arithmetic/equalities.lisp \
- arithmetic/equalities.acl2
-
-
-arithmetic/factorial.cert : acl2x = 0
-arithmetic/factorial.cert : no_pcert = 0
-
-arithmetic/factorial.cert : \
- arithmetic/factorial.lisp
-
-
-arithmetic/idiv.cert : acl2x = 0
-arithmetic/idiv.cert : no_pcert = 0
-
-arithmetic/idiv.cert : \
- arithmetic/top.cert \
- arithmetic/idiv.lisp
-
-
-arithmetic/inequalities.cert : acl2x = 0
-arithmetic/inequalities.cert : no_pcert = 0
-
-arithmetic/inequalities.cert : \
- arithmetic/equalities.cert \
- arithmetic/inequalities.lisp
-
-
-arithmetic/mod-gcd.cert : acl2x = 0
-arithmetic/mod-gcd.cert : no_pcert = 0
-
-arithmetic/mod-gcd.cert : \
- arithmetic/inequalities.cert \
- arithmetic/mod-gcd.lisp
-
-
-arithmetic/nat-listp.cert : acl2x = 0
-arithmetic/nat-listp.cert : no_pcert = 0
-
-arithmetic/nat-listp.cert : \
- arithmetic/nat-listp.lisp
-
-
-arithmetic/natp-posp.cert : acl2x = 0
-arithmetic/natp-posp.cert : no_pcert = 0
-
-arithmetic/natp-posp.cert : \
- arithmetic/inequalities.cert \
- arithmetic/natp-posp.lisp
-
-
-arithmetic/rational-listp.cert : acl2x = 0
-arithmetic/rational-listp.cert : no_pcert = 0
-
-arithmetic/rational-listp.cert : \
- arithmetic/rational-listp.lisp
-
-
-arithmetic/rationals.cert : acl2x = 0
-arithmetic/rationals.cert : no_pcert = 0
-
-arithmetic/rationals.cert : \
- arithmetic/inequalities.cert \
- arithmetic/inequalities.cert \
- arithmetic/mod-gcd.cert \
- arithmetic/rationals.lisp
-
-
-arithmetic/sumlist.cert : acl2x = 0
-arithmetic/sumlist.cert : no_pcert = 0
-
-arithmetic/sumlist.cert : \
- arithmetic/sumlist.lisp
-
-
-arithmetic/top-with-meta.cert : acl2x = 0
-arithmetic/top-with-meta.cert : no_pcert = 0
-
-arithmetic/top-with-meta.cert : \
- arithmetic/top.cert \
- meta/meta.cert \
- arithmetic/top-with-meta.lisp
-
-
-arithmetic/top.cert : acl2x = 0
-arithmetic/top.cert : no_pcert = 0
-
-arithmetic/top.cert : \
- arithmetic/equalities.cert \
- arithmetic/rational-listp.cert \
- arithmetic/nat-listp.cert \
- arithmetic/inequalities.cert \
- arithmetic/natp-posp.cert \
- arithmetic/rationals.cert \
- arithmetic/top.lisp
-
-
-bdd/alu-proofs.cert : acl2x = 0
-bdd/alu-proofs.cert : no_pcert = 0
-
-bdd/alu-proofs.cert : \
- bdd/alu.cert \
- bdd/alu-proofs.lisp
-
-
-bdd/alu.cert : acl2x = 0
-bdd/alu.cert : no_pcert = 0
-
-bdd/alu.cert : \
- bdd/bdd-primitives.cert \
- bdd/alu.lisp
-
-
-bdd/bdd-primitives.cert : acl2x = 0
-bdd/bdd-primitives.cert : no_pcert = 0
-
-bdd/bdd-primitives.cert : \
- bdd/bdd-primitives.lisp
-
-
-bdd/bool-ops.cert : acl2x = 0
-bdd/bool-ops.cert : no_pcert = 0
-
-bdd/bool-ops.cert : \
- bdd/bool-ops.lisp
-
-
-bdd/cbf.cert : acl2x = 0
-bdd/cbf.cert : no_pcert = 0
-
-bdd/cbf.cert : \
- bdd/bool-ops.cert \
- bdd/cbf.lisp
-
-
-bdd/hamming.cert : acl2x = 0
-bdd/hamming.cert : no_pcert = 0
-
-bdd/hamming.cert : \
- bdd/bdd-primitives.cert \
- bdd/hamming.lisp
-
-
-bdd/pg-theory.cert : acl2x = 0
-bdd/pg-theory.cert : no_pcert = 0
-
-bdd/pg-theory.cert : \
- bdd/bdd-primitives.cert \
- bdd/pg-theory.lisp
-
-
-centaur/4v-sexpr/4v-logic.cert : acl2x = 0
-centaur/4v-sexpr/4v-logic.cert : no_pcert = 0
-
-centaur/4v-sexpr/4v-logic.cert : \
- centaur/misc/witness-cp.cert \
- tools/rulesets.cert \
- xdoc/top.cert \
- misc/definline.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/4v-logic.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/bitspecs.cert : acl2x = 0
-centaur/4v-sexpr/bitspecs.cert : no_pcert = 0
-
-centaur/4v-sexpr/bitspecs.cert : \
- centaur/4v-sexpr/4v-logic.cert \
- centaur/4v-sexpr/sexpr-equivs.cert \
- centaur/misc/vecs-ints.cert \
- centaur/misc/hons-sets.cert \
- centaur/misc/fast-alists.cert \
- centaur/misc/patterns.cert \
- arithmetic/top-with-meta.cert \
- ihs/logops-lemmas.cert \
- data-structures/no-duplicates.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/bitspecs.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/compose-sexpr.cert : acl2x = 0
-centaur/4v-sexpr/compose-sexpr.cert : no_pcert = 0
-
-centaur/4v-sexpr/compose-sexpr.cert : \
- centaur/4v-sexpr/bitspecs.cert \
- centaur/4v-sexpr/sexpr-to-faig.cert \
- centaur/4v-sexpr/sexpr-advanced.cert \
- centaur/misc/hons-extra.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/compose-sexpr.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/g-sexpr-eval.cert : acl2x = 0
-centaur/4v-sexpr/g-sexpr-eval.cert : no_pcert = 0
-
-centaur/4v-sexpr/g-sexpr-eval.cert : \
- centaur/4v-sexpr/svarmap.cert \
- centaur/4v-sexpr/sexpr-to-faig.cert \
- centaur/4v-sexpr/sexpr-equivs.cert \
- centaur/gl/gl-util.cert \
- centaur/misc/numlist.cert \
- centaur/misc/hons-extra.cert \
- centaur/misc/hons-sets.cert \
- centaur/aig/eval-restrict.cert \
- arithmetic/top-with-meta.cert \
- std/lists/take.cert \
- centaur/gl/portcullis.cert \
- centaur/4v-sexpr/g-sexpr-eval.lisp \
- centaur/4v-sexpr/g-sexpr-eval.acl2
-
-
-centaur/4v-sexpr/nsexprs.cert : acl2x = 0
-centaur/4v-sexpr/nsexprs.cert : no_pcert = 0
-
-centaur/4v-sexpr/nsexprs.cert : \
- centaur/4v-sexpr/sexpr-vars.cert \
- centaur/bitops/bitsets.cert \
- centaur/bitops/sbitsets.cert \
- arithmetic/nat-listp.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/nsexprs.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/onehot-rewrite.cert : acl2x = 0
-centaur/4v-sexpr/onehot-rewrite.cert : no_pcert = 0
-
-centaur/4v-sexpr/onehot-rewrite.cert : \
- centaur/4v-sexpr/sexpr-rewrites.cert \
- centaur/4v-sexpr/sexpr-building.cert \
- cutil/defprojection.cert \
- centaur/misc/filter-alist.cert \
- data-structures/list-defthms.cert \
- arithmetic/top.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/onehot-rewrite.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/portcullis.cert : acl2x = 0
-centaur/4v-sexpr/portcullis.cert : no_pcert = 0
-
-centaur/4v-sexpr/portcullis.cert : \
- centaur/4v-sexpr/portcullis.lisp \
- centaur/4v-sexpr/portcullis.acl2 \
- tools/flag-package.lsp \
- xdoc/package.lsp \
- centaur/vl/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-
-
-centaur/4v-sexpr/sexpr-3v.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-3v.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-3v.cert : \
- centaur/4v-sexpr/sexpr-eval.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-3v.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-advanced.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-advanced.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-advanced.cert : \
- centaur/4v-sexpr/sexpr-vars.cert \
- centaur/4v-sexpr/sexpr-equivs.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-advanced.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-building.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-building.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-building.cert : \
- centaur/4v-sexpr/sexpr-eval.cert \
- centaur/4v-sexpr/sexpr-vars.cert \
- centaur/4v-sexpr/sexpr-3v.cert \
- cutil/defprojection.cert \
- misc/definline.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-building.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-equivs.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-equivs.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-equivs.cert : \
- centaur/4v-sexpr/sexpr-eval.cert \
- centaur/misc/universal-equiv.cert \
- centaur/misc/fast-alists.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-equivs.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-eval.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-eval.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-eval.cert : \
- centaur/4v-sexpr/4v-logic.cert \
- centaur/misc/fast-alists.cert \
- centaur/misc/hons-extra.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-eval.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-fixpoint-correct.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-correct.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-fixpoint-correct.cert : \
- centaur/4v-sexpr/sexpr-fixpoint-spec.cert \
- centaur/misc/hons-sets.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-fixpoint-correct.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-fixpoint-rewriting.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-rewriting.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-fixpoint-rewriting.cert : \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-fixpoint-rewriting.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-fixpoint-spec.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-spec.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-fixpoint-spec.cert : \
- centaur/4v-sexpr/sexpr-fixpoint.cert \
- centaur/4v-sexpr/sexpr-advanced.cert \
- misc/bash.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-fixpoint-spec.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-fixpoint-top.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-top.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-fixpoint-top.cert : \
- centaur/4v-sexpr/sexpr-fixpoint.cert \
- centaur/4v-sexpr/sexpr-equivs.cert \
- centaur/4v-sexpr/sexpr-fixpoint-correct.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-fixpoint-top.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-fixpoint.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-fixpoint.cert : \
- centaur/4v-sexpr/nsexprs.cert \
- centaur/4v-sexpr/sexpr-rewrites.cert \
- centaur/misc/hons-extra.cert \
- centaur/misc/sneaky-load.cert \
- centaur/misc/nat-list-duplicates.cert \
- centaur/misc/tuplep.cert \
- centaur/misc/dfs-measure.cert \
- std/ks/two-nats-measure.cert \
- centaur/vl/util/cwtime.cert \
- arithmetic/top-with-meta.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-fixpoint.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-loop-debug.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-loop-debug.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-loop-debug.cert : \
- centaur/4v-sexpr/sexpr-fixpoint.cert \
- centaur/vl/toe/toe-emodwire.cert \
- centaur/vl/util/cw-unformatted.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- arithmetic-3/top.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-loop-debug.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-rewrites.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-rewrites.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-rewrites.cert : \
- centaur/aig/base.cert \
- centaur/4v-sexpr/sexpr-advanced.cert \
- centaur/misc/hons-extra.cert \
- centaur/4v-sexpr/sexpr-vars-1pass.cert \
- std/ks/two-nats-measure.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-rewrites.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-to-faig.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-to-faig.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-to-faig.cert : \
- centaur/4v-sexpr/sexpr-eval.cert \
- centaur/4v-sexpr/sexpr-3v.cert \
- centaur/aig/three-four.cert \
- centaur/aig/aig-equivs.cert \
- centaur/misc/tuplep.cert \
- centaur/aig/eval-restrict.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-to-faig.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-vars-1pass.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-vars-1pass.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-vars-1pass.cert : \
- centaur/4v-sexpr/sexpr-vars.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-vars-1pass.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/sexpr-vars.cert : acl2x = 0
-centaur/4v-sexpr/sexpr-vars.cert : no_pcert = 0
-
-centaur/4v-sexpr/sexpr-vars.cert : \
- centaur/4v-sexpr/sexpr-eval.cert \
- centaur/misc/hons-alphorder-merge.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/sexpr-vars.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/svarmap.cert : acl2x = 0
-centaur/4v-sexpr/svarmap.cert : no_pcert = 0
-
-centaur/4v-sexpr/svarmap.cert : \
- centaur/aig/base.cert \
- centaur/misc/fast-alists.cert \
- centaur/misc/hons-sets.cert \
- data-structures/no-duplicates.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/svarmap.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/4v-sexpr/top.cert : acl2x = 0
-centaur/4v-sexpr/top.cert : no_pcert = 0
-
-centaur/4v-sexpr/top.cert : \
- centaur/4v-sexpr/4v-logic.cert \
- centaur/4v-sexpr/bitspecs.cert \
- centaur/4v-sexpr/compose-sexpr.cert \
- centaur/4v-sexpr/g-sexpr-eval.cert \
- centaur/4v-sexpr/nsexprs.cert \
- centaur/4v-sexpr/onehot-rewrite.cert \
- centaur/4v-sexpr/sexpr-advanced.cert \
- centaur/4v-sexpr/sexpr-building.cert \
- centaur/4v-sexpr/sexpr-equivs.cert \
- centaur/4v-sexpr/sexpr-eval.cert \
- centaur/4v-sexpr/sexpr-fixpoint-correct.cert \
- centaur/4v-sexpr/sexpr-fixpoint.cert \
- centaur/4v-sexpr/sexpr-fixpoint-rewriting.cert \
- centaur/4v-sexpr/sexpr-fixpoint-spec.cert \
- centaur/4v-sexpr/sexpr-fixpoint-top.cert \
- centaur/4v-sexpr/sexpr-loop-debug.cert \
- centaur/4v-sexpr/sexpr-rewrites.cert \
- centaur/4v-sexpr/sexpr-to-faig.cert \
- centaur/4v-sexpr/sexpr-vars.cert \
- centaur/4v-sexpr/svarmap.cert \
- centaur/4v-sexpr/portcullis.cert \
- centaur/4v-sexpr/top.lisp \
- centaur/4v-sexpr/cert.acl2
-
-
-centaur/aig/aig-equivs.cert : acl2x = 0
-centaur/aig/aig-equivs.cert : no_pcert = 0
-
-centaur/aig/aig-equivs.cert : \
- centaur/aig/base.cert \
- centaur/misc/witness-cp.cert \
- centaur/misc/universal-equiv.cert \
- centaur/misc/fast-alists.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/aig-equivs.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/aig-vars-ext.cert : acl2x = 0
-centaur/aig/aig-vars-ext.cert : no_pcert = 0
-
-centaur/aig/aig-vars-ext.cert : \
- defsort/defsort.cert \
- centaur/aig/base.cert \
- tools/bstar.cert \
- centaur/bitops/sbitsets.cert \
- centaur/misc/hons-extra.cert \
- centaur/misc/alist-defs.cert \
- centaur/misc/numlist.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/aig-vars-ext.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/aig-vars.cert : acl2x = 0
-centaur/aig/aig-vars.cert : no_pcert = 0
-
-centaur/aig/aig-vars.cert : \
- centaur/aig/base.cert \
- centaur/misc/equal-sets.cert \
- centaur/misc/alist-equiv.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/aig-vars.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/aiger.cert : acl2x = 0
-centaur/aig/aiger.cert : no_pcert = 0
-
-centaur/aig/aiger.cert : \
- tools/bstar.cert \
- tools/mv-nth.cert \
- data-structures/list-defthms.cert \
- centaur/aig/aig-vars-ext.cert \
- centaur/vl/util/cwtime.cert \
- centaur/misc/sneaky-load.cert \
- centaur/misc/numlist.cert \
- tools/defmacfun.cert \
- misc/definline.cert \
- system/io.cert \
- arithmetic/nat-listp.cert \
- clause-processors/instantiate.cert \
- centaur/bitops/ihsext-basics.cert \
- arithmetic/top-with-meta.cert \
- cutil/defmvtypes.cert \
- ihs/quotient-remainder-lemmas.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/aiger.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/base.cert : acl2x = 0
-centaur/aig/base.cert : no_pcert = 0
-
-centaur/aig/base.cert : \
- cutil/defsection.cert \
- centaur/misc/hons-alphorder-merge.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/base.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/bddify-correct.cert : acl2x = 0
-centaur/aig/bddify-correct.cert : no_pcert = 0
-
-centaur/aig/bddify-correct.cert : \
- centaur/aig/bddify.cert \
- centaur/ubdds/param.cert \
- centaur/ubdds/lite.cert \
- centaur/misc/suffixp.cert \
- tools/with-quoted-forms.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/bddify-correct.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/bddify.cert : acl2x = 0
-centaur/aig/bddify.cert : no_pcert = 0
-
-centaur/aig/bddify.cert : \
- centaur/aig/base.cert \
- tools/bstar.cert \
- tools/mv-nth.cert \
- misc/hons-help2.cert \
- centaur/ubdds/extra-operations.cert \
- centaur/misc/memory-mgmt-logic.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/bddify.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/eval-restrict.cert : acl2x = 0
-centaur/aig/eval-restrict.cert : no_pcert = 0
-
-centaur/aig/eval-restrict.cert : \
- centaur/aig/base.cert \
- centaur/aig/aig-equivs.cert \
- centaur/aig/three-four.cert \
- centaur/aig/aig-vars.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/eval-restrict.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/g-aig-eval.cert : acl2x = 0
-centaur/aig/g-aig-eval.cert : no_pcert = 0
-
-centaur/aig/g-aig-eval.cert : \
- centaur/aig/bddify-correct.cert \
- centaur/gl/g-if.cert \
- centaur/gl/gify.cert \
- centaur/gl/gify-thms.cert \
- centaur/gl/eval-f-i-cp.cert \
- centaur/gl/bvecs.cert \
- centaur/gl/gify-clause-proc.cert \
- centaur/gl/general-object-thms.cert \
- centaur/aig/eval-restrict.cert \
- centaur/gl/portcullis.cert \
- centaur/aig/g-aig-eval.lisp \
- centaur/aig/g-aig-eval.acl2
-
-
-centaur/aig/induction.cert : acl2x = 0
-centaur/aig/induction.cert : no_pcert = 0
-
-centaur/aig/induction.cert : \
- centaur/aig/eval-restrict.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/induction.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/misc.cert : acl2x = 0
-centaur/aig/misc.cert : no_pcert = 0
-
-centaur/aig/misc.cert : \
- centaur/aig/base.cert \
- centaur/misc/equal-sets.cert \
- tools/mv-nth.cert \
- misc/gentle.cert \
- misc/hons-help.cert \
- centaur/aig/eval-restrict.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/misc.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/portcullis.cert : acl2x = 0
-centaur/aig/portcullis.cert : no_pcert = 0
-
-centaur/aig/portcullis.cert : \
- centaur/aig/portcullis.lisp \
- centaur/aig/portcullis.acl2 \
- centaur/vl/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- centaur/vl/other-packages.lsp \
- data-structures/define-u-package.lsp \
- tools/flag-package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- cowles/packages.lsp \
- centaur/aig/fsm-pkg.lsp
-
-
-centaur/aig/three-four.cert : acl2x = 0
-centaur/aig/three-four.cert : no_pcert = 0
-
-centaur/aig/three-four.cert : \
- centaur/aig/base.cert \
- tools/bstar.cert \
- tools/rulesets.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/three-four.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/vuaig.cert : acl2x = 0
-centaur/aig/vuaig.cert : no_pcert = 0
-
-centaur/aig/vuaig.cert : \
- centaur/aig/three-four.cert \
- centaur/aig/portcullis.cert \
- centaur/aig/vuaig.lisp \
- centaur/aig/cert.acl2
-
-
-centaur/aig/witness.cert : acl2x = 0
-centaur/aig/witness.cert : no_pcert = 0
-
-centaur/aig/witness.cert : \
- misc/hons-help2.cert \
- centaur/aig/base.cert \
- clause-processors/term-patterns.cert \
- clause-processors/join-thms.cert \
- tools/flag.cert \
- centaur/aig/witness.lisp \
- centaur/aig/witness.acl2 \
- tools/flag-package.lsp
-
-
-centaur/bitops/bits-between.cert : acl2x = 0
-centaur/bitops/bits-between.cert : no_pcert = 0
-
-centaur/bitops/bits-between.cert : \
- cutil/defsection.cert \
- tools/bstar.cert \
- finite-set-theory/osets/sets.cert \
- centaur/bitops/ihs-extensions.cert \
- std/lists/rev.cert \
- std/lists/append.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/bits-between.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/bitsets-opt.cert : acl2x = 0
-centaur/bitops/bitsets-opt.cert : no_pcert = 0
-
-centaur/bitops/bitsets-opt.cert : \
- centaur/bitops/bitsets.cert \
- tools/include-raw.cert \
- make-event/assert.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/bitsets-opt.lisp \
- centaur/bitops/cert.acl2 \
- centaur/bitops/bitsets-opt-raw.lsp
-
-
-centaur/bitops/bitsets.cert : acl2x = 0
-centaur/bitops/bitsets.cert : no_pcert = 0
-
-centaur/bitops/bitsets.cert : \
- centaur/bitops/bits-between.cert \
- centaur/bitops/equal-by-logbitp.cert \
- misc/definline.cert \
- centaur/misc/witness-cp.cert \
- centaur/bitops/ihs-extensions.cert \
- ihs/quotient-remainder-lemmas.cert \
- arithmetic-3/bind-free/top.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/bitsets.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/congruences.cert : acl2x = 0
-centaur/bitops/congruences.cert : no_pcert = 0
-
-centaur/bitops/congruences.cert : \
- tools/rulesets.cert \
- centaur/misc/context-rw.cert \
- ihs/basic-definitions.cert \
- centaur/bitops/ihsext-basics.cert \
- centaur/bitops/ihs-extensions.cert \
- arithmetic/top-with-meta.cert \
- centaur/bitops/equal-by-logbitp.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/congruences.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/equal-by-logbitp.cert : acl2x = 0
-centaur/bitops/equal-by-logbitp.cert : no_pcert = 0
-
-centaur/bitops/equal-by-logbitp.cert : \
- cutil/wizard.cert \
- centaur/bitops/integer-length.cert \
- centaur/bitops/ihsext-basics.cert \
- arithmetic/top-with-meta.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/equal-by-logbitp.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/extra-defs.cert : acl2x = 0
-centaur/bitops/extra-defs.cert : no_pcert = 0
-
-centaur/bitops/extra-defs.cert : \
- centaur/bitops/ihsext-basics.cert \
- arithmetic/top.cert \
- centaur/misc/arith-equivs.cert \
- ihs/logops-definitions.cert \
- xdoc/top.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/extra-defs.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/ihs-extensions.cert : acl2x = 0
-centaur/bitops/ihs-extensions.cert : no_pcert = 0
-
-centaur/bitops/ihs-extensions.cert : \
- centaur/bitops/ihsext-basics.cert \
- centaur/bitops/integer-length.cert \
- centaur/bitops/equal-by-logbitp.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/ihs-extensions.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/ihsext-basics.cert : acl2x = 0
-centaur/bitops/ihsext-basics.cert : no_pcert = 0
-
-centaur/bitops/ihsext-basics.cert : \
- centaur/misc/arith-equivs.cert \
- xdoc/top.cert \
- tools/defredundant.cert \
- ihs/quotient-remainder-lemmas.cert \
- arithmetic/top-with-meta.cert \
- ihs/logops-lemmas.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/ihsext-basics.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/install-bit.cert : acl2x = 0
-centaur/bitops/install-bit.cert : no_pcert = 0
-
-centaur/bitops/install-bit.cert : \
- cutil/defsection.cert \
- centaur/misc/arith-equivs.cert \
- centaur/misc/mfc-utils.cert \
- centaur/misc/introduce-var.cert \
- centaur/bitops/equal-by-logbitp.cert \
- centaur/bitops/ihsext-basics.cert \
- arithmetic/top-with-meta.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/install-bit.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/integer-length.cert : acl2x = 0
-centaur/bitops/integer-length.cert : no_pcert = 0
-
-centaur/bitops/integer-length.cert : \
- cutil/defsection.cert \
- ihs/logops-definitions.cert \
- ihs/logops-lemmas.cert \
- arithmetic/top-with-meta.cert \
- centaur/bitops/ihsext-basics.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/integer-length.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/part-select.cert : acl2x = 0
-centaur/bitops/part-select.cert : no_pcert = 0
-
-centaur/bitops/part-select.cert : \
- ihs/logops-definitions.cert \
- arithmetic/top-with-meta.cert \
- centaur/bitops/ihsext-basics.cert \
- misc/assert.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/part-select.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/rotate.cert : acl2x = 0
-centaur/bitops/rotate.cert : no_pcert = 0
-
-centaur/bitops/rotate.cert : \
- xdoc/top.cert \
- tools/bstar.cert \
- ihs/logops-definitions.cert \
- centaur/misc/arith-equivs.cert \
- centaur/bitops/ihsext-basics.cert \
- arithmetic/top-with-meta.cert \
- centaur/bitops/equal-by-logbitp.cert \
- ihs/quotient-remainder-lemmas.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/rotate.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/sbitsets.cert : acl2x = 0
-centaur/bitops/sbitsets.cert : no_pcert = 0
-
-centaur/bitops/sbitsets.cert : \
- centaur/bitops/bits-between.cert \
- misc/definline.cert \
- centaur/bitops/equal-by-logbitp.cert \
- centaur/bitops/ihs-extensions.cert \
- centaur/misc/equal-sets.cert \
- std/lists/revappend.cert \
- std/lists/rev.cert \
- std/lists/append.cert \
- arithmetic-3/bind-free/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/sbitsets.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/sign-extend.cert : acl2x = 0
-centaur/bitops/sign-extend.cert : no_pcert = 0
-
-centaur/bitops/sign-extend.cert : \
- xdoc/top.cert \
- misc/definline.cert \
- tools/bstar.cert \
- ihs/logops-definitions.cert \
- centaur/bitops/ihs-extensions.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/sign-extend.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bitops/top.cert : acl2x = 0
-centaur/bitops/top.cert : no_pcert = 0
-
-centaur/bitops/top.cert : \
- centaur/bitops/bits-between.cert \
- centaur/bitops/bitsets.cert \
- centaur/bitops/bitsets-opt.cert \
- centaur/bitops/equal-by-logbitp.cert \
- centaur/bitops/ihs-extensions.cert \
- centaur/bitops/integer-length.cert \
- centaur/bitops/sbitsets.cert \
- centaur/bitops/part-select.cert \
- centaur/bitops/extra-defs.cert \
- finite-set-theory/osets/portcullis.cert \
- cutil/portcullis.cert \
- centaur/bitops/top.lisp \
- centaur/bitops/cert.acl2
-
-
-centaur/bridge/portcullis.cert : acl2x = 0
-centaur/bridge/portcullis.cert : no_pcert = 0
-
-centaur/bridge/portcullis.cert : \
- str/portcullis.cert \
- xdoc/portcullis.cert \
- centaur/bridge/portcullis.lisp \
- centaur/bridge/portcullis.acl2 \
- centaur/bridge/package.lsp \
- tools/flag-package.lsp
-
-
-centaur/bridge/to-json.cert : acl2x = 0
-centaur/bridge/to-json.cert : no_pcert = 0
-
-centaur/bridge/to-json.cert : \
- misc/definline.cert \
- str/cat.cert \
- str/natstr.cert \
- std/ks/two-nats-measure.cert \
- std/ks/explode-atom.cert \
- centaur/bitops/ihsext-basics.cert \
- misc/assert.cert \
- std/lists/nthcdr.cert \
- arithmetic/top.cert \
- str/strtok.cert \
- tools/flag.cert \
- centaur/bridge/portcullis.cert \
- centaur/bridge/to-json.lisp \
- centaur/bridge/cert.acl2
-
-
-centaur/bridge/top.cert : acl2x = 0
-centaur/bridge/top.cert : no_pcert = 0
-
-centaur/bridge/top.cert : \
- xdoc/top.cert \
- tools/include-raw.cert \
- str/top.cert \
- centaur/bridge/to-json.cert \
- centaur/bridge/portcullis.cert \
- centaur/bridge/top.lisp \
- centaur/bridge/cert.acl2 \
- centaur/bridge/bridge-raw.lsp
-
-
-centaur/defrstobj/array-lemmas.cert : acl2x = 0
-centaur/defrstobj/array-lemmas.cert : no_pcert = 0
-
-centaur/defrstobj/array-lemmas.cert : \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/array-lemmas.lisp \
- centaur/defrstobj/cert.acl2
-
-
-centaur/defrstobj/basic-tests.cert : acl2x = 0
-centaur/defrstobj/basic-tests.cert : no_pcert = 0
-
-centaur/defrstobj/basic-tests.cert : \
- centaur/defrstobj/defrstobj.cert \
- centaur/defrstobj/typed-record-tests.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/basic-tests.lisp \
- centaur/defrstobj/cert.acl2
-
-
-centaur/defrstobj/def-typed-record.cert : acl2x = 0
-centaur/defrstobj/def-typed-record.cert : no_pcert = 0
-
-centaur/defrstobj/def-typed-record.cert : \
- centaur/defrstobj/typed-records.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/def-typed-record.lisp \
- centaur/defrstobj/cert.acl2
-
-
-centaur/defrstobj/defrstobj.cert : acl2x = 0
-centaur/defrstobj/defrstobj.cert : no_pcert = 0
-
-centaur/defrstobj/defrstobj.cert : \
- centaur/defrstobj/def-typed-record.cert \
- centaur/defrstobj/g-delete-keys.cert \
- centaur/defrstobj/fancy-worseguy.cert \
- misc/definline.cert \
- misc/records.cert \
- tools/bstar.cert \
- cutil/defsection.cert \
- centaur/defrstobj/array-lemmas.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/defrstobj.lisp \
- centaur/defrstobj/cert.acl2
-
-
-centaur/defrstobj/fancy-worseguy.cert : acl2x = 0
-centaur/defrstobj/fancy-worseguy.cert : no_pcert = 0
-
-centaur/defrstobj/fancy-worseguy.cert : \
- centaur/defrstobj/g-delete-keys.cert \
- misc/equal-by-g-help.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/fancy-worseguy.lisp \
- centaur/defrstobj/cert.acl2
-
-
-centaur/defrstobj/g-delete-keys.cert : acl2x = 0
-centaur/defrstobj/g-delete-keys.cert : no_pcert = 0
-
-centaur/defrstobj/g-delete-keys.cert : \
- misc/records.cert \
- misc/equal-by-g.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/g-delete-keys.lisp \
- centaur/defrstobj/cert.acl2
-
-
-centaur/defrstobj/groundwork/array-rec.cert : acl2x = 0
-centaur/defrstobj/groundwork/array-rec.cert : no_pcert = 0
-
-centaur/defrstobj/groundwork/array-rec.cert : \
- cutil/defsection.cert \
- misc/records.cert \
- misc/equal-by-g.cert \
- centaur/misc/equal-by-nths.cert \
- centaur/defrstobj/groundwork/local.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/groundwork/array-rec.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-
-
-centaur/defrstobj/groundwork/demo1.cert : acl2x = 0
-centaur/defrstobj/groundwork/demo1.cert : no_pcert = 0
-
-centaur/defrstobj/groundwork/demo1.cert : \
- misc/records.cert \
- misc/definline.cert \
- centaur/defrstobj/groundwork/local.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/groundwork/demo1.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-
-
-centaur/defrstobj/groundwork/demo2.cert : acl2x = 0
-centaur/defrstobj/groundwork/demo2.cert : no_pcert = 0
-
-centaur/defrstobj/groundwork/demo2.cert : \
- misc/records.cert \
- misc/definline.cert \
- centaur/defrstobj/groundwork/local.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/groundwork/demo2.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-
-
-centaur/defrstobj/groundwork/demo3.cert : acl2x = 0
-centaur/defrstobj/groundwork/demo3.cert : no_pcert = 0
-
-centaur/defrstobj/groundwork/demo3.cert : \
- cutil/defsection.cert \
- misc/definline.cert \
- misc/records.cert \
- centaur/defrstobj/groundwork/local.cert \
- centaur/defrstobj/groundwork/array-rec.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/groundwork/demo3.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-
-
-centaur/defrstobj/groundwork/demo4.cert : acl2x = 0
-centaur/defrstobj/groundwork/demo4.cert : no_pcert = 0
-
-centaur/defrstobj/groundwork/demo4.cert : \
- cutil/defsection.cert \
- misc/definline.cert \
- misc/records.cert \
- centaur/defrstobj/groundwork/array-rec.cert \
- centaur/defrstobj/groundwork/local.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/groundwork/demo4.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-
-
-centaur/defrstobj/groundwork/demo5.cert : acl2x = 0
-centaur/defrstobj/groundwork/demo5.cert : no_pcert = 0
-
-centaur/defrstobj/groundwork/demo5.cert : \
- cutil/defsection.cert \
- misc/definline.cert \
- misc/records.cert \
- centaur/defrstobj/def-typed-record.cert \
- centaur/defrstobj/array-lemmas.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/groundwork/demo5.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-
-
-centaur/defrstobj/groundwork/local.cert : acl2x = 0
-centaur/defrstobj/groundwork/local.cert : no_pcert = 0
-
-centaur/defrstobj/groundwork/local.cert : \
- misc/records.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/groundwork/local.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-
-
-centaur/defrstobj/portcullis.cert : acl2x = 0
-centaur/defrstobj/portcullis.cert : no_pcert = 0
-
-centaur/defrstobj/portcullis.cert : \
- centaur/defrstobj/portcullis.lisp \
- centaur/defrstobj/portcullis.acl2 \
- centaur/defrstobj/package.lsp
-
-
-centaur/defrstobj/typed-record-tests.cert : acl2x = 0
-centaur/defrstobj/typed-record-tests.cert : no_pcert = 0
-
-centaur/defrstobj/typed-record-tests.cert : \
- centaur/defrstobj/def-typed-record.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/typed-record-tests.lisp \
- centaur/defrstobj/cert.acl2
-
-
-centaur/defrstobj/typed-records.cert : acl2x = 0
-centaur/defrstobj/typed-records.cert : no_pcert = 0
-
-centaur/defrstobj/typed-records.cert : \
- misc/total-order.cert \
- centaur/misc/mfc-utils.cert \
- centaur/misc/introduce-var.cert \
- centaur/misc/equal-by-nths.cert \
- centaur/defrstobj/array-lemmas.cert \
- centaur/defrstobj/portcullis.cert \
- centaur/defrstobj/typed-records.lisp \
- centaur/defrstobj/cert.acl2
-
-
-centaur/esim/esim-paths.cert : acl2x = 0
-centaur/esim/esim-paths.cert : no_pcert = 0
-
-centaur/esim/esim-paths.cert : \
- centaur/esim/esim-sexpr-support.cert \
- centaur/esim/esim-sexpr-support-thms.cert \
- cutil/deflist.cert \
- cutil/defmvtypes.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/esim-paths.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/esim-primitives.cert : acl2x = 0
-centaur/esim/esim-primitives.cert : no_pcert = 0
-
-centaur/esim/esim-primitives.cert : \
- tools/bstar.cert \
- xdoc/top.cert \
- centaur/esim/plist.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/esim-primitives.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/esim-sexpr-correct.cert : acl2x = 0
-centaur/esim/esim-sexpr-correct.cert : no_pcert = 0
-
-centaur/esim/esim-sexpr-correct.cert : \
- centaur/esim/esim-sexpr.cert \
- centaur/esim/esim-spec.cert \
- centaur/esim/esim-sexpr-support-thms.cert \
- centaur/4v-sexpr/sexpr-advanced.cert \
- centaur/4v-sexpr/sexpr-fixpoint-top.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/esim-sexpr-correct.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/esim-sexpr-support-thms.cert : acl2x = 0
-centaur/esim/esim-sexpr-support-thms.cert : no_pcert = 0
-
-centaur/esim/esim-sexpr-support-thms.cert : \
- centaur/esim/esim-sexpr-support.cert \
- centaur/esim/local-theory.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/esim-sexpr-support-thms.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/esim-sexpr-support.cert : acl2x = 0
-centaur/esim/esim-sexpr-support.cert : no_pcert = 0
-
-centaur/esim/esim-sexpr-support.cert : \
- centaur/esim/plist.cert \
- centaur/misc/patterns.cert \
- centaur/4v-sexpr/sexpr-vars.cert \
- std/ks/explode-nonnegative-integer.cert \
- std/ks/two-nats-measure.cert \
- arithmetic/nat-listp.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/esim-sexpr-support.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/esim-sexpr.cert : acl2x = 0
-centaur/esim/esim-sexpr.cert : no_pcert = 0
-
-centaur/esim/esim-sexpr.cert : \
- centaur/esim/esim-paths.cert \
- centaur/esim/esim-sexpr-support.cert \
- str/strsubst.cert \
- str/substrp.cert \
- centaur/misc/ap.cert \
- centaur/4v-sexpr/sexpr-fixpoint.cert \
- centaur/4v-sexpr/sexpr-to-faig.cert \
- centaur/4v-sexpr/sexpr-equivs.cert \
- centaur/esim/esim-sexpr-support-thms.cert \
- centaur/4v-sexpr/sexpr-advanced.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/esim-sexpr.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/esim-spec.cert : acl2x = 0
-centaur/esim/esim-spec.cert : no_pcert = 0
-
-centaur/esim/esim-spec.cert : \
- centaur/esim/esim-sexpr-support.cert \
- std/ks/two-nats-measure.cert \
- std/lists/rev.cert \
- centaur/4v-sexpr/4v-logic.cert \
- centaur/4v-sexpr/sexpr-equivs.cert \
- centaur/misc/patterns.cert \
- centaur/esim/esim-sexpr-support-thms.cert \
- centaur/4v-sexpr/sexpr-advanced.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/esim-spec.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/esim-vcd.cert : acl2x = 0
-centaur/esim/esim-vcd.cert : no_pcert = 0
-
-centaur/esim/esim-vcd.cert : \
- centaur/esim/esim-vl.cert \
- centaur/esim/esim-paths.cert \
- centaur/misc/load-stobj.cert \
- centaur/vl/mlib/writer.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/util/string-alists.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/esim-vcd.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/esim-vl.cert : acl2x = 0
-centaur/esim/esim-vl.cert : no_pcert = 0
-
-centaur/esim/esim-vl.cert : \
- centaur/esim/esim-sexpr-support.cert \
- centaur/vl/toe/toe-wirealist.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/esim-vl.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/follow-backwards.cert : acl2x = 0
-centaur/esim/follow-backwards.cert : no_pcert = 0
-
-centaur/esim/follow-backwards.cert : \
- centaur/esim/esim-paths.cert \
- centaur/esim/esim-sexpr-support-thms.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/follow-backwards.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/local-theory.cert : acl2x = 0
-centaur/esim/local-theory.cert : no_pcert = 0
-
-centaur/esim/local-theory.cert : \
- std/lists/rev.cert \
- data-structures/list-defthms.cert \
- data-structures/no-duplicates.cert \
- centaur/misc/fast-alists.cert \
- centaur/misc/equal-sets.cert \
- arithmetic/top-with-meta.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/local-theory.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/plist.cert : acl2x = 0
-centaur/esim/plist.cert : no_pcert = 0
-
-centaur/esim/plist.cert : \
- centaur/esim/portcullis.cert \
- centaur/esim/plist.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/portcullis.cert : acl2x = 0
-centaur/esim/portcullis.cert : no_pcert = 0
-
-centaur/esim/portcullis.cert : \
- cutil/portcullis.cert \
- str/portcullis.cert \
- centaur/vl/portcullis.cert \
- centaur/gl/portcullis.cert \
- centaur/esim/portcullis.lisp \
- centaur/esim/portcullis.acl2 \
- centaur/esim/packages.lsp \
- tools/flag-package.lsp
-
-
-centaur/esim/steps.cert : acl2x = 0
-centaur/esim/steps.cert : no_pcert = 0
-
-centaur/esim/steps.cert : \
- centaur/esim/esim-sexpr.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/steps.lisp \
- centaur/esim/cert.acl2
-
-
-centaur/esim/stv/stv-compile.cert : acl2x = 0
-centaur/esim/stv/stv-compile.cert : no_pcert = 0
-
-centaur/esim/stv/stv-compile.cert : \
- centaur/esim/stv/stv-util.cert \
- centaur/esim/esim-sexpr-support.cert \
- centaur/esim/follow-backwards.cert \
- centaur/misc/vecs-ints.cert \
- centaur/misc/tuplep.cert \
- cutil/defmvtypes.cert \
- cutil/defprojection.cert \
- str/natstr.cert \
- std/lists/final-cdr.cert \
- centaur/vl/util/defs.cert \
- centaur/esim/esim-sexpr-support-thms.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/stv/stv-compile.lisp \
- centaur/esim/stv/cert.acl2
-
-
-centaur/esim/stv/stv-debug.cert : acl2x = 0
-centaur/esim/stv/stv-debug.cert : no_pcert = 0
-
-centaur/esim/stv/stv-debug.cert : \
- centaur/esim/stv/stv-run.cert \
- centaur/esim/stv/stv-sim.cert \
- oslib/date.cert \
- centaur/misc/tshell.cert \
- centaur/esim/esim-vcd.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/stv/stv-debug.lisp \
- centaur/esim/stv/cert.acl2
-
-
-centaur/esim/stv/stv-doc.cert : acl2x = 0
-centaur/esim/stv/stv-doc.cert : no_pcert = 0
-
-centaur/esim/stv/stv-doc.cert : \
- centaur/esim/stv/stv-util.cert \
- centaur/esim/stv/stv-widen.cert \
- str/stringify.cert \
- centaur/vl/util/print-htmlencode.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/stv/stv-doc.lisp \
- centaur/esim/stv/cert.acl2
-
-
-centaur/esim/stv/stv-expand.cert : acl2x = 0
-centaur/esim/stv/stv-expand.cert : no_pcert = 0
-
-centaur/esim/stv/stv-expand.cert : \
- centaur/esim/stv/stv-util.cert \
- centaur/esim/esim-vl.cert \
- centaur/esim/esim-paths.cert \
- centaur/vl/mlib/hid-tools.cert \
- centaur/vl/mlib/expr-parse.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/stv/stv-expand.lisp \
- centaur/esim/stv/cert.acl2
-
-
-centaur/esim/stv/stv-run.cert : acl2x = 0
-centaur/esim/stv/stv-run.cert : no_pcert = 0
-
-centaur/esim/stv/stv-run.cert : \
- centaur/esim/stv/stv-util.cert \
- str/hexify.cert \
- centaur/misc/vecs-ints.cert \
- centaur/vl/util/defs.cert \
- centaur/4v-sexpr/bitspecs.cert \
- centaur/4v-sexpr/sexpr-rewrites.cert \
- centaur/gl/gl-util.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/stv/stv-run.lisp \
- centaur/esim/stv/cert.acl2
-
-
-centaur/esim/stv/stv-sim.cert : acl2x = 0
-centaur/esim/stv/stv-sim.cert : no_pcert = 0
-
-centaur/esim/stv/stv-sim.cert : \
- centaur/esim/stv/stv-util.cert \
- centaur/vl/util/defs.cert \
- centaur/esim/steps.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/stv/stv-sim.lisp \
- centaur/esim/stv/cert.acl2
-
-
-centaur/esim/stv/stv-top.cert : acl2x = 0
-centaur/esim/stv/stv-top.cert : no_pcert = 0
-
-centaur/esim/stv/stv-top.cert : \
- centaur/esim/stv/stv-sim.cert \
- centaur/esim/stv/stv-compile.cert \
- centaur/esim/stv/stv-expand.cert \
- centaur/esim/stv/stv-widen.cert \
- centaur/esim/stv/stv-doc.cert \
- centaur/esim/stv/stv-run.cert \
- centaur/gl/auto-bindings.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/stv/stv-top.lisp \
- centaur/esim/stv/cert.acl2
-
-
-centaur/esim/stv/stv-util.cert : acl2x = 0
-centaur/esim/stv/stv-util.cert : no_pcert = 0
-
-centaur/esim/stv/stv-util.cert : \
- centaur/esim/esim-sexpr-support.cert \
- cutil/defaggregate.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/stv/stv-util.lisp \
- centaur/esim/stv/cert.acl2
-
-
-centaur/esim/stv/stv-widen.cert : acl2x = 0
-centaur/esim/stv/stv-widen.cert : no_pcert = 0
-
-centaur/esim/stv/stv-widen.cert : \
- centaur/esim/stv/stv-util.cert \
- std/lists/repeat.cert \
- std/lists/take.cert \
- centaur/esim/portcullis.cert \
- centaur/esim/stv/stv-widen.lisp \
- centaur/esim/stv/cert.acl2
-
-
-centaur/gl/always-equal-prep.cert : acl2x = 0
-centaur/gl/always-equal-prep.cert : no_pcert = 0
-
-centaur/gl/always-equal-prep.cert : \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/hyp-fix-logic.cert \
- centaur/gl/g-if.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/eval-g-base.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/always-equal-prep.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/auto-bindings.cert : acl2x = 0
-centaur/gl/auto-bindings.cert : no_pcert = 0
-
-centaur/gl/auto-bindings.cert : \
- centaur/gl/gl-doc-string.cert \
- centaur/gl/gobject-types.cert \
- centaur/misc/numlist.cert \
- tools/bstar.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/auto-bindings.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/bfr-aig-bddify.cert : acl2x = 0
-centaur/gl/bfr-aig-bddify.cert : no_pcert = 0
-
-centaur/gl/bfr-aig-bddify.cert : \
- centaur/gl/bfr-sat.cert \
- centaur/gl/gl-doc-string.cert \
- centaur/aig/bddify-correct.cert \
- centaur/aig/eval-restrict.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/bfr-aig-bddify.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/bfr-sat.cert : acl2x = 0
-centaur/gl/bfr-sat.cert : no_pcert = 0
-
-centaur/gl/bfr-sat.cert : \
- centaur/gl/bfr.cert \
- centaur/gl/gl-doc-string.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/bfr-sat.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/bfr.cert : acl2x = 0
-centaur/gl/bfr.cert : no_pcert = 0
-
-centaur/gl/bfr.cert : \
- centaur/ubdds/lite.cert \
- centaur/aig/witness.cert \
- clause-processors/term-patterns.cert \
- clause-processors/join-thms.cert \
- tools/flag.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/bfr.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/bvec-ite.cert : acl2x = 0
-centaur/gl/bvec-ite.cert : no_pcert = 0
-
-centaur/gl/bvec-ite.cert : \
- centaur/gl/bvecs.cert \
- tools/bstar.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/bvec-ite.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/bvecs.cert : acl2x = 0
-centaur/gl/bvecs.cert : no_pcert = 0
-
-centaur/gl/bvecs.cert : \
- centaur/gl/bfr.cert \
- ihs/quotient-remainder-lemmas.cert \
- ihs/math-lemmas.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/bvecs.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/def-gl-clause-proc.cert : acl2x = 0
-centaur/gl/def-gl-clause-proc.cert : no_pcert = 0
-
-centaur/gl/def-gl-clause-proc.cert : \
- parallel/without-waterfall-parallelism.cert \
- centaur/misc/defapply.cert \
- centaur/gl/gify.cert \
- centaur/gl/gify-thms.cert \
- centaur/gl/run-gified-cp.cert \
- centaur/gl/general-object-thms.cert \
- centaur/gl/glcp-templates.cert \
- centaur/gl/gl-doc-string.cert \
- centaur/gl/generic-geval.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/def-gl-clause-proc.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/defagg.cert : acl2x = 0
-centaur/gl/defagg.cert : no_pcert = 0
-
-centaur/gl/defagg.cert : \
- cutil/defaggregate.cert \
- tools/flag.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/defagg.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/defapply.cert : acl2x = 0
-centaur/gl/defapply.cert : no_pcert = 0
-
-centaur/gl/defapply.cert : \
- clause-processors/generalize.cert \
- tools/mv-nth.cert \
- tools/rulesets.cert \
- centaur/gl/gl-util.cert \
- misc/hons-help2.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/defapply.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/eval-f-i-cp.cert : acl2x = 0
-centaur/gl/eval-f-i-cp.cert : no_pcert = 0
-
-centaur/gl/eval-f-i-cp.cert : \
- centaur/gl/gl-util.cert \
- tools/bstar.cert \
- tools/mv-nth.cert \
- misc/hons-help2.cert \
- clause-processors/join-thms.cert \
- centaur/misc/hons-sets.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/eval-f-i-cp.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/eval-g-base-help.cert : acl2x = 0
-centaur/gl/eval-g-base-help.cert : no_pcert = 0
-
-centaur/gl/eval-g-base-help.cert : \
- centaur/gl/eval-g-base.cert \
- centaur/gl/gify-clause-proc.cert \
- centaur/gl/general-object-thms.cert \
- tools/def-functional-instance.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/eval-g-base-help.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/eval-g-base.cert : acl2x = 0
-centaur/gl/eval-g-base.cert : no_pcert = 0
-
-centaur/gl/eval-g-base.cert : \
- centaur/gl/defapply.cert \
- centaur/gl/generic-geval.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/eval-g-base.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/factor-fns.cert : acl2x = 0
-centaur/gl/factor-fns.cert : no_pcert = 0
-
-centaur/gl/factor-fns.cert : \
- tools/bstar.cert \
- centaur/gl/rws.cert \
- clause-processors/generalize.cert \
- misc/hons-help.cert \
- centaur/gl/gl-util.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/factor-fns.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-always-equal.cert : acl2x = 0
-centaur/gl/g-always-equal.cert : no_pcert = 0
-
-centaur/gl/g-always-equal.cert : \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/g-if.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/hyp-fix-logic.cert \
- centaur/gl/always-equal-prep.cert \
- centaur/gl/g-equal.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-always-equal.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-ash.cert : acl2x = 0
-centaur/gl/g-ash.cert : no_pcert = 0
-
-centaur/gl/g-ash.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-ash.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-binary-+.cert : acl2x = 0
-centaur/gl/g-binary-+.cert : no_pcert = 0
-
-centaur/gl/g-binary-+.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-binary-+.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-binary-mult.cert : acl2x = 0
-centaur/gl/g-binary-mult.cert : no_pcert = 0
-
-centaur/gl/g-binary-mult.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-binary-mult.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-code-char.cert : acl2x = 0
-centaur/gl/g-code-char.cert : no_pcert = 0
-
-centaur/gl/g-code-char.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- centaur/gl/g-lessthan.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-code-char.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-coerce.cert : acl2x = 0
-centaur/gl/g-coerce.cert : no_pcert = 0
-
-centaur/gl/g-coerce.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-coerce.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-cons.cert : acl2x = 0
-centaur/gl/g-cons.cert : no_pcert = 0
-
-centaur/gl/g-cons.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/hyp-fix-logic.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-cons.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-equal.cert : acl2x = 0
-centaur/gl/g-equal.cert : no_pcert = 0
-
-centaur/gl/g-equal.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-equal.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-floor.cert : acl2x = 0
-centaur/gl/g-floor.cert : no_pcert = 0
-
-centaur/gl/g-floor.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-floor.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-gl-mbe.cert : acl2x = 0
-centaur/gl/g-gl-mbe.cert : no_pcert = 0
-
-centaur/gl/g-gl-mbe.cert : \
- centaur/gl/bfr-sat.cert \
- centaur/gl/g-always-equal.cert \
- centaur/gl/gl-mbe.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-gl-mbe.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-hide.cert : acl2x = 0
-centaur/gl/g-hide.cert : no_pcert = 0
-
-centaur/gl/g-hide.cert : \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/gobjectp-thms.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-hide.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-if.cert : acl2x = 0
-centaur/gl/g-if.cert : no_pcert = 0
-
-centaur/gl/g-if.cert : \
- centaur/gl/ite-merge.cert \
- centaur/gl/gtests.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-if.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-integer-length.cert : acl2x = 0
-centaur/gl/g-integer-length.cert : no_pcert = 0
-
-centaur/gl/g-integer-length.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-integer-length.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-intern.cert : acl2x = 0
-centaur/gl/g-intern.cert : no_pcert = 0
-
-centaur/gl/g-intern.cert : \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/g-if.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-intern.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-lessthan.cert : acl2x = 0
-centaur/gl/g-lessthan.cert : no_pcert = 0
-
-centaur/gl/g-lessthan.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-lessthan.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-logand.cert : acl2x = 0
-centaur/gl/g-logand.cert : no_pcert = 0
-
-centaur/gl/g-logand.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-logand.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-logbitp.cert : acl2x = 0
-centaur/gl/g-logbitp.cert : no_pcert = 0
-
-centaur/gl/g-logbitp.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-logbitp.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-logior.cert : acl2x = 0
-centaur/gl/g-logior.cert : no_pcert = 0
-
-centaur/gl/g-logior.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-logior.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-lognot.cert : acl2x = 0
-centaur/gl/g-lognot.cert : no_pcert = 0
-
-centaur/gl/g-lognot.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-lognot.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-make-fast-alist.cert : acl2x = 0
-centaur/gl/g-make-fast-alist.cert : no_pcert = 0
-
-centaur/gl/g-make-fast-alist.cert : \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/g-if.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-make-fast-alist.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-mod.cert : acl2x = 0
-centaur/gl/g-mod.cert : no_pcert = 0
-
-centaur/gl/g-mod.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-mod.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-predicates.cert : acl2x = 0
-centaur/gl/g-predicates.cert : no_pcert = 0
-
-centaur/gl/g-predicates.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-predicates.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-primitives-help.cert : acl2x = 0
-centaur/gl/g-primitives-help.cert : no_pcert = 0
-
-centaur/gl/g-primitives-help.cert : \
- tools/flag.cert \
- centaur/gl/gl-util.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-primitives-help.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-rem.cert : acl2x = 0
-centaur/gl/g-rem.cert : no_pcert = 0
-
-centaur/gl/g-rem.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-rem.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-truncate.cert : acl2x = 0
-centaur/gl/g-truncate.cert : no_pcert = 0
-
-centaur/gl/g-truncate.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-truncate.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-unary--.cert : acl2x = 0
-centaur/gl/g-unary--.cert : no_pcert = 0
-
-centaur/gl/g-unary--.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-unary--.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/g-unary-concrete.cert : acl2x = 0
-centaur/gl/g-unary-concrete.cert : no_pcert = 0
-
-centaur/gl/g-unary-concrete.cert : \
- centaur/gl/g-if.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/symbolic-arithmetic-fns.cert \
- centaur/gl/eval-g-base.cert \
- centaur/gl/symbolic-arithmetic.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/hyp-fix-logic.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/g-unary-concrete.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/general-object-thms.cert : acl2x = 0
-centaur/gl/general-object-thms.cert : no_pcert = 0
-
-centaur/gl/general-object-thms.cert : \
- centaur/gl/gtype-thms.cert \
- centaur/gl/general-objects.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/general-object-thms.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/general-objects.cert : acl2x = 0
-centaur/gl/general-objects.cert : no_pcert = 0
-
-centaur/gl/general-objects.cert : \
- centaur/gl/gtypes.cert \
- centaur/gl/gobjectp-thms.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/general-objects.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/generic-geval.cert : acl2x = 0
-centaur/gl/generic-geval.cert : no_pcert = 0
-
-centaur/gl/generic-geval.cert : \
- centaur/gl/gobjectp.cert \
- centaur/gl/bvecs.cert \
- tools/bstar.cert \
- centaur/gl/gobjectp-thms.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/generic-geval.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gify-clause-proc.cert : acl2x = 0
-centaur/gl/gify-clause-proc.cert : no_pcert = 0
-
-centaur/gl/gify-clause-proc.cert : \
- centaur/gl/g-if.cert \
- clause-processors/unify-subst.cert \
- tools/def-functional-instance.cert \
- tools/defevaluator-fast.cert \
- centaur/gl/gtype-thms.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gify-clause-proc.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gify-thms.cert : acl2x = 0
-centaur/gl/gify-thms.cert : no_pcert = 0
-
-centaur/gl/gify-thms.cert : \
- centaur/gl/gify-clause-proc.cert \
- centaur/gl/gtype-thms.cert \
- centaur/gl/gobjectp-thms.cert \
- centaur/gl/general-object-thms.cert \
- centaur/gl/hyp-fix-logic.cert \
- std/ks/two-nats-measure.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gify-thms.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gify.cert : acl2x = 0
-centaur/gl/gify.cert : no_pcert = 0
-
-centaur/gl/gify.cert : \
- tools/bstar.cert \
- centaur/gl/defapply.cert \
- misc/hons-help.cert \
- centaur/gl/factor-fns.cert \
- centaur/gl/g-primitives-help.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gify.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gl-doc-string.cert : acl2x = 0
-centaur/gl/gl-doc-string.cert : no_pcert = 0
-
-centaur/gl/gl-doc-string.cert : \
- centaur/gl/portcullis.cert \
- centaur/gl/gl-doc-string.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gl-generic-clause-proc.cert : acl2x = 0
-centaur/gl/gl-generic-clause-proc.cert : no_pcert = 0
-
-centaur/gl/gl-generic-clause-proc.cert : \
- centaur/gl/param.cert \
- centaur/gl/g-if.cert \
- centaur/gl/gify.cert \
- centaur/gl/bfr-sat.cert \
- centaur/gl/glcp-templates.cert \
- misc/untranslate-patterns.cert \
- data-structures/no-duplicates.cert \
- clause-processors/use-by-hint.cert \
- clause-processors/decomp-hint.cert \
- centaur/misc/interp-function-lookup.cert \
- centaur/gl/general-object-thms.cert \
- centaur/misc/hons-sets.cert \
- tools/with-quoted-forms.cert \
- centaur/gl/hyp-fix-logic.cert \
- system/f-put-global.cert \
- tools/def-functional-instance.cert \
- centaur/misc/vecs-ints.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gl-generic-clause-proc.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gl-mbe.cert : acl2x = 0
-centaur/gl/gl-mbe.cert : no_pcert = 0
-
-centaur/gl/gl-mbe.cert : \
- centaur/gl/gl-doc-string.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gl-mbe.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gl-misc-defs.cert : acl2x = 0
-centaur/gl/gl-misc-defs.cert : no_pcert = 0
-
-centaur/gl/gl-misc-defs.cert : \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- std/ks/two-nats-measure.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gl-misc-defs.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gl-misc-doc.cert : acl2x = 0
-centaur/gl/gl-misc-doc.cert : no_pcert = 0
-
-centaur/gl/gl-misc-doc.cert : \
- centaur/gl/gl-doc-string.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gl-misc-doc.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gl-util.cert : acl2x = 0
-centaur/gl/gl-util.cert : no_pcert = 0
-
-centaur/gl/gl-util.cert : \
- tools/flag.cert \
- tools/bstar.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gl-util.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gl.cert : acl2x = 0
-centaur/gl/gl.cert : no_pcert = 0
-
-centaur/gl/gl.cert : \
- centaur/gl/g-ash.cert \
- centaur/gl/g-binary-+.cert \
- centaur/gl/g-cons.cert \
- centaur/gl/g-equal.cert \
- centaur/gl/g-always-equal.cert \
- centaur/gl/g-integer-length.cert \
- centaur/gl/g-lessthan.cert \
- centaur/gl/g-logand.cert \
- centaur/gl/g-logior.cert \
- centaur/gl/g-lognot.cert \
- centaur/gl/g-logbitp.cert \
- centaur/gl/g-unary--.cert \
- centaur/gl/g-hide.cert \
- centaur/gl/g-predicates.cert \
- centaur/gl/g-binary-mult.cert \
- centaur/gl/g-floor.cert \
- centaur/gl/g-make-fast-alist.cert \
- centaur/gl/g-mod.cert \
- centaur/gl/g-truncate.cert \
- centaur/gl/g-rem.cert \
- centaur/gl/g-unary-concrete.cert \
- centaur/gl/g-coerce.cert \
- centaur/gl/g-code-char.cert \
- centaur/gl/g-intern.cert \
- centaur/gl/gl-misc-defs.cert \
- centaur/gl/eval-f-i-cp.cert \
- centaur/gl/gl-generic-clause-proc.cert \
- centaur/gl/def-gl-clause-proc.cert \
- centaur/gl/gify-thms.cert \
- centaur/gl/gl-misc-doc.cert \
- centaur/gl/auto-bindings.cert \
- centaur/gl/g-gl-mbe.cert \
- centaur/gl/general-object-thms.cert \
- centaur/gl/eval-g-base-help.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gl.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/glcp-templates.cert : acl2x = 0
-centaur/gl/glcp-templates.cert : no_pcert = 0
-
-centaur/gl/glcp-templates.cert : \
- tools/flag.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/glcp-templates.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gobject-type-thms.cert : acl2x = 0
-centaur/gl/gobject-type-thms.cert : no_pcert = 0
-
-centaur/gl/gobject-type-thms.cert : \
- centaur/gl/defagg.cert \
- tools/pattern-match.cert \
- misc/untranslate-patterns.cert \
- tools/rulesets.cert \
- centaur/gl/gobject-types.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gobject-type-thms.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gobject-types.cert : acl2x = 0
-centaur/gl/gobject-types.cert : no_pcert = 0
-
-centaur/gl/gobject-types.cert : \
- centaur/gl/defagg.cert \
- tools/pattern-match.cert \
- misc/untranslate-patterns.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gobject-types.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gobjectp-thms.cert : acl2x = 0
-centaur/gl/gobjectp-thms.cert : no_pcert = 0
-
-centaur/gl/gobjectp-thms.cert : \
- centaur/gl/gobjectp.cert \
- centaur/gl/gobject-type-thms.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gobjectp-thms.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gobjectp.cert : acl2x = 0
-centaur/gl/gobjectp.cert : no_pcert = 0
-
-centaur/gl/gobjectp.cert : \
- centaur/gl/bfr.cert \
- centaur/gl/defagg.cert \
- tools/pattern-match.cert \
- centaur/gl/bvecs.cert \
- centaur/gl/gobject-types.cert \
- centaur/gl/gobject-type-thms.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gobjectp.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gtests.cert : acl2x = 0
-centaur/gl/gtests.cert : no_pcert = 0
-
-centaur/gl/gtests.cert : \
- centaur/gl/hyp-fix.cert \
- centaur/gl/gtypes.cert \
- centaur/gl/gtype-thms.cert \
- centaur/gl/hyp-fix-logic.cert \
- tools/mv-nth.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gtests.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gtype-thms.cert : acl2x = 0
-centaur/gl/gtype-thms.cert : no_pcert = 0
-
-centaur/gl/gtype-thms.cert : \
- centaur/gl/gtypes.cert \
- centaur/gl/gobjectp-thms.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gtype-thms.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/gtypes.cert : acl2x = 0
-centaur/gl/gtypes.cert : no_pcert = 0
-
-centaur/gl/gtypes.cert : \
- centaur/gl/gobjectp.cert \
- centaur/gl/generic-geval.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/gtypes.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/hyp-fix-logic.cert : acl2x = 0
-centaur/gl/hyp-fix-logic.cert : no_pcert = 0
-
-centaur/gl/hyp-fix-logic.cert : \
- centaur/gl/hyp-fix.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/hyp-fix-logic.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/hyp-fix.cert : acl2x = 0
-centaur/gl/hyp-fix.cert : no_pcert = 0
-
-centaur/gl/hyp-fix.cert : \
- centaur/gl/bfr.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/hyp-fix.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/ite-merge.cert : acl2x = 0
-centaur/gl/ite-merge.cert : no_pcert = 0
-
-centaur/gl/ite-merge.cert : \
- centaur/gl/general-objects.cert \
- centaur/gl/general-object-thms.cert \
- centaur/gl/hyp-fix-logic.cert \
- centaur/gl/bvec-ite.cert \
- centaur/gl/hyp-fix.cert \
- std/ks/two-nats-measure.cert \
- tools/mv-nth.cert \
- misc/invariants.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/ite-merge.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/param.cert : acl2x = 0
-centaur/gl/param.cert : no_pcert = 0
-
-centaur/gl/param.cert : \
- centaur/gl/shape-spec.cert \
- centaur/gl/gtype-thms.cert \
- data-structures/no-duplicates.cert \
- tools/mv-nth.cert \
- ihs/ihs-lemmas.cert \
- centaur/ubdds/param.cert \
- centaur/ubdds/lite.cert \
- centaur/aig/misc.cert \
- centaur/aig/eval-restrict.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/param.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/portcullis.cert : acl2x = 0
-centaur/gl/portcullis.cert : no_pcert = 0
-
-centaur/gl/portcullis.cert : \
- cutil/portcullis.cert \
- centaur/gl/portcullis.lisp \
- centaur/gl/portcullis.acl2 \
- centaur/gl/package.lsp \
- centaur/vl/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- centaur/aignet/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- tools/flag-package.lsp \
- centaur/satlink/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- tools/flag-package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- tools/flag-package.lsp
-
-
-centaur/gl/run-gified-cp.cert : acl2x = 0
-centaur/gl/run-gified-cp.cert : no_pcert = 0
-
-centaur/gl/run-gified-cp.cert : \
- centaur/gl/bfr.cert \
- centaur/gl/gobjectp.cert \
- tools/mv-nth.cert \
- tools/bstar.cert \
- tools/defevaluator-fast.cert \
- clause-processors/unify-subst.cert \
- centaur/misc/evaluator-metatheorems.cert \
- centaur/misc/interp-function-lookup.cert \
- centaur/ubdds/witness.cert \
- std/lists/take.cert \
- centaur/gl/gobjectp-thms.cert \
- tools/def-functional-instance.cert \
- centaur/gl/gl-util.cert \
- arithmetic/top-with-meta.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/run-gified-cp.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/rws.cert : acl2x = 0
-centaur/gl/rws.cert : no_pcert = 0
-
-centaur/gl/rws.cert : \
- clause-processors/use-by-hint.cert \
- clause-processors/multi-env-trick.cert \
- tools/bstar.cert \
- tools/mv-nth.cert \
- tools/flag.cert \
- tools/rulesets.cert \
- centaur/misc/equal-sets.cert \
- centaur/misc/alist-equiv.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/rws.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/shape-spec.cert : acl2x = 0
-centaur/gl/shape-spec.cert : no_pcert = 0
-
-centaur/gl/shape-spec.cert : \
- centaur/gl/gtypes.cert \
- centaur/gl/gl-doc-string.cert \
- centaur/gl/gtype-thms.cert \
- data-structures/no-duplicates.cert \
- tools/mv-nth.cert \
- ihs/ihs-lemmas.cert \
- centaur/misc/fast-alists.cert \
- ihs/ihs-lemmas.cert \
- ihs/ihs-lemmas.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/shape-spec.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/symbolic-arithmetic-fns.cert : acl2x = 0
-centaur/gl/symbolic-arithmetic-fns.cert : no_pcert = 0
-
-centaur/gl/symbolic-arithmetic-fns.cert : \
- centaur/gl/bvec-ite.cert \
- tools/mv-nth.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/symbolic-arithmetic-fns.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/gl/symbolic-arithmetic.cert : acl2x = 0
-centaur/gl/symbolic-arithmetic.cert : no_pcert = 0
-
-centaur/gl/symbolic-arithmetic.cert : \
- centaur/gl/symbolic-arithmetic-fns.cert \
- arithmetic/top-with-meta.cert \
- ihs/logops-lemmas.cert \
- ihs/quotient-remainder-lemmas.cert \
- centaur/gl/portcullis.cert \
- centaur/gl/symbolic-arithmetic.lisp \
- centaur/gl/cert.acl2
-
-
-centaur/misc/absstobjs.cert : acl2x = 0
-centaur/misc/absstobjs.cert : no_pcert = 0
-
-centaur/misc/absstobjs.cert : \
- tools/bstar.cert \
- centaur/misc/absstobjs.lisp
-
-
-centaur/misc/alist-defs.cert : acl2x = 0
-centaur/misc/alist-defs.cert : no_pcert = 0
-
-centaur/misc/alist-defs.cert : \
- misc/hons-help.cert \
- centaur/misc/hons-extra.cert \
- centaur/misc/alist-defs.lisp
-
-
-centaur/misc/alist-equiv.cert : acl2x = 0
-centaur/misc/alist-equiv.cert : no_pcert = 0
-
-centaur/misc/alist-equiv.cert : \
- misc/hons-help2.cert \
- cutil/defsection.cert \
- centaur/misc/alist-defs.cert \
- std/lists/sets.cert \
- centaur/misc/alist-equiv.lisp
-
-
-centaur/misc/alist-witness.cert : acl2x = 0
-centaur/misc/alist-witness.cert : no_pcert = 0
-
-centaur/misc/alist-witness.cert : \
- centaur/misc/alist-equiv.cert \
- centaur/misc/witness-cp.cert \
- centaur/misc/alist-witness.lisp
-
-
-centaur/misc/ap.cert : acl2x = 0
-centaur/misc/ap.cert : no_pcert = 0
-
-centaur/misc/ap.cert : \
- centaur/misc/ap.lisp
-
-
-centaur/misc/arith-equivs.cert : acl2x = 0
-centaur/misc/arith-equivs.cert : no_pcert = 0
-
-centaur/misc/arith-equivs.cert : \
- ihs/basic-definitions.cert \
- tools/rulesets.cert \
- std/lists/mfc-utils.cert \
- centaur/misc/arith-equivs.lisp
-
-
-centaur/misc/context-rw.cert : acl2x = 0
-centaur/misc/context-rw.cert : no_pcert = 0
-
-centaur/misc/context-rw.cert : \
- clause-processors/unify-subst.cert \
- centaur/misc/alist-witness.cert \
- clause-processors/meta-extract-user.cert \
- centaur/misc/equal-sets.cert \
- clause-processors/sublis-var-meaning.cert \
- xdoc/top.cert \
- finite-set-theory/osets/portcullis.cert \
- centaur/misc/context-rw.lisp \
- centaur/misc/context-rw.acl2
-
-
-centaur/misc/defapply.cert : acl2x = 0
-centaur/misc/defapply.cert : no_pcert = 0
-
-centaur/misc/defapply.cert : \
- tools/bstar.cert \
- clause-processors/generalize.cert \
- tools/rulesets.cert \
- clause-processors/use-by-hint.cert \
- misc/untranslate-patterns.cert \
- tools/defevaluator-fast.cert \
- tools/mv-nth.cert \
- centaur/misc/evaluator-metatheorems.cert \
- centaur/misc/interp-function-lookup.cert \
- tools/def-functional-instance.cert \
- tools/with-quoted-forms.cert \
- centaur/misc/defapply.lisp
-
-
-centaur/misc/dfs-measure.cert : acl2x = 0
-centaur/misc/dfs-measure.cert : no_pcert = 0
-
-centaur/misc/dfs-measure.cert : \
- centaur/misc/suffixp.cert \
- tools/rulesets.cert \
- std/ks/two-nats-measure.cert \
- misc/hons-help.cert \
- tools/bstar.cert \
- centaur/misc/dfs-measure.lisp
-
-
-centaur/misc/equal-by-nths.cert : acl2x = 0
-centaur/misc/equal-by-nths.cert : no_pcert = 0
-
-centaur/misc/equal-by-nths.cert : \
- centaur/misc/equal-by-nths.lisp
-
-
-centaur/misc/equal-sets.cert : acl2x = 0
-centaur/misc/equal-sets.cert : no_pcert = 0
-
-centaur/misc/equal-sets.cert : \
- finite-set-theory/osets/sets.cert \
- std/lists/sets.cert \
- centaur/misc/witness-cp.cert \
- centaur/misc/equal-sets.lisp \
- centaur/misc/equal-sets.acl2 \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-
-
-centaur/misc/evaluator-metatheorems.cert : acl2x = 0
-centaur/misc/evaluator-metatheorems.cert : no_pcert = 0
-
-centaur/misc/evaluator-metatheorems.cert : \
- tools/bstar.cert \
- tools/mv-nth.cert \
- clause-processors/use-by-hint.cert \
- tools/rulesets.cert \
- clause-processors/ev-theoremp.cert \
- centaur/misc/evaluator-metatheorems.lisp
-
-
-centaur/misc/fal-graphs.cert : acl2x = 0
-centaur/misc/fal-graphs.cert : no_pcert = 0
-
-centaur/misc/fal-graphs.cert : \
- tools/bstar.cert \
- centaur/misc/fal-graphs.lisp
-
-
-centaur/misc/fast-alists.cert : acl2x = 0
-centaur/misc/fast-alists.cert : no_pcert = 0
-
-centaur/misc/fast-alists.cert : \
- centaur/misc/alist-witness.cert \
- centaur/misc/equal-sets.cert \
- centaur/misc/universal-equiv.cert \
- centaur/misc/fast-alists.lisp
-
-
-centaur/misc/filter-alist.cert : acl2x = 0
-centaur/misc/filter-alist.cert : no_pcert = 0
-
-centaur/misc/filter-alist.cert : \
- centaur/misc/fast-alists.cert \
- std/lists/rev.cert \
- centaur/misc/filter-alist.lisp
-
-
-centaur/misc/hons-alphorder-merge.cert : acl2x = 0
-centaur/misc/hons-alphorder-merge.cert : no_pcert = 0
-
-centaur/misc/hons-alphorder-merge.cert : \
- misc/total-order.cert \
- centaur/misc/equal-sets.cert \
- finite-set-theory/osets/portcullis.cert \
- centaur/misc/hons-alphorder-merge.lisp \
- centaur/misc/hons-alphorder-merge.acl2
-
-
-centaur/misc/hons-extra.cert : acl2x = 0
-centaur/misc/hons-extra.cert : no_pcert = 0
-
-centaur/misc/hons-extra.cert : \
- tools/bstar.cert \
- centaur/misc/hons-extra.lisp
-
-
-centaur/misc/hons-remove-dups.cert : acl2x = 0
-centaur/misc/hons-remove-dups.cert : no_pcert = 0
-
-centaur/misc/hons-remove-dups.cert : \
- std/lists/rev.cert \
- centaur/misc/alist-equiv.cert \
- centaur/misc/hons-remove-dups.lisp
-
-
-centaur/misc/hons-sets.cert : acl2x = 0
-centaur/misc/hons-sets.cert : no_pcert = 0
-
-centaur/misc/hons-sets.cert : \
- misc/hons-help2.cert \
- centaur/misc/equal-sets.cert \
- centaur/misc/alist-defs.cert \
- centaur/misc/hons-sets.lisp
-
-
-centaur/misc/interp-function-lookup.cert : acl2x = 0
-centaur/misc/interp-function-lookup.cert : no_pcert = 0
-
-centaur/misc/interp-function-lookup.cert : \
- centaur/misc/hons-sets.cert \
- tools/bstar.cert \
- tools/mv-nth.cert \
- clause-processors/use-by-hint.cert \
- tools/rulesets.cert \
- misc/untranslate-patterns.cert \
- clause-processors/ev-theoremp.cert \
- tools/def-functional-instance.cert \
- centaur/misc/interp-function-lookup.lisp
-
-
-centaur/misc/introduce-var.cert : acl2x = 0
-centaur/misc/introduce-var.cert : no_pcert = 0
-
-centaur/misc/introduce-var.cert : \
- clause-processors/generalize.cert \
- centaur/vl/util/namedb.cert \
- centaur/vl/portcullis.cert \
- centaur/misc/introduce-var.lisp \
- centaur/misc/introduce-var.acl2
-
-
-centaur/misc/lists.cert : acl2x = 0
-centaur/misc/lists.cert : no_pcert = 0
-
-centaur/misc/lists.cert : \
- centaur/misc/arith-equivs.cert \
- std/lists/equiv.cert \
- data-structures/list-defthms.cert \
- arithmetic/top-with-meta.cert \
- centaur/misc/lists.lisp
-
-
-centaur/misc/load-stobj-tests.cert : acl2x = 0
-centaur/misc/load-stobj-tests.cert : no_pcert = 0
-
-centaur/misc/load-stobj-tests.cert : \
- centaur/misc/load-stobj.cert \
- tools/defconsts.cert \
- misc/assert.cert \
- centaur/misc/load-stobj-tests.lisp
-
-
-centaur/misc/load-stobj.cert : acl2x = 0
-centaur/misc/load-stobj.cert : no_pcert = 0
-
-centaur/misc/load-stobj.cert : \
- std/lists/list-fix.cert \
- arithmetic/top.cert \
- data-structures/list-defthms.cert \
- centaur/misc/equal-by-nths.cert \
- tools/do-not.cert \
- centaur/misc/load-stobj.lisp
-
-
-centaur/misc/memory-mgmt-logic.cert : acl2x = 0
-centaur/misc/memory-mgmt-logic.cert : no_pcert = 0
-
-centaur/misc/memory-mgmt-logic.cert : \
- centaur/misc/memory-mgmt-logic.lisp
-
-
-centaur/misc/memory-mgmt-raw.cert : acl2x = 0
-centaur/misc/memory-mgmt-raw.cert : no_pcert = 0
-
-centaur/misc/memory-mgmt-raw.cert : \
- centaur/misc/memory-mgmt-logic.cert \
- tools/include-raw.cert \
- centaur/misc/memory-mgmt-raw.lisp \
- centaur/misc/hons-analyze-memory-raw.lsp
-
-
-centaur/misc/mfc-utils.cert : acl2x = 0
-centaur/misc/mfc-utils.cert : no_pcert = 0
-
-centaur/misc/mfc-utils.cert : \
- std/lists/mfc-utils.cert \
- centaur/misc/mfc-utils.lisp
-
-
-centaur/misc/nat-list-duplicates.cert : acl2x = 0
-centaur/misc/nat-list-duplicates.cert : no_pcert = 0
-
-centaur/misc/nat-list-duplicates.cert : \
- xdoc/top.cert \
- misc/hons-help.cert \
- tools/bstar.cert \
- arithmetic/nat-listp.cert \
- arithmetic/top-with-meta.cert \
- tools/mv-nth.cert \
- centaur/misc/alist-equiv.cert \
- centaur/misc/nat-list-duplicates.lisp
-
-
-centaur/misc/numlist.cert : acl2x = 0
-centaur/misc/numlist.cert : no_pcert = 0
-
-centaur/misc/numlist.cert : \
- centaur/misc/numlist.lisp
-
-
-centaur/misc/osets-witnessing.cert : acl2x = 0
-centaur/misc/osets-witnessing.cert : no_pcert = 0
-
-centaur/misc/osets-witnessing.cert : \
- finite-set-theory/osets/sets.cert \
- centaur/misc/witness-cp.cert \
- tools/rulesets.cert \
- finite-set-theory/osets/portcullis.cert \
- centaur/misc/osets-witnessing.lisp \
- centaur/misc/osets-witnessing.acl2
-
-
-centaur/misc/patterns.cert : acl2x = 0
-centaur/misc/patterns.cert : no_pcert = 0
-
-centaur/misc/patterns.cert : \
- centaur/misc/alist-equiv.cert \
- centaur/misc/fast-alists.cert \
- centaur/misc/patterns.lisp
-
-
-centaur/misc/seed-random.cert : acl2x = 0
-centaur/misc/seed-random.cert : no_pcert = 0
-
-centaur/misc/seed-random.cert : \
- tools/defconsts.cert \
- tools/bstar.cert \
- misc/assert.cert \
- centaur/misc/seed-random.lisp
-
-
-centaur/misc/smm-impl.cert : acl2x = 0
-centaur/misc/smm-impl.cert : no_pcert = 0
-
-centaur/misc/smm-impl.cert : \
- tools/bstar.cert \
- centaur/misc/u32-listp.cert \
- xdoc/base.cert \
- arithmetic/nat-listp.cert \
- arithmetic/top-with-meta.cert \
- centaur/misc/arith-equivs.cert \
- centaur/misc/absstobjs.cert \
- tools/mv-nth.cert \
- centaur/misc/lists.cert \
- misc/definline.cert \
- centaur/misc/smm-impl.lisp
-
-
-centaur/misc/smm.cert : acl2x = 0
-centaur/misc/smm.cert : no_pcert = 0
-
-centaur/misc/smm.cert : \
- centaur/misc/smm-impl.cert \
- tools/bstar.cert \
- xdoc/base.cert \
- misc/definline.cert \
- centaur/misc/arith-equivs.cert \
- centaur/misc/u32-listp.cert \
- centaur/misc/smm.lisp
-
-
-centaur/misc/sneaky-load.cert : acl2x = 0
-centaur/misc/sneaky-load.cert : no_pcert = 0
-
-centaur/misc/sneaky-load.cert : \
- tools/bstar.cert \
- centaur/misc/sneaky-load.lisp
-
-
-centaur/misc/suffixp.cert : acl2x = 0
-centaur/misc/suffixp.cert : no_pcert = 0
-
-centaur/misc/suffixp.cert : \
- centaur/misc/suffixp.lisp
-
-
-centaur/misc/tailrec.cert : acl2x = 0
-centaur/misc/tailrec.cert : no_pcert = 0
-
-centaur/misc/tailrec.cert : \
- tools/bstar.cert \
- tools/mv-nth.cert \
- clause-processors/use-by-hint.cert \
- clause-processors/generalize.cert \
- std/lists/take.cert \
- arithmetic/top.cert \
- centaur/misc/tailrec.lisp \
- centaur/misc/tailrec.acl2 \
- tools/flag-package.lsp
-
-
-centaur/misc/top.cert : acl2x = 0
-centaur/misc/top.cert : no_pcert = 0
-
-centaur/misc/top.cert : \
- centaur/misc/alist-defs.cert \
- centaur/misc/alist-equiv.cert \
- centaur/misc/ap.cert \
- centaur/misc/defapply.cert \
- centaur/misc/dfs-measure.cert \
- centaur/misc/equal-by-nths.cert \
- centaur/misc/equal-sets.cert \
- centaur/misc/evaluator-metatheorems.cert \
- centaur/misc/fal-graphs.cert \
- centaur/misc/fast-alists.cert \
- centaur/misc/filter-alist.cert \
- centaur/misc/hons-alphorder-merge.cert \
- centaur/misc/hons-extra.cert \
- centaur/misc/hons-remove-dups.cert \
- centaur/misc/hons-sets.cert \
- centaur/misc/interp-function-lookup.cert \
- centaur/misc/memory-mgmt-logic.cert \
- centaur/misc/memory-mgmt-raw.cert \
- centaur/misc/nat-list-duplicates.cert \
- centaur/misc/numlist.cert \
- centaur/misc/patterns.cert \
- centaur/misc/seed-random.cert \
- centaur/misc/sneaky-load.cert \
- centaur/misc/suffixp.cert \
- centaur/misc/tuplep.cert \
- centaur/misc/universal-equiv.cert \
- centaur/misc/vecs-ints.cert \
- centaur/misc/witness-cp.cert \
- centaur/misc/top.lisp
-
-
-centaur/misc/tshell.cert : acl2x = 0
-centaur/misc/tshell.cert : no_pcert = 0
-
-centaur/misc/tshell.cert : \
- tools/include-raw.cert \
- str/strprefixp.cert \
- centaur/misc/tshell.lisp \
- centaur/misc/tshell-raw.lsp
-
-
-centaur/misc/tuplep.cert : acl2x = 0
-centaur/misc/tuplep.cert : no_pcert = 0
-
-centaur/misc/tuplep.cert : \
- centaur/misc/tuplep.lisp
-
-
-centaur/misc/u32-listp.cert : acl2x = 0
-centaur/misc/u32-listp.cert : no_pcert = 0
-
-centaur/misc/u32-listp.cert : \
- centaur/misc/u32-listp.lisp
-
-
-centaur/misc/universal-equiv.cert : acl2x = 0
-centaur/misc/universal-equiv.cert : no_pcert = 0
-
-centaur/misc/universal-equiv.cert : \
- clause-processors/equality.cert \
- centaur/misc/universal-equiv.lisp
-
-
-centaur/misc/vecs-ints.cert : acl2x = 0
-centaur/misc/vecs-ints.cert : no_pcert = 0
-
-centaur/misc/vecs-ints.cert : \
- ihs/quotient-remainder-lemmas.cert \
- ihs/math-lemmas.cert \
- centaur/misc/vecs-ints.lisp
-
-
-centaur/misc/witness-cp.cert : acl2x = 0
-centaur/misc/witness-cp.cert : no_pcert = 0
-
-centaur/misc/witness-cp.cert : \
- clause-processors/witness-cp.cert \
- centaur/misc/witness-cp.lisp
-
-
-centaur/ubdds/core.cert : acl2x = 0
-centaur/ubdds/core.cert : no_pcert = 0
-
-centaur/ubdds/core.cert : \
- misc/definline.cert \
- centaur/misc/memory-mgmt-logic.cert \
- misc/computed-hint-rewrite.cert \
- tools/rulesets.cert \
- xdoc/top.cert \
- xdoc/portcullis.cert \
- centaur/ubdds/core.lisp \
- centaur/ubdds/cert.acl2
-
-
-centaur/ubdds/extra-operations.cert : acl2x = 0
-centaur/ubdds/extra-operations.cert : no_pcert = 0
-
-centaur/ubdds/extra-operations.cert : \
- centaur/ubdds/core.cert \
- xdoc/portcullis.cert \
- centaur/ubdds/extra-operations.lisp \
- centaur/ubdds/cert.acl2
-
-
-centaur/ubdds/lite.cert : acl2x = 0
-centaur/ubdds/lite.cert : no_pcert = 0
-
-centaur/ubdds/lite.cert : \
- centaur/ubdds/witness.cert \
- centaur/ubdds/subset.cert \
- misc/untranslate-patterns.cert \
- xdoc/portcullis.cert \
- centaur/ubdds/lite.lisp \
- centaur/ubdds/cert.acl2
-
-
-centaur/ubdds/param.cert : acl2x = 0
-centaur/ubdds/param.cert : no_pcert = 0
-
-centaur/ubdds/param.cert : \
- centaur/ubdds/extra-operations.cert \
- misc/hons-help2.cert \
- tools/rulesets.cert \
- std/lists/take.cert \
- arithmetic/top.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top.cert \
- arithmetic/top-with-meta.cert \
- xdoc/portcullis.cert \
- centaur/ubdds/param.lisp \
- centaur/ubdds/cert.acl2
-
-
-centaur/ubdds/sanity-check-macros.cert : acl2x = 0
-centaur/ubdds/sanity-check-macros.cert : no_pcert = 0
-
-centaur/ubdds/sanity-check-macros.cert : \
- centaur/ubdds/lite.cert \
- xdoc/portcullis.cert \
- centaur/ubdds/sanity-check-macros.lisp \
- centaur/ubdds/cert.acl2
-
-
-centaur/ubdds/subset.cert : acl2x = 0
-centaur/ubdds/subset.cert : no_pcert = 0
-
-centaur/ubdds/subset.cert : \
- centaur/ubdds/extra-operations.cert \
- xdoc/portcullis.cert \
- centaur/ubdds/subset.lisp \
- centaur/ubdds/cert.acl2
-
-
-centaur/ubdds/witness.cert : acl2x = 0
-centaur/ubdds/witness.cert : no_pcert = 0
-
-centaur/ubdds/witness.cert : \
- centaur/ubdds/extra-operations.cert \
- misc/hons-help2.cert \
- clause-processors/term-patterns.cert \
- clause-processors/use-by-hint.cert \
- tools/mv-nth.cert \
- clause-processors/generalize.cert \
- tools/flag.cert \
- centaur/ubdds/witness.lisp \
- centaur/ubdds/witness.acl2 \
- tools/flag-package.lsp
-
-
-centaur/vl/checkers/checkers.cert : acl2x = 0
-centaur/vl/checkers/checkers.cert : no_pcert = 0
-
-centaur/vl/checkers/checkers.cert : \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/checkers.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/condcheck.cert : acl2x = 0
-centaur/vl/checkers/condcheck.cert : no_pcert = 0
-
-centaur/vl/checkers/condcheck.cert : \
- centaur/vl/mlib/ctxexprs.cert \
- centaur/vl/checkers/duplicate-detect.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/condcheck.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/dupeinst-check.cert : acl2x = 0
-centaur/vl/checkers/dupeinst-check.cert : no_pcert = 0
-
-centaur/vl/checkers/dupeinst-check.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/checkers/duplicate-detect.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/dupeinst-check.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/duperhs.cert : acl2x = 0
-centaur/vl/checkers/duperhs.cert : no_pcert = 0
-
-centaur/vl/checkers/duperhs.cert : \
- centaur/vl/checkers/duplicate-detect.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/writer.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/duperhs.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/duplicate-detect.cert : acl2x = 0
-centaur/vl/checkers/duplicate-detect.cert : no_pcert = 0
-
-centaur/vl/checkers/duplicate-detect.cert : \
- centaur/vl/mlib/writer.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/duplicate-detect.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/leftright.cert : acl2x = 0
-centaur/vl/checkers/leftright.cert : no_pcert = 0
-
-centaur/vl/checkers/leftright.cert : \
- centaur/vl/mlib/ctxexprs.cert \
- centaur/vl/checkers/duplicate-detect.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/leftright.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/multidrive-detect.cert : acl2x = 0
-centaur/vl/checkers/multidrive-detect.cert : no_pcert = 0
-
-centaur/vl/checkers/multidrive-detect.cert : \
- centaur/vl/checkers/duplicate-detect.cert \
- centaur/vl/mlib/lvalues.cert \
- centaur/vl/toe/toe-wirealist.cert \
- centaur/vl/toe/toe-verilogify.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/misc/fal-graphs.cert \
- centaur/misc/hons-extra.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/multidrive-detect.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/oddexpr.cert : acl2x = 0
-centaur/vl/checkers/oddexpr.cert : no_pcert = 0
-
-centaur/vl/checkers/oddexpr.cert : \
- centaur/vl/mlib/ctxexprs.cert \
- centaur/vl/transforms/xf-sizing.cert \
- centaur/vl/mlib/fmt.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/oddexpr.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/portcheck.cert : acl2x = 0
-centaur/vl/checkers/portcheck.cert : no_pcert = 0
-
-centaur/vl/checkers/portcheck.cert : \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/portcheck.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/qmarksize-check.cert : acl2x = 0
-centaur/vl/checkers/qmarksize-check.cert : no_pcert = 0
-
-centaur/vl/checkers/qmarksize-check.cert : \
- centaur/vl/mlib/ctxexprs.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/qmarksize-check.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/selfassigns.cert : acl2x = 0
-centaur/vl/checkers/selfassigns.cert : no_pcert = 0
-
-centaur/vl/checkers/selfassigns.cert : \
- centaur/vl/mlib/ctxexprs.cert \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/selfassigns.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/skip-detect.cert : acl2x = 0
-centaur/vl/checkers/skip-detect.cert : no_pcert = 0
-
-centaur/vl/checkers/skip-detect.cert : \
- centaur/vl/mlib/ctxexprs.cert \
- centaur/vl/mlib/print-context.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/skip-detect.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/typo-detect.cert : acl2x = 0
-centaur/vl/checkers/typo-detect.cert : no_pcert = 0
-
-centaur/vl/checkers/typo-detect.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/string-alists.cert \
- centaur/vl/util/character-list-listp.cert \
- centaur/vl/loader/lexer-utils.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/typo-detect.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/use-set-report.cert : acl2x = 0
-centaur/vl/checkers/use-set-report.cert : no_pcert = 0
-
-centaur/vl/checkers/use-set-report.cert : \
- centaur/vl/mlib/writer.cert \
- centaur/vl/mlib/print-warnings.cert \
- centaur/vl/util/string-alists.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/use-set-report.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/use-set-tool.cert : acl2x = 0
-centaur/vl/checkers/use-set-tool.cert : no_pcert = 0
-
-centaur/vl/checkers/use-set-tool.cert : \
- centaur/vl/checkers/use-set.cert \
- centaur/vl/loader/loader.cert \
- centaur/vl/transforms/xf-argresolve.cert \
- centaur/vl/transforms/xf-portdecl-sign.cert \
- centaur/vl/transforms/cn-hooks.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/mlib/modname-sets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/use-set-tool.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/checkers/use-set.cert : acl2x = 0
-centaur/vl/checkers/use-set.cert : no_pcert = 0
-
-centaur/vl/checkers/use-set.cert : \
- centaur/vl/checkers/typo-detect.cert \
- centaur/vl/checkers/use-set-report.cert \
- centaur/vl/mlib/warnings.cert \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/checkers/use-set.lisp \
- centaur/vl/checkers/cert.acl2
-
-
-centaur/vl/lint/bit-use-set.cert : acl2x = 0
-centaur/vl/lint/bit-use-set.cert : no_pcert = 0
-
-centaur/vl/lint/bit-use-set.cert : \
- centaur/vl/toe/toe-preliminary.cert \
- centaur/vl/wf-reasonable-p.cert \
- centaur/vl/lint/disconnected.cert \
- centaur/vl/mlib/hierarchy.cert \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/mlib/lvalues.cert \
- centaur/vl/mlib/warnings.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/lint/use-set-ignore.cert \
- centaur/bitops/bitsets.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/bit-use-set.lisp \
- centaur/vl/lint/cert.acl2
-
-
-centaur/vl/lint/check-case.cert : acl2x = 0
-centaur/vl/lint/check-case.cert : no_pcert = 0
-
-centaur/vl/lint/check-case.cert : \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/mlib/writer.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/check-case.lisp \
- centaur/vl/lint/cert.acl2
-
-
-centaur/vl/lint/check-namespace.cert : acl2x = 0
-centaur/vl/lint/check-namespace.cert : no_pcert = 0
-
-centaur/vl/lint/check-namespace.cert : \
- centaur/vl/wf-reasonable-p.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/check-namespace.lisp \
- centaur/vl/lint/cert.acl2
-
-
-centaur/vl/lint/disconnected.cert : acl2x = 0
-centaur/vl/lint/disconnected.cert : no_pcert = 0
-
-centaur/vl/lint/disconnected.cert : \
- centaur/vl/toe/toe-wirealist.cert \
- centaur/vl/toe/toe-verilogify.cert \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/mlib/fmt.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/disconnected.lisp \
- centaur/vl/lint/cert.acl2
-
-
-centaur/vl/lint/lint.cert : acl2x = 0
-centaur/vl/lint/lint.cert : no_pcert = 0
-
-centaur/vl/lint/lint.cert : \
- centaur/vl/lint/bit-use-set.cert \
- centaur/vl/lint/check-case.cert \
- centaur/vl/lint/check-namespace.cert \
- centaur/vl/lint/disconnected.cert \
- centaur/vl/lint/xf-drop-missing-submodules.cert \
- centaur/vl/lint/xf-lint-stmt-rewrite.cert \
- centaur/vl/lint/xf-remove-toohard.cert \
- centaur/vl/lint/xf-undefined-names.cert \
- centaur/vl/lint/xf-suppress-warnings.cert \
- centaur/vl/checkers/condcheck.cert \
- centaur/vl/checkers/duplicate-detect.cert \
- centaur/vl/checkers/dupeinst-check.cert \
- centaur/vl/checkers/duperhs.cert \
- centaur/vl/checkers/leftright.cert \
- centaur/vl/checkers/multidrive-detect.cert \
- centaur/vl/checkers/oddexpr.cert \
- centaur/vl/checkers/portcheck.cert \
- centaur/vl/checkers/qmarksize-check.cert \
- centaur/vl/checkers/selfassigns.cert \
- centaur/vl/checkers/skip-detect.cert \
- centaur/vl/loader/loader.cert \
- centaur/vl/transforms/cn-hooks.cert \
- centaur/vl/transforms/xf-argresolve.cert \
- centaur/vl/transforms/xf-array-indexing.cert \
- centaur/vl/transforms/xf-assign-trunc.cert \
- centaur/vl/transforms/xf-blankargs.cert \
- centaur/vl/transforms/xf-clean-params.cert \
- centaur/vl/transforms/xf-drop-blankports.cert \
- centaur/vl/transforms/xf-expr-split.cert \
- centaur/vl/transforms/xf-expand-functions.cert \
- centaur/vl/transforms/xf-follow-hids.cert \
- centaur/vl/transforms/xf-hid-elim.cert \
- centaur/vl/transforms/xf-orig.cert \
- centaur/vl/transforms/xf-oprewrite.cert \
- centaur/vl/transforms/xf-portdecl-sign.cert \
- centaur/vl/transforms/xf-resolve-ranges.cert \
- centaur/vl/transforms/xf-replicate-insts.cert \
- centaur/vl/transforms/xf-sizing.cert \
- centaur/vl/transforms/xf-unparameterize.cert \
- centaur/vl/transforms/xf-unused-reg.cert \
- centaur/vl/mlib/modname-sets.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/lint.lisp \
- centaur/vl/lint/lint.acl2
-
-
-centaur/vl/lint/use-set-ignore.cert : acl2x = 0
-centaur/vl/lint/use-set-ignore.cert : no_pcert = 0
-
-centaur/vl/lint/use-set-ignore.cert : \
- centaur/vl/loader/parse-lvalues.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/mlib/fmt.cert \
- centaur/vl/checkers/oddexpr.cert \
- centaur/vl/toe/toe-wirealist.cert \
- centaur/vl/transforms/xf-sizing.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/use-set-ignore.lisp \
- centaur/vl/lint/cert.acl2
-
-
-centaur/vl/lint/xf-drop-missing-submodules.cert : acl2x = 0
-centaur/vl/lint/xf-drop-missing-submodules.cert : no_pcert = 0
-
-centaur/vl/lint/xf-drop-missing-submodules.cert : \
- centaur/vl/mlib/filter.cert \
- centaur/vl/mlib/hierarchy.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/xf-drop-missing-submodules.lisp \
- centaur/vl/lint/cert.acl2
-
-
-centaur/vl/lint/xf-drop-unresolved-submodules.cert : acl2x = 0
-centaur/vl/lint/xf-drop-unresolved-submodules.cert : no_pcert = 0
-
-centaur/vl/lint/xf-drop-unresolved-submodules.cert : \
- centaur/vl/mlib/filter.cert \
- centaur/vl/mlib/hierarchy.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/xf-drop-unresolved-submodules.lisp \
- centaur/vl/lint/cert.acl2
-
-
-centaur/vl/lint/xf-lint-stmt-rewrite.cert : acl2x = 0
-centaur/vl/lint/xf-lint-stmt-rewrite.cert : no_pcert = 0
-
-centaur/vl/lint/xf-lint-stmt-rewrite.cert : \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/xf-lint-stmt-rewrite.lisp \
- centaur/vl/lint/cert.acl2
-
-
-centaur/vl/lint/xf-remove-toohard.cert : acl2x = 0
-centaur/vl/lint/xf-remove-toohard.cert : no_pcert = 0
-
-centaur/vl/lint/xf-remove-toohard.cert : \
- centaur/vl/mlib/writer.cert \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/xf-remove-toohard.lisp \
- centaur/vl/lint/cert.acl2
-
-
-centaur/vl/lint/xf-suppress-warnings.cert : acl2x = 0
-centaur/vl/lint/xf-suppress-warnings.cert : no_pcert = 0
-
-centaur/vl/lint/xf-suppress-warnings.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/xf-suppress-warnings.lisp \
- centaur/vl/lint/cert.acl2
-
-
-centaur/vl/lint/xf-undefined-names.cert : acl2x = 0
-centaur/vl/lint/xf-undefined-names.cert : no_pcert = 0
-
-centaur/vl/lint/xf-undefined-names.cert : \
- centaur/vl/portcullis.cert \
- centaur/vl/lint/xf-undefined-names.lisp \
- centaur/vl/lint/cert.acl2
-
-
-centaur/vl/loader/defines.cert : acl2x = 0
-centaur/vl/loader/defines.cert : no_pcert = 0
-
-centaur/vl/loader/defines.cert : \
- centaur/vl/util/echars.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/defines.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/filemap.cert : acl2x = 0
-centaur/vl/loader/filemap.cert : no_pcert = 0
-
-centaur/vl/loader/filemap.cert : \
- centaur/vl/util/echars.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/filemap.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/find-file.cert : acl2x = 0
-centaur/vl/loader/find-file.cert : no_pcert = 0
-
-centaur/vl/loader/find-file.cert : \
- centaur/vl/util/warnings.cert \
- std/io/open-input-channel.cert \
- std/io/close-input-channel.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/find-file.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/inject-comments.cert : acl2x = 0
-centaur/vl/loader/inject-comments.cert : no_pcert = 0
-
-centaur/vl/loader/inject-comments.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/inject-comments.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/lexer-tests.cert : acl2x = 0
-centaur/vl/loader/lexer-tests.cert : no_pcert = 0
-
-centaur/vl/loader/lexer-tests.cert : \
- centaur/vl/loader/lexer.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/lexer-tests.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/lexer-tokens.cert : acl2x = 0
-centaur/vl/loader/lexer-tokens.cert : no_pcert = 0
-
-centaur/vl/loader/lexer-tokens.cert : \
- centaur/vl/util/bits.cert \
- centaur/vl/util/echars.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/lexer-tokens.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/lexer-utils.cert : acl2x = 0
-centaur/vl/loader/lexer-utils.cert : no_pcert = 0
-
-centaur/vl/loader/lexer-utils.cert : \
- std/lists/prefixp.cert \
- centaur/vl/util/echars.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/lexer-utils.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/lexer.cert : acl2x = 0
-centaur/vl/loader/lexer.cert : no_pcert = 0
-
-centaur/vl/loader/lexer.cert : \
- centaur/vl/loader/lexer-tokens.cert \
- centaur/vl/loader/lexer-utils.cert \
- centaur/vl/util/warnings.cert \
- centaur/vl/util/commentmap.cert \
- centaur/vl/util/arithmetic.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/lexer.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/loader.cert : acl2x = 0
-centaur/vl/loader/loader.cert : no_pcert = 0
-
-centaur/vl/loader/loader.cert : \
- centaur/vl/loader/read-file.cert \
- centaur/vl/loader/find-file.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/loader/preprocessor.cert \
- centaur/vl/loader/parser.cert \
- centaur/vl/loader/filemap.cert \
- centaur/vl/loader/inject-comments.cert \
- centaur/vl/loader/overrides.cert \
- centaur/vl/mlib/hierarchy.cert \
- centaur/vl/mlib/print-warnings.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/util/gc.cert \
- centaur/misc/hons-extra.cert \
- defsort/duplicated-members.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/loader.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/make-implicit-wires.cert : acl2x = 0
-centaur/vl/loader/make-implicit-wires.cert : no_pcert = 0
-
-centaur/vl/loader/make-implicit-wires.cert : \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/make-implicit-wires.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/overrides.cert : acl2x = 0
-centaur/vl/loader/overrides.cert : no_pcert = 0
-
-centaur/vl/loader/overrides.cert : \
- centaur/vl/loader/read-file.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/loader/preprocessor.cert \
- centaur/vl/loader/parse-utils.cert \
- centaur/vl/loader/parse-error.cert \
- centaur/vl/loader/filemap.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/mlib/warnings.cert \
- oslib/ls.cert \
- str/top.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/overrides.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-blockitems.cert : acl2x = 0
-centaur/vl/loader/parse-blockitems.cert : no_pcert = 0
-
-centaur/vl/loader/parse-blockitems.cert : \
- centaur/vl/loader/parse-ranges.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-blockitems.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-delays.cert : acl2x = 0
-centaur/vl/loader/parse-delays.cert : no_pcert = 0
-
-centaur/vl/loader/parse-delays.cert : \
- centaur/vl/loader/parse-expressions.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-delays.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-error.cert : acl2x = 0
-centaur/vl/loader/parse-error.cert : no_pcert = 0
-
-centaur/vl/loader/parse-error.cert : \
- centaur/vl/loader/lexer-tokens.cert \
- centaur/vl/mlib/fmt.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-error.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-eventctrl.cert : acl2x = 0
-centaur/vl/loader/parse-eventctrl.cert : no_pcert = 0
-
-centaur/vl/loader/parse-eventctrl.cert : \
- centaur/vl/loader/parse-delays.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-eventctrl.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-expressions-def.cert : acl2x = 0
-centaur/vl/loader/parse-expressions-def.cert : no_pcert = 0
-
-centaur/vl/loader/parse-expressions-def.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/loader/parse-utils.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-expressions-def.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-expressions-eof.cert : acl2x = 0
-centaur/vl/loader/parse-expressions-eof.cert : no_pcert = 0
-
-centaur/vl/loader/parse-expressions-eof.cert : \
- centaur/vl/loader/parse-expressions-def.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-expressions-eof.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-expressions-error.cert : acl2x = 0
-centaur/vl/loader/parse-expressions-error.cert : no_pcert = 0
-
-centaur/vl/loader/parse-expressions-error.cert : \
- centaur/vl/loader/parse-expressions-def.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-expressions-error.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-expressions-progress.cert : acl2x = 0
-centaur/vl/loader/parse-expressions-progress.cert : no_pcert = 0
-
-centaur/vl/loader/parse-expressions-progress.cert : \
- centaur/vl/loader/parse-expressions-def.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-expressions-progress.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-expressions-result.cert : acl2x = 0
-centaur/vl/loader/parse-expressions-result.cert : no_pcert = 0
-
-centaur/vl/loader/parse-expressions-result.cert : \
- centaur/vl/loader/parse-expressions-def.cert \
- centaur/vl/loader/parse-expressions-tokenlist.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-expressions-result.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-expressions-tokenlist.cert : acl2x = 0
-centaur/vl/loader/parse-expressions-tokenlist.cert : no_pcert = 0
-
-centaur/vl/loader/parse-expressions-tokenlist.cert : \
- centaur/vl/loader/parse-expressions-def.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-expressions-tokenlist.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-expressions-warnings.cert : acl2x = 0
-centaur/vl/loader/parse-expressions-warnings.cert : no_pcert = 0
-
-centaur/vl/loader/parse-expressions-warnings.cert : \
- centaur/vl/loader/parse-expressions-def.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-expressions-warnings.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-expressions.cert : acl2x = 0
-centaur/vl/loader/parse-expressions.cert : no_pcert = 0
-
-centaur/vl/loader/parse-expressions.cert : \
- centaur/vl/loader/parse-expressions-def.cert \
- centaur/vl/loader/parse-expressions-error.cert \
- centaur/vl/loader/parse-expressions-tokenlist.cert \
- centaur/vl/loader/parse-expressions-warnings.cert \
- centaur/vl/loader/parse-expressions-progress.cert \
- centaur/vl/loader/parse-expressions-eof.cert \
- centaur/vl/loader/parse-expressions-result.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-expressions.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-functions.cert : acl2x = 0
-centaur/vl/loader/parse-functions.cert : no_pcert = 0
-
-centaur/vl/loader/parse-functions.cert : \
- centaur/vl/loader/parse-blockitems.cert \
- centaur/vl/loader/parse-ports.cert \
- centaur/vl/loader/parse-statements.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-functions.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-gates.cert : acl2x = 0
-centaur/vl/loader/parse-gates.cert : no_pcert = 0
-
-centaur/vl/loader/parse-gates.cert : \
- centaur/vl/loader/parse-strengths.cert \
- centaur/vl/loader/parse-delays.cert \
- centaur/vl/loader/parse-ranges.cert \
- centaur/vl/loader/parse-lvalues.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-gates.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-insts.cert : acl2x = 0
-centaur/vl/loader/parse-insts.cert : no_pcert = 0
-
-centaur/vl/loader/parse-insts.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/loader/parse-ranges.cert \
- centaur/vl/loader/parse-lvalues.cert \
- centaur/vl/loader/parse-delays.cert \
- centaur/vl/loader/parse-strengths.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-insts.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-lvalues.cert : acl2x = 0
-centaur/vl/loader/parse-lvalues.cert : no_pcert = 0
-
-centaur/vl/loader/parse-lvalues.cert : \
- centaur/vl/loader/parse-expressions.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-lvalues.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-modules.cert : acl2x = 0
-centaur/vl/loader/parse-modules.cert : no_pcert = 0
-
-centaur/vl/loader/parse-modules.cert : \
- centaur/vl/loader/parse-statements.cert \
- centaur/vl/loader/parse-ports.cert \
- centaur/vl/loader/parse-nets.cert \
- centaur/vl/loader/parse-blockitems.cert \
- centaur/vl/loader/parse-insts.cert \
- centaur/vl/loader/parse-gates.cert \
- centaur/vl/loader/parse-functions.cert \
- centaur/vl/loader/make-implicit-wires.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/mlib/port-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-modules.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-nets.cert : acl2x = 0
-centaur/vl/loader/parse-nets.cert : no_pcert = 0
-
-centaur/vl/loader/parse-nets.cert : \
- centaur/vl/loader/parse-ranges.cert \
- centaur/vl/loader/parse-lvalues.cert \
- centaur/vl/loader/parse-delays.cert \
- centaur/vl/loader/parse-strengths.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-nets.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-ports.cert : acl2x = 0
-centaur/vl/loader/parse-ports.cert : no_pcert = 0
-
-centaur/vl/loader/parse-ports.cert : \
- centaur/vl/loader/parse-nets.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-ports.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-ranges.cert : acl2x = 0
-centaur/vl/loader/parse-ranges.cert : no_pcert = 0
-
-centaur/vl/loader/parse-ranges.cert : \
- centaur/vl/loader/parse-expressions.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-ranges.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-statements-def.cert : acl2x = 0
-centaur/vl/loader/parse-statements-def.cert : no_pcert = 0
-
-centaur/vl/loader/parse-statements-def.cert : \
- centaur/vl/loader/parse-eventctrl.cert \
- centaur/vl/loader/parse-blockitems.cert \
- centaur/vl/loader/parse-lvalues.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-statements-def.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-statements-error.cert : acl2x = 0
-centaur/vl/loader/parse-statements-error.cert : no_pcert = 0
-
-centaur/vl/loader/parse-statements-error.cert : \
- centaur/vl/loader/parse-statements-def.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-statements-error.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-statements-progress.cert : acl2x = 0
-centaur/vl/loader/parse-statements-progress.cert : no_pcert = 0
-
-centaur/vl/loader/parse-statements-progress.cert : \
- centaur/vl/loader/parse-statements-def.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-statements-progress.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-statements-result.cert : acl2x = 0
-centaur/vl/loader/parse-statements-result.cert : no_pcert = 0
-
-centaur/vl/loader/parse-statements-result.cert : \
- centaur/vl/loader/parse-statements-def.cert \
- centaur/vl/loader/parse-statements-tokenlist.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-statements-result.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-statements-tokenlist.cert : acl2x = 0
-centaur/vl/loader/parse-statements-tokenlist.cert : no_pcert = 0
-
-centaur/vl/loader/parse-statements-tokenlist.cert : \
- centaur/vl/loader/parse-statements-def.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-statements-tokenlist.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-statements-warninglist.cert : acl2x = 0
-centaur/vl/loader/parse-statements-warninglist.cert : no_pcert = 0
-
-centaur/vl/loader/parse-statements-warninglist.cert : \
- centaur/vl/loader/parse-statements-def.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-statements-warninglist.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-statements.cert : acl2x = 0
-centaur/vl/loader/parse-statements.cert : no_pcert = 0
-
-centaur/vl/loader/parse-statements.cert : \
- centaur/vl/loader/parse-statements-def.cert \
- centaur/vl/loader/parse-statements-error.cert \
- centaur/vl/loader/parse-statements-progress.cert \
- centaur/vl/loader/parse-statements-tokenlist.cert \
- centaur/vl/loader/parse-statements-warninglist.cert \
- centaur/vl/loader/parse-statements-result.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-statements.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-strengths.cert : acl2x = 0
-centaur/vl/loader/parse-strengths.cert : no_pcert = 0
-
-centaur/vl/loader/parse-strengths.cert : \
- centaur/vl/loader/parse-utils.cert \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-strengths.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parse-utils.cert : acl2x = 0
-centaur/vl/loader/parse-utils.cert : no_pcert = 0
-
-centaur/vl/loader/parse-utils.cert : \
- centaur/vl/loader/lexer-tokens.cert \
- misc/seqw.cert \
- misc/untranslate-patterns.cert \
- tools/flag.cert \
- centaur/vl/util/warnings.cert \
- tools/rulesets.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parse-utils.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/parser.cert : acl2x = 0
-centaur/vl/loader/parser.cert : no_pcert = 0
-
-centaur/vl/loader/parser.cert : \
- centaur/vl/loader/parse-modules.cert \
- centaur/vl/loader/parse-error.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/parser.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/preprocessor-tests.cert : acl2x = 0
-centaur/vl/loader/preprocessor-tests.cert : no_pcert = 0
-
-centaur/vl/loader/preprocessor-tests.cert : \
- centaur/vl/loader/preprocessor.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/preprocessor-tests.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/preprocessor.cert : acl2x = 0
-centaur/vl/loader/preprocessor.cert : no_pcert = 0
-
-centaur/vl/loader/preprocessor.cert : \
- centaur/vl/util/cwtime.cert \
- centaur/vl/loader/read-file.cert \
- centaur/vl/loader/find-file.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/loader/defines.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/preprocessor.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/loader/read-file.cert : acl2x = 0
-centaur/vl/loader/read-file.cert : no_pcert = 0
-
-centaur/vl/loader/read-file.cert : \
- centaur/vl/util/echars.cert \
- std/io/file-measure.cert \
- std/io/open-input-channel.cert \
- std/io/read-byte.cert \
- std/io/close-input-channel.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/loader/read-file.lisp \
- centaur/vl/loader/cert.acl2
-
-
-centaur/vl/mlib/allexprs.cert : acl2x = 0
-centaur/vl/mlib/allexprs.cert : no_pcert = 0
-
-centaur/vl/mlib/allexprs.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/allexprs.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/atts.cert : acl2x = 0
-centaur/vl/mlib/atts.cert : no_pcert = 0
-
-centaur/vl/mlib/atts.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/atts.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/clean-concats.cert : acl2x = 0
-centaur/vl/mlib/clean-concats.cert : no_pcert = 0
-
-centaur/vl/mlib/clean-concats.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/clean-concats.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/comment-writer.cert : acl2x = 0
-centaur/vl/mlib/comment-writer.cert : no_pcert = 0
-
-centaur/vl/mlib/comment-writer.cert : \
- centaur/vl/mlib/writer.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/loader/inject-comments.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/comment-writer.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/context.cert : acl2x = 0
-centaur/vl/mlib/context.cert : no_pcert = 0
-
-centaur/vl/mlib/context.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/context.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/ctxexprs.cert : acl2x = 0
-centaur/vl/mlib/ctxexprs.cert : no_pcert = 0
-
-centaur/vl/mlib/ctxexprs.cert : \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/ctxexprs.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/delta.cert : acl2x = 0
-centaur/vl/mlib/delta.cert : no_pcert = 0
-
-centaur/vl/mlib/delta.cert : \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/delta.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/expr-building.cert : acl2x = 0
-centaur/vl/mlib/expr-building.cert : no_pcert = 0
-
-centaur/vl/mlib/expr-building.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/expr-building.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/expr-parse.cert : acl2x = 0
-centaur/vl/mlib/expr-parse.cert : no_pcert = 0
-
-centaur/vl/mlib/expr-parse.cert : \
- centaur/vl/mlib/print-warnings.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/loader/parse-expressions.cert \
- centaur/vl/loader/parse-error.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/expr-parse.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/expr-slice.cert : acl2x = 0
-centaur/vl/mlib/expr-slice.cert : no_pcert = 0
-
-centaur/vl/mlib/expr-slice.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/mlib/welltyped.cert \
- centaur/vl/mlib/expr-building.cert \
- centaur/vl/util/arithmetic.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/expr-slice.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/expr-tools.cert : acl2x = 0
-centaur/vl/mlib/expr-tools.cert : no_pcert = 0
-
-centaur/vl/mlib/expr-tools.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/expr-tools.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/filter.cert : acl2x = 0
-centaur/vl/mlib/filter.cert : no_pcert = 0
-
-centaur/vl/mlib/filter.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/filter.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/find-item.cert : acl2x = 0
-centaur/vl/mlib/find-item.cert : no_pcert = 0
-
-centaur/vl/mlib/find-item.cert : \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/find-item.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/find-module.cert : acl2x = 0
-centaur/vl/mlib/find-module.cert : no_pcert = 0
-
-centaur/vl/mlib/find-module.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/find-module.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/fmt.cert : acl2x = 0
-centaur/vl/mlib/fmt.cert : no_pcert = 0
-
-centaur/vl/mlib/fmt.cert : \
- centaur/vl/mlib/writer.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/mlib/print-context.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/fmt.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/hid-tools.cert : acl2x = 0
-centaur/vl/mlib/hid-tools.cert : no_pcert = 0
-
-centaur/vl/mlib/hid-tools.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/hid-tools.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/hierarchy.cert : acl2x = 0
-centaur/vl/mlib/hierarchy.cert : no_pcert = 0
-
-centaur/vl/mlib/hierarchy.cert : \
- centaur/vl/mlib/find-module.cert \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/mlib/filter.cert \
- centaur/vl/util/string-alists.cert \
- centaur/vl/util/defwellformed.cert \
- centaur/vl/mlib/modname-sets.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/misc/osets-witnessing.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/hierarchy.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/lvalues-mentioning.cert : acl2x = 0
-centaur/vl/mlib/lvalues-mentioning.cert : no_pcert = 0
-
-centaur/vl/mlib/lvalues-mentioning.cert : \
- centaur/vl/mlib/lvalues.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/lvalues-mentioning.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/lvalues.cert : acl2x = 0
-centaur/vl/mlib/lvalues.cert : no_pcert = 0
-
-centaur/vl/mlib/lvalues.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/hid-tools.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/lvalues.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/modname-sets.cert : acl2x = 0
-centaur/vl/mlib/modname-sets.cert : no_pcert = 0
-
-centaur/vl/mlib/modname-sets.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/modname-sets.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/modnamespace.cert : acl2x = 0
-centaur/vl/mlib/modnamespace.cert : no_pcert = 0
-
-centaur/vl/mlib/modnamespace.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/modnamespace.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/namefactory.cert : acl2x = 0
-centaur/vl/mlib/namefactory.cert : no_pcert = 0
-
-centaur/vl/mlib/namefactory.cert : \
- centaur/vl/util/namedb.cert \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/namefactory.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/namemangle.cert : acl2x = 0
-centaur/vl/mlib/namemangle.cert : no_pcert = 0
-
-centaur/vl/mlib/namemangle.cert : \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/namemangle.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/port-tools.cert : acl2x = 0
-centaur/vl/mlib/port-tools.cert : no_pcert = 0
-
-centaur/vl/mlib/port-tools.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/port-tools.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/print-context.cert : acl2x = 0
-centaur/vl/mlib/print-context.cert : no_pcert = 0
-
-centaur/vl/mlib/print-context.cert : \
- centaur/vl/mlib/context.cert \
- centaur/vl/mlib/writer.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/print-context.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/print-warnings.cert : acl2x = 0
-centaur/vl/mlib/print-warnings.cert : no_pcert = 0
-
-centaur/vl/mlib/print-warnings.cert : \
- centaur/vl/mlib/warnings.cert \
- centaur/vl/mlib/fmt.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/print-warnings.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/range-tools.cert : acl2x = 0
-centaur/vl/mlib/range-tools.cert : no_pcert = 0
-
-centaur/vl/mlib/range-tools.cert : \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/range-tools.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/relocate.cert : acl2x = 0
-centaur/vl/mlib/relocate.cert : no_pcert = 0
-
-centaur/vl/mlib/relocate.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/relocate.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/remove-bad.cert : acl2x = 0
-centaur/vl/mlib/remove-bad.cert : no_pcert = 0
-
-centaur/vl/mlib/remove-bad.cert : \
- centaur/vl/mlib/hierarchy.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/mlib/modname-sets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/remove-bad.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/rvalues.cert : acl2x = 0
-centaur/vl/mlib/rvalues.cert : no_pcert = 0
-
-centaur/vl/mlib/rvalues.cert : \
- centaur/vl/mlib/hid-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/rvalues.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/stmt-tools.cert : acl2x = 0
-centaur/vl/mlib/stmt-tools.cert : no_pcert = 0
-
-centaur/vl/mlib/stmt-tools.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/stmt-tools.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/sub-counts.cert : acl2x = 0
-centaur/vl/mlib/sub-counts.cert : no_pcert = 0
-
-centaur/vl/mlib/sub-counts.cert : \
- centaur/vl/mlib/find-module.cert \
- centaur/vl/transforms/xf-resolve-ranges.cert \
- centaur/vl/transforms/xf-subst.cert \
- centaur/vl/transforms/xf-unparameterize.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/sub-counts.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/warnings.cert : acl2x = 0
-centaur/vl/mlib/warnings.cert : no_pcert = 0
-
-centaur/vl/mlib/warnings.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/warnings.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/welltyped.cert : acl2x = 0
-centaur/vl/mlib/welltyped.cert : no_pcert = 0
-
-centaur/vl/mlib/welltyped.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/util/sum-nats.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/welltyped.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/mlib/writer.cert : acl2x = 0
-centaur/vl/mlib/writer.cert : no_pcert = 0
-
-centaur/vl/mlib/writer.cert : \
- centaur/vl/mlib/find-module.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/loader/lexer.cert \
- centaur/vl/util/print.cert \
- str/strrpos.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/mlib/writer.lisp \
- centaur/vl/mlib/cert.acl2
-
-
-centaur/vl/onehot.cert : acl2x = 0
-centaur/vl/onehot.cert : no_pcert = 0
-
-centaur/vl/onehot.cert : \
- centaur/vl/transforms/occform/simple.cert \
- centaur/vl/util/arithmetic.cert \
- arithmetic-5/top.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/onehot.lisp \
- centaur/vl/cert.acl2
-
-
-centaur/vl/parsetree.cert : acl2x = 0
-centaur/vl/parsetree.cert : no_pcert = 0
-
-centaur/vl/parsetree.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/bits.cert \
- centaur/vl/util/commentmap.cert \
- centaur/vl/util/warnings.cert \
- centaur/vl/util/echars.cert \
- tools/flag.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/parsetree.lisp \
- centaur/vl/cert.acl2
-
-
-centaur/vl/portcullis.cert : acl2x = 0
-centaur/vl/portcullis.cert : no_pcert = 0
-
-centaur/vl/portcullis.cert : \
- tools/safe-case.cert \
- xdoc/top.cert \
- clause-processors/autohide.cert \
- tools/rulesets.cert \
- centaur/vl/portcullis.lisp \
- centaur/vl/portcullis.acl2 \
- centaur/vl/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- centaur/vl/other-packages.lsp \
- data-structures/define-u-package.lsp \
- tools/flag-package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- cowles/packages.lsp
-
-
-centaur/vl/primitives.cert : acl2x = 0
-centaur/vl/primitives.cert : no_pcert = 0
-
-centaur/vl/primitives.cert : \
- centaur/vl/mlib/expr-building.cert \
- centaur/esim/esim-primitives.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/primitives.lisp \
- centaur/vl/cert.acl2
-
-
-centaur/vl/toe/toe-add-res-modules.cert : acl2x = 0
-centaur/vl/toe/toe-add-res-modules.cert : no_pcert = 0
-
-centaur/vl/toe/toe-add-res-modules.cert : \
- centaur/vl/toe/toe-wirealist.cert \
- centaur/esim/esim-sexpr-support.cert \
- centaur/esim/esim-primitives.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/esim-lemmas.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/toe/toe-add-res-modules.lisp \
- centaur/vl/toe/cert.acl2
-
-
-centaur/vl/toe/toe-add-zdrivers.cert : acl2x = 0
-centaur/vl/toe/toe-add-zdrivers.cert : no_pcert = 0
-
-centaur/vl/toe/toe-add-zdrivers.cert : \
- centaur/vl/toe/toe-wirealist.cert \
- centaur/esim/esim-sexpr-support.cert \
- centaur/esim/esim-primitives.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/esim-lemmas.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/toe/toe-add-zdrivers.lisp \
- centaur/vl/toe/cert.acl2
-
-
-centaur/vl/toe/toe-emodwire.cert : acl2x = 0
-centaur/vl/toe/toe-emodwire.cert : no_pcert = 0
-
-centaur/vl/toe/toe-emodwire.cert : \
- centaur/vl/util/defs.cert \
- misc/assert.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/position.cert \
- std/ks/intern-in-package-of-symbol.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/toe/toe-emodwire.lisp \
- centaur/vl/toe/cert.acl2
-
-
-centaur/vl/toe/toe-eocc-allnames.cert : acl2x = 0
-centaur/vl/toe/toe-eocc-allnames.cert : no_pcert = 0
-
-centaur/vl/toe/toe-eocc-allnames.cert : \
- centaur/esim/esim-sexpr-support.cert \
- centaur/vl/toe/toe-emodwire.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/esim-lemmas.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/toe/toe-eocc-allnames.lisp \
- centaur/vl/toe/cert.acl2
-
-
-centaur/vl/toe/toe-preliminary.cert : acl2x = 0
-centaur/vl/toe/toe-preliminary.cert : no_pcert = 0
-
-centaur/vl/toe/toe-preliminary.cert : \
- centaur/vl/toe/toe-wirealist.cert \
- centaur/vl/toe/toe-verilogify.cert \
- centaur/vl/mlib/find-module.cert \
- centaur/esim/esim-sexpr-support.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/util/esim-lemmas.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/toe/toe-preliminary.lisp \
- centaur/vl/toe/cert.acl2
-
-
-centaur/vl/toe/toe-top.cert : acl2x = 0
-centaur/vl/toe/toe-top.cert : no_pcert = 0
-
-centaur/vl/toe/toe-top.cert : \
- centaur/vl/toe/toe-eocc-allnames.cert \
- centaur/vl/toe/toe-preliminary.cert \
- centaur/vl/toe/toe-add-res-modules.cert \
- centaur/vl/toe/toe-add-zdrivers.cert \
- centaur/vl/mlib/remove-bad.cert \
- centaur/vl/mlib/atts.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/esim-lemmas.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/toe/toe-top.lisp \
- centaur/vl/toe/cert.acl2
-
-
-centaur/vl/toe/toe-verilogify.cert : acl2x = 0
-centaur/vl/toe/toe-verilogify.cert : no_pcert = 0
-
-centaur/vl/toe/toe-verilogify.cert : \
- centaur/vl/toe/toe-emodwire.cert \
- misc/assert.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/toe/toe-verilogify.lisp \
- centaur/vl/toe/cert.acl2
-
-
-centaur/vl/toe/toe-wirealist.cert : acl2x = 0
-centaur/vl/toe/toe-wirealist.cert : no_pcert = 0
-
-centaur/vl/toe/toe-wirealist.cert : \
- centaur/vl/toe/toe-emodwire.cert \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/intersectp-equal.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/toe/toe-wirealist.lisp \
- centaur/vl/toe/cert.acl2
-
-
-centaur/vl/top.cert : acl2x = 0
-centaur/vl/top.cert : no_pcert = 0
-
-centaur/vl/top.cert : \
- centaur/vl/checkers/checkers.cert \
- centaur/vl/checkers/duplicate-detect.cert \
- centaur/vl/checkers/multidrive-detect.cert \
- centaur/vl/checkers/portcheck.cert \
- centaur/vl/checkers/use-set.cert \
- centaur/vl/loader/loader.cert \
- centaur/vl/mlib/comment-writer.cert \
- centaur/vl/toe/toe-top.cert \
- centaur/vl/transforms/cn-hooks.cert \
- centaur/vl/transforms/always/top.cert \
- centaur/vl/transforms/occform/top.cert \
- centaur/vl/transforms/xf-addinstnames.cert \
- centaur/vl/transforms/xf-argresolve.cert \
- centaur/vl/transforms/xf-assign-trunc.cert \
- centaur/vl/transforms/xf-blankargs.cert \
- centaur/vl/transforms/xf-clean-params.cert \
- centaur/vl/transforms/xf-designregs.cert \
- centaur/vl/transforms/xf-designwires.cert \
- centaur/vl/transforms/xf-delayredux.cert \
- centaur/vl/transforms/xf-drop-blankports.cert \
- centaur/vl/transforms/xf-elim-supply.cert \
- centaur/vl/transforms/xf-expand-functions.cert \
- centaur/vl/transforms/xf-expr-split.cert \
- centaur/vl/transforms/xf-follow-hids.cert \
- centaur/vl/transforms/xf-gateredux.cert \
- centaur/vl/transforms/xf-gatesplit.cert \
- centaur/vl/transforms/xf-gate-elim.cert \
- centaur/vl/transforms/xf-hid-elim.cert \
- centaur/vl/transforms/xf-oprewrite.cert \
- centaur/vl/transforms/xf-optimize-rw.cert \
- centaur/vl/transforms/xf-orig.cert \
- centaur/vl/transforms/xf-portdecl-sign.cert \
- centaur/vl/transforms/xf-replicate-insts.cert \
- centaur/vl/transforms/xf-resolve-ranges.cert \
- centaur/vl/transforms/xf-sizing.cert \
- centaur/vl/transforms/xf-unparameterize.cert \
- centaur/vl/transforms/xf-unused-reg.cert \
- centaur/vl/transforms/xf-weirdint-elim.cert \
- centaur/vl/transforms/xf-annotate-mods.cert \
- centaur/vl/util/clean-alist.cert \
- centaur/vl/translation.cert \
- centaur/misc/sneaky-load.cert \
- centaur/vl/mlib/modname-sets.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- system/f-put-global.cert \
- centaur/vl/loader/lexer-tests.cert \
- centaur/vl/loader/preprocessor-tests.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/top.lisp \
- centaur/vl/top.acl2
-
-
-centaur/vl/transforms/always/conditions.cert : acl2x = 0
-centaur/vl/transforms/always/conditions.cert : no_pcert = 0
-
-centaur/vl/transforms/always/conditions.cert : \
- centaur/vl/mlib/welltyped.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/conditions.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/elimalways.cert : acl2x = 0
-centaur/vl/transforms/always/elimalways.cert : no_pcert = 0
-
-centaur/vl/transforms/always/elimalways.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/elimalways.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/eliminitial.cert : acl2x = 0
-centaur/vl/transforms/always/eliminitial.cert : no_pcert = 0
-
-centaur/vl/transforms/always/eliminitial.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/eliminitial.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/elimnegedge.cert : acl2x = 0
-centaur/vl/transforms/always/elimnegedge.cert : no_pcert = 0
-
-centaur/vl/transforms/always/elimnegedge.cert : \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/mlib/delta.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/transforms/occform/util.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/elimnegedge.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/flopcode-debug.cert : acl2x = 0
-centaur/vl/transforms/always/flopcode-debug.cert : no_pcert = 0
-
-centaur/vl/transforms/always/flopcode-debug.cert : \
- centaur/vl/transforms/always/flopcode-prog.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/flopcode-debug.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/flopcode-prog.cert : acl2x = 0
-centaur/vl/transforms/always/flopcode-prog.cert : no_pcert = 0
-
-centaur/vl/transforms/always/flopcode-prog.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/welltyped.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/flopcode-prog.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/flopcode-synth.cert : acl2x = 0
-centaur/vl/transforms/always/flopcode-synth.cert : no_pcert = 0
-
-centaur/vl/transforms/always/flopcode-synth.cert : \
- centaur/vl/transforms/always/flopcode-prog.cert \
- centaur/vl/transforms/always/flopcode-debug.cert \
- centaur/vl/transforms/always/util.cert \
- centaur/vl/transforms/always/make-flop.cert \
- centaur/vl/mlib/delta.cert \
- centaur/vl/mlib/filter.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/flopcode-synth.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/ifmerge.cert : acl2x = 0
-centaur/vl/transforms/always/ifmerge.cert : no_pcert = 0
-
-centaur/vl/transforms/always/ifmerge.cert : \
- centaur/vl/transforms/always/conditions.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/ifmerge.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/latchcode.cert : acl2x = 0
-centaur/vl/transforms/always/latchcode.cert : no_pcert = 0
-
-centaur/vl/transforms/always/latchcode.cert : \
- centaur/vl/transforms/always/util.cert \
- centaur/vl/transforms/always/make-latch.cert \
- centaur/vl/mlib/delta.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/latchcode.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/make-flop.cert : acl2x = 0
-centaur/vl/transforms/always/make-flop.cert : no_pcert = 0
-
-centaur/vl/transforms/always/make-flop.cert : \
- centaur/vl/primitives.cert \
- centaur/vl/transforms/occform/util.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/make-flop.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/make-latch.cert : acl2x = 0
-centaur/vl/transforms/always/make-latch.cert : no_pcert = 0
-
-centaur/vl/transforms/always/make-latch.cert : \
- centaur/vl/primitives.cert \
- centaur/vl/transforms/occform/util.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/make-latch.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/stmtrewrite.cert : acl2x = 0
-centaur/vl/transforms/always/stmtrewrite.cert : no_pcert = 0
-
-centaur/vl/transforms/always/stmtrewrite.cert : \
- centaur/vl/transforms/xf-resolve-ranges.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/stmtrewrite.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/stmttemps.cert : acl2x = 0
-centaur/vl/transforms/always/stmttemps.cert : no_pcert = 0
-
-centaur/vl/transforms/always/stmttemps.cert : \
- centaur/vl/transforms/always/util.cert \
- centaur/vl/transforms/always/conditions.cert \
- centaur/vl/transforms/occform/util.cert \
- centaur/vl/mlib/expr-slice.cert \
- centaur/vl/mlib/delta.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/stmttemps.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/synthalways.cert : acl2x = 0
-centaur/vl/transforms/always/synthalways.cert : no_pcert = 0
-
-centaur/vl/transforms/always/synthalways.cert : \
- centaur/vl/transforms/always/flopcode-synth.cert \
- centaur/vl/transforms/always/latchcode.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/synthalways.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/top.cert : acl2x = 0
-centaur/vl/transforms/always/top.cert : no_pcert = 0
-
-centaur/vl/transforms/always/top.cert : \
- centaur/vl/transforms/always/elimalways.cert \
- centaur/vl/transforms/always/eliminitial.cert \
- centaur/vl/transforms/always/elimnegedge.cert \
- centaur/vl/transforms/always/synthalways.cert \
- centaur/vl/transforms/always/stmtrewrite.cert \
- centaur/vl/transforms/always/stmttemps.cert \
- centaur/vl/transforms/always/unelse.cert \
- centaur/vl/transforms/always/ifmerge.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/top.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/unelse.cert : acl2x = 0
-centaur/vl/transforms/always/unelse.cert : no_pcert = 0
-
-centaur/vl/transforms/always/unelse.cert : \
- centaur/vl/transforms/always/conditions.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/unelse.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/always/util.cert : acl2x = 0
-centaur/vl/transforms/always/util.cert : no_pcert = 0
-
-centaur/vl/transforms/always/util.cert : \
- centaur/vl/mlib/context.cert \
- centaur/vl/mlib/lvalues.cert \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/always/util.lisp \
- centaur/vl/transforms/always/cert.acl2
-
-
-centaur/vl/transforms/cn-hooks.cert : acl2x = 0
-centaur/vl/transforms/cn-hooks.cert : no_pcert = 0
-
-centaur/vl/transforms/cn-hooks.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/cn-hooks.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/occform/add.cert : acl2x = 0
-centaur/vl/transforms/occform/add.cert : no_pcert = 0
-
-centaur/vl/transforms/occform/add.cert : \
- centaur/vl/transforms/occform/simple.cert \
- centaur/vl/transforms/occform/xdet.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/occform/add.lisp \
- centaur/vl/transforms/occform/cert.acl2
-
-
-centaur/vl/transforms/occform/compare.cert : acl2x = 0
-centaur/vl/transforms/occform/compare.cert : no_pcert = 0
-
-centaur/vl/transforms/occform/compare.cert : \
- centaur/vl/transforms/occform/add.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/occform/compare.lisp \
- centaur/vl/transforms/occform/cert.acl2
-
-
-centaur/vl/transforms/occform/div.cert : acl2x = 0
-centaur/vl/transforms/occform/div.cert : no_pcert = 0
-
-centaur/vl/transforms/occform/div.cert : \
- centaur/vl/transforms/occform/add.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/occform/div.lisp \
- centaur/vl/transforms/occform/cert.acl2
-
-
-centaur/vl/transforms/occform/mul.cert : acl2x = 0
-centaur/vl/transforms/occform/mul.cert : no_pcert = 0
-
-centaur/vl/transforms/occform/mul.cert : \
- centaur/vl/transforms/occform/add.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/occform/mul.lisp \
- centaur/vl/transforms/occform/cert.acl2
-
-
-centaur/vl/transforms/occform/select.cert : acl2x = 0
-centaur/vl/transforms/occform/select.cert : no_pcert = 0
-
-centaur/vl/transforms/occform/select.cert : \
- centaur/vl/transforms/occform/simple.cert \
- centaur/vl/util/next-power-of-2.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/occform/select.lisp \
- centaur/vl/transforms/occform/cert.acl2
-
-
-centaur/vl/transforms/occform/shl.cert : acl2x = 0
-centaur/vl/transforms/occform/shl.cert : no_pcert = 0
-
-centaur/vl/transforms/occform/shl.cert : \
- centaur/vl/transforms/occform/simple.cert \
- centaur/vl/transforms/occform/xdet.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/occform/shl.lisp \
- centaur/vl/transforms/occform/cert.acl2
-
-
-centaur/vl/transforms/occform/shr.cert : acl2x = 0
-centaur/vl/transforms/occform/shr.cert : no_pcert = 0
-
-centaur/vl/transforms/occform/shr.cert : \
- centaur/vl/transforms/occform/shl.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/occform/shr.lisp \
- centaur/vl/transforms/occform/cert.acl2
-
-
-centaur/vl/transforms/occform/simple.cert : acl2x = 0
-centaur/vl/transforms/occform/simple.cert : no_pcert = 0
-
-centaur/vl/transforms/occform/simple.cert : \
- centaur/vl/transforms/occform/util.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/occform/simple.lisp \
- centaur/vl/transforms/occform/cert.acl2
-
-
-centaur/vl/transforms/occform/top.cert : acl2x = 0
-centaur/vl/transforms/occform/top.cert : no_pcert = 0
-
-centaur/vl/transforms/occform/top.cert : \
- centaur/vl/transforms/occform/add.cert \
- centaur/vl/transforms/occform/compare.cert \
- centaur/vl/transforms/occform/div.cert \
- centaur/vl/transforms/occform/mul.cert \
- centaur/vl/transforms/occform/select.cert \
- centaur/vl/transforms/occform/shl.cert \
- centaur/vl/transforms/occform/shr.cert \
- centaur/vl/transforms/occform/simple.cert \
- centaur/vl/transforms/occform/xdet.cert \
- centaur/vl/mlib/expr-slice.cert \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/occform/top.lisp \
- centaur/vl/transforms/occform/cert.acl2
-
-
-centaur/vl/transforms/occform/util.cert : acl2x = 0
-centaur/vl/transforms/occform/util.cert : no_pcert = 0
-
-centaur/vl/transforms/occform/util.cert : \
- centaur/vl/primitives.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/expr-building.cert \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/occform/util.lisp \
- centaur/vl/transforms/occform/cert.acl2
-
-
-centaur/vl/transforms/occform/xdet.cert : acl2x = 0
-centaur/vl/transforms/occform/xdet.cert : no_pcert = 0
-
-centaur/vl/transforms/occform/xdet.cert : \
- centaur/vl/transforms/occform/simple.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/occform/xdet.lisp \
- centaur/vl/transforms/occform/cert.acl2
-
-
-centaur/vl/transforms/xf-addinstnames.cert : acl2x = 0
-centaur/vl/transforms/xf-addinstnames.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-addinstnames.cert : \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-addinstnames.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-annotate-mods.cert : acl2x = 0
-centaur/vl/transforms/xf-annotate-mods.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-annotate-mods.cert : \
- centaur/vl/checkers/duplicate-detect.cert \
- centaur/vl/checkers/portcheck.cert \
- centaur/vl/mlib/warnings.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/transforms/xf-designwires.cert \
- centaur/vl/transforms/xf-portdecl-sign.cert \
- centaur/vl/transforms/xf-argresolve.cert \
- centaur/vl/transforms/xf-orig.cert \
- centaur/vl/transforms/cn-hooks.cert \
- centaur/vl/transforms/xf-follow-hids.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-annotate-mods.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-argresolve.cert : acl2x = 0
-centaur/vl/transforms/xf-argresolve.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-argresolve.cert : \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/mlib/port-tools.cert \
- centaur/vl/mlib/find-module.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-argresolve.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-array-indexing.cert : acl2x = 0
-centaur/vl/transforms/xf-array-indexing.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-array-indexing.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-array-indexing.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-assign-trunc.cert : acl2x = 0
-centaur/vl/transforms/xf-assign-trunc.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-assign-trunc.cert : \
- centaur/vl/wf-ranges-resolved-p.cert \
- centaur/vl/wf-widthsfixed-p.cert \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/mlib/welltyped.cert \
- centaur/vl/mlib/delta.cert \
- centaur/vl/util/arithmetic.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-assign-trunc.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-blankargs.cert : acl2x = 0
-centaur/vl/transforms/xf-blankargs.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-blankargs.cert : \
- centaur/vl/mlib/find-module.cert \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/mlib/port-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-blankargs.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-clean-params.cert : acl2x = 0
-centaur/vl/transforms/xf-clean-params.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-clean-params.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/mlib/filter.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-clean-params.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-clean-selects.cert : acl2x = 0
-centaur/vl/transforms/xf-clean-selects.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-clean-selects.cert : \
- centaur/vl/mlib/clean-concats.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-clean-selects.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-delayredux.cert : acl2x = 0
-centaur/vl/transforms/xf-delayredux.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-delayredux.cert : \
- centaur/vl/transforms/occform/util.cert \
- centaur/vl/mlib/delta.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-delayredux.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-designregs.cert : acl2x = 0
-centaur/vl/transforms/xf-designregs.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-designregs.cert : \
- centaur/vl/mlib/writer.cert \
- centaur/vl/mlib/hid-tools.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/util/sum-nats.cert \
- centaur/vl/util/cwtime.cert \
- defsort/defsort.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/primitives.cert \
- centaur/esim/esim-sexpr-support.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-designregs.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-designwires.cert : acl2x = 0
-centaur/vl/transforms/xf-designwires.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-designwires.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-designwires.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-drop-blankports.cert : acl2x = 0
-centaur/vl/transforms/xf-drop-blankports.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-drop-blankports.cert : \
- centaur/vl/mlib/find-module.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-drop-blankports.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-elim-supply.cert : acl2x = 0
-centaur/vl/transforms/xf-elim-supply.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-elim-supply.cert : \
- centaur/vl/transforms/xf-subst.cert \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-elim-supply.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-expand-functions.cert : acl2x = 0
-centaur/vl/transforms/xf-expand-functions.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-expand-functions.cert : \
- centaur/vl/transforms/always/stmtrewrite.cert \
- centaur/vl/transforms/xf-subst.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/util/toposort.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-expand-functions.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-expr-simp.cert : acl2x = 0
-centaur/vl/transforms/xf-expr-simp.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-expr-simp.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/fmt.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-expr-simp.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-expr-split.cert : acl2x = 0
-centaur/vl/transforms/xf-expr-split.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-expr-split.cert : \
- centaur/vl/mlib/expr-slice.cert \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/mlib/delta.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-expr-split.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-follow-hids.cert : acl2x = 0
-centaur/vl/transforms/xf-follow-hids.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-follow-hids.cert : \
- centaur/vl/transforms/xf-resolve-ranges.cert \
- centaur/vl/mlib/hierarchy.cert \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/hid-tools.cert \
- centaur/vl/wf-ranges-resolved-p.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-follow-hids.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-gate-elim.cert : acl2x = 0
-centaur/vl/transforms/xf-gate-elim.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-gate-elim.cert : \
- centaur/vl/primitives.cert \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-gate-elim.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-gateredux.cert : acl2x = 0
-centaur/vl/transforms/xf-gateredux.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-gateredux.cert : \
- centaur/vl/transforms/occform/simple.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-gateredux.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-gatesplit.cert : acl2x = 0
-centaur/vl/transforms/xf-gatesplit.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-gatesplit.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-gatesplit.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-hid-elim.cert : acl2x = 0
-centaur/vl/transforms/xf-hid-elim.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-hid-elim.cert : \
- centaur/vl/transforms/xf-resolve-ranges.cert \
- centaur/vl/mlib/find-module.cert \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/hid-tools.cert \
- centaur/vl/wf-ranges-resolved-p.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-hid-elim.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-inline.cert : acl2x = 0
-centaur/vl/transforms/xf-inline.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-inline.cert : \
- centaur/vl/transforms/xf-subst.cert \
- centaur/vl/mlib/namemangle.cert \
- centaur/vl/mlib/relocate.cert \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/mlib/port-tools.cert \
- centaur/vl/mlib/writer.cert \
- centaur/vl/mlib/print-warnings.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-inline.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-oprewrite.cert : acl2x = 0
-centaur/vl/transforms/xf-oprewrite.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-oprewrite.cert : \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/checkers/duplicate-detect.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-oprewrite.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-optimize-rw.cert : acl2x = 0
-centaur/vl/transforms/xf-optimize-rw.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-optimize-rw.cert : \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-optimize-rw.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-orig.cert : acl2x = 0
-centaur/vl/transforms/xf-orig.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-orig.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-orig.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-portdecl-sign.cert : acl2x = 0
-centaur/vl/transforms/xf-portdecl-sign.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-portdecl-sign.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-portdecl-sign.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-propagate.cert : acl2x = 0
-centaur/vl/transforms/xf-propagate.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-propagate.cert : \
- centaur/vl/transforms/xf-subst.cert \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-propagate.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-replicate-insts.cert : acl2x = 0
-centaur/vl/transforms/xf-replicate-insts.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-replicate-insts.cert : \
- centaur/vl/mlib/expr-slice.cert \
- centaur/vl/mlib/namefactory.cert \
- centaur/vl/mlib/find-module.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/util/arithmetic.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-replicate-insts.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-resolve-ranges.cert : acl2x = 0
-centaur/vl/transforms/xf-resolve-ranges.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-resolve-ranges.cert : \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-resolve-ranges.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-sizing.cert : acl2x = 0
-centaur/vl/transforms/xf-sizing.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-sizing.cert : \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/util/sum-nats.cert \
- centaur/vl/mlib/context.cert \
- centaur/vl/mlib/welltyped.cert \
- centaur/vl/mlib/lvalues.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/bitops/ihs-extensions.cert \
- arithmetic-3/bind-free/top.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-sizing.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-subst.cert : acl2x = 0
-centaur/vl/transforms/xf-subst.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-subst.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-subst.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-unparameterize.cert : acl2x = 0
-centaur/vl/transforms/xf-unparameterize.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-unparameterize.cert : \
- centaur/vl/transforms/xf-subst.cert \
- centaur/vl/mlib/remove-bad.cert \
- centaur/vl/mlib/print-warnings.cert \
- centaur/vl/wf-ranges-resolved-p.cert \
- centaur/vl/onehot.cert \
- centaur/vl/util/cwtime.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/mlib/modname-sets.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-unparameterize.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-unused-reg.cert : acl2x = 0
-centaur/vl/transforms/xf-unused-reg.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-unused-reg.cert : \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-unused-reg.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/transforms/xf-weirdint-elim.cert : acl2x = 0
-centaur/vl/transforms/xf-weirdint-elim.cert : no_pcert = 0
-
-centaur/vl/transforms/xf-weirdint-elim.cert : \
- centaur/vl/transforms/occform/util.cert \
- centaur/vl/mlib/allexprs.cert \
- centaur/vl/mlib/stmt-tools.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/transforms/xf-weirdint-elim.lisp \
- centaur/vl/transforms/cert.acl2
-
-
-centaur/vl/translation.cert : acl2x = 0
-centaur/vl/translation.cert : no_pcert = 0
-
-centaur/vl/translation.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/loader/filemap.cert \
- centaur/vl/loader/defines.cert \
- centaur/vl/checkers/use-set-report.cert \
- centaur/vl/transforms/xf-designregs.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/translation.lisp \
- centaur/vl/cert.acl2
-
-
-centaur/vl/util/arithmetic.cert : acl2x = 0
-centaur/vl/util/arithmetic.cert : no_pcert = 0
-
-centaur/vl/util/arithmetic.cert : \
- arithmetic/top-with-meta.cert \
- centaur/bitops/integer-length.cert \
- cutil/deflist.cert \
- centaur/vl/util/subsetp-equal.cert \
- data-structures/list-defthms.cert \
- misc/hons-help.cert \
- std/lists/list-defuns.cert \
- std/lists/nthcdr.cert \
- std/lists/take.cert \
- std/lists/coerce.cert \
- std/lists/list-fix.cert \
- std/ks/explode-atom.cert \
- std/lists/repeat.cert \
- std/lists/rev.cert \
- defsort/duplicity.cert \
- tools/mv-nth.cert \
- tools/bstar.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/arithmetic.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/bits.cert : acl2x = 0
-centaur/vl/util/bits.cert : no_pcert = 0
-
-centaur/vl/util/bits.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/bits.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/character-list-listp.cert : acl2x = 0
-centaur/vl/util/character-list-listp.cert : no_pcert = 0
-
-centaur/vl/util/character-list-listp.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/character-list-listp.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/clean-alist.cert : acl2x = 0
-centaur/vl/util/clean-alist.cert : no_pcert = 0
-
-centaur/vl/util/clean-alist.cert : \
- centaur/vl/util/defs.cert \
- misc/hons-help.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/clean-alist.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/commentmap.cert : acl2x = 0
-centaur/vl/util/commentmap.cert : no_pcert = 0
-
-centaur/vl/util/commentmap.cert : \
- centaur/vl/util/echars.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/commentmap.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/cw-unformatted.cert : acl2x = 0
-centaur/vl/util/cw-unformatted.cert : no_pcert = 0
-
-centaur/vl/util/cw-unformatted.cert : \
- centaur/vl/portcullis.cert \
- centaur/vl/util/cw-unformatted.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/cwtime.cert : acl2x = 0
-centaur/vl/util/cwtime.cert : no_pcert = 0
-
-centaur/vl/util/cwtime.cert : \
- centaur/vl/portcullis.cert \
- centaur/vl/util/cwtime.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/defs.cert : acl2x = 0
-centaur/vl/util/defs.cert : no_pcert = 0
-
-centaur/vl/util/defs.cert : \
- cutil/top.cert \
- tools/defconsts.cert \
- std/ks/two-nats-measure.cert \
- std/lists/list-defuns.cert \
- centaur/bitops/integer-length.cert \
- centaur/misc/alist-equiv.cert \
- centaur/misc/hons-extra.cert \
- str/top.cert \
- str/fast-cat.cert \
- arithmetic/top-with-meta.cert \
- data-structures/list-defthms.cert \
- centaur/misc/equal-sets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/defs.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/defwellformed.cert : acl2x = 0
-centaur/vl/util/defwellformed.cert : no_pcert = 0
-
-centaur/vl/util/defwellformed.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/warnings.cert \
- tools/flag.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/defwellformed.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/echars.cert : acl2x = 0
-centaur/vl/util/echars.cert : no_pcert = 0
-
-centaur/vl/util/echars.cert : \
- centaur/vl/util/defs.cert \
- misc/assert.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/echars.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/esim-lemmas.cert : acl2x = 0
-centaur/vl/util/esim-lemmas.cert : no_pcert = 0
-
-centaur/vl/util/esim-lemmas.cert : \
- centaur/esim/esim-sexpr-support.cert \
- centaur/esim/esim-sexpr-support-thms.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/esim-lemmas.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/gc.cert : acl2x = 0
-centaur/vl/util/gc.cert : no_pcert = 0
-
-centaur/vl/util/gc.cert : \
- centaur/misc/memory-mgmt-raw.cert \
- tools/include-raw.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/gc.lisp \
- centaur/vl/util/cert.acl2 \
- centaur/vl/util/gc-raw.lsp
-
-
-centaur/vl/util/intersectp-equal.cert : acl2x = 0
-centaur/vl/util/intersectp-equal.cert : no_pcert = 0
-
-centaur/vl/util/intersectp-equal.cert : \
- std/lists/list-defuns.cert \
- cutil/define.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/intersectp-equal.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/namedb.cert : acl2x = 0
-centaur/vl/util/namedb.cert : no_pcert = 0
-
-centaur/vl/util/namedb.cert : \
- str/top.cert \
- centaur/vl/util/string-alists.cert \
- centaur/vl/util/nat-alists.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/namedb.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/nat-alists.cert : acl2x = 0
-centaur/vl/util/nat-alists.cert : no_pcert = 0
-
-centaur/vl/util/nat-alists.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/nat-alists.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/next-power-of-2.cert : acl2x = 0
-centaur/vl/util/next-power-of-2.cert : no_pcert = 0
-
-centaur/vl/util/next-power-of-2.cert : \
- arithmetic-3/floor-mod/floor-mod.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/next-power-of-2.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/osets.cert : acl2x = 0
-centaur/vl/util/osets.cert : no_pcert = 0
-
-centaur/vl/util/osets.cert : \
- centaur/vl/util/subsetp-equal.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/osets.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/position.cert : acl2x = 0
-centaur/vl/util/position.cert : no_pcert = 0
-
-centaur/vl/util/position.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/position.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/prefix-hash.cert : acl2x = 0
-centaur/vl/util/prefix-hash.cert : no_pcert = 0
-
-centaur/vl/util/prefix-hash.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/prefix-hash.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/prefixp.cert : acl2x = 0
-centaur/vl/util/prefixp.cert : no_pcert = 0
-
-centaur/vl/util/prefixp.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/prefixp.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/print-htmlencode.cert : acl2x = 0
-centaur/vl/util/print-htmlencode.cert : no_pcert = 0
-
-centaur/vl/util/print-htmlencode.cert : \
- tools/bstar.cert \
- make-event/assert.cert \
- centaur/vl/util/arithmetic.cert \
- ihs/quotient-remainder-lemmas.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/print-htmlencode.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/print-urlencode.cert : acl2x = 0
-centaur/vl/util/print-urlencode.cert : no_pcert = 0
-
-centaur/vl/util/print-urlencode.cert : \
- xdoc/top.cert \
- misc/definline.cert \
- make-event/assert.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/print-urlencode.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/print.cert : acl2x = 0
-centaur/vl/util/print.cert : no_pcert = 0
-
-centaur/vl/util/print.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/print-urlencode.cert \
- centaur/vl/util/print-htmlencode.cert \
- centaur/vl/util/cw-unformatted.cert \
- str/natstr.cert \
- centaur/vl/util/arithmetic.cert \
- make-event/assert.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/print.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/string-alists.cert : acl2x = 0
-centaur/vl/util/string-alists.cert : no_pcert = 0
-
-centaur/vl/util/string-alists.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/string-alists.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/subsetp-equal.cert : acl2x = 0
-centaur/vl/util/subsetp-equal.cert : no_pcert = 0
-
-centaur/vl/util/subsetp-equal.cert : \
- centaur/misc/equal-sets.cert \
- finite-set-theory/osets/sets.cert \
- std/lists/list-fix.cert \
- std/lists/take.cert \
- defsort/duplicated-members.cert \
- arithmetic/top.cert \
- data-structures/list-defthms.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/subsetp-equal.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/sum-nats.cert : acl2x = 0
-centaur/vl/util/sum-nats.cert : no_pcert = 0
-
-centaur/vl/util/sum-nats.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/sum-nats.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/toposort.cert : acl2x = 0
-centaur/vl/util/toposort.cert : no_pcert = 0
-
-centaur/vl/util/toposort.cert : \
- centaur/vl/util/defs.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- make-event/assert.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/toposort.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/util/warnings.cert : acl2x = 0
-centaur/vl/util/warnings.cert : no_pcert = 0
-
-centaur/vl/util/warnings.cert : \
- centaur/vl/util/defs.cert \
- defsort/remove-dups.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/util/warnings.lisp \
- centaur/vl/util/cert.acl2
-
-
-centaur/vl/wf-ranges-resolved-p.cert : acl2x = 0
-centaur/vl/wf-ranges-resolved-p.cert : no_pcert = 0
-
-centaur/vl/wf-ranges-resolved-p.cert : \
- centaur/vl/mlib/range-tools.cert \
- centaur/vl/util/defwellformed.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/wf-ranges-resolved-p.lisp \
- centaur/vl/cert.acl2
-
-
-centaur/vl/wf-reasonable-p.cert : acl2x = 0
-centaur/vl/wf-reasonable-p.cert : no_pcert = 0
-
-centaur/vl/wf-reasonable-p.cert : \
- centaur/vl/mlib/modnamespace.cert \
- centaur/vl/mlib/find-item.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/util/defwellformed.cert \
- centaur/vl/util/warnings.cert \
- defsort/duplicated-members.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/util/osets.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/wf-reasonable-p.lisp \
- centaur/vl/cert.acl2
-
-
-centaur/vl/wf-widthsfixed-p.cert : acl2x = 0
-centaur/vl/wf-widthsfixed-p.cert : no_pcert = 0
-
-centaur/vl/wf-widthsfixed-p.cert : \
- centaur/vl/parsetree.cert \
- centaur/vl/mlib/expr-tools.cert \
- centaur/vl/wf-reasonable-p.cert \
- centaur/vl/util/arithmetic.cert \
- centaur/vl/portcullis.cert \
- centaur/vl/wf-widthsfixed-p.lisp \
- centaur/vl/cert.acl2
-
-
-clause-processors/autohide.cert : acl2x = 0
-clause-processors/autohide.cert : no_pcert = 0
-
-clause-processors/autohide.cert : \
- clause-processors/join-thms.cert \
- tools/flag.cert \
- tools/do-not.cert \
- clause-processors/equality.cert \
- clause-processors/autohide.lisp \
- clause-processors/autohide.acl2 \
- tools/flag-package.lsp
-
-
-clause-processors/basic-examples.cert : acl2x = 0
-clause-processors/basic-examples.cert : no_pcert = 0
-
-clause-processors/basic-examples.cert : \
- misc/eval.cert \
- arithmetic/top-with-meta.cert \
- clause-processors/basic-examples.lisp \
- clause-processors/basic-examples.acl2
-
-
-clause-processors/bv-add-common.cert : acl2x = 0
-clause-processors/bv-add-common.cert : no_pcert = 0
-
-clause-processors/bv-add-common.cert : \
- arithmetic-3/floor-mod/floor-mod.cert \
- clause-processors/bv-add-common.lisp
-
-
-clause-processors/bv-add-tests.cert : acl2x = 0
-clause-processors/bv-add-tests.cert : no_pcert = 0
-
-clause-processors/bv-add-tests.cert : \
- arithmetic-3/floor-mod/floor-mod.cert \
- clause-processors/bv-add-common.cert \
- clause-processors/bv-add.cert \
- clause-processors/bv-add-tests.lisp
-
-
-clause-processors/bv-add.cert : acl2x = 0
-clause-processors/bv-add.cert : no_pcert = 0
-
-clause-processors/bv-add.cert : \
- textbook/chap11/perm-append.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- clause-processors/bv-add.lisp
-
-
-clause-processors/decomp-hint.cert : acl2x = 0
-clause-processors/decomp-hint.cert : no_pcert = 0
-
-clause-processors/decomp-hint.cert : \
- clause-processors/join-thms.cert \
- tools/bstar.cert \
- clause-processors/decomp-hint.lisp
-
-
-clause-processors/equality.cert : acl2x = 0
-clause-processors/equality.cert : no_pcert = 0
-
-clause-processors/equality.cert : \
- tools/flag.cert \
- misc/eval.cert \
- clause-processors/equality.lisp \
- clause-processors/equality.acl2 \
- tools/flag-package.lsp
-
-
-clause-processors/ev-find-rules.cert : acl2x = 0
-clause-processors/ev-find-rules.cert : no_pcert = 0
-
-clause-processors/ev-find-rules.cert : \
- clause-processors/ev-find-rules.lisp
-
-
-clause-processors/ev-theoremp.cert : acl2x = 0
-clause-processors/ev-theoremp.cert : no_pcert = 0
-
-clause-processors/ev-theoremp.cert : \
- clause-processors/join-thms.cert \
- clause-processors/ev-theoremp.lisp
-
-
-clause-processors/find-subterms.cert : acl2x = 0
-clause-processors/find-subterms.cert : no_pcert = 0
-
-clause-processors/find-subterms.cert : \
- clause-processors/find-subterms.lisp
-
-
-clause-processors/generalize.cert : acl2x = 0
-clause-processors/generalize.cert : no_pcert = 0
-
-clause-processors/generalize.cert : \
- tools/flag.cert \
- data-structures/list-theory.cert \
- clause-processors/join-thms.cert \
- arithmetic/top-with-meta.cert \
- ihs/quotient-remainder-lemmas.cert \
- clause-processors/generalize.lisp \
- clause-processors/generalize.acl2 \
- tools/flag-package.lsp
-
-
-clause-processors/instantiate.cert : acl2x = 0
-clause-processors/instantiate.cert : no_pcert = 0
-
-clause-processors/instantiate.cert : \
- clause-processors/unify-subst.cert \
- tools/flag.cert \
- tools/bstar.cert \
- clause-processors/instantiate.lisp
-
-
-clause-processors/join-thms.cert : acl2x = 0
-clause-processors/join-thms.cert : no_pcert = 0
-
-clause-processors/join-thms.cert : \
- clause-processors/ev-find-rules.cert \
- clause-processors/join-thms.lisp
-
-
-clause-processors/just-expand.cert : acl2x = 0
-clause-processors/just-expand.cert : no_pcert = 0
-
-clause-processors/just-expand.cert : \
- clause-processors/unify-subst.cert \
- tools/bstar.cert \
- clause-processors/ev-theoremp.cert \
- clause-processors/use-by-hint.cert \
- clause-processors/just-expand.lisp
-
-
-clause-processors/meta-extract-simple-test.cert : acl2x = 0
-clause-processors/meta-extract-simple-test.cert : no_pcert = 0
-
-clause-processors/meta-extract-simple-test.cert : \
- system/meta-extract.cert \
- arithmetic-5/top.cert \
- arithmetic-5/top.cert \
- arithmetic-5/top.cert \
- clause-processors/meta-extract-simple-test.lisp
-
-
-clause-processors/meta-extract-user.cert : acl2x = 0
-clause-processors/meta-extract-user.cert : no_pcert = 0
-
-clause-processors/meta-extract-user.cert : \
- tools/defevaluator-fast.cert \
- clause-processors/ev-theoremp.cert \
- tools/def-functional-instance.cert \
- system/sublis-var.cert \
- system/meta-extract.cert \
- clause-processors/meta-extract-user.lisp
-
-
-clause-processors/multi-env-trick.cert : acl2x = 0
-clause-processors/multi-env-trick.cert : no_pcert = 0
-
-clause-processors/multi-env-trick.cert : \
- clause-processors/join-thms.cert \
- misc/untranslate-patterns.cert \
- clause-processors/multi-env-trick.lisp
-
-
-clause-processors/null-fail-hints.cert : acl2x = 0
-clause-processors/null-fail-hints.cert : no_pcert = 0
-
-clause-processors/null-fail-hints.cert : \
- clause-processors/join-thms.cert \
- clause-processors/null-fail-hints.lisp
-
-
-clause-processors/nvalues-thms.cert : acl2x = 0
-clause-processors/nvalues-thms.cert : no_pcert = 0
-
-clause-processors/nvalues-thms.cert : \
- tools/bstar.cert \
- tools/mv-nth.cert \
- clause-processors/multi-env-trick.cert \
- clause-processors/join-thms.cert \
- tools/flag.cert \
- arithmetic/top-with-meta.cert \
- clause-processors/nvalues-thms.lisp
-
-
-clause-processors/replace-defined-consts.cert : acl2x = 0
-clause-processors/replace-defined-consts.cert : no_pcert = 0
-
-clause-processors/replace-defined-consts.cert : \
- clause-processors/use-by-hint.cert \
- clause-processors/multi-env-trick.cert \
- tools/bstar.cert \
- tools/flag.cert \
- tools/mv-nth.cert \
- clause-processors/replace-defined-consts.lisp \
- clause-processors/replace-defined-consts.acl2 \
- tools/flag-package.lsp
-
-
-clause-processors/replace-impl.cert : acl2x = 0
-clause-processors/replace-impl.cert : no_pcert = 0
-
-clause-processors/replace-impl.cert : \
- clause-processors/replace-impl.lisp
-
-
-clause-processors/stobj-preservation.cert : acl2x = 0
-clause-processors/stobj-preservation.cert : no_pcert = 0
-
-clause-processors/stobj-preservation.cert : \
- xdoc/top.cert \
- clause-processors/just-expand.cert \
- clause-processors/stobj-preservation.lisp
-
-
-clause-processors/sublis-var-meaning.cert : acl2x = 0
-clause-processors/sublis-var-meaning.cert : no_pcert = 0
-
-clause-processors/sublis-var-meaning.cert : \
- system/sublis-var.cert \
- tools/flag.cert \
- tools/mv-nth.cert \
- tools/defevaluator-fast.cert \
- clause-processors/sublis-var-meaning.lisp
-
-
-clause-processors/term-patterns.cert : acl2x = 0
-clause-processors/term-patterns.cert : no_pcert = 0
-
-clause-processors/term-patterns.cert : \
- tools/flag.cert \
- tools/flag.cert \
- clause-processors/term-patterns.lisp \
- clause-processors/term-patterns.acl2
-
-
-clause-processors/unify-subst.cert : acl2x = 0
-clause-processors/unify-subst.cert : no_pcert = 0
-
-clause-processors/unify-subst.cert : \
- tools/flag.cert \
- tools/bstar.cert \
- tools/mv-nth.cert \
- tools/def-functional-instance.cert \
- clause-processors/ev-find-rules.cert \
- clause-processors/unify-subst.lisp \
- clause-processors/unify-subst.acl2 \
- tools/flag-package.lsp
-
-
-clause-processors/use-by-hint.cert : acl2x = 0
-clause-processors/use-by-hint.cert : no_pcert = 0
-
-clause-processors/use-by-hint.cert : \
- clause-processors/join-thms.cert \
- clause-processors/use-by-hint.lisp
-
-
-clause-processors/witness-cp.cert : acl2x = 0
-clause-processors/witness-cp.cert : no_pcert = 0
-
-clause-processors/witness-cp.cert : \
- clause-processors/use-by-hint.cert \
- clause-processors/generalize.cert \
- clause-processors/unify-subst.cert \
- tools/bstar.cert \
- clause-processors/ev-theoremp.cert \
- tools/def-functional-instance.cert \
- tools/oracle-eval.cert \
- data-structures/no-duplicates.cert \
- clause-processors/witness-cp.lisp \
- clause-processors/witness-cp.acl2 \
- tools/flag-package.lsp
-
-
-coi/adviser/adviser-pkg.cert : acl2x = 0
-coi/adviser/adviser-pkg.cert : no_pcert = 0
-
-coi/adviser/adviser-pkg.cert : \
- coi/adviser/adviser-pkg.lisp \
- coi/adviser/cert.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/adviser/adviser.cert : acl2x = 0
-coi/adviser/adviser.cert : no_pcert = 0
-
-coi/adviser/adviser.cert : \
- misc/symbol-btree.cert \
- coi/symbol-fns/symbol-fns.cert \
- coi/adviser/adviser.lisp \
- coi/adviser/cert.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/adviser/test.cert : acl2x = 0
-coi/adviser/test.cert : no_pcert = 0
-
-coi/adviser/test.cert : \
- coi/adviser/adviser.cert \
- coi/adviser/test.lisp \
- coi/adviser/cert.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/alists/alist-pkg.cert : acl2x = 0
-coi/alists/alist-pkg.cert : no_pcert = 0
-
-coi/alists/alist-pkg.cert : \
- coi/alists/alist-pkg.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/alists/bindequiv.cert : acl2x = 0
-coi/alists/bindequiv.cert : no_pcert = 0
-
-coi/alists/bindequiv.cert : \
- coi/util/mv-nth.cert \
- coi/nary/nary.cert \
- coi/util/good-rewrite-order.cert \
- coi/alists/keyquiv.cert \
- coi/bags/top.cert \
- misc/total-order.cert \
- coi/alists/bindequiv.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/alists/clearkey.cert : acl2x = 0
-coi/alists/clearkey.cert : no_pcert = 0
-
-coi/alists/clearkey.cert : \
- coi/alists/equiv.cert \
- coi/bags/basic.cert \
- coi/alists/clearkey.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/alists/deshadow.cert : acl2x = 0
-coi/alists/deshadow.cert : no_pcert = 0
-
-coi/alists/deshadow.cert : \
- coi/alists/strip.cert \
- coi/alists/clearkey.cert \
- coi/bags/basic.cert \
- coi/util/iff.cert \
- coi/bags/pick-a-point.cert \
- coi/alists/deshadow.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/alists/equiv.cert : acl2x = 0
-coi/alists/equiv.cert : no_pcert = 0
-
-coi/alists/equiv.cert : \
- coi/lists/basic.cert \
- coi/util/iff.cert \
- coi/alists/equiv.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/alists/keyquiv.cert : acl2x = 0
-coi/alists/keyquiv.cert : no_pcert = 0
-
-coi/alists/keyquiv.cert : \
- coi/util/iff.cert \
- coi/lists/basic.cert \
- coi/lists/memberp.cert \
- coi/lists/set.cert \
- coi/util/good-rewrite-order.cert \
- coi/alists/equiv.cert \
- coi/util/iff.cert \
- coi/lists/remove-induction.cert \
- coi/lists/remove.cert \
- coi/alists/keyquiv.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/alists/preimage.cert : acl2x = 0
-coi/alists/preimage.cert : no_pcert = 0
-
-coi/alists/preimage.cert : \
- coi/alists/deshadow.cert \
- coi/alists/strip.cert \
- coi/alists/preimage.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/alists/strip.cert : acl2x = 0
-coi/alists/strip.cert : no_pcert = 0
-
-coi/alists/strip.cert : \
- coi/alists/equiv.cert \
- coi/lists/memberp.cert \
- coi/util/iff.cert \
- coi/alists/strip.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/alists/subkeyquiv.cert : acl2x = 0
-coi/alists/subkeyquiv.cert : no_pcert = 0
-
-coi/alists/subkeyquiv.cert : \
- coi/lists/set.cert \
- coi/alists/keyquiv.cert \
- coi/util/good-rewrite-order.cert \
- coi/nary/nary.cert \
- coi/alists/subkeyquiv.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/alists/top.cert : acl2x = 0
-coi/alists/top.cert : no_pcert = 0
-
-coi/alists/top.cert : \
- coi/alists/equiv.cert \
- coi/alists/strip.cert \
- coi/alists/clearkey.cert \
- coi/alists/deshadow.cert \
- coi/alists/preimage.cert \
- coi/alists/top.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/bags/basic.cert : acl2x = 0
-coi/bags/basic.cert : no_pcert = 0
-
-coi/bags/basic.cert : \
- coi/lists/basic.cert \
- coi/lists/memberp.cert \
- coi/lists/disjoint.cert \
- coi/bags/basic.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/bags/bind-free-rules.cert : acl2x = 0
-coi/bags/bind-free-rules.cert : no_pcert = 0
-
-coi/bags/bind-free-rules.cert : \
- coi/bags/meta.cert \
- coi/bags/bind-free-rules.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/bags/cons.cert : acl2x = 0
-coi/bags/cons.cert : no_pcert = 0
-
-coi/bags/cons.cert : \
- coi/syntax/syntax.cert \
- coi/bags/cons.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/bags/eric-meta.cert : acl2x = 0
-coi/bags/eric-meta.cert : no_pcert = 0
-
-coi/bags/eric-meta.cert : \
- coi/bags/bind-free-rules.cert \
- coi/util/iff.cert \
- rtl/rel4/support/logand.cert \
- coi/bags/eric-meta.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/bags/extras.cert : acl2x = 0
-coi/bags/extras.cert : no_pcert = 0
-
-coi/bags/extras.cert : \
- coi/bags/basic.cert \
- coi/lists/find-index.cert \
- coi/bags/extras.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/bags/meta.cert : acl2x = 0
-coi/bags/meta.cert : no_pcert = 0
-
-coi/bags/meta.cert : \
- coi/bags/basic.cert \
- ordinals/e0-ordinal.cert \
- coi/util/mv-nth.cert \
- coi/util/iff.cert \
- coi/syntax/syntax.cert \
- arithmetic/top-with-meta.cert \
- coi/bags/meta.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/bags/neq.cert : acl2x = 0
-coi/bags/neq.cert : no_pcert = 0
-
-coi/bags/neq.cert : \
- coi/bags/bind-free-rules.cert \
- coi/bags/neq.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/bags/pick-a-point.cert : acl2x = 0
-coi/bags/pick-a-point.cert : no_pcert = 0
-
-coi/bags/pick-a-point.cert : \
- coi/bags/basic.cert \
- coi/adviser/adviser.cert \
- coi/bags/pick-a-point.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/bags/top.cert : acl2x = 0
-coi/bags/top.cert : no_pcert = 0
-
-coi/bags/top.cert : \
- coi/bags/bind-free-rules.cert \
- coi/bags/cons.cert \
- coi/bags/neq.cert \
- coi/bags/eric-meta.cert \
- coi/bags/top.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/bags/two-level-meta.cert : acl2x = 0
-coi/bags/two-level-meta.cert : no_pcert = 0
-
-coi/bags/two-level-meta.cert : \
- coi/bags/two-level.cert \
- coi/bags/two-level-meta.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/bags/two-level.cert : acl2x = 0
-coi/bags/two-level.cert : no_pcert = 0
-
-coi/bags/two-level.cert : \
- coi/bags/bind-free-rules.cert \
- coi/bags/two-level.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/defpun/ack.cert : acl2x = 0
-coi/defpun/ack.cert : no_pcert = 0
-
-coi/defpun/ack.cert : \
- coi/defpun/defminterm.cert \
- coi/defpun/ack.lisp
-
-
-coi/defpun/defminterm.cert : acl2x = 0
-coi/defpun/defminterm.cert : no_pcert = 0
-
-coi/defpun/defminterm.cert : \
- coi/defpun/defxch.cert \
- coi/defpun/defpun.cert \
- coi/defpun/defminterm.lisp
-
-
-coi/defpun/defpun.cert : acl2x = 0
-coi/defpun/defpun.cert : no_pcert = 0
-
-coi/defpun/defpun.cert : \
- coi/defpun/defpun.lisp
-
-
-coi/defpun/defxch.cert : acl2x = 0
-coi/defpun/defxch.cert : no_pcert = 0
-
-coi/defpun/defxch.cert : \
- arithmetic-2/meta/top.cert \
- misc/defpun.cert \
- coi/defpun/defxch.lisp
-
-
-coi/defstructure/defstructure-pkg.cert : acl2x = 0
-coi/defstructure/defstructure-pkg.cert : no_pcert = 0
-
-coi/defstructure/defstructure-pkg.cert : \
- coi/defstructure/defstructure-pkg.lisp \
- coi/defstructure/cert.acl2 \
- coi/defstructure/structures-defpkg.lsp \
- coi/symbol-fns/symbol-fns-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/define-u-package.lsp
-
-
-coi/defstructure/defstructure.cert : acl2x = 0
-coi/defstructure/defstructure.cert : no_pcert = 0
-
-coi/defstructure/defstructure.cert : \
- coi/paths/path.cert \
- data-structures/utilities.cert \
- coi/defstructure/defstructure.lisp \
- coi/defstructure/cert.acl2 \
- coi/defstructure/structures-defpkg.lsp \
- coi/symbol-fns/symbol-fns-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/define-u-package.lsp
-
-
-coi/dtrees/base.cert : acl2x = 0
-coi/dtrees/base.cert : no_pcert = 0
-
-coi/dtrees/base.cert : \
- coi/util/iff.cert \
- coi/maps/maps.cert \
- coi/lists/basic.cert \
- coi/osets/multicons.cert \
- coi/maps/typed-maps.cert \
- coi/dtrees/base.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/dtrees/child.cert : acl2x = 0
-coi/dtrees/child.cert : no_pcert = 0
-
-coi/dtrees/child.cert : \
- coi/dtrees/raw.cert \
- coi/dtrees/set.cert \
- coi/dtrees/erase.cert \
- coi/dtrees/child.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/dtrees/deps.cert : acl2x = 0
-coi/dtrees/deps.cert : no_pcert = 0
-
-coi/dtrees/deps.cert : \
- coi/dtrees/base.cert \
- coi/dtrees/deps.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/dtrees/equiv.cert : acl2x = 0
-coi/dtrees/equiv.cert : no_pcert = 0
-
-coi/dtrees/equiv.cert : \
- coi/dtrees/deps.cert \
- coi/dtrees/equiv.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/dtrees/erase.cert : acl2x = 0
-coi/dtrees/erase.cert : no_pcert = 0
-
-coi/dtrees/erase.cert : \
- coi/dtrees/set.cert \
- coi/paths/dominates.cert \
- coi/paths/diverge.cert \
- arithmetic/top-with-meta.cert \
- coi/dtrees/erase.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/dtrees/leafp.cert : acl2x = 0
-coi/dtrees/leafp.cert : no_pcert = 0
-
-coi/dtrees/leafp.cert : \
- coi/dtrees/equiv.cert \
- coi/paths/dominates.cert \
- coi/paths/diverge.cert \
- arithmetic/top-with-meta.cert \
- coi/dtrees/leafp.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/dtrees/raw.cert : acl2x = 0
-coi/dtrees/raw.cert : no_pcert = 0
-
-coi/dtrees/raw.cert : \
- coi/dtrees/equiv.cert \
- coi/dtrees/raw.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/dtrees/royalp.cert : acl2x = 0
-coi/dtrees/royalp.cert : no_pcert = 0
-
-coi/dtrees/royalp.cert : \
- coi/dtrees/equiv.cert \
- coi/paths/dominates.cert \
- coi/paths/diverge.cert \
- arithmetic/top-with-meta.cert \
- coi/dtrees/royalp.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/dtrees/set.cert : acl2x = 0
-coi/dtrees/set.cert : no_pcert = 0
-
-coi/dtrees/set.cert : \
- coi/dtrees/raw.cert \
- coi/paths/dominates.cert \
- coi/paths/diverge.cert \
- arithmetic/top-with-meta.cert \
- coi/dtrees/set.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/dtrees/top.cert : acl2x = 0
-coi/dtrees/top.cert : no_pcert = 0
-
-coi/dtrees/top.cert : \
- coi/dtrees/base.cert \
- coi/dtrees/deps.cert \
- coi/dtrees/equiv.cert \
- coi/dtrees/raw.cert \
- coi/dtrees/set.cert \
- coi/dtrees/erase.cert \
- coi/dtrees/leafp.cert \
- coi/dtrees/royalp.cert \
- coi/dtrees/child.cert \
- coi/dtrees/top.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/abstract-gacc.cert : acl2x = 0
-coi/gacc/abstract-gacc.cert : no_pcert = 0
-
-coi/gacc/abstract-gacc.cert : \
- coi/records/defrecord.cert \
- coi/gacc/abstract-gacc.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/addr-range.cert : acl2x = 0
-coi/gacc/addr-range.cert : no_pcert = 0
-
-coi/gacc/addr-range.cert : \
- coi/bags/basic.cert \
- coi/gacc/addr-range.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/bits.cert : acl2x = 0
-coi/gacc/bits.cert : no_pcert = 0
-
-coi/gacc/bits.cert : \
- coi/super-ihs/super-ihs.cert \
- coi/gacc/bits.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/block.cert : acl2x = 0
-coi/gacc/block.cert : no_pcert = 0
-
-coi/gacc/block.cert : \
- coi/bags/basic.cert \
- arithmetic/top-with-meta.cert \
- coi/gacc/block.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/finite.cert : acl2x = 0
-coi/gacc/finite.cert : no_pcert = 0
-
-coi/gacc/finite.cert : \
- coi/gacc/gax.cert \
- coi/gacc/gax.cert \
- coi/gacc/finite.lisp \
- coi/gacc/finite.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/fr-path-connection.cert : acl2x = 0
-coi/gacc/fr-path-connection.cert : no_pcert = 0
-
-coi/gacc/fr-path-connection.cert : \
- coi/gacc/mem-fast.cert \
- coi/paths/path.cert \
- coi/records/mem-domain.cert \
- coi/osets/extras.cert \
- coi/paths/path.cert \
- coi/gacc/fr-path-connection.lisp \
- coi/gacc/fr-path-connection.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/gacc-exports.cert : acl2x = 0
-coi/gacc/gacc-exports.cert : no_pcert = 0
-
-coi/gacc/gacc-exports.cert : \
- coi/gacc/gacc-exports.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/gacc-pkg.cert : acl2x = 0
-coi/gacc/gacc-pkg.cert : no_pcert = 0
-
-coi/gacc/gacc-pkg.cert : \
- coi/gacc/gacc-pkg.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/gacc.cert : acl2x = 0
-coi/gacc/gacc.cert : no_pcert = 0
-
-coi/gacc/gacc.cert : \
- coi/gacc/ram.cert \
- ordinals/e0-ordinal.cert \
- coi/bags/top.cert \
- coi/gacc/ram.cert \
- ordinals/e0-ordinal.cert \
- coi/gacc/gacc.lisp \
- coi/gacc/gacc.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/gacc2.cert : acl2x = 0
-coi/gacc/gacc2.cert : no_pcert = 0
-
-coi/gacc/gacc2.cert : \
- coi/defstructure/defstructure.cert \
- coi/gacc/ram.cert \
- coi/defstructure/defstructure.cert \
- coi/gacc/ram.cert \
- coi/gacc/gacc2.lisp \
- coi/gacc/gacc2.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/gacc3.cert : acl2x = 0
-coi/gacc/gacc3.cert : no_pcert = 0
-
-coi/gacc/gacc3.cert : \
- coi/gacc/finite.cert \
- coi/gacc/finite.cert \
- coi/gacc/gacc3.lisp \
- coi/gacc/gacc3.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/gax.cert : acl2x = 0
-coi/gacc/gax.cert : no_pcert = 0
-
-coi/gacc/gax.cert : \
- coi/gacc/gacc2.cert \
- coi/gacc/gacc.cert \
- coi/util/mv-nth.cert \
- coi/gacc/gacc2.cert \
- coi/gacc/gacc.cert \
- coi/gacc/gax.lisp \
- coi/gacc/gax.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/list-ops-common.cert : acl2x = 0
-coi/gacc/list-ops-common.cert : no_pcert = 0
-
-coi/gacc/list-ops-common.cert : \
- coi/super-ihs/super-ihs.cert \
- coi/lists/memberp.cert \
- coi/lists/repeat.cert \
- coi/bags/basic.cert \
- coi/lists/find-index.cert \
- coi/bags/pick-a-point.cert \
- coi/gacc/list-ops-common.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/list-ops-fast.cert : acl2x = 0
-coi/gacc/list-ops-fast.cert : no_pcert = 0
-
-coi/gacc/list-ops-fast.cert : \
- coi/gacc/mem-fast.cert \
- coi/lists/memberp.cert \
- coi/bags/extras.cert \
- coi/super-ihs/super-ihs.cert \
- coi/gacc/list-ops-common.cert \
- coi/gacc/list-ops-fast.lisp \
- coi/gacc/list-ops-fast.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp
-
-
-coi/gacc/list-ops.cert : acl2x = 0
-coi/gacc/list-ops.cert : no_pcert = 0
-
-coi/gacc/list-ops.cert : \
- coi/gacc/mem.cert \
- coi/lists/memberp.cert \
- coi/bags/basic.cert \
- coi/gacc/list-ops-common.cert \
- coi/super-ihs/super-ihs.cert \
- coi/gacc/list-ops.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/mem-fast.cert : acl2x = 0
-coi/gacc/mem-fast.cert : no_pcert = 0
-
-coi/gacc/mem-fast.cert : \
- coi/records/defrecord-fast.cert \
- coi/super-ihs/loghead.cert \
- coi/super-ihs/unsigned-byte-p.cert \
- coi/util/syntaxp.cert \
- coi/gacc/mem-fast.lisp \
- coi/gacc/mem-fast.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp
-
-
-coi/gacc/mem.cert : acl2x = 0
-coi/gacc/mem.cert : no_pcert = 0
-
-coi/gacc/mem.cert : \
- coi/records/defrecord.cert \
- coi/super-ihs/loghead.cert \
- coi/super-ihs/unsigned-byte-p.cert \
- coi/util/syntaxp.cert \
- coi/gacc/mem.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/ram.cert : acl2x = 0
-coi/gacc/ram.cert : no_pcert = 0
-
-coi/gacc/ram.cert : \
- coi/gacc/ram0.cert \
- coi/gacc/block.cert \
- coi/bags/two-level-meta.cert \
- rtl/rel4/arithmetic/fl.cert \
- coi/super-ihs/super-ihs.cert \
- coi/gacc/addr-range.cert \
- coi/gacc/list-ops.cert \
- coi/gacc/ram.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/ram0.cert : acl2x = 0
-coi/gacc/ram0.cert : no_pcert = 0
-
-coi/gacc/ram0.cert : \
- coi/gacc/mem.cert \
- coi/super-ihs/byte-p.cert \
- coi/gacc/ram0.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/ram2.cert : acl2x = 0
-coi/gacc/ram2.cert : no_pcert = 0
-
-coi/gacc/ram2.cert : \
- coi/gacc/list-ops-fast.cert \
- coi/gacc/addr-range.cert \
- coi/gacc/wrap.cert \
- rtl/rel4/arithmetic/fl.cert \
- coi/super-ihs/super-ihs.cert \
- coi/gacc/ram2.lisp \
- coi/gacc/ram2.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp
-
-
-coi/gacc/ram2b.cert : acl2x = 0
-coi/gacc/ram2b.cert : no_pcert = 0
-
-coi/gacc/ram2b.cert : \
- coi/gacc/list-ops-fast.cert \
- coi/gacc/addr-range.cert \
- coi/gacc/ram3.cert \
- rtl/rel4/arithmetic/fl.cert \
- coi/super-ihs/super-ihs.cert \
- coi/gacc/ram2b.lisp \
- coi/gacc/ram2b.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp
-
-
-coi/gacc/ram3.cert : acl2x = 0
-coi/gacc/ram3.cert : no_pcert = 0
-
-coi/gacc/ram3.cert : \
- coi/util/iff.cert \
- coi/gacc/list-ops-fast.cert \
- coi/gacc/wrap.cert \
- rtl/rel4/arithmetic/fl.cert \
- coi/super-ihs/super-ihs.cert \
- coi/super-ihs/fast.cert \
- coi/lists/mixed.cert \
- coi/bags/pick-a-point.cert \
- coi/lists/repeat.cert \
- coi/gacc/ram3.lisp \
- coi/gacc/ram3.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp
-
-
-coi/gacc/top.cert : acl2x = 0
-coi/gacc/top.cert : no_pcert = 0
-
-coi/gacc/top.cert : \
- coi/gacc/gacc3.cert \
- coi/gacc/gacc3.cert \
- coi/gacc/top.lisp \
- coi/gacc/top.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/tr-path-connection.cert : acl2x = 0
-coi/gacc/tr-path-connection.cert : no_pcert = 0
-
-coi/gacc/tr-path-connection.cert : \
- coi/gacc/mem.cert \
- coi/paths/path.cert \
- coi/records/domain.cert \
- coi/osets/conversions.cert \
- coi/osets/quantify.cert \
- coi/gacc/tr-path-connection.lisp \
- coi/gacc/tr-path-connection.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/gacc/wrap.cert : acl2x = 0
-coi/gacc/wrap.cert : no_pcert = 0
-
-coi/gacc/wrap.cert : \
- coi/bags/basic.cert \
- coi/super-ihs/super-ihs.cert \
- coi/gacc/addr-range.cert \
- coi/lists/mixed.cert \
- coi/lists/find-index.cert \
- coi/util/syntaxp.cert \
- coi/gacc/wrap.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-
-
-coi/generalize/generalize.cert : acl2x = 0
-coi/generalize/generalize.cert : no_pcert = 0
-
-coi/generalize/generalize.cert : \
- coi/symbol-fns/symbol-fns.cert \
- coi/util/mv-nth.cert \
- coi/gensym/gensym.cert \
- coi/bags/top.cert \
- coi/lists/set.cert \
- coi/util/clause-processor.cert \
- coi/generalize/generalize.lisp \
- coi/generalize/cert.acl2 \
- coi/util/def-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/gensym/gensym-list.cert : acl2x = 0
-coi/gensym/gensym-list.cert : no_pcert = 0
-
-coi/gensym/gensym-list.cert : \
- coi/gensym/gensym.cert \
- coi/lists/disjoint.cert \
- coi/bags/basic.cert \
- coi/gensym/gensym-list.lisp \
- coi/gensym/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/gensym/gensym.cert : acl2x = 0
-coi/gensym/gensym.cert : no_pcert = 0
-
-coi/gensym/gensym.cert : \
- coi/symbol-fns/symbol-fns.cert \
- coi/util/ordinal-order.cert \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- coi/bags/top.cert \
- coi/lists/set.cert \
- coi/lists/memberp.cert \
- coi/gensym/gensym.lisp \
- coi/gensym/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/lists/acl2-count.cert : acl2x = 0
-coi/lists/acl2-count.cert : no_pcert = 0
-
-coi/lists/acl2-count.cert : \
- coi/lists/acl2-count.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/basic.cert : acl2x = 0
-coi/lists/basic.cert : no_pcert = 0
-
-coi/lists/basic.cert : \
- arithmetic/top-with-meta.cert \
- coi/util/debug.cert \
- coi/lists/acl2-count.cert \
- coi/util/iff.cert \
- coi/adviser/adviser.cert \
- coi/lists/basic.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/disjoint.cert : acl2x = 0
-coi/lists/disjoint.cert : no_pcert = 0
-
-coi/lists/disjoint.cert : \
- coi/lists/memberp.cert \
- coi/util/iff.cert \
- coi/lists/remove.cert \
- coi/lists/disjoint.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/find-index.cert : acl2x = 0
-coi/lists/find-index.cert : no_pcert = 0
-
-coi/lists/find-index.cert : \
- coi/lists/nth-and-update-nth.cert \
- coi/lists/memberp.cert \
- coi/util/iff.cert \
- coi/lists/find-index.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/list-top.cert : acl2x = 0
-coi/lists/list-top.cert : no_pcert = 0
-
-coi/lists/list-top.cert : \
- coi/lists/basic.cert \
- coi/lists/memberp.cert \
- coi/lists/map-cons.cert \
- coi/lists/repeat.cert \
- coi/lists/nth-and-update-nth.cert \
- coi/lists/update-nth-array.cert \
- coi/lists/list-top.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/listset-induction.cert : acl2x = 0
-coi/lists/listset-induction.cert : no_pcert = 0
-
-coi/lists/listset-induction.cert : \
- coi/lists/subsetp.cert \
- coi/lists/remove.cert \
- coi/lists/set.cert \
- coi/lists/listset-induction.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/map-cons.cert : acl2x = 0
-coi/lists/map-cons.cert : no_pcert = 0
-
-coi/lists/map-cons.cert : \
- coi/lists/basic.cert \
- coi/lists/memberp.cert \
- coi/util/iff.cert \
- coi/lists/map-cons.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/memberp.cert : acl2x = 0
-coi/lists/memberp.cert : no_pcert = 0
-
-coi/lists/memberp.cert : \
- coi/lists/basic.cert \
- coi/lists/memberp.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/mixed.cert : acl2x = 0
-coi/lists/mixed.cert : no_pcert = 0
-
-coi/lists/mixed.cert : \
- coi/lists/repeat.cert \
- coi/lists/memberp.cert \
- coi/lists/mixed.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/mv-nth.cert : acl2x = 0
-coi/lists/mv-nth.cert : no_pcert = 0
-
-coi/lists/mv-nth.cert : \
- coi/lists/mv-nth.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/nth-and-update-nth.cert : acl2x = 0
-coi/lists/nth-and-update-nth.cert : no_pcert = 0
-
-coi/lists/nth-and-update-nth.cert : \
- coi/lists/basic.cert \
- coi/lists/repeat.cert \
- arithmetic/top-with-meta.cert \
- coi/lists/nth-and-update-nth.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/nth-meta.cert : acl2x = 0
-coi/lists/nth-meta.cert : no_pcert = 0
-
-coi/lists/nth-meta.cert : \
- coi/lists/nth-meta.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/nth-meta2.cert : acl2x = 0
-coi/lists/nth-meta2.cert : no_pcert = 0
-
-coi/lists/nth-meta2.cert : \
- coi/lists/nth-meta2.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/remove-induction.cert : acl2x = 0
-coi/lists/remove-induction.cert : no_pcert = 0
-
-coi/lists/remove-induction.cert : \
- coi/lists/remove.cert \
- coi/lists/remove-induction.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/remove.cert : acl2x = 0
-coi/lists/remove.cert : no_pcert = 0
-
-coi/lists/remove.cert : \
- coi/lists/subsetp.cert \
- coi/lists/remove.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/repeat.cert : acl2x = 0
-coi/lists/repeat.cert : no_pcert = 0
-
-coi/lists/repeat.cert : \
- coi/lists/basic.cert \
- coi/lists/repeat.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/set.cert : acl2x = 0
-coi/lists/set.cert : no_pcert = 0
-
-coi/lists/set.cert : \
- coi/lists/remove.cert \
- coi/lists/disjoint.cert \
- coi/util/defbinding.cert \
- coi/util/iff.cert \
- coi/lists/remove-induction.cert \
- coi/lists/remove-induction.cert \
- coi/lists/set.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/subsetp.cert : acl2x = 0
-coi/lists/subsetp.cert : no_pcert = 0
-
-coi/lists/subsetp.cert : \
- coi/adviser/adviser.cert \
- coi/lists/memberp.cert \
- coi/lists/subsetp.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/lists/update-nth-array.cert : acl2x = 0
-coi/lists/update-nth-array.cert : no_pcert = 0
-
-coi/lists/update-nth-array.cert : \
- coi/lists/nth-and-update-nth.cert \
- arithmetic/top-with-meta.cert \
- coi/lists/update-nth-array.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/maps/aliases.cert : acl2x = 0
-coi/maps/aliases.cert : no_pcert = 0
-
-coi/maps/aliases.cert : \
- coi/maps/maps.cert \
- coi/maps/aliases.lisp \
- coi/maps/cert.acl2 \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/maps/maps.cert : acl2x = 0
-coi/maps/maps.cert : no_pcert = 0
-
-coi/maps/maps.cert : \
- coi/osets/sets.cert \
- coi/adviser/adviser.cert \
- misc/untranslate-patterns.cert \
- coi/maps/maps.lisp \
- coi/maps/cert.acl2 \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/maps/typed-maps.cert : acl2x = 0
-coi/maps/typed-maps.cert : no_pcert = 0
-
-coi/maps/typed-maps.cert : \
- coi/maps/maps.cert \
- coi/maps/typed-maps.lisp \
- coi/maps/cert.acl2 \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/nary/example.cert : acl2x = 0
-coi/nary/example.cert : no_pcert = 0
-
-coi/nary/example.cert : \
- coi/nary/nary.cert \
- ihs/ihs-definitions.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- ihs/ihs-lemmas.cert \
- ihs/ihs-lemmas.cert \
- coi/nary/nth-rules.cert \
- coi/nary/example.lisp \
- coi/nary/cert.acl2
-
-
-coi/nary/nary.cert : acl2x = 0
-coi/nary/nary.cert : no_pcert = 0
-
-coi/nary/nary.cert : \
- coi/util/in-conclusion.cert \
- coi/util/implies.cert \
- coi/nary/nary.lisp \
- coi/nary/cert.acl2
-
-
-coi/nary/nth-rules.cert : acl2x = 0
-coi/nary/nth-rules.cert : no_pcert = 0
-
-coi/nary/nth-rules.cert : \
- coi/nary/nth-rules.lisp \
- coi/nary/cert.acl2
-
-
-coi/nary/ordinal-order.cert : acl2x = 0
-coi/nary/ordinal-order.cert : no_pcert = 0
-
-coi/nary/ordinal-order.cert : \
- ordinals/lexicographic-ordering.cert \
- coi/nary/ordinal-order.lisp \
- coi/nary/cert.acl2
-
-
-coi/nary/rewrite-equal-hint.cert : acl2x = 0
-coi/nary/rewrite-equal-hint.cert : no_pcert = 0
-
-coi/nary/rewrite-equal-hint.cert : \
- coi/nary/rewrite-equal-hint.lisp \
- coi/nary/cert.acl2
-
-
-coi/osets/computed-hints.cert : acl2x = 0
-coi/osets/computed-hints.cert : no_pcert = 0
-
-coi/osets/computed-hints.cert : \
- coi/osets/instance.cert \
- coi/osets/computed-hints.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/conversions.cert : acl2x = 0
-coi/osets/conversions.cert : no_pcert = 0
-
-coi/osets/conversions.cert : \
- coi/osets/sets.cert \
- coi/lists/set.cert \
- coi/osets/conversions.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/extras.cert : acl2x = 0
-coi/osets/extras.cert : no_pcert = 0
-
-coi/osets/extras.cert : \
- coi/osets/sets.cert \
- coi/osets/set-order.cert \
- coi/osets/conversions.cert \
- coi/util/iff.cert \
- misc/total-order.cert \
- coi/osets/extras.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/fast.cert : acl2x = 0
-coi/osets/fast.cert : no_pcert = 0
-
-coi/osets/fast.cert : \
- coi/osets/membership.cert \
- coi/osets/fast.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/instance.cert : acl2x = 0
-coi/osets/instance.cert : no_pcert = 0
-
-coi/osets/instance.cert : \
- coi/osets/instance.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/listsets.cert : acl2x = 0
-coi/osets/listsets.cert : no_pcert = 0
-
-coi/osets/listsets.cert : \
- misc/untranslate-patterns.cert \
- coi/lists/basic.cert \
- coi/lists/memberp.cert \
- coi/osets/map.cert \
- coi/osets/listsets.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/map.cert : acl2x = 0
-coi/osets/map.cert : no_pcert = 0
-
-coi/osets/map.cert : \
- coi/osets/quantify.cert \
- coi/osets/map.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/membership.cert : acl2x = 0
-coi/osets/membership.cert : no_pcert = 0
-
-coi/osets/membership.cert : \
- coi/osets/primitives.cert \
- coi/osets/computed-hints.cert \
- coi/osets/membership.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/multiappend.cert : acl2x = 0
-coi/osets/multiappend.cert : no_pcert = 0
-
-coi/osets/multiappend.cert : \
- coi/osets/multicons.cert \
- coi/util/iff.cert \
- arithmetic/top-with-meta.cert \
- coi/osets/multiappend.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/multicons.cert : acl2x = 0
-coi/osets/multicons.cert : no_pcert = 0
-
-coi/osets/multicons.cert : \
- coi/osets/sets.cert \
- coi/osets/listsets.cert \
- coi/osets/multicons.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/outer.cert : acl2x = 0
-coi/osets/outer.cert : no_pcert = 0
-
-coi/osets/outer.cert : \
- coi/osets/fast.cert \
- coi/osets/outer.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/primitives.cert : acl2x = 0
-coi/osets/primitives.cert : no_pcert = 0
-
-coi/osets/primitives.cert : \
- misc/total-order.cert \
- coi/osets/primitives.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/quantify.cert : acl2x = 0
-coi/osets/quantify.cert : no_pcert = 0
-
-coi/osets/quantify.cert : \
- coi/osets/sets.cert \
- coi/osets/quantify.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/set-order.cert : acl2x = 0
-coi/osets/set-order.cert : no_pcert = 0
-
-coi/osets/set-order.cert : \
- coi/osets/primitives.cert \
- coi/osets/membership.cert \
- coi/osets/fast.cert \
- coi/osets/sets.cert \
- misc/total-order.cert \
- coi/osets/set-order.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/set-processor.cert : acl2x = 0
-coi/osets/set-processor.cert : no_pcert = 0
-
-coi/osets/set-processor.cert : \
- coi/osets/sets.cert \
- coi/osets/set-processor.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/sets.cert : acl2x = 0
-coi/osets/sets.cert : no_pcert = 0
-
-coi/osets/sets.cert : \
- coi/osets/computed-hints.cert \
- coi/osets/primitives.cert \
- coi/osets/membership.cert \
- coi/osets/fast.cert \
- coi/osets/outer.cert \
- coi/osets/sort.cert \
- misc/total-order.cert \
- coi/osets/sets.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/osets/sort.cert : acl2x = 0
-coi/osets/sort.cert : no_pcert = 0
-
-coi/osets/sort.cert : \
- coi/osets/outer.cert \
- coi/osets/sort.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/paths/compatibility.cert : acl2x = 0
-coi/paths/compatibility.cert : no_pcert = 0
-
-coi/paths/compatibility.cert : \
- coi/alists/top.cert \
- coi/paths/compatibility.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-
-
-coi/paths/cp-set.cert : acl2x = 0
-coi/paths/cp-set.cert : no_pcert = 0
-
-coi/paths/cp-set.cert : \
- coi/osets/multicons.cert \
- coi/paths/hints.cert \
- arithmetic/top-with-meta.cert \
- coi/osets/multiappend.cert \
- coi/paths/cp-set.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-
-
-coi/paths/defs.cert : acl2x = 0
-coi/paths/defs.cert : no_pcert = 0
-
-coi/paths/defs.cert : \
- coi/lists/basic.cert \
- coi/paths/defs.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-
-
-coi/paths/diverge.cert : acl2x = 0
-coi/paths/diverge.cert : no_pcert = 0
-
-coi/paths/diverge.cert : \
- coi/paths/dominates.cert \
- coi/bags/basic.cert \
- coi/util/iff.cert \
- coi/paths/diverge.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-
-
-coi/paths/dominates.cert : acl2x = 0
-coi/paths/dominates.cert : no_pcert = 0
-
-coi/paths/dominates.cert : \
- coi/lists/basic.cert \
- coi/lists/memberp.cert \
- coi/bags/basic.cert \
- coi/adviser/adviser.cert \
- arithmetic/top-with-meta.cert \
- coi/util/iff.cert \
- coi/paths/dominates.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-
-
-coi/paths/equiv.cert : acl2x = 0
-coi/paths/equiv.cert : no_pcert = 0
-
-coi/paths/equiv.cert : \
- coi/util/iff.cert \
- coi/paths/path.cert \
- coi/paths/equiv.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-
-
-coi/paths/hints.cert : acl2x = 0
-coi/paths/hints.cert : no_pcert = 0
-
-coi/paths/hints.cert : \
- coi/paths/pm.cert \
- coi/util/iff.cert \
- coi/paths/hints.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-
-
-coi/paths/list-path-connection.cert : acl2x = 0
-coi/paths/list-path-connection.cert : no_pcert = 0
-
-coi/paths/list-path-connection.cert : \
- coi/records/domain.cert \
- coi/bags/extras.cert \
- arithmetic/top-with-meta.cert \
- coi/paths/path.cert \
- coi/paths/list-path-connection.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-
-
-coi/paths/meta.cert : acl2x = 0
-coi/paths/meta.cert : no_pcert = 0
-
-coi/paths/meta.cert : \
- coi/lists/basic.cert \
- coi/lists/map-cons.cert \
- coi/syntax/syntax.cert \
- coi/util/mv-nth.cert \
- coi/util/iff.cert \
- coi/paths/path.cert \
- coi/paths/meta.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-
-
-coi/paths/path.cert : acl2x = 0
-coi/paths/path.cert : no_pcert = 0
-
-coi/paths/path.cert : \
- coi/lists/repeat.cert \
- coi/bags/top.cert \
- coi/alists/top.cert \
- coi/records/records.cert \
- coi/records/domain.cert \
- coi/paths/compatibility.cert \
- coi/paths/dominates.cert \
- coi/paths/diverge.cert \
- arithmetic/top-with-meta.cert \
- coi/util/iff.cert \
- coi/util/syntaxp.cert \
- coi/paths/path.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-
-
-coi/paths/pm.cert : acl2x = 0
-coi/paths/pm.cert : no_pcert = 0
-
-coi/paths/pm.cert : \
- coi/paths/meta.cert \
- arithmetic/top-with-meta.cert \
- coi/paths/equiv.cert \
- coi/paths/pm.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-
-
-coi/quantification/quantification.cert : acl2x = 0
-coi/quantification/quantification.cert : no_pcert = 0
-
-coi/quantification/quantification.cert : \
- misc/records.cert \
- misc/bash.cert \
- coi/generalize/generalize.cert \
- coi/util/mv-nth.cert \
- coi/util/table.cert \
- coi/util/skip-rewrite.cert \
- coi/util/in-conclusion.cert \
- coi/quantification/quantification.lisp \
- coi/quantification/quantification.acl2 \
- coi/quantification/cert.acl2 \
- coi/util/def-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/util/table-defpkg.lsp \
- coi/quantification/quant-defpkg.lsp
-
-
-coi/records/defarray.cert : acl2x = 0
-coi/records/defarray.cert : no_pcert = 0
-
-coi/records/defarray.cert : \
- coi/records/records.cert \
- coi/symbol-fns/symbol-fns.cert \
- coi/records/defarray.lisp \
- coi/records/defarray.acl2 \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-
-
-coi/records/defrecord-fast.cert : acl2x = 0
-coi/records/defrecord-fast.cert : no_pcert = 0
-
-coi/records/defrecord-fast.cert : \
- coi/records/memory.cert \
- coi/records/records.cert \
- data-structures/memories/memory.cert \
- coi/records/defrecord-fast.lisp \
- coi/records/defrecord-fast.acl2 \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp \
- data-structures/memories/package.lsp
-
-
-coi/records/defrecord.cert : acl2x = 0
-coi/records/defrecord.cert : no_pcert = 0
-
-coi/records/defrecord.cert : \
- coi/records/records.cert \
- coi/records/defrecord.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-
-
-coi/records/domain.cert : acl2x = 0
-coi/records/domain.cert : no_pcert = 0
-
-coi/records/domain.cert : \
- coi/alists/keyquiv.cert \
- coi/records/records.cert \
- coi/bags/basic.cert \
- coi/bags/pick-a-point.cert \
- coi/records/records.cert \
- coi/records/domain.lisp \
- coi/records/domain.acl2 \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-
-
-coi/records/fixedpoint.cert : acl2x = 0
-coi/records/fixedpoint.cert : no_pcert = 0
-
-coi/records/fixedpoint.cert : \
- coi/records/domain.cert \
- coi/util/rule-sets.cert \
- coi/records/domain.cert \
- coi/records/fixedpoint.lisp \
- coi/records/fixedpoint.acl2 \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp
-
-
-coi/records/mem-domain.cert : acl2x = 0
-coi/records/mem-domain.cert : no_pcert = 0
-
-coi/records/mem-domain.cert : \
- coi/records/memory.cert \
- coi/records/domain.cert \
- coi/osets/conversions.cert \
- coi/osets/extras.cert \
- coi/osets/map.cert \
- coi/bags/basic.cert \
- coi/util/iff.cert \
- coi/osets/set-processor.cert \
- data-structures/memories/log2.cert \
- coi/records/set-domain.cert \
- data-structures/memories/memory-impl.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/arithmetic/top.cert \
- coi/records/mem-domain.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-
-
-coi/records/memory.cert : acl2x = 0
-coi/records/memory.cert : no_pcert = 0
-
-coi/records/memory.cert : \
- data-structures/memories/memory.cert \
- coi/records/memory.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-
-
-coi/records/record-exports.cert : acl2x = 0
-coi/records/record-exports.cert : no_pcert = 0
-
-coi/records/record-exports.cert : \
- coi/records/record-exports.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-
-
-coi/records/records.cert : acl2x = 0
-coi/records/records.cert : no_pcert = 0
-
-coi/records/records.cert : \
- coi/lists/basic.cert \
- misc/records.cert \
- coi/records/records.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-
-
-coi/records/set-domain.cert : acl2x = 0
-coi/records/set-domain.cert : no_pcert = 0
-
-coi/records/set-domain.cert : \
- coi/records/domain.cert \
- coi/osets/sets.cert \
- coi/osets/extras.cert \
- coi/records/records.cert \
- coi/osets/sets.cert \
- coi/osets/map.cert \
- coi/osets/extras.cert \
- coi/records/set-domain.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-
-
-coi/super-ihs/arithmetic.cert : acl2x = 0
-coi/super-ihs/arithmetic.cert : no_pcert = 0
-
-coi/super-ihs/arithmetic.cert : \
- ihs/quotient-remainder-lemmas.cert \
- ihs/math-lemmas.cert \
- coi/super-ihs/eric.cert \
- coi/super-ihs/from-rtl.cert \
- rtl/rel4/arithmetic/floor.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/denominator.cert \
- coi/super-ihs/arithmetic.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/ash.cert : acl2x = 0
-coi/super-ihs/ash.cert : no_pcert = 0
-
-coi/super-ihs/ash.cert : \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/evenp.cert \
- coi/super-ihs/ash.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/basics.cert : acl2x = 0
-coi/super-ihs/basics.cert : no_pcert = 0
-
-coi/super-ihs/basics.cert : \
- coi/super-ihs/inductions.cert \
- coi/super-ihs/evenp.cert \
- coi/super-ihs/bit-functions.cert \
- coi/super-ihs/from-rtl.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/loghead.cert \
- coi/super-ihs/logext.cert \
- coi/super-ihs/logcar.cert \
- coi/super-ihs/ash.cert \
- coi/super-ihs/basics.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/bit-functions.cert : acl2x = 0
-coi/super-ihs/bit-functions.cert : no_pcert = 0
-
-coi/super-ihs/bit-functions.cert : \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/bit-functions.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/bit-twiddling-logops.cert : acl2x = 0
-coi/super-ihs/bit-twiddling-logops.cert : no_pcert = 0
-
-coi/super-ihs/bit-twiddling-logops.cert : \
- coi/super-ihs/logical-logops.cert \
- coi/super-ihs/bit-twiddling-logops.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/byte-p.cert : acl2x = 0
-coi/super-ihs/byte-p.cert : no_pcert = 0
-
-coi/super-ihs/byte-p.cert : \
- coi/super-ihs/logpair.cert \
- coi/super-ihs/byte-p.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/c-functions.cert : acl2x = 0
-coi/super-ihs/c-functions.cert : no_pcert = 0
-
-coi/super-ihs/c-functions.cert : \
- coi/super-ihs/hacks.cert \
- coi/super-ihs/c-functions.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/carry.cert : acl2x = 0
-coi/super-ihs/carry.cert : no_pcert = 0
-
-coi/super-ihs/carry.cert : \
- coi/super-ihs/super-ihs.cert \
- coi/super-ihs/carry.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/eric.cert : acl2x = 0
-coi/super-ihs/eric.cert : no_pcert = 0
-
-coi/super-ihs/eric.cert : \
- rtl/rel4/arithmetic/expo.cert \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/arithmetic/top.cert \
- coi/super-ihs/eric.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/evenp.cert : acl2x = 0
-coi/super-ihs/evenp.cert : no_pcert = 0
-
-coi/super-ihs/evenp.cert : \
- coi/super-ihs/arithmetic.cert \
- rtl/rel4/arithmetic/even-odd.cert \
- rtl/rel4/arithmetic/integerp.cert \
- coi/super-ihs/evenp.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/fast.cert : acl2x = 0
-coi/super-ihs/fast.cert : no_pcert = 0
-
-coi/super-ihs/fast.cert : \
- coi/super-ihs/super-ihs.cert \
- coi/super-ihs/fast.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/from-rtl.cert : acl2x = 0
-coi/super-ihs/from-rtl.cert : no_pcert = 0
-
-coi/super-ihs/from-rtl.cert : \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/logxor.cert \
- rtl/rel4/support/logior.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/arithmetic/top.cert \
- coi/super-ihs/from-rtl.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/hacks.cert : acl2x = 0
-coi/super-ihs/hacks.cert : no_pcert = 0
-
-coi/super-ihs/hacks.cert : \
- coi/super-ihs/bit-twiddling-logops.cert \
- coi/super-ihs/eric.cert \
- coi/super-ihs/hacks.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/inductions.cert : acl2x = 0
-coi/super-ihs/inductions.cert : no_pcert = 0
-
-coi/super-ihs/inductions.cert : \
- coi/super-ihs/arithmetic.cert \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/inductions.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/iter-sqrt.cert : acl2x = 0
-coi/super-ihs/iter-sqrt.cert : no_pcert = 0
-
-coi/super-ihs/iter-sqrt.cert : \
- coi/super-ihs/arithmetic.cert \
- arithmetic/top-with-meta.cert \
- coi/super-ihs/iter-sqrt.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/logapp.cert : acl2x = 0
-coi/super-ihs/logapp.cert : no_pcert = 0
-
-coi/super-ihs/logapp.cert : \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/logapp.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/logbit.cert : acl2x = 0
-coi/super-ihs/logbit.cert : no_pcert = 0
-
-coi/super-ihs/logbit.cert : \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/logbit.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/logbitp.cert : acl2x = 0
-coi/super-ihs/logbitp.cert : no_pcert = 0
-
-coi/super-ihs/logbitp.cert : \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/logbitp.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/logcar.cert : acl2x = 0
-coi/super-ihs/logcar.cert : no_pcert = 0
-
-coi/super-ihs/logcar.cert : \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/evenp.cert \
- coi/super-ihs/logcar.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/logcdr.cert : acl2x = 0
-coi/super-ihs/logcdr.cert : no_pcert = 0
-
-coi/super-ihs/logcdr.cert : \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/evenp.cert \
- coi/super-ihs/unsigned-byte-p.cert \
- coi/super-ihs/ash.cert \
- coi/super-ihs/logcdr.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/logcons.cert : acl2x = 0
-coi/super-ihs/logcons.cert : no_pcert = 0
-
-coi/super-ihs/logcons.cert : \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/evenp.cert \
- coi/super-ihs/logcons.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/logext.cert : acl2x = 0
-coi/super-ihs/logext.cert : no_pcert = 0
-
-coi/super-ihs/logext.cert : \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/logbitp.cert \
- coi/super-ihs/logapp.cert \
- coi/super-ihs/loghead.cert \
- coi/super-ihs/logext.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/loghead.cert : acl2x = 0
-coi/super-ihs/loghead.cert : no_pcert = 0
-
-coi/super-ihs/loghead.cert : \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/ash.cert \
- coi/super-ihs/unsigned-byte-p.cert \
- coi/super-ihs/logcar.cert \
- coi/super-ihs/logcdr.cert \
- coi/super-ihs/logcons.cert \
- coi/super-ihs/inductions.cert \
- coi/util/syntaxp.cert \
- coi/super-ihs/loghead.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/logical-logops.cert : acl2x = 0
-coi/super-ihs/logical-logops.cert : no_pcert = 0
-
-coi/super-ihs/logical-logops.cert : \
- coi/super-ihs/loglist.cert \
- coi/super-ihs/logext.cert \
- coi/super-ihs/logical-logops.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/logior-logapp-crock.cert : acl2x = 0
-coi/super-ihs/logior-logapp-crock.cert : no_pcert = 0
-
-coi/super-ihs/logior-logapp-crock.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- coi/super-ihs/logior-logapp-crock.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/loglist.cert : acl2x = 0
-coi/super-ihs/loglist.cert : no_pcert = 0
-
-coi/super-ihs/loglist.cert : \
- coi/super-ihs/byte-p.cert \
- coi/super-ihs/logapp.cert \
- coi/super-ihs/loglist.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/logpair.cert : acl2x = 0
-coi/super-ihs/logpair.cert : no_pcert = 0
-
-coi/super-ihs/logpair.cert : \
- coi/super-ihs/basics.cert \
- coi/super-ihs/loghead.cert \
- coi/super-ihs/logtail.cert \
- coi/super-ihs/logcons.cert \
- coi/super-ihs/logcdr.cert \
- coi/super-ihs/logtail.cert \
- coi/super-ihs/logbitp.cert \
- coi/super-ihs/logbit.cert \
- coi/super-ihs/unsigned-byte-p.cert \
- coi/super-ihs/logpair.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/logtail.cert : acl2x = 0
-coi/super-ihs/logtail.cert : no_pcert = 0
-
-coi/super-ihs/logtail.cert : \
- coi/super-ihs/arithmetic.cert \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/ash.cert \
- coi/super-ihs/logtail.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/lshu.cert : acl2x = 0
-coi/super-ihs/lshu.cert : no_pcert = 0
-
-coi/super-ihs/lshu.cert : \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/hacks.cert \
- coi/super-ihs/lshu.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/meta.cert : acl2x = 0
-coi/super-ihs/meta.cert : no_pcert = 0
-
-coi/super-ihs/meta.cert : \
- coi/super-ihs/loghead.cert \
- coi/super-ihs/arithmetic.cert \
- coi/super-ihs/meta.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/min-max.cert : acl2x = 0
-coi/super-ihs/min-max.cert : no_pcert = 0
-
-coi/super-ihs/min-max.cert : \
- coi/super-ihs/min-max.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/plus-logapp-suck.cert : acl2x = 0
-coi/super-ihs/plus-logapp-suck.cert : no_pcert = 0
-
-coi/super-ihs/plus-logapp-suck.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/plus-logapp-suck.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/signed-byte-p-overflow.cert : acl2x = 0
-coi/super-ihs/signed-byte-p-overflow.cert : no_pcert = 0
-
-coi/super-ihs/signed-byte-p-overflow.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/signed-byte-p-overflow.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/super-ihs.cert : acl2x = 0
-coi/super-ihs/super-ihs.cert : no_pcert = 0
-
-coi/super-ihs/super-ihs.cert : \
- coi/super-ihs/hacks.cert \
- coi/super-ihs/eric.cert \
- coi/super-ihs/c-functions.cert \
- coi/super-ihs/lshu.cert \
- coi/super-ihs/min-max.cert \
- coi/super-ihs/meta.cert \
- rtl/rel4/arithmetic/expo.cert \
- arithmetic/top-with-meta.cert \
- coi/super-ihs/super-ihs.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/super-ihs/unsigned-byte-p.cert : acl2x = 0
-coi/super-ihs/unsigned-byte-p.cert : no_pcert = 0
-
-coi/super-ihs/unsigned-byte-p.cert : \
- coi/super-ihs/arithmetic.cert \
- ihs/ihs-lemmas.cert \
- coi/super-ihs/eric.cert \
- coi/super-ihs/unsigned-byte-p.lisp \
- coi/super-ihs/cert.acl2
-
-
-coi/symbol-fns/symbol-fns-exports.cert : acl2x = 0
-coi/symbol-fns/symbol-fns-exports.cert : no_pcert = 0
-
-coi/symbol-fns/symbol-fns-exports.cert : \
- coi/symbol-fns/symbol-fns-exports.lisp \
- coi/symbol-fns/cert.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/symbol-fns/symbol-fns.cert : acl2x = 0
-coi/symbol-fns/symbol-fns.cert : no_pcert = 0
-
-coi/symbol-fns/symbol-fns.cert : \
- coi/symbol-fns/symbol-fns.lisp \
- coi/symbol-fns/cert.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/syntax/auxilary.cert : acl2x = 0
-coi/syntax/auxilary.cert : no_pcert = 0
-
-coi/syntax/auxilary.cert : \
- coi/symbol-fns/symbol-fns.cert \
- coi/syntax/auxilary.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/syntax/defbinding.cert : acl2x = 0
-coi/syntax/defbinding.cert : no_pcert = 0
-
-coi/syntax/defbinding.cert : \
- coi/symbol-fns/symbol-fns.cert \
- coi/syntax/defbinding.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/syntax/defevaluator.cert : acl2x = 0
-coi/syntax/defevaluator.cert : no_pcert = 0
-
-coi/syntax/defevaluator.cert : \
- coi/syntax/defevaluator.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/syntax/quine.cert : acl2x = 0
-coi/syntax/quine.cert : no_pcert = 0
-
-coi/syntax/quine.cert : \
- coi/syntax/syntax.cert \
- coi/syntax/quine.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/syntax/syn-pkg.cert : acl2x = 0
-coi/syntax/syn-pkg.cert : no_pcert = 0
-
-coi/syntax/syn-pkg.cert : \
- coi/syntax/syn-pkg.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/syntax/syntax-extensions.cert : acl2x = 0
-coi/syntax/syntax-extensions.cert : no_pcert = 0
-
-coi/syntax/syntax-extensions.cert : \
- coi/syntax/auxilary.cert \
- coi/util/mv-nth.cert \
- coi/syntax/syntax-extensions.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/syntax/syntax.cert : acl2x = 0
-coi/syntax/syntax.cert : no_pcert = 0
-
-coi/syntax/syntax.cert : \
- coi/syntax/syntax-extensions.cert \
- coi/syntax/defevaluator.cert \
- coi/syntax/syntax.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/termination/assuming/compiler-proof.cert : acl2x = 0
-coi/termination/assuming/compiler-proof.cert : no_pcert = 0
-
-coi/termination/assuming/compiler-proof.cert : \
- coi/defpun/defminterm.cert \
- coi/defpun/ack.cert \
- coi/nary/nary.cert \
- coi/util/mv-nth.cert \
- coi/termination/assuming/compiler-proof.lisp \
- coi/termination/assuming/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/util/def-defpkg.lsp \
- coi/util/defun-defpkg.lsp
-
-
-coi/termination/assuming/compiler.cert : acl2x = 0
-coi/termination/assuming/compiler.cert : no_pcert = 0
-
-coi/termination/assuming/compiler.cert : \
- coi/syntax/syntax.cert \
- coi/util/mv-nth.cert \
- coi/termination/assuming/compiler-proof.cert \
- make-event/eval.cert \
- coi/util/pseudo-translate.cert \
- coi/util/recursion-support.cert \
- arithmetic/top-with-meta.cert \
- coi/termination/assuming/compiler.lisp \
- coi/termination/assuming/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/util/def-defpkg.lsp \
- coi/util/defun-defpkg.lsp
-
-
-coi/termination/assuming/zero.cert : acl2x = 0
-coi/termination/assuming/zero.cert : no_pcert = 0
-
-coi/termination/assuming/zero.cert : \
- coi/termination/assuming/compiler.cert \
- ordinals/lexicographic-ordering.cert \
- coi/termination/assuming/zero.lisp \
- coi/termination/assuming/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/util/def-defpkg.lsp \
- coi/util/defun-defpkg.lsp
-
-
-coi/util/clause-processor.cert : acl2x = 0
-coi/util/clause-processor.cert : no_pcert = 0
-
-coi/util/clause-processor.cert : \
- coi/util/clause-processor.lisp \
- coi/util/cert.acl2
-
-
-coi/util/debug.cert : acl2x = 0
-coi/util/debug.cert : no_pcert = 0
-
-coi/util/debug.cert : \
- coi/util/defdoc.cert \
- coi/util/debug.lisp \
- coi/util/debug.acl2 \
- coi/util/def-defpkg.lsp \
- coi/util/debug-defpkg.lsp
-
-
-coi/util/defbinding.cert : acl2x = 0
-coi/util/defbinding.cert : no_pcert = 0
-
-coi/util/defbinding.cert : \
- coi/util/defbinding.lisp \
- coi/util/defbinding.acl2 \
- coi/util/def-defpkg.lsp
-
-
-coi/util/defdoc.cert : acl2x = 0
-coi/util/defdoc.cert : no_pcert = 0
-
-coi/util/defdoc.cert : \
- coi/util/defdoc.lisp \
- coi/util/defdoc.acl2 \
- coi/util/def-defpkg.lsp
-
-
-coi/util/deffix.cert : acl2x = 0
-coi/util/deffix.cert : no_pcert = 0
-
-coi/util/deffix.cert : \
- coi/symbol-fns/symbol-fns.cert \
- coi/util/deffix.lisp \
- coi/util/deffix.acl2 \
- coi/util/def-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/util/defsubtype.cert : acl2x = 0
-coi/util/defsubtype.cert : no_pcert = 0
-
-coi/util/defsubtype.cert : \
- coi/util/rule-sets.cert \
- coi/util/mv-nth.cert \
- coi/util/defun-support.cert \
- coi/util/rule-sets.cert \
- coi/util/defsubtype.lisp \
- coi/util/defsubtype.acl2 \
- coi/util/def-defpkg.lsp \
- coi/util/defun-defpkg.lsp
-
-
-coi/util/defun-support.cert : acl2x = 0
-coi/util/defun-support.cert : no_pcert = 0
-
-coi/util/defun-support.cert : \
- misc/beta-reduce.cert \
- coi/util/debug.cert \
- coi/symbol-fns/symbol-fns.cert \
- coi/util/mv-nth.cert \
- coi/symbol-fns/symbol-fns.cert \
- coi/util/defun-support.lisp \
- coi/util/defun-support.acl2 \
- coi/util/cert.acl2 \
- coi/util/defun-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/util/defun.cert : acl2x = 0
-coi/util/defun.cert : no_pcert = 0
-
-coi/util/defun.cert : \
- coi/util/recursion-support.cert \
- coi/util/pseudo-translate.cert \
- coi/util/mv-nth.cert \
- coi/util/defun.lisp \
- coi/util/defun.acl2 \
- coi/util/cert.acl2 \
- coi/util/defun-defpkg.lsp \
- coi/util/def-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-
-
-coi/util/extra-info-test.cert : acl2x = 0
-coi/util/extra-info-test.cert : no_pcert = 0
-
-coi/util/extra-info-test.cert : \
- coi/util/extra-info.cert \
- make-event/eval.cert \
- coi/util/extra-info-test.lisp \
- coi/util/cert.acl2
-
-
-coi/util/extra-info.cert : acl2x = 0
-coi/util/extra-info.cert : no_pcert = 0
-
-coi/util/extra-info.cert : \
- coi/util/in-conclusion.cert \
- coi/util/extra-info.lisp \
- coi/util/cert.acl2
-
-
-coi/util/fixequiv.cert : acl2x = 0
-coi/util/fixequiv.cert : no_pcert = 0
-
-coi/util/fixequiv.cert : \
- coi/util/fixequiv.lisp \
- coi/util/cert.acl2
-
-
-coi/util/good-rewrite-order.cert : acl2x = 0
-coi/util/good-rewrite-order.cert : no_pcert = 0
-
-coi/util/good-rewrite-order.cert : \
- coi/util/syntaxp.cert \
- misc/total-order.cert \
- coi/util/good-rewrite-order.lisp \
- coi/util/cert.acl2
-
-
-coi/util/ifdef.cert : acl2x = 0
-coi/util/ifdef.cert : no_pcert = 0
-
-coi/util/ifdef.cert : \
- coi/util/defdoc.cert \
- coi/util/ifdef.lisp \
- coi/util/ifdef.acl2 \
- coi/util/def-defpkg.lsp
-
-
-coi/util/iff.cert : acl2x = 0
-coi/util/iff.cert : no_pcert = 0
-
-coi/util/iff.cert : \
- coi/util/iff.lisp \
- coi/util/cert.acl2
-
-
-coi/util/ifixequiv.cert : acl2x = 0
-coi/util/ifixequiv.cert : no_pcert = 0
-
-coi/util/ifixequiv.cert : \
- coi/util/fixequiv.cert \
- coi/util/ifixequiv.lisp \
- coi/util/cert.acl2
-
-
-coi/util/implies.cert : acl2x = 0
-coi/util/implies.cert : no_pcert = 0
-
-coi/util/implies.cert : \
- coi/util/in-conclusion.cert \
- coi/util/implies.lisp \
- coi/util/cert.acl2
-
-
-coi/util/in-conclusion.cert : acl2x = 0
-coi/util/in-conclusion.cert : no_pcert = 0
-
-coi/util/in-conclusion.cert : \
- coi/util/in-conclusion.lisp \
- coi/util/cert.acl2
-
-
-coi/util/ith.cert : acl2x = 0
-coi/util/ith.cert : no_pcert = 0
-
-coi/util/ith.cert : \
- coi/util/ith.lisp \
- coi/util/cert.acl2
-
-
-coi/util/mv-nth.cert : acl2x = 0
-coi/util/mv-nth.cert : no_pcert = 0
-
-coi/util/mv-nth.cert : \
- coi/util/mv-nth.lisp \
- coi/util/mv-nth.acl2 \
- coi/util/gensym-defpkg.lsp
-
-
-coi/util/nfixequiv.cert : acl2x = 0
-coi/util/nfixequiv.cert : no_pcert = 0
-
-coi/util/nfixequiv.cert : \
- coi/util/ifixequiv.cert \
- coi/util/nfixequiv.lisp \
- coi/util/cert.acl2
-
-
-coi/util/ordinal-order.cert : acl2x = 0
-coi/util/ordinal-order.cert : no_pcert = 0
-
-coi/util/ordinal-order.cert : \
- ordinals/lexicographic-ordering.cert \
- coi/util/ordinal-order.lisp \
- coi/util/cert.acl2
-
-
-coi/util/pseudo-translate.cert : acl2x = 0
-coi/util/pseudo-translate.cert : no_pcert = 0
-
-coi/util/pseudo-translate.cert : \
- coi/util/pseudo-translate.lisp \
- coi/util/cert.acl2
-
-
-coi/util/recursion-support.cert : acl2x = 0
-coi/util/recursion-support.cert : no_pcert = 0
-
-coi/util/recursion-support.cert : \
- coi/util/mv-nth.cert \
- coi/util/defun-support.cert \
- coi/symbol-fns/symbol-fns.cert \
- coi/util/recursion-support.lisp \
- coi/util/recursion-support.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/util/defun-defpkg.lsp
-
-
-coi/util/rewrite-equiv.cert : acl2x = 0
-coi/util/rewrite-equiv.cert : no_pcert = 0
-
-coi/util/rewrite-equiv.cert : \
- coi/util/good-rewrite-order.cert \
- coi/util/clause-processor.cert \
- coi/util/rewrite-equiv.lisp \
- coi/util/cert.acl2
-
-
-coi/util/rule-sets-documentation.cert : acl2x = 0
-coi/util/rule-sets-documentation.cert : no_pcert = 0
-
-coi/util/rule-sets-documentation.cert : \
- coi/util/defdoc.cert \
- coi/util/rule-sets-documentation.lisp \
- coi/util/rule-sets-documentation.acl2 \
- coi/util/cert.acl2 \
- coi/util/def-defpkg.lsp
-
-
-coi/util/rule-sets-support.cert : acl2x = 0
-coi/util/rule-sets-support.cert : no_pcert = 0
-
-coi/util/rule-sets-support.cert : \
- coi/util/rule-sets-support.lisp \
- coi/util/rule-sets-support.acl2 \
- coi/util/cert.acl2 \
- coi/util/rule-sets-defpkg.lsp
-
-
-coi/util/rule-sets.cert : acl2x = 0
-coi/util/rule-sets.cert : no_pcert = 0
-
-coi/util/rule-sets.cert : \
- coi/util/rule-sets-documentation.cert \
- coi/util/rule-sets-support.cert \
- coi/util/table.cert \
- coi/util/rule-sets.lisp \
- coi/util/rule-sets.acl2 \
- coi/util/cert.acl2 \
- coi/util/rule-sets-defpkg.lsp \
- coi/util/table-defpkg.lsp \
- coi/util/def-defpkg.lsp
-
-
-coi/util/skip-rewrite.cert : acl2x = 0
-coi/util/skip-rewrite.cert : no_pcert = 0
-
-coi/util/skip-rewrite.cert : \
- misc/beta-reduce.cert \
- coi/util/skip-rewrite.lisp \
- coi/util/cert.acl2
-
-
-coi/util/syntaxp.cert : acl2x = 0
-coi/util/syntaxp.cert : no_pcert = 0
-
-coi/util/syntaxp.cert : \
- coi/util/syntaxp.lisp \
- coi/util/cert.acl2
-
-
-coi/util/table.cert : acl2x = 0
-coi/util/table.cert : no_pcert = 0
-
-coi/util/table.cert : \
- coi/util/table.lisp \
- coi/util/table.acl2 \
- coi/util/cert.acl2 \
- coi/util/table-defpkg.lsp
-
-
-concurrent-programs/bakery/apply-total-order.cert : acl2x = 0
-concurrent-programs/bakery/apply-total-order.cert : no_pcert = 0
-
-concurrent-programs/bakery/apply-total-order.cert : \
- misc/total-order.cert \
- concurrent-programs/bakery/apply-total-order.lisp
-
-
-concurrent-programs/bakery/fairenv.cert : acl2x = 0
-concurrent-programs/bakery/fairenv.cert : no_pcert = 0
-
-concurrent-programs/bakery/fairenv.cert : \
- concurrent-programs/bakery/measures.cert \
- concurrent-programs/bakery/records.cert \
- concurrent-programs/bakery/fairenv.lisp
-
-
-concurrent-programs/bakery/final-theorems.cert : acl2x = 0
-concurrent-programs/bakery/final-theorems.cert : no_pcert = 0
-
-concurrent-programs/bakery/final-theorems.cert : \
- concurrent-programs/bakery/labels.cert \
- concurrent-programs/bakery/stutter1-match.cert \
- concurrent-programs/bakery/stutter2.cert \
- concurrent-programs/bakery/initial-state.cert \
- concurrent-programs/bakery/inv-persists.cert \
- concurrent-programs/bakery/inv-sufficient.cert \
- concurrent-programs/bakery/final-theorems.lisp
-
-
-concurrent-programs/bakery/initial-state.cert : acl2x = 0
-concurrent-programs/bakery/initial-state.cert : no_pcert = 0
-
-concurrent-programs/bakery/initial-state.cert : \
- concurrent-programs/bakery/programs.cert \
- concurrent-programs/bakery/properties.cert \
- concurrent-programs/bakery/initial-state.lisp
-
-
-concurrent-programs/bakery/inv-persists.cert : acl2x = 0
-concurrent-programs/bakery/inv-persists.cert : no_pcert = 0
-
-concurrent-programs/bakery/inv-persists.cert : \
- concurrent-programs/bakery/programs.cert \
- concurrent-programs/bakery/properties.cert \
- concurrent-programs/bakery/lexicographic-pos.cert \
- concurrent-programs/bakery/inv-persists.lisp
-
-
-concurrent-programs/bakery/inv-sufficient.cert : acl2x = 0
-concurrent-programs/bakery/inv-sufficient.cert : no_pcert = 0
-
-concurrent-programs/bakery/inv-sufficient.cert : \
- concurrent-programs/bakery/programs.cert \
- concurrent-programs/bakery/properties.cert \
- concurrent-programs/bakery/lexicographic-pos.cert \
- concurrent-programs/bakery/properties-of-sets.cert \
- concurrent-programs/bakery/inv-sufficient.lisp
-
-
-concurrent-programs/bakery/labels.cert : acl2x = 0
-concurrent-programs/bakery/labels.cert : no_pcert = 0
-
-concurrent-programs/bakery/labels.cert : \
- concurrent-programs/bakery/properties.cert \
- concurrent-programs/bakery/labels.lisp
-
-
-concurrent-programs/bakery/lexicographic-pos.cert : acl2x = 0
-concurrent-programs/bakery/lexicographic-pos.cert : no_pcert = 0
-
-concurrent-programs/bakery/lexicographic-pos.cert : \
- concurrent-programs/bakery/properties.cert \
- concurrent-programs/bakery/pos-temp.cert \
- concurrent-programs/bakery/lexicographic-pos.lisp
-
-
-concurrent-programs/bakery/lexicographic.cert : acl2x = 0
-concurrent-programs/bakery/lexicographic.cert : no_pcert = 0
-
-concurrent-programs/bakery/lexicographic.cert : \
- misc/total-order.cert \
- concurrent-programs/bakery/measures.cert \
- concurrent-programs/bakery/lexicographic.lisp
-
-
-concurrent-programs/bakery/measures.cert : acl2x = 0
-concurrent-programs/bakery/measures.cert : no_pcert = 0
-
-concurrent-programs/bakery/measures.cert : \
- ordinals/e0-ordinal.cert \
- concurrent-programs/bakery/measures.lisp
-
-
-concurrent-programs/bakery/pos-temp.cert : acl2x = 0
-concurrent-programs/bakery/pos-temp.cert : no_pcert = 0
-
-concurrent-programs/bakery/pos-temp.cert : \
- concurrent-programs/bakery/variables.cert \
- concurrent-programs/bakery/properties.cert \
- concurrent-programs/bakery/pos-temp.lisp
-
-
-concurrent-programs/bakery/programs.cert : acl2x = 0
-concurrent-programs/bakery/programs.cert : no_pcert = 0
-
-concurrent-programs/bakery/programs.cert : \
- concurrent-programs/bakery/variables.cert \
- concurrent-programs/bakery/lexicographic.cert \
- concurrent-programs/bakery/fairenv.cert \
- concurrent-programs/bakery/programs.lisp
-
-
-concurrent-programs/bakery/properties-of-sets.cert : acl2x = 0
-concurrent-programs/bakery/properties-of-sets.cert : no_pcert = 0
-
-concurrent-programs/bakery/properties-of-sets.cert : \
- concurrent-programs/bakery/records.cert \
- concurrent-programs/bakery/properties-of-sets.lisp
-
-
-concurrent-programs/bakery/properties.cert : acl2x = 0
-concurrent-programs/bakery/properties.cert : no_pcert = 0
-
-concurrent-programs/bakery/properties.cert : \
- concurrent-programs/bakery/lexicographic.cert \
- concurrent-programs/bakery/measures.cert \
- concurrent-programs/bakery/properties-of-sets.cert \
- concurrent-programs/bakery/variables.cert \
- concurrent-programs/bakery/fairenv.cert \
- concurrent-programs/bakery/properties.lisp
-
-
-concurrent-programs/bakery/records.cert : acl2x = 0
-concurrent-programs/bakery/records.cert : no_pcert = 0
-
-concurrent-programs/bakery/records.cert : \
- concurrent-programs/bakery/apply-total-order.cert \
- concurrent-programs/bakery/records.lisp
-
-
-concurrent-programs/bakery/stutter1-match.cert : acl2x = 0
-concurrent-programs/bakery/stutter1-match.cert : no_pcert = 0
-
-concurrent-programs/bakery/stutter1-match.cert : \
- concurrent-programs/bakery/programs.cert \
- concurrent-programs/bakery/properties.cert \
- concurrent-programs/bakery/stutter1-match.lisp
-
-
-concurrent-programs/bakery/stutter2.cert : acl2x = 0
-concurrent-programs/bakery/stutter2.cert : no_pcert = 0
-
-concurrent-programs/bakery/stutter2.cert : \
- concurrent-programs/bakery/programs.cert \
- concurrent-programs/bakery/properties.cert \
- arithmetic-2/meta/top.cert \
- concurrent-programs/bakery/lexicographic-pos.cert \
- concurrent-programs/bakery/stutter2.lisp
-
-
-concurrent-programs/bakery/variables.cert : acl2x = 0
-concurrent-programs/bakery/variables.cert : no_pcert = 0
-
-concurrent-programs/bakery/variables.cert : \
- concurrent-programs/bakery/records.cert \
- concurrent-programs/bakery/variables.lisp
-
-
-concurrent-programs/german-protocol/german.cert : acl2x = 0
-concurrent-programs/german-protocol/german.cert : no_pcert = 0
-
-concurrent-programs/german-protocol/german.cert : \
- misc/records.cert \
- concurrent-programs/german-protocol/german.lisp
-
-
-countereg-gen/acl2s-parameter.cert : acl2x = 0
-countereg-gen/acl2s-parameter.cert : no_pcert = 0
-
-countereg-gen/acl2s-parameter.cert : \
- countereg-gen/utilities.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/acl2s-parameter.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/base.cert : acl2x = 0
-countereg-gen/base.cert : no_pcert = 0
-
-countereg-gen/base.cert : \
- countereg-gen/data.cert \
- countereg-gen/splitnat.cert \
- countereg-gen/switchnat.cert \
- countereg-gen/graph.cert \
- countereg-gen/library-support.cert \
- arithmetic-5/top.cert \
- arithmetic-5/top.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/base.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/basis.cert : acl2x = 0
-countereg-gen/basis.cert : no_pcert = 0
-
-countereg-gen/basis.cert : \
- tools/bstar.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/basis.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/data.cert : acl2x = 0
-countereg-gen/data.cert : no_pcert = 0
-
-countereg-gen/data.cert : \
- countereg-gen/utilities.cert \
- countereg-gen/basis.cert \
- countereg-gen/acl2s-parameter.cert \
- countereg-gen/splitnat.cert \
- countereg-gen/switchnat.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/data.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/graph.cert : acl2x = 0
-countereg-gen/graph.cert : no_pcert = 0
-
-countereg-gen/graph.cert : \
- countereg-gen/utilities.cert \
- countereg-gen/data.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/graph.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/library-support.cert : acl2x = 0
-countereg-gen/library-support.cert : no_pcert = 0
-
-countereg-gen/library-support.cert : \
- defexec/other-apps/records/records.cert \
- finite-set-theory/osets/sets.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/library-support.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/main.cert : acl2x = 0
-countereg-gen/main.cert : no_pcert = 0
-
-countereg-gen/main.cert : \
- tools/bstar.cert \
- countereg-gen/basis.cert \
- countereg-gen/with-timeout.cert \
- countereg-gen/type.cert \
- countereg-gen/acl2s-parameter.cert \
- countereg-gen/simple-graph-array.cert \
- countereg-gen/random-state.cert \
- tools/easy-simplify.cert \
- countereg-gen/data.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/main.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/mv-proof.cert : acl2x = 0
-countereg-gen/mv-proof.cert : no_pcert = 0
-
-countereg-gen/mv-proof.cert : \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/mv-proof.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/num-list-fns.cert : acl2x = 0
-countereg-gen/num-list-fns.cert : no_pcert = 0
-
-countereg-gen/num-list-fns.cert : \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/num-list-fns.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/num-list-thms.cert : acl2x = 0
-countereg-gen/num-list-thms.cert : no_pcert = 0
-
-countereg-gen/num-list-thms.cert : \
- countereg-gen/num-list-fns.cert \
- arithmetic-5/top.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/num-list-thms.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/random-state-basis1.cert : acl2x = 0
-countereg-gen/random-state-basis1.cert : no_pcert = 0
-
-countereg-gen/random-state-basis1.cert : \
- tools/bstar.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/random-state-basis1.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/random-state.cert : acl2x = 0
-countereg-gen/random-state.cert : no_pcert = 0
-
-countereg-gen/random-state.cert : \
- countereg-gen/random-state-basis1.cert \
- arithmetic/rationals.cert \
- arithmetic-3/top.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/random-state.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/random.cert : acl2x = 0
-countereg-gen/random.cert : no_pcert = 0
-
-countereg-gen/random.cert : \
- arithmetic-3/floor-mod/floor-mod.cert \
- arithmetic/rationals.cert \
- arithmetic-3/top.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/random.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/rem-and-floor.cert : acl2x = 0
-countereg-gen/rem-and-floor.cert : no_pcert = 0
-
-countereg-gen/rem-and-floor.cert : \
- arithmetic-5/top.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/rem-and-floor.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/simple-graph-array.cert : acl2x = 0
-countereg-gen/simple-graph-array.cert : no_pcert = 0
-
-countereg-gen/simple-graph-array.cert : \
- countereg-gen/utilities.cert \
- ordinals/lexicographic-ordering-without-arithmetic.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/simple-graph-array.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/splitnat.cert : acl2x = 0
-countereg-gen/splitnat.cert : no_pcert = 0
-
-countereg-gen/splitnat.cert : \
- countereg-gen/num-list-fns.cert \
- countereg-gen/num-list-thms.cert \
- countereg-gen/rem-and-floor.cert \
- arithmetic-5/top.cert \
- arithmetic-5/top.cert \
- arithmetic-5/top.cert \
- arithmetic-3/top.cert \
- arithmetic-5/top.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/splitnat.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/switchnat.cert : acl2x = 0
-countereg-gen/switchnat.cert : no_pcert = 0
-
-countereg-gen/switchnat.cert : \
- countereg-gen/num-list-fns.cert \
- countereg-gen/num-list-thms.cert \
- countereg-gen/rem-and-floor.cert \
- countereg-gen/mv-proof.cert \
- arithmetic-5/top.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/switchnat.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/top.cert : acl2x = 0
-countereg-gen/top.cert : no_pcert = 0
-
-countereg-gen/top.cert : \
- countereg-gen/acl2s-parameter.cert \
- countereg-gen/main.cert \
- countereg-gen/base.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/top.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/type.cert : acl2x = 0
-countereg-gen/type.cert : no_pcert = 0
-
-countereg-gen/type.cert : \
- countereg-gen/graph.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/type.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/utilities.cert : acl2x = 0
-countereg-gen/utilities.cert : no_pcert = 0
-
-countereg-gen/utilities.cert : \
- tools/bstar.cert \
- misc/total-order.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/utilities.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-countereg-gen/with-timeout.cert : acl2x = 0
-countereg-gen/with-timeout.cert : no_pcert = 0
-
-countereg-gen/with-timeout.cert : \
- xdoc/top.cert \
- finite-set-theory/osets/portcullis.cert \
- countereg-gen/with-timeout.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-
-
-cowles/acl2-agp.cert : acl2x = 0
-cowles/acl2-agp.cert : no_pcert = 0
-
-cowles/acl2-agp.cert : \
- cowles/acl2-asg.cert \
- cowles/acl2-agp.lisp \
- cowles/cert.acl2 \
- cowles/packages.lsp
-
-
-cowles/acl2-asg.cert : acl2x = 0
-cowles/acl2-asg.cert : no_pcert = 0
-
-cowles/acl2-asg.cert : \
- cowles/acl2-asg.lisp \
- cowles/cert.acl2 \
- cowles/packages.lsp
-
-
-cowles/acl2-crg.cert : acl2x = 0
-cowles/acl2-crg.cert : no_pcert = 0
-
-cowles/acl2-crg.cert : \
- cowles/acl2-agp.cert \
- cowles/acl2-crg.lisp \
- cowles/cert.acl2 \
- cowles/packages.lsp
-
-
-cutil/da-base.cert : acl2x = 0
-cutil/da-base.cert : no_pcert = 0
-
-cutil/da-base.cert : \
- cutil/support.cert \
- tools/bstar.cert \
- cutil/portcullis.cert \
- cutil/da-base.lisp \
- cutil/cert.acl2
-
-
-cutil/defaggregate-tests.cert : acl2x = 0
-cutil/defaggregate-tests.cert : no_pcert = 0
-
-cutil/defaggregate-tests.cert : \
- cutil/defaggregate.cert \
- cutil/deflist.cert \
- cutil/portcullis.cert \
- cutil/defaggregate-tests.lisp \
- cutil/cert.acl2
-
-
-cutil/defaggregate.cert : acl2x = 0
-cutil/defaggregate.cert : no_pcert = 0
-
-cutil/defaggregate.cert : \
- cutil/da-base.cert \
- cutil/formals.cert \
- xdoc-impl/fmt-to-str.cert \
- tools/rulesets.cert \
- xdoc/names.cert \
- str/cat.cert \
- cutil/portcullis.cert \
- cutil/defaggregate.lisp \
- cutil/cert.acl2
-
-
-cutil/defalist-tests.cert : acl2x = 0
-cutil/defalist-tests.cert : no_pcert = 0
-
-cutil/defalist-tests.cert : \
- cutil/defalist.cert \
- cutil/portcullis.cert \
- cutil/defalist-tests.lisp \
- cutil/cert.acl2
-
-
-cutil/defalist.cert : acl2x = 0
-cutil/defalist.cert : no_pcert = 0
-
-cutil/defalist.cert : \
- cutil/deflist.cert \
- misc/hons-help.cert \
- cutil/portcullis.cert \
- cutil/defalist.lisp \
- cutil/cert.acl2
-
-
-cutil/defenum.cert : acl2x = 0
-cutil/defenum.cert : no_pcert = 0
-
-cutil/defenum.cert : \
- cutil/deflist.cert \
- cutil/portcullis.cert \
- cutil/defenum.lisp \
- cutil/cert.acl2
-
-
-cutil/define-tests.cert : acl2x = 0
-cutil/define-tests.cert : no_pcert = 0
-
-cutil/define-tests.cert : \
- cutil/define.cert \
- cutil/portcullis.cert \
- cutil/define-tests.lisp \
- cutil/define-tests.acl2
-
-
-cutil/define.cert : acl2x = 0
-cutil/define.cert : no_pcert = 0
-
-cutil/define.cert : \
- cutil/formals.cert \
- cutil/returnspecs.cert \
- xdoc-impl/fmt-to-str.cert \
- tools/mv-nth.cert \
- str/cat.cert \
- misc/assert.cert \
- cutil/portcullis.cert \
- cutil/define.lisp \
- cutil/cert.acl2
-
-
-cutil/deflist-aux.cert : acl2x = 0
-cutil/deflist-aux.cert : no_pcert = 0
-
-cutil/deflist-aux.cert : \
- finite-set-theory/osets/sets.cert \
- cutil/portcullis.cert \
- cutil/deflist-aux.lisp \
- cutil/cert.acl2
-
-
-cutil/deflist-tests.cert : acl2x = 0
-cutil/deflist-tests.cert : no_pcert = 0
-
-cutil/deflist-tests.cert : \
- cutil/deflist.cert \
- str/top.cert \
- misc/assert.cert \
- cutil/portcullis.cert \
- cutil/deflist-tests.lisp \
- cutil/cert.acl2
-
-
-cutil/deflist.cert : acl2x = 0
-cutil/deflist.cert : no_pcert = 0
-
-cutil/deflist.cert : \
- xdoc/top.cert \
- tools/bstar.cert \
- str/cat.cert \
- finite-set-theory/osets/sets.cert \
- defsort/duplicated-members.cert \
- std/lists/sets.cert \
- std/lists/list-fix.cert \
- std/lists/take.cert \
- std/lists/repeat.cert \
- std/lists/rev.cert \
- cutil/maybe-defthm.cert \
- finite-set-theory/osets/under-set-equiv.cert \
- arithmetic/top-with-meta.cert \
- cutil/portcullis.cert \
- cutil/deflist.lisp \
- cutil/cert.acl2
-
-
-cutil/defmapappend-tests.cert : acl2x = 0
-cutil/defmapappend-tests.cert : no_pcert = 0
-
-cutil/defmapappend-tests.cert : \
- cutil/defmapappend.cert \
- cutil/portcullis.cert \
- cutil/defmapappend-tests.lisp \
- cutil/cert.acl2
-
-
-cutil/defmapappend.cert : acl2x = 0
-cutil/defmapappend.cert : no_pcert = 0
-
-cutil/defmapappend.cert : \
- cutil/defprojection.cert \
- cutil/portcullis.cert \
- cutil/defmapappend.lisp \
- cutil/cert.acl2
-
-
-cutil/defmvtypes.cert : acl2x = 0
-cutil/defmvtypes.cert : no_pcert = 0
-
-cutil/defmvtypes.cert : \
- cutil/deflist.cert \
- cutil/portcullis.cert \
- cutil/defmvtypes.lisp \
- cutil/cert.acl2
-
-
-cutil/defprojection-tests.cert : acl2x = 0
-cutil/defprojection-tests.cert : no_pcert = 0
-
-cutil/defprojection-tests.cert : \
- cutil/defprojection.cert \
- misc/assert.cert \
- cutil/portcullis.cert \
- cutil/defprojection-tests.lisp \
- cutil/defprojection-tests.acl2
-
-
-cutil/defprojection.cert : acl2x = 0
-cutil/defprojection.cert : no_pcert = 0
-
-cutil/defprojection.cert : \
- cutil/deflist.cert \
- cutil/portcullis.cert \
- cutil/defprojection.lisp \
- cutil/cert.acl2
-
-
-cutil/defsection.cert : acl2x = 0
-cutil/defsection.cert : no_pcert = 0
-
-cutil/defsection.cert : \
- xdoc/top.cert \
- tools/bstar.cert \
- cutil/portcullis.cert \
- cutil/defsection.lisp \
- cutil/cert.acl2
-
-
-cutil/formals.cert : acl2x = 0
-cutil/formals.cert : no_pcert = 0
-
-cutil/formals.cert : \
- cutil/look-up.cert \
- cutil/da-base.cert \
- misc/assert.cert \
- cutil/portcullis.cert \
- cutil/formals.lisp \
- cutil/cert.acl2
-
-
-cutil/look-up.cert : acl2x = 0
-cutil/look-up.cert : no_pcert = 0
-
-cutil/look-up.cert : \
- cutil/support.cert \
- tools/bstar.cert \
- misc/assert.cert \
- cutil/portcullis.cert \
- cutil/look-up.lisp \
- cutil/cert.acl2
-
-
-cutil/maybe-defthm.cert : acl2x = 0
-cutil/maybe-defthm.cert : no_pcert = 0
-
-cutil/maybe-defthm.cert : \
- tools/bstar.cert \
- misc/assert.cert \
- cutil/portcullis.cert \
- cutil/maybe-defthm.lisp \
- cutil/cert.acl2
-
-
-cutil/portcullis.cert : acl2x = 0
-cutil/portcullis.cert : no_pcert = 0
-
-cutil/portcullis.cert : \
- cutil/portcullis.lisp \
- cutil/portcullis.acl2 \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-
-
-cutil/returnspecs.cert : acl2x = 0
-cutil/returnspecs.cert : no_pcert = 0
-
-cutil/returnspecs.cert : \
- cutil/da-base.cert \
- cutil/look-up.cert \
- misc/assert.cert \
- cutil/portcullis.cert \
- cutil/returnspecs.lisp \
- cutil/cert.acl2
-
-
-cutil/support.cert : acl2x = 0
-cutil/support.cert : no_pcert = 0
-
-cutil/support.cert : \
- xdoc/top.cert \
- misc/definline.cert \
- tools/bstar.cert \
- cutil/portcullis.cert \
- cutil/support.lisp \
- cutil/cert.acl2
-
-
-cutil/top.cert : acl2x = 0
-cutil/top.cert : no_pcert = 0
-
-cutil/top.cert : \
- cutil/defaggregate.cert \
- cutil/defalist.cert \
- cutil/defenum.cert \
- cutil/deflist.cert \
- cutil/defmapappend.cert \
- cutil/defmvtypes.cert \
- cutil/defprojection.cert \
- cutil/define.cert \
- cutil/portcullis.cert \
- cutil/top.lisp \
- cutil/top.acl2
-
-
-cutil/wizard.cert : acl2x = 0
-cutil/wizard.cert : no_pcert = 0
-
-cutil/wizard.cert : \
- cutil/defaggregate.cert \
- cutil/deflist.cert \
- clause-processors/unify-subst.cert \
- cutil/portcullis.cert \
- cutil/wizard.lisp \
- cutil/cert.acl2
-
-
-data-structures/alist-defthms.cert : acl2x = 0
-data-structures/alist-defthms.cert : no_pcert = 0
-
-data-structures/alist-defthms.cert : \
- data-structures/alist-defuns.cert \
- data-structures/list-defuns.cert \
- data-structures/set-defuns.cert \
- arithmetic/equalities.cert \
- data-structures/set-defthms.cert \
- data-structures/alist-defthms.lisp
-
-
-data-structures/alist-defuns.cert : acl2x = 0
-data-structures/alist-defuns.cert : no_pcert = 0
-
-data-structures/alist-defuns.cert : \
- data-structures/alist-defuns.lisp
-
-
-data-structures/alist-theory.cert : acl2x = 0
-data-structures/alist-theory.cert : no_pcert = 0
-
-data-structures/alist-theory.cert : \
- data-structures/alist-defuns.cert \
- data-structures/alist-defthms.cert \
- data-structures/defalist.cert \
- data-structures/alist-theory.lisp
-
-
-data-structures/array1.cert : acl2x = 0
-data-structures/array1.cert : no_pcert = 0
-
-data-structures/array1.cert : \
- data-structures/doc-section.cert \
- data-structures/array1.lisp
-
-
-data-structures/defalist.cert : acl2x = 0
-data-structures/defalist.cert : no_pcert = 0
-
-data-structures/defalist.cert : \
- data-structures/alist-defuns.cert \
- data-structures/list-defuns.cert \
- data-structures/utilities.cert \
- data-structures/defalist.lisp \
- data-structures/defalist.acl2 \
- data-structures/define-u-package.lsp
-
-
-data-structures/deflist.cert : acl2x = 0
-data-structures/deflist.cert : no_pcert = 0
-
-data-structures/deflist.cert : \
- data-structures/list-defuns.cert \
- data-structures/utilities.cert \
- data-structures/list-defthms.cert \
- data-structures/deflist.lisp \
- data-structures/deflist.acl2 \
- data-structures/define-u-package.lsp
-
-
-data-structures/doc-section.cert : acl2x = 0
-data-structures/doc-section.cert : no_pcert = 0
-
-data-structures/doc-section.cert : \
- data-structures/doc-section.lisp
-
-
-data-structures/list-defthms.cert : acl2x = 0
-data-structures/list-defthms.cert : no_pcert = 0
-
-data-structures/list-defthms.cert : \
- data-structures/list-defuns.cert \
- arithmetic/equalities.cert \
- data-structures/list-defthms.lisp
-
-
-data-structures/list-defuns.cert : acl2x = 0
-data-structures/list-defuns.cert : no_pcert = 0
-
-data-structures/list-defuns.cert : \
- data-structures/list-defuns.lisp
-
-
-data-structures/list-theory.cert : acl2x = 0
-data-structures/list-theory.cert : no_pcert = 0
-
-data-structures/list-theory.cert : \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- data-structures/deflist.cert \
- data-structures/list-theory.lisp
-
-
-data-structures/memories/log2.cert : acl2x = 0
-data-structures/memories/log2.cert : no_pcert = 0
-
-data-structures/memories/log2.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- data-structures/memories/log2.lisp \
- data-structures/memories/cert.acl2 \
- data-structures/memories/package.lsp
-
-
-data-structures/memories/memory-impl.cert : acl2x = 0
-data-structures/memories/memory-impl.cert : no_pcert = 0
-
-data-structures/memories/memory-impl.cert : \
- data-structures/memories/log2.cert \
- data-structures/memories/memtree.cert \
- misc/records.cert \
- data-structures/memories/memory-impl.lisp \
- data-structures/memories/cert.acl2 \
- data-structures/memories/package.lsp
-
-
-data-structures/memories/memory.cert : acl2x = 0
-data-structures/memories/memory.cert : no_pcert = 0
-
-data-structures/memories/memory.cert : \
- data-structures/memories/memory-impl.cert \
- data-structures/doc-section.cert \
- data-structures/memories/private.cert \
- misc/records.cert \
- data-structures/memories/memory.lisp \
- data-structures/memories/cert.acl2 \
- data-structures/memories/package.lsp
-
-
-data-structures/memories/memtree.cert : acl2x = 0
-data-structures/memories/memtree.cert : no_pcert = 0
-
-data-structures/memories/memtree.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- data-structures/memories/memtree.lisp \
- data-structures/memories/cert.acl2 \
- data-structures/memories/package.lsp
-
-
-data-structures/memories/private.cert : acl2x = 0
-data-structures/memories/private.cert : no_pcert = 0
-
-data-structures/memories/private.cert : \
- data-structures/doc-section.cert \
- data-structures/memories/private.lisp \
- data-structures/memories/cert.acl2 \
- data-structures/memories/package.lsp
-
-
-data-structures/no-duplicates.cert : acl2x = 0
-data-structures/no-duplicates.cert : no_pcert = 0
-
-data-structures/no-duplicates.cert : \
- data-structures/no-duplicates.lisp
-
-
-data-structures/number-list-defthms.cert : acl2x = 0
-data-structures/number-list-defthms.cert : no_pcert = 0
-
-data-structures/number-list-defthms.cert : \
- data-structures/number-list-defuns.cert \
- data-structures/deflist.cert \
- data-structures/number-list-defthms.lisp
-
-
-data-structures/number-list-defuns.cert : acl2x = 0
-data-structures/number-list-defuns.cert : no_pcert = 0
-
-data-structures/number-list-defuns.cert : \
- data-structures/list-defuns.cert \
- data-structures/number-list-defuns.lisp
-
-
-data-structures/number-list-theory.cert : acl2x = 0
-data-structures/number-list-theory.cert : no_pcert = 0
-
-data-structures/number-list-theory.cert : \
- data-structures/number-list-defuns.cert \
- data-structures/number-list-defthms.cert \
- data-structures/number-list-theory.lisp
-
-
-data-structures/set-defthms.cert : acl2x = 0
-data-structures/set-defthms.cert : no_pcert = 0
-
-data-structures/set-defthms.cert : \
- data-structures/set-defuns.cert \
- data-structures/set-defthms.lisp
-
-
-data-structures/set-defuns.cert : acl2x = 0
-data-structures/set-defuns.cert : no_pcert = 0
-
-data-structures/set-defuns.cert : \
- data-structures/set-defuns.lisp
-
-
-data-structures/set-theory.cert : acl2x = 0
-data-structures/set-theory.cert : no_pcert = 0
-
-data-structures/set-theory.cert : \
- data-structures/set-defuns.cert \
- data-structures/set-defthms.cert \
- data-structures/set-theory.lisp
-
-
-data-structures/structures.cert : acl2x = 0
-data-structures/structures.cert : no_pcert = 0
-
-data-structures/structures.cert : \
- data-structures/utilities.cert \
- data-structures/structures.lisp \
- data-structures/structures.acl2 \
- data-structures/define-u-package.lsp \
- data-structures/define-structures-package.lsp
-
-
-data-structures/utilities.cert : acl2x = 0
-data-structures/utilities.cert : no_pcert = 0
-
-data-structures/utilities.cert : \
- data-structures/doc-section.cert \
- data-structures/utilities.lisp \
- data-structures/utilities.acl2 \
- data-structures/define-u-package.lsp
-
-
-deduction/passmore/bewijs.cert : acl2x = 0
-deduction/passmore/bewijs.cert : no_pcert = 0
-
-deduction/passmore/bewijs.cert : \
- deduction/passmore/bewijs.lisp
-
-
-deduction/passmore/general.cert : acl2x = 0
-deduction/passmore/general.cert : no_pcert = 0
-
-deduction/passmore/general.cert : \
- deduction/passmore/general.lisp
-
-
-deduction/passmore/paramod.cert : acl2x = 0
-deduction/passmore/paramod.cert : no_pcert = 0
-
-deduction/passmore/paramod.cert : \
- deduction/passmore/weighting.cert \
- deduction/passmore/paramod.lisp
-
-
-deduction/passmore/prover.cert : acl2x = 0
-deduction/passmore/prover.cert : no_pcert = 0
-
-deduction/passmore/prover.cert : \
- deduction/passmore/general.cert \
- deduction/passmore/unification.cert \
- deduction/passmore/weighting.cert \
- deduction/passmore/resolution.cert \
- deduction/passmore/paramod.cert \
- deduction/passmore/bewijs.cert \
- deduction/passmore/prover.lisp
-
-
-deduction/passmore/resolution.cert : acl2x = 0
-deduction/passmore/resolution.cert : no_pcert = 0
-
-deduction/passmore/resolution.cert : \
- deduction/passmore/general.cert \
- deduction/passmore/unification.cert \
- deduction/passmore/weighting.cert \
- deduction/passmore/resolution.lisp
-
-
-deduction/passmore/unification.cert : acl2x = 0
-deduction/passmore/unification.cert : no_pcert = 0
-
-deduction/passmore/unification.cert : \
- deduction/passmore/general.cert \
- deduction/passmore/unification.lisp
-
-
-deduction/passmore/weighting.cert : acl2x = 0
-deduction/passmore/weighting.cert : no_pcert = 0
-
-deduction/passmore/weighting.cert : \
- deduction/passmore/unification.cert \
- deduction/passmore/weighting.lisp
-
-
-defexec/dag-unification/basic.cert : acl2x = 0
-defexec/dag-unification/basic.cert : no_pcert = 0
-
-defexec/dag-unification/basic.cert : \
- arithmetic/top-with-meta.cert \
- defexec/dag-unification/basic.lisp
-
-
-defexec/dag-unification/dag-unification-l.cert : acl2x = 0
-defexec/dag-unification/dag-unification-l.cert : no_pcert = 0
-
-defexec/dag-unification/dag-unification-l.cert : \
- defexec/dag-unification/dag-unification-rules.cert \
- defexec/dag-unification/terms-as-dag.cert \
- defexec/dag-unification/dag-unification-l.lisp
-
-
-defexec/dag-unification/dag-unification-rules.cert : acl2x = 0
-defexec/dag-unification/dag-unification-rules.cert : no_pcert = 0
-
-defexec/dag-unification/dag-unification-rules.cert : \
- defexec/dag-unification/dags.cert \
- defexec/dag-unification/list-unification-rules.cert \
- defexec/dag-unification/dag-unification-rules.lisp
-
-
-defexec/dag-unification/dag-unification-st.cert : acl2x = 0
-defexec/dag-unification/dag-unification-st.cert : no_pcert = 0
-
-defexec/dag-unification/dag-unification-st.cert : \
- defexec/dag-unification/dag-unification-l.cert \
- defexec/dag-unification/terms-dag-stobj.cert \
- defexec/dag-unification/dag-unification-st.lisp
-
-
-defexec/dag-unification/dags.cert : acl2x = 0
-defexec/dag-unification/dags.cert : no_pcert = 0
-
-defexec/dag-unification/dags.cert : \
- defexec/dag-unification/basic.cert \
- defexec/dag-unification/dags.lisp
-
-
-defexec/dag-unification/list-unification-rules.cert : acl2x = 0
-defexec/dag-unification/list-unification-rules.cert : no_pcert = 0
-
-defexec/dag-unification/list-unification-rules.cert : \
- defexec/dag-unification/subsumption-subst.cert \
- defexec/dag-unification/list-unification-rules.lisp
-
-
-defexec/dag-unification/matching.cert : acl2x = 0
-defexec/dag-unification/matching.cert : no_pcert = 0
-
-defexec/dag-unification/matching.cert : \
- defexec/dag-unification/terms.cert \
- defexec/dag-unification/matching.lisp
-
-
-defexec/dag-unification/subsumption-subst.cert : acl2x = 0
-defexec/dag-unification/subsumption-subst.cert : no_pcert = 0
-
-defexec/dag-unification/subsumption-subst.cert : \
- defexec/dag-unification/subsumption.cert \
- defexec/dag-unification/subsumption-subst.lisp
-
-
-defexec/dag-unification/subsumption.cert : acl2x = 0
-defexec/dag-unification/subsumption.cert : no_pcert = 0
-
-defexec/dag-unification/subsumption.cert : \
- defexec/dag-unification/matching.cert \
- defexec/dag-unification/terms.cert \
- defexec/dag-unification/subsumption.lisp
-
-
-defexec/dag-unification/terms-as-dag.cert : acl2x = 0
-defexec/dag-unification/terms-as-dag.cert : no_pcert = 0
-
-defexec/dag-unification/terms-as-dag.cert : \
- defexec/dag-unification/dag-unification-rules.cert \
- defexec/dag-unification/terms-as-dag.lisp
-
-
-defexec/dag-unification/terms-dag-stobj.cert : acl2x = 0
-defexec/dag-unification/terms-dag-stobj.cert : no_pcert = 0
-
-defexec/dag-unification/terms-dag-stobj.cert : \
- defexec/dag-unification/dag-unification-rules.cert \
- defexec/dag-unification/terms-dag-stobj.lisp
-
-
-defexec/dag-unification/terms.cert : acl2x = 0
-defexec/dag-unification/terms.cert : no_pcert = 0
-
-defexec/dag-unification/terms.cert : \
- defexec/dag-unification/basic.cert \
- defexec/dag-unification/terms.lisp
-
-
-defexec/defpun-exec/defpun-exec.cert : acl2x = 0
-defexec/defpun-exec/defpun-exec.cert : no_pcert = 0
-
-defexec/defpun-exec/defpun-exec.cert : \
- misc/defpun.cert \
- defexec/defpun-exec/defpun-exec.lisp
-
-
-defexec/find-path/fpst.cert : acl2x = 0
-defexec/find-path/fpst.cert : no_pcert = 0
-
-defexec/find-path/fpst.cert : \
- defexec/find-path/graph/linear-find-path.cert \
- defexec/find-path/fpst.lisp
-
-
-defexec/find-path/graph/find-path1.cert : acl2x = 0
-defexec/find-path/graph/find-path1.cert : no_pcert = 0
-
-defexec/find-path/graph/find-path1.cert : \
- arithmetic/top.cert \
- ordinals/e0-ordinal.cert \
- defexec/find-path/graph/find-path1.lisp
-
-
-defexec/find-path/graph/find-path2.cert : acl2x = 0
-defexec/find-path/graph/find-path2.cert : no_pcert = 0
-
-defexec/find-path/graph/find-path2.cert : \
- arithmetic/top.cert \
- defexec/find-path/graph/helpers.cert \
- ordinals/e0-ordinal.cert \
- defexec/find-path/graph/find-path2.lisp
-
-
-defexec/find-path/graph/find-path3.cert : acl2x = 0
-defexec/find-path/graph/find-path3.cert : no_pcert = 0
-
-defexec/find-path/graph/find-path3.cert : \
- arithmetic/top.cert \
- defexec/find-path/graph/helpers.cert \
- ordinals/e0-ordinal.cert \
- defexec/find-path/graph/find-path3.lisp
-
-
-defexec/find-path/graph/helpers.cert : acl2x = 0
-defexec/find-path/graph/helpers.cert : no_pcert = 0
-
-defexec/find-path/graph/helpers.cert : \
- defexec/find-path/graph/helpers.lisp
-
-
-defexec/find-path/graph/linear-find-path.cert : acl2x = 0
-defexec/find-path/graph/linear-find-path.cert : no_pcert = 0
-
-defexec/find-path/graph/linear-find-path.cert : \
- defexec/find-path/graph/find-path3.cert \
- defexec/find-path/graph/linear-find-path.lisp
-
-
-defexec/find-path/run-fpst.cert : acl2x = 0
-defexec/find-path/run-fpst.cert : no_pcert = 0
-
-defexec/find-path/run-fpst.cert : \
- defexec/find-path/fpst.cert \
- defexec/find-path/run-fpst.lisp
-
-
-defexec/ordinals/supporting-ordinals.cert : acl2x = 0
-defexec/ordinals/supporting-ordinals.cert : no_pcert = 0
-
-defexec/ordinals/supporting-ordinals.cert : \
- ordinals/ordinals.cert \
- defexec/ordinals/supporting-ordinals.lisp
-
-
-defexec/other-apps/misc/memos.cert : acl2x = 0
-defexec/other-apps/misc/memos.cert : no_pcert = 0
-
-defexec/other-apps/misc/memos.cert : \
- defexec/other-apps/misc/memos.lisp
-
-
-defexec/other-apps/misc/stobjsim.cert : acl2x = 0
-defexec/other-apps/misc/stobjsim.cert : no_pcert = 0
-
-defexec/other-apps/misc/stobjsim.cert : \
- defexec/other-apps/misc/stobjsim.lisp
-
-
-defexec/other-apps/qsort/extraction.cert : acl2x = 0
-defexec/other-apps/qsort/extraction.cert : no_pcert = 0
-
-defexec/other-apps/qsort/extraction.cert : \
- defexec/other-apps/qsort/programs.cert \
- defexec/other-apps/qsort/intermediate-program.cert \
- defexec/other-apps/qsort/first-last.cert \
- defexec/other-apps/qsort/extraction.lisp
-
-
-defexec/other-apps/qsort/final-theorem.cert : acl2x = 0
-defexec/other-apps/qsort/final-theorem.cert : no_pcert = 0
-
-defexec/other-apps/qsort/final-theorem.cert : \
- defexec/other-apps/qsort/sort-qs-properties.cert \
- defexec/other-apps/qsort/load-extract.cert \
- defexec/other-apps/qsort/final-theorem.lisp
-
-
-defexec/other-apps/qsort/first-last.cert : acl2x = 0
-defexec/other-apps/qsort/first-last.cert : no_pcert = 0
-
-defexec/other-apps/qsort/first-last.cert : \
- defexec/other-apps/qsort/programs.cert \
- defexec/other-apps/qsort/first-last.lisp
-
-
-defexec/other-apps/qsort/intermediate-program.cert : acl2x = 0
-defexec/other-apps/qsort/intermediate-program.cert : no_pcert = 0
-
-defexec/other-apps/qsort/intermediate-program.cert : \
- defexec/other-apps/qsort/total-order.cert \
- defexec/other-apps/qsort/permutations.cert \
- defexec/other-apps/qsort/intermediate-program.lisp
-
-
-defexec/other-apps/qsort/intermediate-to-spec.cert : acl2x = 0
-defexec/other-apps/qsort/intermediate-to-spec.cert : no_pcert = 0
-
-defexec/other-apps/qsort/intermediate-to-spec.cert : \
- defexec/other-apps/qsort/intermediate-program.cert \
- defexec/other-apps/qsort/spec-properties.cert \
- defexec/other-apps/qsort/intermediate-to-spec.lisp
-
-
-defexec/other-apps/qsort/load-extract.cert : acl2x = 0
-defexec/other-apps/qsort/load-extract.cert : no_pcert = 0
-
-defexec/other-apps/qsort/load-extract.cert : \
- defexec/other-apps/qsort/programs.cert \
- defexec/other-apps/qsort/first-last.cert \
- defexec/other-apps/qsort/extraction.cert \
- defexec/other-apps/qsort/load-extract.lisp
-
-
-defexec/other-apps/qsort/merge-intermediate.cert : acl2x = 0
-defexec/other-apps/qsort/merge-intermediate.cert : no_pcert = 0
-
-defexec/other-apps/qsort/merge-intermediate.cert : \
- defexec/other-apps/qsort/programs.cert \
- defexec/other-apps/qsort/intermediate-to-spec.cert \
- defexec/other-apps/qsort/first-last.cert \
- defexec/other-apps/qsort/merge-intermediate.lisp
-
-
-defexec/other-apps/qsort/nth-update-nth.cert : acl2x = 0
-defexec/other-apps/qsort/nth-update-nth.cert : no_pcert = 0
-
-defexec/other-apps/qsort/nth-update-nth.cert : \
- defexec/other-apps/qsort/nth-update-nth.lisp
-
-
-defexec/other-apps/qsort/permutations.cert : acl2x = 0
-defexec/other-apps/qsort/permutations.cert : no_pcert = 0
-
-defexec/other-apps/qsort/permutations.cert : \
- defexec/other-apps/qsort/permutations.lisp
-
-
-defexec/other-apps/qsort/programs.cert : acl2x = 0
-defexec/other-apps/qsort/programs.cert : no_pcert = 0
-
-defexec/other-apps/qsort/programs.cert : \
- defexec/other-apps/qsort/total-order.cert \
- defexec/other-apps/qsort/nth-update-nth.cert \
- arithmetic/top-with-meta.cert \
- defexec/other-apps/qsort/programs.lisp
-
-
-defexec/other-apps/qsort/sort-qs-properties.cert : acl2x = 0
-defexec/other-apps/qsort/sort-qs-properties.cert : no_pcert = 0
-
-defexec/other-apps/qsort/sort-qs-properties.cert : \
- defexec/other-apps/qsort/split-qs-properties.cert \
- arithmetic/top-with-meta.cert \
- defexec/other-apps/qsort/load-extract.cert \
- defexec/other-apps/qsort/sort-qs-properties.lisp
-
-
-defexec/other-apps/qsort/spec-properties.cert : acl2x = 0
-defexec/other-apps/qsort/spec-properties.cert : no_pcert = 0
-
-defexec/other-apps/qsort/spec-properties.cert : \
- defexec/other-apps/qsort/programs.cert \
- defexec/other-apps/qsort/permutations.cert \
- defexec/other-apps/qsort/spec-properties.lisp
-
-
-defexec/other-apps/qsort/split-qs-properties.cert : acl2x = 0
-defexec/other-apps/qsort/split-qs-properties.cert : no_pcert = 0
-
-defexec/other-apps/qsort/split-qs-properties.cert : \
- defexec/other-apps/qsort/programs.cert \
- defexec/other-apps/qsort/merge-intermediate.cert \
- defexec/other-apps/qsort/extraction.cert \
- arithmetic/top-with-meta.cert \
- defexec/other-apps/qsort/split-qs-properties.lisp
-
-
-defexec/other-apps/qsort/total-order.cert : acl2x = 0
-defexec/other-apps/qsort/total-order.cert : no_pcert = 0
-
-defexec/other-apps/qsort/total-order.cert : \
- defexec/other-apps/qsort/total-order.lisp
-
-
-defexec/other-apps/records/inline.cert : acl2x = 0
-defexec/other-apps/records/inline.cert : no_pcert = 0
-
-defexec/other-apps/records/inline.cert : \
- defexec/other-apps/records/inline.lisp
-
-
-defexec/other-apps/records/records-bsd.cert : acl2x = 0
-defexec/other-apps/records/records-bsd.cert : no_pcert = 0
-
-defexec/other-apps/records/records-bsd.cert : \
- misc/total-order-bsd.cert \
- defexec/other-apps/records/records-bsd.lisp
-
-
-defexec/other-apps/records/records.cert : acl2x = 0
-defexec/other-apps/records/records.cert : no_pcert = 0
-
-defexec/other-apps/records/records.cert : \
- misc/total-order.cert \
- defexec/other-apps/records/records.lisp
-
-
-defexec/other-apps/records/recordsim.cert : acl2x = 0
-defexec/other-apps/records/recordsim.cert : no_pcert = 0
-
-defexec/other-apps/records/recordsim.cert : \
- defexec/other-apps/records/records.cert \
- defexec/other-apps/records/inline.cert \
- defexec/other-apps/records/recordsim.lisp
-
-
-defexec/reflexive/reflexive.cert : acl2x = 0
-defexec/reflexive/reflexive.cert : no_pcert = 0
-
-defexec/reflexive/reflexive.cert : \
- misc/eval.cert \
- defexec/reflexive/reflexive.lisp
-
-
-defsort/defsort.cert : acl2x = 0
-defsort/defsort.cert : no_pcert = 0
-
-defsort/defsort.cert : \
- defsort/generic.cert \
- defsort/defsort.lisp
-
-
-defsort/duplicated-members.cert : acl2x = 0
-defsort/duplicated-members.cert : no_pcert = 0
-
-defsort/duplicated-members.cert : \
- defsort/uniquep.cert \
- defsort/duplicity.cert \
- defsort/duplicated-members.lisp
-
-
-defsort/duplicity.cert : acl2x = 0
-defsort/duplicity.cert : no_pcert = 0
-
-defsort/duplicity.cert : \
- defsort/duplicity.lisp
-
-
-defsort/examples.cert : acl2x = 0
-defsort/examples.cert : no_pcert = 0
-
-defsort/examples.cert : \
- defsort/defsort.cert \
- misc/total-order.cert \
- misc/assert.cert \
- defsort/examples.lisp
-
-
-defsort/generic-impl.cert : acl2x = 0
-defsort/generic-impl.cert : no_pcert = 0
-
-defsort/generic-impl.cert : \
- std/lists/take.cert \
- std/lists/nthcdr.cert \
- std/lists/list-fix.cert \
- defsort/duplicity.cert \
- ihs/ihs-lemmas.cert \
- defsort/generic-impl.lisp
-
-
-defsort/generic.cert : acl2x = 0
-defsort/generic.cert : no_pcert = 0
-
-defsort/generic.cert : \
- defsort/generic-impl.cert \
- defsort/generic.lisp
-
-
-defsort/remove-dups.cert : acl2x = 0
-defsort/remove-dups.cert : no_pcert = 0
-
-defsort/remove-dups.cert : \
- defsort/uniquep.cert \
- misc/hons-help.cert \
- defsort/remove-dups.lisp
-
-
-defsort/uniquep.cert : acl2x = 0
-defsort/uniquep.cert : no_pcert = 0
-
-defsort/uniquep.cert : \
- defsort/defsort.cert \
- misc/total-order.cert \
- defsort/uniquep.lisp
-
-
-demos/list-theory.cert : acl2x = 0
-demos/list-theory.cert : no_pcert = 0
-
-demos/list-theory.cert : \
- demos/list-theory.lisp
-
-
-demos/modeling/memories.cert : acl2x = 0
-demos/modeling/memories.cert : no_pcert = 0
-
-demos/modeling/memories.cert : \
- defexec/other-apps/records/records.cert \
- cutil/defalist.cert \
- misc/defun-plus.cert \
- cutil/portcullis.cert \
- demos/modeling/memories.lisp \
- demos/modeling/cert.acl2
-
-
-demos/modeling/network-state-basic.cert : acl2x = 0
-demos/modeling/network-state-basic.cert : no_pcert = 0
-
-demos/modeling/network-state-basic.cert : \
- make-event/eval.cert \
- cutil/portcullis.cert \
- demos/modeling/network-state-basic.lisp \
- demos/modeling/cert.acl2
-
-
-demos/modeling/network-state.cert : acl2x = 0
-demos/modeling/network-state.cert : no_pcert = 0
-
-demos/modeling/network-state.cert : \
- make-event/eval.cert \
- cutil/defaggregate.cert \
- cutil/deflist.cert \
- misc/defun-plus.cert \
- tools/bstar.cert \
- arithmetic/top.cert \
- cutil/portcullis.cert \
- demos/modeling/network-state.lisp \
- demos/modeling/cert.acl2
-
-
-demos/modeling/nondeterminism.cert : acl2x = 0
-demos/modeling/nondeterminism.cert : no_pcert = 0
-
-demos/modeling/nondeterminism.cert : \
- make-event/eval.cert \
- cutil/portcullis.cert \
- demos/modeling/nondeterminism.lisp \
- demos/modeling/cert.acl2
-
-
-finite-set-theory/osets/cardinality.cert : acl2x = 0
-finite-set-theory/osets/cardinality.cert : no_pcert = 0
-
-finite-set-theory/osets/cardinality.cert : \
- finite-set-theory/osets/delete.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/cardinality.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/computed-hints.cert : acl2x = 0
-finite-set-theory/osets/computed-hints.cert : no_pcert = 0
-
-finite-set-theory/osets/computed-hints.cert : \
- finite-set-theory/osets/instance.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/computed-hints.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/delete.cert : acl2x = 0
-finite-set-theory/osets/delete.cert : no_pcert = 0
-
-finite-set-theory/osets/delete.cert : \
- finite-set-theory/osets/membership.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/delete.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/difference.cert : acl2x = 0
-finite-set-theory/osets/difference.cert : no_pcert = 0
-
-finite-set-theory/osets/difference.cert : \
- finite-set-theory/osets/membership.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/difference.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/instance.cert : acl2x = 0
-finite-set-theory/osets/instance.cert : no_pcert = 0
-
-finite-set-theory/osets/instance.cert : \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/instance.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/intersect.cert : acl2x = 0
-finite-set-theory/osets/intersect.cert : no_pcert = 0
-
-finite-set-theory/osets/intersect.cert : \
- finite-set-theory/osets/membership.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/intersect.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/map-tests.cert : acl2x = 0
-finite-set-theory/osets/map-tests.cert : no_pcert = 0
-
-finite-set-theory/osets/map-tests.cert : \
- finite-set-theory/osets/map.cert \
- misc/assert.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/map-tests.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/map.cert : acl2x = 0
-finite-set-theory/osets/map.cert : no_pcert = 0
-
-finite-set-theory/osets/map.cert : \
- finite-set-theory/osets/quantify.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/map.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/membership.cert : acl2x = 0
-finite-set-theory/osets/membership.cert : no_pcert = 0
-
-finite-set-theory/osets/membership.cert : \
- finite-set-theory/osets/primitives.cert \
- finite-set-theory/osets/computed-hints.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/membership.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/outer.cert : acl2x = 0
-finite-set-theory/osets/outer.cert : no_pcert = 0
-
-finite-set-theory/osets/outer.cert : \
- finite-set-theory/osets/delete.cert \
- finite-set-theory/osets/union.cert \
- finite-set-theory/osets/intersect.cert \
- finite-set-theory/osets/difference.cert \
- finite-set-theory/osets/cardinality.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/outer.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/portcullis.cert : acl2x = 0
-finite-set-theory/osets/portcullis.cert : no_pcert = 0
-
-finite-set-theory/osets/portcullis.cert : \
- finite-set-theory/osets/portcullis.lisp \
- finite-set-theory/osets/portcullis.acl2 \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-
-
-finite-set-theory/osets/primitives.cert : acl2x = 0
-finite-set-theory/osets/primitives.cert : no_pcert = 0
-
-finite-set-theory/osets/primitives.cert : \
- misc/total-order.cert \
- tools/rulesets.cert \
- xdoc/top.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/primitives.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/quantify.cert : acl2x = 0
-finite-set-theory/osets/quantify.cert : no_pcert = 0
-
-finite-set-theory/osets/quantify.cert : \
- finite-set-theory/osets/sets.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/quantify.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/sets.cert : acl2x = 0
-finite-set-theory/osets/sets.cert : no_pcert = 0
-
-finite-set-theory/osets/sets.cert : \
- misc/total-order.cert \
- tools/rulesets.cert \
- std/lists/list-defuns.cert \
- finite-set-theory/osets/computed-hints.cert \
- finite-set-theory/osets/primitives.cert \
- finite-set-theory/osets/membership.cert \
- finite-set-theory/osets/outer.cert \
- finite-set-theory/osets/sort.cert \
- finite-set-theory/osets/under-set-equiv.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/sets.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/sort.cert : acl2x = 0
-finite-set-theory/osets/sort.cert : no_pcert = 0
-
-finite-set-theory/osets/sort.cert : \
- finite-set-theory/osets/union.cert \
- std/lists/app.cert \
- std/lists/rev.cert \
- tools/mv-nth.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/sort.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/under-set-equiv.cert : acl2x = 0
-finite-set-theory/osets/under-set-equiv.cert : no_pcert = 0
-
-finite-set-theory/osets/under-set-equiv.cert : \
- finite-set-theory/osets/outer.cert \
- finite-set-theory/osets/sort.cert \
- std/lists/sets.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/under-set-equiv.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/osets/union.cert : acl2x = 0
-finite-set-theory/osets/union.cert : no_pcert = 0
-
-finite-set-theory/osets/union.cert : \
- finite-set-theory/osets/membership.cert \
- finite-set-theory/osets/portcullis.cert \
- finite-set-theory/osets/union.lisp \
- finite-set-theory/osets/cert.acl2
-
-
-finite-set-theory/set-theory.cert : acl2x = 0
-finite-set-theory/set-theory.cert : no_pcert = 0
-
-finite-set-theory/set-theory.cert : \
- finite-set-theory/total-ordering.cert \
- ordinals/e0-ordinal.cert \
- arithmetic/top-with-meta.cert \
- finite-set-theory/set-theory.lisp \
- finite-set-theory/set-theory.acl2
-
-
-finite-set-theory/total-ordering.cert : acl2x = 0
-finite-set-theory/total-ordering.cert : no_pcert = 0
-
-finite-set-theory/total-ordering.cert : \
- finite-set-theory/total-ordering.lisp
-
-
-hacking/all.cert : acl2x = 0
-hacking/all.cert : no_pcert = 0
-
-hacking/all.cert : \
- hacking/hacker.cert \
- hacking/defstruct-parsing.cert \
- hacking/rewrite-code.cert \
- hacking/defcode.cert \
- hacking/raw.cert \
- hacking/redefun.cert \
- hacking/bridge.cert \
- hacking/subsumption.cert \
- hacking/table-guard.cert \
- hacking/all.lisp \
- hacking/all.acl2 \
- hacking/hacker-pkg.lsp \
- hacking/rewrite-code-pkg.lsp
-
-
-hacking/bridge.cert : acl2x = 0
-hacking/bridge.cert : no_pcert = 0
-
-hacking/bridge.cert : \
- hacking/doc-section.cert \
- hacking/bridge.lisp \
- hacking/bridge.acl2 \
- hacking/hacker-pkg.lsp
-
-
-hacking/defcode.cert : acl2x = 0
-hacking/defcode.cert : no_pcert = 0
-
-hacking/defcode.cert : \
- hacking/hacker.cert \
- hacking/progn-bang-enh.cert \
- hacking/defcode.lisp \
- hacking/defcode.acl2 \
- hacking/hacker-pkg.lsp
-
-
-hacking/defstruct-parsing.cert : acl2x = 0
-hacking/defstruct-parsing.cert : no_pcert = 0
-
-hacking/defstruct-parsing.cert : \
- hacking/defstruct-parsing.lisp \
- hacking/defstruct-parsing.acl2 \
- hacking/hacker-pkg.lsp
-
-
-hacking/doc-section.cert : acl2x = 0
-hacking/doc-section.cert : no_pcert = 0
-
-hacking/doc-section.cert : \
- hacking/doc-section.lisp
-
-
-hacking/dynamic-make-event-test.cert : acl2x = 0
-hacking/dynamic-make-event-test.cert : no_pcert = 0
-
-hacking/dynamic-make-event-test.cert : \
- hacking/defcode.cert \
- hacking/rewrite-code.cert \
- hacking/redefun.cert \
- hacking/dynamic-make-event.cert \
- hacking/rewrite-code.cert \
- hacking/dynamic-make-event-test.lisp \
- hacking/dynamic-make-event-test.acl2 \
- hacking/hacker-pkg.lsp
-
-
-hacking/dynamic-make-event.cert : acl2x = 0
-hacking/dynamic-make-event.cert : no_pcert = 0
-
-hacking/dynamic-make-event.cert : \
- hacking/rewrite-code.cert \
- hacking/dynamic-make-event.lisp \
- hacking/dynamic-make-event.acl2 \
- hacking/hacker-pkg.lsp
-
-
-hacking/evalable-ld-printing.cert : acl2x = 0
-hacking/evalable-ld-printing.cert : no_pcert = 0
-
-hacking/evalable-ld-printing.cert : \
- misc/evalable-printing.cert \
- hacking/hacker.cert \
- hacking/defcode.cert \
- hacking/subsumption.cert \
- hacking/raw.cert \
- hacking/evalable-ld-printing.lisp \
- hacking/evalable-ld-printing.acl2
-
-
-hacking/hacker.cert : acl2x = 0
-hacking/hacker.cert : no_pcert = 0
-
-hacking/hacker.cert : \
- hacking/doc-section.cert \
- hacking/hacker.lisp \
- hacking/hacker.acl2 \
- hacking/hacker-pkg.lsp
-
-
-hacking/progn-bang-enh.cert : acl2x = 0
-hacking/progn-bang-enh.cert : no_pcert = 0
-
-hacking/progn-bang-enh.cert : \
- hacking/progn-bang-enh.lisp \
- hacking/progn-bang-enh.acl2
-
-
-hacking/raw.cert : acl2x = 0
-hacking/raw.cert : no_pcert = 0
-
-hacking/raw.cert : \
- hacking/defstruct-parsing.cert \
- hacking/raw.lisp \
- hacking/raw.acl2 \
- hacking/hacker-pkg.lsp
-
-
-hacking/redefun.cert : acl2x = 0
-hacking/redefun.cert : no_pcert = 0
-
-hacking/redefun.cert : \
- hacking/redefun.lisp \
- hacking/redefun.acl2 \
- hacking/hacker-pkg.lsp
-
-
-hacking/rewrite-code.cert : acl2x = 0
-hacking/rewrite-code.cert : no_pcert = 0
-
-hacking/rewrite-code.cert : \
- hacking/rewrite-code.lisp \
- hacking/rewrite-code.acl2 \
- hacking/rewrite-code-pkg.lsp
-
-
-hacking/subsumption.cert : acl2x = 0
-hacking/subsumption.cert : no_pcert = 0
-
-hacking/subsumption.cert : \
- hacking/doc-section.cert \
- hacking/subsumption.lisp \
- hacking/subsumption.acl2 \
- hacking/hacker-pkg.lsp
-
-
-hacking/table-guard.cert : acl2x = 0
-hacking/table-guard.cert : no_pcert = 0
-
-hacking/table-guard.cert : \
- hacking/defcode.cert \
- hacking/rewrite-code.cert \
- hacking/redefun.cert \
- hacking/rewrite-code.cert \
- hacking/table-guard.lisp \
- hacking/table-guard.acl2 \
- hacking/hacker-pkg.lsp
-
-
-hints/basic-tests.cert : acl2x = 0
-hints/basic-tests.cert : no_pcert = 0
-
-hints/basic-tests.cert : \
- misc/eval.cert \
- hints/basic-tests.lisp \
- hints/basic-tests.acl2
-
-
-hints/consider-hint-tests.cert : acl2x = 0
-hints/consider-hint-tests.cert : no_pcert = 0
-
-hints/consider-hint-tests.cert : \
- hints/consider-hint.cert \
- misc/eval.cert \
- hints/consider-hint-tests.lisp \
- hints/consider-hint-tests.acl2
-
-
-hints/consider-hint.cert : acl2x = 0
-hints/consider-hint.cert : no_pcert = 0
-
-hints/consider-hint.cert : \
- hints/huet-lang-algorithm.cert \
- hints/merge-hint.cert \
- hints/consider-hint.lisp
-
-
-hints/huet-lang-algorithm-tests.cert : acl2x = 0
-hints/huet-lang-algorithm-tests.cert : no_pcert = 0
-
-hints/huet-lang-algorithm-tests.cert : \
- hints/huet-lang-algorithm.cert \
- misc/eval.cert \
- hints/huet-lang-algorithm-tests.lisp
-
-
-hints/huet-lang-algorithm.cert : acl2x = 0
-hints/huet-lang-algorithm.cert : no_pcert = 0
-
-hints/huet-lang-algorithm.cert : \
- hints/huet-lang-algorithm.lisp
-
-
-hints/merge-hint.cert : acl2x = 0
-hints/merge-hint.cert : no_pcert = 0
-
-hints/merge-hint.cert : \
- misc/eval.cert \
- hints/merge-hint.lisp
-
-
-ihs/@logops.cert : acl2x = 0
-ihs/@logops.cert : no_pcert = 0
-
-ihs/@logops.cert : \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- ihs/@logops.lisp
-
-
-ihs/basic-definitions.cert : acl2x = 0
-ihs/basic-definitions.cert : no_pcert = 0
-
-ihs/basic-definitions.cert : \
- ihs/ihs-doc-topic.cert \
- ihs/math-lemmas.cert \
- ihs/quotient-remainder-lemmas.cert \
- ihs/basic-definitions.lisp
-
-
-ihs/ihs-definitions.cert : acl2x = 0
-ihs/ihs-definitions.cert : no_pcert = 0
-
-ihs/ihs-definitions.cert : \
- ihs/ihs-init.cert \
- ihs/ihs-theories.cert \
- ihs/logops-definitions.cert \
- ihs/ihs-definitions.lisp
-
-
-ihs/ihs-doc-topic.cert : acl2x = 0
-ihs/ihs-doc-topic.cert : no_pcert = 0
-
-ihs/ihs-doc-topic.cert : \
- ihs/ihs-doc-topic.lisp
-
-
-ihs/ihs-init.cert : acl2x = 0
-ihs/ihs-init.cert : no_pcert = 0
-
-ihs/ihs-init.cert : \
- ihs/ihs-doc-topic.cert \
- data-structures/utilities.cert \
- ihs/ihs-init.lisp \
- ihs/ihs-init.acl2 \
- data-structures/define-u-package.lsp
-
-
-ihs/ihs-lemmas.cert : acl2x = 0
-ihs/ihs-lemmas.cert : no_pcert = 0
-
-ihs/ihs-lemmas.cert : \
- ihs/math-lemmas.cert \
- ihs/quotient-remainder-lemmas.cert \
- ihs/logops-lemmas.cert \
- ihs/ihs-lemmas.lisp
-
-
-ihs/ihs-theories.cert : acl2x = 0
-ihs/ihs-theories.cert : no_pcert = 0
-
-ihs/ihs-theories.cert : \
- ihs/ihs-init.cert \
- ihs/ihs-theories.lisp
-
-
-ihs/logops-definitions.cert : acl2x = 0
-ihs/logops-definitions.cert : no_pcert = 0
-
-ihs/logops-definitions.cert : \
- ihs/ihs-init.cert \
- ihs/ihs-theories.cert \
- ihs/math-lemmas.cert \
- ihs/quotient-remainder-lemmas.cert \
- ihs/basic-definitions.cert \
- ihs/logops-definitions.lisp
-
-
-ihs/logops-lemmas.cert : acl2x = 0
-ihs/logops-lemmas.cert : no_pcert = 0
-
-ihs/logops-lemmas.cert : \
- ihs/ihs-init.cert \
- ihs/ihs-theories.cert \
- ihs/math-lemmas.cert \
- ihs/quotient-remainder-lemmas.cert \
- ihs/logops-definitions.cert \
- ihs/logops-lemmas.lisp
-
-
-ihs/math-lemmas.cert : acl2x = 0
-ihs/math-lemmas.cert : no_pcert = 0
-
-ihs/math-lemmas.cert : \
- arithmetic/top.cert \
- ihs/ihs-init.cert \
- ihs/math-lemmas.lisp
-
-
-ihs/quotient-remainder-lemmas.cert : acl2x = 0
-ihs/quotient-remainder-lemmas.cert : no_pcert = 0
-
-ihs/quotient-remainder-lemmas.cert : \
- ihs/ihs-init.cert \
- ihs/ihs-theories.cert \
- ihs/math-lemmas.cert \
- ihs/quotient-remainder-lemmas.lisp
-
-
-leftist-trees/leftist-tree-defthms.cert : acl2x = 0
-leftist-trees/leftist-tree-defthms.cert : no_pcert = 0
-
-leftist-trees/leftist-tree-defthms.cert : \
- leftist-trees/leftist-tree-defuns.cert \
- arithmetic-5/top.cert \
- leftist-trees/leftist-tree-defthms.lisp
-
-
-leftist-trees/leftist-tree-defuns.cert : acl2x = 0
-leftist-trees/leftist-tree-defuns.cert : no_pcert = 0
-
-leftist-trees/leftist-tree-defuns.cert : \
- leftist-trees/leftist-tree-defuns.lisp
-
-
-leftist-trees/leftist-tree-sort-equivalent.cert : acl2x = 0
-leftist-trees/leftist-tree-sort-equivalent.cert : no_pcert = 0
-
-leftist-trees/leftist-tree-sort-equivalent.cert : \
- sorting/equisort.cert \
- sorting/isort.cert \
- leftist-trees/leftist-tree-sort.cert \
- leftist-trees/leftist-tree-sort-equivalent.lisp
-
-
-leftist-trees/leftist-tree-sort-equivalent2.cert : acl2x = 0
-leftist-trees/leftist-tree-sort-equivalent2.cert : no_pcert = 0
-
-leftist-trees/leftist-tree-sort-equivalent2.cert : \
- sorting/equisort2.cert \
- sorting/isort.cert \
- leftist-trees/leftist-tree-sort.cert \
- leftist-trees/leftist-tree-sort-equivalent2.lisp
-
-
-leftist-trees/leftist-tree-sort-equivalent3.cert : acl2x = 0
-leftist-trees/leftist-tree-sort-equivalent3.cert : no_pcert = 0
-
-leftist-trees/leftist-tree-sort-equivalent3.cert : \
- sorting/equisort3.cert \
- sorting/isort.cert \
- leftist-trees/leftist-tree-sort.cert \
- leftist-trees/leftist-tree-sort-equivalent3.lisp
-
-
-leftist-trees/leftist-tree-sort.cert : acl2x = 0
-leftist-trees/leftist-tree-sort.cert : no_pcert = 0
-
-leftist-trees/leftist-tree-sort.cert : \
- sorting/perm.cert \
- sorting/ordered-perms.cert \
- sorting/convert-perm-to-how-many.cert \
- leftist-trees/leftist-tree-defuns.cert \
- leftist-trees/leftist-tree-defthms.cert \
- leftist-trees/leftist-tree-sort.lisp
-
-
-leftist-trees/top.cert : acl2x = 0
-leftist-trees/top.cert : no_pcert = 0
-
-leftist-trees/top.cert : \
- leftist-trees/leftist-tree-defuns.cert \
- leftist-trees/leftist-tree-defthms.cert \
- leftist-trees/leftist-tree-sort.cert \
- leftist-trees/top.lisp
-
-
-make-event/acl2x-help.cert : acl2x = 0
-make-event/acl2x-help.cert : no_pcert = 0
-
-make-event/acl2x-help.cert : \
- misc/hons-help.cert \
- make-event/acl2x-help.lisp
-
-
-make-event/assert-check-include-1.cert : acl2x = 0
-make-event/assert-check-include-1.cert : no_pcert = 0
-
-make-event/assert-check-include-1.cert : \
- make-event/assert-check.cert \
- make-event/eval.cert \
- make-event/assert-check-include-1.lisp \
- make-event/assert-check-include-1.acl2
-
-
-make-event/assert-check-include.cert : acl2x = 0
-make-event/assert-check-include.cert : no_pcert = 0
-
-make-event/assert-check-include.cert : \
- make-event/assert-check.cert \
- make-event/assert-check-include.lisp
-
-
-make-event/assert-check.cert : acl2x = 0
-make-event/assert-check.cert : no_pcert = 0
-
-make-event/assert-check.cert : \
- make-event/eval-check.cert \
- make-event/assert-check.lisp
-
-
-make-event/assert-include.cert : acl2x = 0
-make-event/assert-include.cert : no_pcert = 0
-
-make-event/assert-include.cert : \
- make-event/assert.cert \
- make-event/assert-include.lisp \
- make-event/assert-include.acl2
-
-
-make-event/assert.cert : acl2x = 0
-make-event/assert.cert : no_pcert = 0
-
-make-event/assert.cert : \
- misc/assert.cert \
- make-event/assert.lisp
-
-
-make-event/basic-check.cert : acl2x = 0
-make-event/basic-check.cert : no_pcert = 0
-
-make-event/basic-check.cert : \
- make-event/basic-check.lisp
-
-
-make-event/basic-pkg-check.cert : acl2x = 0
-make-event/basic-pkg-check.cert : no_pcert = 0
-
-make-event/basic-pkg-check.cert : \
- make-event/basic-pkg-check.lisp \
- make-event/basic-pkg-check.acl2
-
-
-make-event/basic-pkg.cert : acl2x = 0
-make-event/basic-pkg.cert : no_pcert = 0
-
-make-event/basic-pkg.cert : \
- make-event/basic-pkg.lisp \
- make-event/basic-pkg.acl2
-
-
-make-event/basic.cert : acl2x = 0
-make-event/basic.cert : no_pcert = 0
-
-make-event/basic.cert : \
- make-event/basic.lisp
-
-
-make-event/defconst-fast-examples.cert : acl2x = 0
-make-event/defconst-fast-examples.cert : no_pcert = 0
-
-make-event/defconst-fast-examples.cert : \
- make-event/defconst-fast.cert \
- make-event/defconst-fast-examples.lisp
-
-
-make-event/defconst-fast.cert : acl2x = 0
-make-event/defconst-fast.cert : no_pcert = 0
-
-make-event/defconst-fast.cert : \
- make-event/defconst-fast.lisp
-
-
-make-event/defrefine.cert : acl2x = 0
-make-event/defrefine.cert : no_pcert = 0
-
-make-event/defrefine.cert : \
- make-event/eval.cert \
- make-event/defrefine.lisp
-
-
-make-event/defrule.cert : acl2x = 0
-make-event/defrule.cert : no_pcert = 0
-
-make-event/defrule.cert : \
- make-event/defrule.lisp
-
-
-make-event/defspec.cert : acl2x = 0
-make-event/defspec.cert : no_pcert = 0
-
-make-event/defspec.cert : \
- make-event/eval.cert \
- make-event/defspec.lisp
-
-
-make-event/dotimes.cert : acl2x = 0
-make-event/dotimes.cert : no_pcert = 0
-
-make-event/dotimes.cert : \
- make-event/dotimes.lisp
-
-
-make-event/embeddable-event-forms.cert : acl2x = 0
-make-event/embeddable-event-forms.cert : no_pcert = 0
-
-make-event/embeddable-event-forms.cert : \
- make-event/embeddable-event-forms.lisp
-
-
-make-event/eval-check-tests.cert : acl2x = 0
-make-event/eval-check-tests.cert : no_pcert = 0
-
-make-event/eval-check-tests.cert : \
- make-event/eval-check.cert \
- make-event/eval-check-tests.lisp
-
-
-make-event/eval-check.cert : acl2x = 0
-make-event/eval-check.cert : no_pcert = 0
-
-make-event/eval-check.cert : \
- make-event/eval-check.lisp
-
-
-make-event/eval-tests.cert : acl2x = 0
-make-event/eval-tests.cert : no_pcert = 0
-
-make-event/eval-tests.cert : \
- make-event/eval.cert \
- make-event/eval-tests.lisp
-
-
-make-event/eval.cert : acl2x = 0
-make-event/eval.cert : no_pcert = 0
-
-make-event/eval.cert : \
- misc/eval.cert \
- make-event/eval.lisp
-
-
-make-event/gen-defthm-check.cert : acl2x = 0
-make-event/gen-defthm-check.cert : no_pcert = 0
-
-make-event/gen-defthm-check.cert : \
- misc/expander.cert \
- make-event/gen-defthm-check.lisp
-
-
-make-event/gen-defthm.cert : acl2x = 0
-make-event/gen-defthm.cert : no_pcert = 0
-
-make-event/gen-defthm.cert : \
- misc/expander.cert \
- make-event/gen-defthm.lisp
-
-
-make-event/gen-defun-check.cert : acl2x = 0
-make-event/gen-defun-check.cert : no_pcert = 0
-
-make-event/gen-defun-check.cert : \
- make-event/gen-defun-check.lisp
-
-
-make-event/gen-defun.cert : acl2x = 0
-make-event/gen-defun.cert : no_pcert = 0
-
-make-event/gen-defun.cert : \
- make-event/gen-defun.lisp
-
-
-make-event/inline-book.cert : acl2x = 0
-make-event/inline-book.cert : no_pcert = 0
-
-make-event/inline-book.cert : \
- make-event/inline-book.lisp
-
-
-make-event/local-elided-include.cert : acl2x = 0
-make-event/local-elided-include.cert : no_pcert = 0
-
-make-event/local-elided-include.cert : \
- make-event/local-elided.cert \
- make-event/eval.cert \
- misc/file-io.cert \
- make-event/local-elided-include.lisp
-
-
-make-event/local-elided.cert : acl2x = 0
-make-event/local-elided.cert : no_pcert = 0
-
-make-event/local-elided.cert : \
- make-event/eval.cert \
- make-event/local-elided.lisp
-
-
-make-event/local-requires-skip-check-include.cert : acl2x = 0
-make-event/local-requires-skip-check-include.cert : no_pcert = 0
-
-make-event/local-requires-skip-check-include.cert : \
- misc/file-io.cert \
- make-event/local-requires-skip-check.cert \
- make-event/eval.cert \
- make-event/local-requires-skip-check-include.lisp
-
-
-make-event/local-requires-skip-check.cert : acl2x = 0
-make-event/local-requires-skip-check.cert : no_pcert = 0
-
-make-event/local-requires-skip-check.cert : \
- make-event/eval.cert \
- make-event/local-requires-skip-check.lisp
-
-
-make-event/logical-tangent.cert : acl2x = 0
-make-event/logical-tangent.cert : no_pcert = 0
-
-make-event/logical-tangent.cert : \
- make-event/logical-tangent.lisp
-
-
-make-event/macros-include.cert : acl2x = 0
-make-event/macros-include.cert : no_pcert = 0
-
-make-event/macros-include.cert : \
- make-event/macros.cert \
- make-event/eval.cert \
- misc/file-io.cert \
- make-event/macros-include.lisp
-
-
-make-event/macros-skip-proofs-include.cert : acl2x = 0
-make-event/macros-skip-proofs-include.cert : no_pcert = 0
-
-make-event/macros-skip-proofs-include.cert : \
- make-event/macros-skip-proofs.cert \
- make-event/eval.cert \
- misc/file-io.cert \
- make-event/macros-skip-proofs-include.lisp \
- make-event/macros-skip-proofs-include.acl2
-
-
-make-event/macros-skip-proofs.cert : acl2x = 0
-make-event/macros-skip-proofs.cert : no_pcert = 0
-
-make-event/macros-skip-proofs.cert : \
- make-event/macros-skip-proofs.lisp \
- make-event/macros-skip-proofs.acl2
-
-
-make-event/macros.cert : acl2x = 0
-make-event/macros.cert : no_pcert = 0
-
-make-event/macros.cert : \
- make-event/eval.cert \
- make-event/macros.lisp
-
-
-make-event/make-redundant.cert : acl2x = 0
-make-event/make-redundant.cert : no_pcert = 0
-
-make-event/make-redundant.cert : \
- make-event/make-redundant.lisp
-
-
-make-event/nested-check.cert : acl2x = 0
-make-event/nested-check.cert : no_pcert = 0
-
-make-event/nested-check.cert : \
- make-event/nested-check.lisp
-
-
-make-event/nested.cert : acl2x = 0
-make-event/nested.cert : no_pcert = 0
-
-make-event/nested.cert : \
- make-event/nested.lisp
-
-
-make-event/portcullis-expansion-include.cert : acl2x = 0
-make-event/portcullis-expansion-include.cert : no_pcert = 0
-
-make-event/portcullis-expansion-include.cert : \
- make-event/portcullis-expansion.cert \
- make-event/portcullis-expansion.cert \
- make-event/portcullis-expansion-include.lisp \
- make-event/portcullis-expansion-include.acl2
-
-
-make-event/portcullis-expansion.cert : acl2x = 0
-make-event/portcullis-expansion.cert : no_pcert = 0
-
-make-event/portcullis-expansion.cert : \
- make-event/eval.cert \
- make-event/portcullis-expansion.lisp \
- make-event/portcullis-expansion.acl2
-
-
-make-event/proof-by-arith.cert : acl2x = 0
-make-event/proof-by-arith.cert : no_pcert = 0
-
-make-event/proof-by-arith.cert : \
- arithmetic/top-with-meta.cert \
- arithmetic-3/top.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel5/arithmetic/top.cert \
- arithmetic-5/top.cert \
- make-event/proof-by-arith.lisp
-
-
-make-event/read-from-file.cert : acl2x = 0
-make-event/read-from-file.cert : no_pcert = 0
-
-make-event/read-from-file.cert : \
- misc/file-io.cert \
- misc/file-io.cert \
- make-event/read-from-file.lisp
-
-
-make-event/require-book.cert : acl2x = 0
-make-event/require-book.cert : no_pcert = 0
-
-make-event/require-book.cert : \
- make-event/require-book.lisp
-
-
-make-event/test-case-check.cert : acl2x = 0
-make-event/test-case-check.cert : no_pcert = 0
-
-make-event/test-case-check.cert : \
- make-event/assert-check.cert \
- make-event/test-case-check.lisp
-
-
-make-event/test-case.cert : acl2x = 0
-make-event/test-case.cert : no_pcert = 0
-
-make-event/test-case.cert : \
- make-event/assert.cert \
- make-event/test-case.lisp
-
-
-meta/meta-plus-equal.cert : acl2x = 0
-meta/meta-plus-equal.cert : no_pcert = 0
-
-meta/meta-plus-equal.cert : \
- meta/term-defuns.cert \
- meta/term-lemmas.cert \
- meta/meta-plus-equal.lisp
-
-
-meta/meta-plus-lessp.cert : acl2x = 0
-meta/meta-plus-lessp.cert : no_pcert = 0
-
-meta/meta-plus-lessp.cert : \
- meta/term-defuns.cert \
- meta/term-lemmas.cert \
- meta/meta-plus-lessp.lisp
-
-
-meta/meta-times-equal.cert : acl2x = 0
-meta/meta-times-equal.cert : no_pcert = 0
-
-meta/meta-times-equal.cert : \
- meta/term-defuns.cert \
- meta/term-lemmas.cert \
- arithmetic/equalities.cert \
- meta/meta-times-equal.lisp
-
-
-meta/meta.cert : acl2x = 0
-meta/meta.cert : no_pcert = 0
-
-meta/meta.cert : \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- meta/meta-times-equal.cert \
- meta/meta.lisp
-
-
-meta/pseudo-termp-lemmas.cert : acl2x = 0
-meta/pseudo-termp-lemmas.cert : no_pcert = 0
-
-meta/pseudo-termp-lemmas.cert : \
- meta/term-lemmas.cert \
- meta/pseudo-termp-lemmas.lisp
-
-
-meta/term-defuns.cert : acl2x = 0
-meta/term-defuns.cert : no_pcert = 0
-
-meta/term-defuns.cert : \
- meta/term-defuns.lisp
-
-
-meta/term-lemmas.cert : acl2x = 0
-meta/term-lemmas.cert : no_pcert = 0
-
-meta/term-lemmas.cert : \
- meta/term-defuns.cert \
- meta/term-lemmas.lisp
-
-
-misc/assert.cert : acl2x = 0
-misc/assert.cert : no_pcert = 0
-
-misc/assert.cert : \
- misc/eval.cert \
- misc/assert.lisp
-
-
-misc/bash.cert : acl2x = 0
-misc/bash.cert : no_pcert = 0
-
-misc/bash.cert : \
- misc/bash.lisp
-
-
-misc/beta-reduce.cert : acl2x = 0
-misc/beta-reduce.cert : no_pcert = 0
-
-misc/beta-reduce.cert : \
- misc/beta-reduce.lisp
-
-
-misc/callers-and-ancestors.cert : acl2x = 0
-misc/callers-and-ancestors.cert : no_pcert = 0
-
-misc/callers-and-ancestors.cert : \
- misc/callers-and-ancestors.lisp
-
-
-misc/character-encoding-test.cert : acl2x = 0
-misc/character-encoding-test.cert : no_pcert = 0
-
-misc/character-encoding-test.cert : \
- misc/character-encoding-test.lisp
-
-
-misc/check-acl2-exports.cert : acl2x = 0
-misc/check-acl2-exports.cert : no_pcert = 0
-
-misc/check-acl2-exports.cert : \
- misc/check-acl2-exports.lisp
-
-
-misc/check-state.cert : acl2x = 0
-misc/check-state.cert : no_pcert = 0
-
-misc/check-state.cert : \
- misc/check-state.lisp
-
-
-misc/computed-hint-rewrite.cert : acl2x = 0
-misc/computed-hint-rewrite.cert : no_pcert = 0
-
-misc/computed-hint-rewrite.cert : \
- misc/computed-hint-rewrite.lisp
-
-
-misc/computed-hint.cert : acl2x = 0
-misc/computed-hint.cert : no_pcert = 0
-
-misc/computed-hint.cert : \
- misc/computed-hint.lisp
-
-
-misc/congruent-stobjs-test.cert : acl2x = 0
-misc/congruent-stobjs-test.cert : no_pcert = 0
-
-misc/congruent-stobjs-test.cert : \
- misc/eval.cert \
- misc/congruent-stobjs-test.lisp
-
-
-misc/csort.cert : acl2x = 0
-misc/csort.cert : no_pcert = 0
-
-misc/csort.cert : \
- misc/csort.lisp
-
-
-misc/dead-events.cert : acl2x = 0
-misc/dead-events.cert : no_pcert = 0
-
-misc/dead-events.cert : \
- misc/dead-events.lisp
-
-
-misc/defabsstobj-example-1.cert : acl2x = 0
-misc/defabsstobj-example-1.cert : no_pcert = 0
-
-misc/defabsstobj-example-1.cert : \
- misc/defabsstobj-example-1.lisp
-
-
-misc/defabsstobj-example-2.cert : acl2x = 0
-misc/defabsstobj-example-2.cert : no_pcert = 0
-
-misc/defabsstobj-example-2.cert : \
- misc/defabsstobj-example-2.lisp
-
-
-misc/defabsstobj-example-3.cert : acl2x = 0
-misc/defabsstobj-example-3.cert : no_pcert = 0
-
-misc/defabsstobj-example-3.cert : \
- misc/defabsstobj-example-3.lisp
-
-
-misc/defabsstobj-example-4.cert : acl2x = 0
-misc/defabsstobj-example-4.cert : no_pcert = 0
-
-misc/defabsstobj-example-4.cert : \
- misc/defabsstobj-example-4.lisp \
- misc/defabsstobj-example-4.acl2
-
-
-misc/defattach-bang.cert : acl2x = 0
-misc/defattach-bang.cert : no_pcert = 0
-
-misc/defattach-bang.cert : \
- misc/defattach-bang.lisp
-
-
-misc/defattach-example.cert : acl2x = 0
-misc/defattach-example.cert : no_pcert = 0
-
-misc/defattach-example.cert : \
- arithmetic/top.cert \
- misc/defattach-example.lisp
-
-
-misc/definline.cert : acl2x = 0
-misc/definline.cert : no_pcert = 0
-
-misc/definline.cert : \
- misc/doc-section.cert \
- misc/definline.lisp
-
-
-misc/defmac.cert : acl2x = 0
-misc/defmac.cert : no_pcert = 0
-
-misc/defmac.cert : \
- misc/doc-section.cert \
- misc/defmac.lisp
-
-
-misc/defopener.cert : acl2x = 0
-misc/defopener.cert : no_pcert = 0
-
-misc/defopener.cert : \
- misc/doc-section.cert \
- misc/bash.cert \
- misc/defopener.lisp
-
-
-misc/defp.cert : acl2x = 0
-misc/defp.cert : no_pcert = 0
-
-misc/defp.cert : \
- misc/defpun.cert \
- misc/defp.lisp
-
-
-misc/defproxy-test.cert : acl2x = 0
-misc/defproxy-test.cert : no_pcert = 0
-
-misc/defproxy-test.cert : \
- misc/defproxy-test.lisp \
- misc/defproxy-test.acl2
-
-
-misc/defpun.cert : acl2x = 0
-misc/defpun.cert : no_pcert = 0
-
-misc/defpun.cert : \
- misc/defpun.lisp
-
-
-misc/defun-plus.cert : acl2x = 0
-misc/defun-plus.cert : no_pcert = 0
-
-misc/defun-plus.cert : \
- misc/defun-plus.lisp
-
-
-misc/dft-ex.cert : acl2x = 0
-misc/dft-ex.cert : no_pcert = 0
-
-misc/dft-ex.cert : \
- misc/dft.cert \
- arithmetic/top-with-meta.cert \
- misc/dft-ex.lisp \
- misc/dft-ex.acl2
-
-
-misc/dft.cert : acl2x = 0
-misc/dft.cert : no_pcert = 0
-
-misc/dft.cert : \
- misc/dft.lisp
-
-
-misc/dijkstra-shortest-path.cert : acl2x = 0
-misc/dijkstra-shortest-path.cert : no_pcert = 0
-
-misc/dijkstra-shortest-path.cert : \
- misc/dijkstra-shortest-path.lisp
-
-
-misc/disassemble.cert : acl2x = 0
-misc/disassemble.cert : no_pcert = 0
-
-misc/disassemble.cert : \
- misc/disassemble.lisp \
- misc/disassemble.acl2
-
-
-misc/doc-section.cert : acl2x = 0
-misc/doc-section.cert : no_pcert = 0
-
-misc/doc-section.cert : \
- misc/doc-section.lisp
-
-
-misc/dump-events.cert : acl2x = 0
-misc/dump-events.cert : no_pcert = 0
-
-misc/dump-events.cert : \
- misc/doc-section.cert \
- misc/dump-events.lisp
-
-
-misc/equal-by-g-help.cert : acl2x = 0
-misc/equal-by-g-help.cert : no_pcert = 0
-
-misc/equal-by-g-help.cert : \
- misc/records.cert \
- misc/equal-by-g-help.lisp
-
-
-misc/equal-by-g.cert : acl2x = 0
-misc/equal-by-g.cert : no_pcert = 0
-
-misc/equal-by-g.cert : \
- misc/records.cert \
- misc/equal-by-g-help.cert \
- misc/equal-by-g.lisp
-
-
-misc/eval.cert : acl2x = 0
-misc/eval.cert : no_pcert = 0
-
-misc/eval.cert : \
- misc/eval.lisp
-
-
-misc/evalable-printing.cert : acl2x = 0
-misc/evalable-printing.cert : no_pcert = 0
-
-misc/evalable-printing.cert : \
- misc/evalable-printing.lisp
-
-
-misc/expander.cert : acl2x = 0
-misc/expander.cert : no_pcert = 0
-
-misc/expander.cert : \
- misc/doc-section.cert \
- misc/expander.lisp
-
-
-misc/fast-coerce.cert : acl2x = 0
-misc/fast-coerce.cert : no_pcert = 0
-
-misc/fast-coerce.cert : \
- arithmetic/top-with-meta.cert \
- data-structures/list-defthms.cert \
- misc/fast-coerce.lisp
-
-
-misc/fibonacci.cert : acl2x = 0
-misc/fibonacci.cert : no_pcert = 0
-
-misc/fibonacci.cert : \
- misc/int-division.cert \
- misc/grcd.cert \
- misc/fibonacci.lisp
-
-
-misc/file-io.cert : acl2x = 0
-misc/file-io.cert : no_pcert = 0
-
-misc/file-io.cert : \
- misc/file-io.lisp
-
-
-misc/find-lemmas.cert : acl2x = 0
-misc/find-lemmas.cert : no_pcert = 0
-
-misc/find-lemmas.cert : \
- misc/find-lemmas.lisp
-
-
-misc/gentle.cert : acl2x = 0
-misc/gentle.cert : no_pcert = 0
-
-misc/gentle.cert : \
- misc/gentle.lisp
-
-
-misc/getprop.cert : acl2x = 0
-misc/getprop.cert : no_pcert = 0
-
-misc/getprop.cert : \
- misc/getprop.lisp
-
-
-misc/goodstein.cert : acl2x = 0
-misc/goodstein.cert : no_pcert = 0
-
-misc/goodstein.cert : \
- ordinals/e0-ordinal.cert \
- misc/goodstein.lisp
-
-
-misc/grcd.cert : acl2x = 0
-misc/grcd.cert : no_pcert = 0
-
-misc/grcd.cert : \
- misc/int-division.cert \
- ordinals/e0-ordinal.cert \
- misc/grcd.lisp
-
-
-misc/hanoi.cert : acl2x = 0
-misc/hanoi.cert : no_pcert = 0
-
-misc/hanoi.cert : \
- misc/hanoi.lisp \
- misc/hanoi.acl2
-
-
-misc/hons-help.cert : acl2x = 0
-misc/hons-help.cert : no_pcert = 0
-
-misc/hons-help.cert : \
- misc/gentle.cert \
- misc/hons-help.lisp
-
-
-misc/hons-help2.cert : acl2x = 0
-misc/hons-help2.cert : no_pcert = 0
-
-misc/hons-help2.cert : \
- misc/hons-help.cert \
- misc/hons-help2.lisp
-
-
-misc/hons-tests.cert : acl2x = 0
-misc/hons-tests.cert : no_pcert = 0
-
-misc/hons-tests.cert : \
- misc/qi.cert \
- misc/hons-tests.lisp
-
-
-misc/how-to-prove-thms.cert : acl2x = 0
-misc/how-to-prove-thms.cert : no_pcert = 0
-
-misc/how-to-prove-thms.cert : \
- misc/how-to-prove-thms.lisp
-
-
-misc/int-division.cert : acl2x = 0
-misc/int-division.cert : no_pcert = 0
-
-misc/int-division.cert : \
- arithmetic/equalities.cert \
- arithmetic/inequalities.cert \
- misc/int-division.lisp
-
-
-misc/integer-type-set-test.cert : acl2x = 0
-misc/integer-type-set-test.cert : no_pcert = 0
-
-misc/integer-type-set-test.cert : \
- misc/integer-type-set-test.lisp
-
-
-misc/invariants.cert : acl2x = 0
-misc/invariants.cert : no_pcert = 0
-
-misc/invariants.cert : \
- misc/bash.cert \
- misc/invariants.lisp
-
-
-misc/meta-lemmas.cert : acl2x = 0
-misc/meta-lemmas.cert : no_pcert = 0
-
-misc/meta-lemmas.cert : \
- misc/doc-section.cert \
- misc/meta-lemmas.lisp
-
-
-misc/misc2/defpun-exec-domain-example.cert : acl2x = 0
-misc/misc2/defpun-exec-domain-example.cert : no_pcert = 0
-
-misc/misc2/defpun-exec-domain-example.cert : \
- misc/defpun.cert \
- misc/eval.cert \
- misc/misc2/defpun-exec-domain-example.lisp
-
-
-misc/misc2/misc.cert : acl2x = 0
-misc/misc2/misc.cert : no_pcert = 0
-
-misc/misc2/misc.cert : \
- rtl/rel8/arithmetic/top.cert \
- misc/misc2/misc.lisp
-
-
-misc/misc2/reverse-by-separation.cert : acl2x = 0
-misc/misc2/reverse-by-separation.cert : no_pcert = 0
-
-misc/misc2/reverse-by-separation.cert : \
- arithmetic/top-with-meta.cert \
- coi/bags/top.cert \
- coi/bags/top.cert \
- misc/misc2/reverse-by-separation.lisp \
- misc/misc2/reverse-by-separation.acl2
-
-
-misc/misc2/ruler-extenders-tests.cert : acl2x = 0
-misc/misc2/ruler-extenders-tests.cert : no_pcert = 0
-
-misc/misc2/ruler-extenders-tests.cert : \
- misc/eval.cert \
- misc/misc2/ruler-extenders-tests.lisp \
- misc/misc2/ruler-extenders-tests.acl2
-
-
-misc/misc2/step-limits.cert : acl2x = 0
-misc/misc2/step-limits.cert : no_pcert = 0
-
-misc/misc2/step-limits.cert : \
- misc/eval.cert \
- misc/misc2/step-limits.lisp
-
-
-misc/mult.cert : acl2x = 0
-misc/mult.cert : no_pcert = 0
-
-misc/mult.cert : \
- arithmetic/top-with-meta.cert \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- data-structures/structures.cert \
- data-structures/array1.cert \
- ihs/@logops.cert \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- data-structures/deflist.cert \
- data-structures/defalist.cert \
- misc/meta-lemmas.cert \
- misc/mult.lisp
-
-
-misc/oprof.cert : acl2x = 0
-misc/oprof.cert : no_pcert = 0
-
-misc/oprof.cert : \
- misc/oprof.lisp \
- misc/oprof.acl2
-
-
-misc/priorities.cert : acl2x = 0
-misc/priorities.cert : no_pcert = 0
-
-misc/priorities.cert : \
- misc/priorities.lisp
-
-
-misc/problem13.cert : acl2x = 0
-misc/problem13.cert : no_pcert = 0
-
-misc/problem13.cert : \
- arithmetic/equalities.cert \
- arithmetic/inequalities.cert \
- ordinals/e0-ordinal.cert \
- misc/problem13.lisp
-
-
-misc/process-book-readme.cert : acl2x = 0
-misc/process-book-readme.cert : no_pcert = 0
-
-misc/process-book-readme.cert : \
- misc/process-book-readme.lisp
-
-
-misc/profiling.cert : acl2x = 0
-misc/profiling.cert : no_pcert = 0
-
-misc/profiling.cert : \
- misc/profiling.lisp \
- misc/profiling.acl2
-
-
-misc/qi-correct.cert : acl2x = 0
-misc/qi-correct.cert : no_pcert = 0
-
-misc/qi-correct.cert : \
- misc/qi.cert \
- misc/qi-correct.lisp \
- misc/qi-correct.acl2
-
-
-misc/qi.cert : acl2x = 0
-misc/qi.cert : no_pcert = 0
-
-misc/qi.cert : \
- misc/hons-help2.cert \
- misc/qi.lisp \
- misc/qi.acl2
-
-
-misc/radix.cert : acl2x = 0
-misc/radix.cert : no_pcert = 0
-
-misc/radix.cert : \
- arithmetic-2/meta/top.cert \
- arithmetic-2/floor-mod/floor-mod.cert \
- misc/radix.lisp \
- misc/radix.acl2
-
-
-misc/random.cert : acl2x = 0
-misc/random.cert : no_pcert = 0
-
-misc/random.cert : \
- arithmetic-2/floor-mod/floor-mod.cert \
- misc/random.lisp
-
-
-misc/records-bsd.cert : acl2x = 0
-misc/records-bsd.cert : no_pcert = 0
-
-misc/records-bsd.cert : \
- misc/total-order-bsd.cert \
- misc/records-bsd.lisp
-
-
-misc/records.cert : acl2x = 0
-misc/records.cert : no_pcert = 0
-
-misc/records.cert : \
- misc/total-order.cert \
- misc/records.lisp
-
-
-misc/records0.cert : acl2x = 0
-misc/records0.cert : no_pcert = 0
-
-misc/records0.cert : \
- misc/total-order.cert \
- misc/records0.lisp
-
-
-misc/redef-pkg.cert : acl2x = 0
-misc/redef-pkg.cert : no_pcert = 0
-
-misc/redef-pkg.cert : \
- misc/redef-pkg.lisp \
- misc/redef-pkg.acl2
-
-
-misc/rtl-untranslate.cert : acl2x = 0
-misc/rtl-untranslate.cert : no_pcert = 0
-
-misc/rtl-untranslate.cert : \
- misc/symbol-btree.cert \
- misc/rtl-untranslate.lisp
-
-
-misc/save-time.cert : acl2x = 0
-misc/save-time.cert : no_pcert = 0
-
-misc/save-time.cert : \
- misc/save-time.lisp
-
-
-misc/seq.cert : acl2x = 0
-misc/seq.cert : no_pcert = 0
-
-misc/seq.cert : \
- misc/seq.lisp
-
-
-misc/seqw.cert : acl2x = 0
-misc/seqw.cert : no_pcert = 0
-
-misc/seqw.cert : \
- misc/seq.cert \
- misc/seqw.lisp
-
-
-misc/simplify-defuns.cert : acl2x = 0
-misc/simplify-defuns.cert : no_pcert = 0
-
-misc/simplify-defuns.cert : \
- misc/file-io.cert \
- misc/simplify-defuns.lisp
-
-
-misc/simplify-thm.cert : acl2x = 0
-misc/simplify-thm.cert : no_pcert = 0
-
-misc/simplify-thm.cert : \
- misc/bash.cert \
- misc/simplify-thm.lisp
-
-
-misc/sin-cos.cert : acl2x = 0
-misc/sin-cos.cert : no_pcert = 0
-
-misc/sin-cos.cert : \
- misc/doc-section.cert \
- misc/sin-cos.lisp
-
-
-misc/sort-symbols.cert : acl2x = 0
-misc/sort-symbols.cert : no_pcert = 0
-
-misc/sort-symbols.cert : \
- misc/sort-symbols.lisp
-
-
-misc/sticky-disable.cert : acl2x = 0
-misc/sticky-disable.cert : no_pcert = 0
-
-misc/sticky-disable.cert : \
- misc/sticky-disable.lisp
-
-
-misc/symbol-btree.cert : acl2x = 0
-misc/symbol-btree.cert : no_pcert = 0
-
-misc/symbol-btree.cert : \
- ihs/quotient-remainder-lemmas.cert \
- arithmetic/top.cert \
- std/lists/take.cert \
- arithmetic/top.cert \
- arithmetic/top.cert \
- misc/symbol-btree.lisp
-
-
-misc/total-order-bsd.cert : acl2x = 0
-misc/total-order-bsd.cert : no_pcert = 0
-
-misc/total-order-bsd.cert : \
- misc/total-order-bsd.lisp
-
-
-misc/total-order.cert : acl2x = 0
-misc/total-order.cert : no_pcert = 0
-
-misc/total-order.cert : \
- xdoc/top.cert \
- misc/total-order-bsd.cert \
- misc/total-order.lisp
-
-
-misc/trace-star.cert : acl2x = 0
-misc/trace-star.cert : no_pcert = 0
-
-misc/trace-star.cert : \
- misc/evalable-printing.cert \
- misc/trace-star.lisp
-
-
-misc/transfinite.cert : acl2x = 0
-misc/transfinite.cert : no_pcert = 0
-
-misc/transfinite.cert : \
- misc/transfinite.lisp
-
-
-misc/untranslate-patterns.cert : acl2x = 0
-misc/untranslate-patterns.cert : no_pcert = 0
-
-misc/untranslate-patterns.cert : \
- misc/symbol-btree.cert \
- misc/untranslate-patterns.lisp
-
-
-misc/wet.cert : acl2x = 0
-misc/wet.cert : no_pcert = 0
-
-misc/wet.cert : \
- misc/wet.lisp
-
-
-models/jvm/m1-original/m1-story.cert : acl2x = 0
-models/jvm/m1-original/m1-story.cert : no_pcert = 0
-
-models/jvm/m1-original/m1-story.cert : \
- models/jvm/m1-original/problem-set-1-answers.cert \
- arithmetic-3/extra/top-ext.cert \
- models/jvm/m1-original/problem-set-1-answers.cert \
- models/jvm/m1-original/m1-story.lisp \
- models/jvm/m1-original/m1-story.acl2
-
-
-models/jvm/m1-original/problem-set-1-answers.cert : acl2x = 0
-models/jvm/m1-original/problem-set-1-answers.cert : no_pcert = 0
-
-models/jvm/m1-original/problem-set-1-answers.cert : \
- models/jvm/m1-original/problem-set-1-answers.lisp \
- models/jvm/m1-original/problem-set-1-answers.acl2
-
-
-models/jvm/m1/alternating-sum-variant.cert : acl2x = 0
-models/jvm/m1/alternating-sum-variant.cert : no_pcert = 0
-
-models/jvm/m1/alternating-sum-variant.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/alternating-sum-variant.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/alternating-sum.cert : acl2x = 0
-models/jvm/m1/alternating-sum.cert : no_pcert = 0
-
-models/jvm/m1/alternating-sum.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/alternating-sum.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/bexpt.cert : acl2x = 0
-models/jvm/m1/bexpt.cert : no_pcert = 0
-
-models/jvm/m1/bexpt.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/bexpt.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/defsys-utilities.cert : acl2x = 0
-models/jvm/m1/defsys-utilities.cert : no_pcert = 0
-
-models/jvm/m1/defsys-utilities.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/defsys-utilities.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/defsys.cert : acl2x = 0
-models/jvm/m1/defsys.cert : no_pcert = 0
-
-models/jvm/m1/defsys.cert : \
- models/jvm/m1/defsys-utilities.cert \
- models/jvm/m1/defsys.lisp \
- models/jvm/m1/defsys.acl2
-
-
-models/jvm/m1/div.cert : acl2x = 0
-models/jvm/m1/div.cert : no_pcert = 0
-
-models/jvm/m1/div.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/div.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/even-solution-1.cert : acl2x = 0
-models/jvm/m1/even-solution-1.cert : no_pcert = 0
-
-models/jvm/m1/even-solution-1.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/even-solution-1.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/even-solution-2.cert : acl2x = 0
-models/jvm/m1/even-solution-2.cert : no_pcert = 0
-
-models/jvm/m1/even-solution-2.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/even-solution-2.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/expt.cert : acl2x = 0
-models/jvm/m1/expt.cert : no_pcert = 0
-
-models/jvm/m1/expt.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/expt.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/fact.cert : acl2x = 0
-models/jvm/m1/fact.cert : no_pcert = 0
-
-models/jvm/m1/fact.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/fact.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/fib.cert : acl2x = 0
-models/jvm/m1/fib.cert : no_pcert = 0
-
-models/jvm/m1/fib.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/fib.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/find-k!.cert : acl2x = 0
-models/jvm/m1/find-k!.cert : no_pcert = 0
-
-models/jvm/m1/find-k!.cert : \
- models/jvm/m1/theorems-a-and-b.cert \
- models/jvm/m1/find-k!.lisp \
- models/jvm/m1/find-k!.acl2
-
-
-models/jvm/m1/funny-fact.cert : acl2x = 0
-models/jvm/m1/funny-fact.cert : no_pcert = 0
-
-models/jvm/m1/funny-fact.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/funny-fact.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/implementation.cert : acl2x = 0
-models/jvm/m1/implementation.cert : no_pcert = 0
-
-models/jvm/m1/implementation.cert : \
- models/jvm/m1/defsys.cert \
- models/jvm/m1/tmi-reductions.cert \
- models/jvm/m1/implementation.lisp \
- models/jvm/m1/implementation.acl2
-
-
-models/jvm/m1/lessp.cert : acl2x = 0
-models/jvm/m1/lessp.cert : no_pcert = 0
-
-models/jvm/m1/lessp.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/lessp.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/low-seven.cert : acl2x = 0
-models/jvm/m1/low-seven.cert : no_pcert = 0
-
-models/jvm/m1/low-seven.cert : \
- models/jvm/m1/defsys.cert \
- models/jvm/m1/low-seven.lisp \
- models/jvm/m1/low-seven.acl2
-
-
-models/jvm/m1/m1.cert : acl2x = 0
-models/jvm/m1/m1.cert : no_pcert = 0
-
-models/jvm/m1/m1.cert : \
- arithmetic-5/top.cert \
- models/jvm/m1/m1.lisp \
- models/jvm/m1/m1.acl2
-
-
-models/jvm/m1/magic.cert : acl2x = 0
-models/jvm/m1/magic.cert : no_pcert = 0
-
-models/jvm/m1/magic.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/magic.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/power.cert : acl2x = 0
-models/jvm/m1/power.cert : no_pcert = 0
-
-models/jvm/m1/power.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/power.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/sign.cert : acl2x = 0
-models/jvm/m1/sign.cert : no_pcert = 0
-
-models/jvm/m1/sign.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/sign.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/sum.cert : acl2x = 0
-models/jvm/m1/sum.cert : no_pcert = 0
-
-models/jvm/m1/sum.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/sum.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/sumsq.cert : acl2x = 0
-models/jvm/m1/sumsq.cert : no_pcert = 0
-
-models/jvm/m1/sumsq.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/sumsq.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/template.cert : acl2x = 0
-models/jvm/m1/template.cert : no_pcert = 0
-
-models/jvm/m1/template.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/template.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/theorems-a-and-b.cert : acl2x = 0
-models/jvm/m1/theorems-a-and-b.cert : no_pcert = 0
-
-models/jvm/m1/theorems-a-and-b.cert : \
- models/jvm/m1/tmi-reductions.cert \
- models/jvm/m1/implementation.cert \
- models/jvm/m1/m1.cert \
- models/jvm/m1/theorems-a-and-b.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/tmi-reductions.cert : acl2x = 0
-models/jvm/m1/tmi-reductions.cert : no_pcert = 0
-
-models/jvm/m1/tmi-reductions.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/tmi-reductions.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m1/wormhole-abstraction.cert : acl2x = 0
-models/jvm/m1/wormhole-abstraction.cert : no_pcert = 0
-
-models/jvm/m1/wormhole-abstraction.cert : \
- models/jvm/m1/m1.cert \
- models/jvm/m1/wormhole-abstraction.lisp \
- models/jvm/m1/cert.acl2
-
-
-models/jvm/m5/apprentice-state.cert : acl2x = 0
-models/jvm/m5/apprentice-state.cert : no_pcert = 0
-
-models/jvm/m5/apprentice-state.cert : \
- models/jvm/m5/m5.cert \
- models/jvm/m5/m5.cert \
- models/jvm/m5/apprentice-state.lisp \
- models/jvm/m5/apprentice-state.acl2
-
-
-models/jvm/m5/demo.cert : acl2x = 0
-models/jvm/m5/demo.cert : no_pcert = 0
-
-models/jvm/m5/demo.cert : \
- models/jvm/m5/utilities.cert \
- models/jvm/m5/utilities.cert \
- models/jvm/m5/demo.lisp \
- models/jvm/m5/demo.acl2
-
-
-models/jvm/m5/idemo.cert : acl2x = 0
-models/jvm/m5/idemo.cert : no_pcert = 0
-
-models/jvm/m5/idemo.cert : \
- models/jvm/m5/utilities.cert \
- models/jvm/m5/utilities.cert \
- models/jvm/m5/idemo.lisp \
- models/jvm/m5/idemo.acl2
-
-
-models/jvm/m5/infinite-fair-schedule.cert : acl2x = 0
-models/jvm/m5/infinite-fair-schedule.cert : no_pcert = 0
-
-models/jvm/m5/infinite-fair-schedule.cert : \
- arithmetic/top-with-meta.cert \
- models/jvm/m5/infinite-fair-schedule.lisp
-
-
-models/jvm/m5/isort.cert : acl2x = 0
-models/jvm/m5/isort.cert : no_pcert = 0
-
-models/jvm/m5/isort.cert : \
- models/jvm/m5/utilities.cert \
- models/jvm/m5/perm.cert \
- models/jvm/m5/utilities.cert \
- models/jvm/m5/isort.lisp \
- models/jvm/m5/isort.acl2
-
-
-models/jvm/m5/jvm-fact-setup.cert : acl2x = 0
-models/jvm/m5/jvm-fact-setup.cert : no_pcert = 0
-
-models/jvm/m5/jvm-fact-setup.cert : \
- models/jvm/m5/utilities.cert \
- misc/expander.cert \
- models/jvm/m5/utilities.cert \
- models/jvm/m5/jvm-fact-setup.lisp \
- models/jvm/m5/jvm-fact-setup.acl2
-
-
-models/jvm/m5/m5.cert : acl2x = 0
-models/jvm/m5/m5.cert : no_pcert = 0
-
-models/jvm/m5/m5.cert : \
- ordinals/lexicographic-ordering.cert \
- models/jvm/m5/m5.lisp \
- models/jvm/m5/m5.acl2
-
-
-models/jvm/m5/partial.cert : acl2x = 0
-models/jvm/m5/partial.cert : no_pcert = 0
-
-models/jvm/m5/partial.cert : \
- misc/defpun.cert \
- models/jvm/m5/demo.cert \
- models/jvm/m5/utilities.cert \
- models/jvm/m5/partial.lisp \
- models/jvm/m5/partial.acl2
-
-
-models/jvm/m5/perm.cert : acl2x = 0
-models/jvm/m5/perm.cert : no_pcert = 0
-
-models/jvm/m5/perm.cert : \
- models/jvm/m5/perm.lisp
-
-
-models/jvm/m5/universal-never-returns.cert : acl2x = 0
-models/jvm/m5/universal-never-returns.cert : no_pcert = 0
-
-models/jvm/m5/universal-never-returns.cert : \
- models/jvm/m5/universal.cert \
- models/jvm/m5/universal.cert \
- models/jvm/m5/universal-never-returns.lisp \
- models/jvm/m5/universal-never-returns.acl2
-
-
-models/jvm/m5/universal.cert : acl2x = 0
-models/jvm/m5/universal.cert : no_pcert = 0
-
-models/jvm/m5/universal.cert : \
- models/jvm/m5/utilities.cert \
- models/jvm/m5/utilities.cert \
- models/jvm/m5/universal.lisp \
- models/jvm/m5/universal.acl2
-
-
-models/jvm/m5/utilities.cert : acl2x = 0
-models/jvm/m5/utilities.cert : no_pcert = 0
-
-models/jvm/m5/utilities.cert : \
- models/jvm/m5/m5.cert \
- arithmetic/top-with-meta.cert \
- ihs/quotient-remainder-lemmas.cert \
- models/jvm/m5/m5.cert \
- models/jvm/m5/utilities.lisp \
- models/jvm/m5/utilities.acl2
-
-
-ordinals/e0-ordinal.cert : acl2x = 0
-ordinals/e0-ordinal.cert : no_pcert = 0
-
-ordinals/e0-ordinal.cert : \
- ordinals/ordinal-definitions.cert \
- ordinals/ordinal-isomorphism.cert \
- ordinals/e0-ordinal.lisp
-
-
-ordinals/lexicographic-book.cert : acl2x = 0
-ordinals/lexicographic-book.cert : no_pcert = 0
-
-ordinals/lexicographic-book.cert : \
- ordinals/ordinals-without-arithmetic.cert \
- ordinals/top-with-meta.cert \
- ordinals/lexicographic-book.lisp
-
-
-ordinals/lexicographic-ordering-without-arithmetic.cert : acl2x = 0
-ordinals/lexicographic-ordering-without-arithmetic.cert : no_pcert = 0
-
-ordinals/lexicographic-ordering-without-arithmetic.cert : \
- ordinals/lexicographic-book.cert \
- ordinals/lexicographic-ordering-without-arithmetic.lisp
-
-
-ordinals/lexicographic-ordering.cert : acl2x = 0
-ordinals/lexicographic-ordering.cert : no_pcert = 0
-
-ordinals/lexicographic-ordering.cert : \
- ordinals/top-with-meta.cert \
- ordinals/lexicographic-book.cert \
- ordinals/lexicographic-ordering.lisp
-
-
-ordinals/limits.cert : acl2x = 0
-ordinals/limits.cert : no_pcert = 0
-
-ordinals/limits.cert : \
- ordinals/ordinal-exponentiation.cert \
- ordinals/top-with-meta.cert \
- ordinals/limits.lisp
-
-
-ordinals/ordinal-addition.cert : acl2x = 0
-ordinals/ordinal-addition.cert : no_pcert = 0
-
-ordinals/ordinal-addition.cert : \
- ordinals/ordinal-basic-thms.cert \
- ordinals/top-with-meta.cert \
- ordinals/ordinal-addition.lisp
-
-
-ordinals/ordinal-basic-thms.cert : acl2x = 0
-ordinals/ordinal-basic-thms.cert : no_pcert = 0
-
-ordinals/ordinal-basic-thms.cert : \
- ordinals/ordinal-total-order.cert \
- ordinals/top-with-meta.cert \
- ordinals/ordinal-basic-thms.lisp
-
-
-ordinals/ordinal-counter-examples.cert : acl2x = 0
-ordinals/ordinal-counter-examples.cert : no_pcert = 0
-
-ordinals/ordinal-counter-examples.cert : \
- ordinals/ordinal-definitions.cert \
- ordinals/ordinal-counter-examples.lisp
-
-
-ordinals/ordinal-definitions.cert : acl2x = 0
-ordinals/ordinal-definitions.cert : no_pcert = 0
-
-ordinals/ordinal-definitions.cert : \
- ordinals/ordinal-definitions.lisp
-
-
-ordinals/ordinal-exponentiation.cert : acl2x = 0
-ordinals/ordinal-exponentiation.cert : no_pcert = 0
-
-ordinals/ordinal-exponentiation.cert : \
- ordinals/ordinal-multiplication.cert \
- ordinals/top-with-meta.cert \
- ordinals/ordinal-exponentiation.lisp
-
-
-ordinals/ordinal-isomorphism.cert : acl2x = 0
-ordinals/ordinal-isomorphism.cert : no_pcert = 0
-
-ordinals/ordinal-isomorphism.cert : \
- ordinals/ordinal-addition.cert \
- ordinals/top-with-meta.cert \
- ordinals/ordinal-isomorphism.lisp
-
-
-ordinals/ordinal-multiplication.cert : acl2x = 0
-ordinals/ordinal-multiplication.cert : no_pcert = 0
-
-ordinals/ordinal-multiplication.cert : \
- ordinals/ordinal-addition.cert \
- ordinals/top-with-meta.cert \
- ordinals/ordinal-multiplication.lisp
-
-
-ordinals/ordinal-total-order.cert : acl2x = 0
-ordinals/ordinal-total-order.cert : no_pcert = 0
-
-ordinals/ordinal-total-order.cert : \
- ordinals/ordinal-definitions.cert \
- ordinals/ordinal-total-order.lisp
-
-
-ordinals/ordinals-without-arithmetic.cert : acl2x = 0
-ordinals/ordinals-without-arithmetic.cert : no_pcert = 0
-
-ordinals/ordinals-without-arithmetic.cert : \
- ordinals/limits.cert \
- ordinals/ordinals-without-arithmetic.lisp
-
-
-ordinals/ordinals.cert : acl2x = 0
-ordinals/ordinals.cert : no_pcert = 0
-
-ordinals/ordinals.cert : \
- ordinals/top-with-meta.cert \
- ordinals/limits.cert \
- ordinals/ordinals.lisp
-
-
-ordinals/proof-of-well-foundedness.cert : acl2x = 0
-ordinals/proof-of-well-foundedness.cert : no_pcert = 0
-
-ordinals/proof-of-well-foundedness.cert : \
- ordinals/proof-of-well-foundedness.lisp \
- ordinals/proof-of-well-foundedness.acl2
-
-
-ordinals/top-with-meta.cert : acl2x = 0
-ordinals/top-with-meta.cert : no_pcert = 0
-
-ordinals/top-with-meta.cert : \
- arithmetic/top-with-meta.cert \
- ordinals/top-with-meta.lisp
-
-
-oslib/catpath.cert : acl2x = 0
-oslib/catpath.cert : no_pcert = 0
-
-oslib/catpath.cert : \
- cutil/define.cert \
- misc/assert.cert \
- oslib/portcullis.cert \
- oslib/catpath.lisp \
- oslib/cert.acl2
-
-
-oslib/date.cert : acl2x = 0
-oslib/date.cert : no_pcert = 0
-
-oslib/date.cert : \
- oslib/read-acl2-oracle.cert \
- cutil/define.cert \
- tools/include-raw.cert \
- str/cat.cert \
- str/natstr.cert \
- oslib/portcullis.cert \
- oslib/date.lisp \
- oslib/cert.acl2 \
- oslib/date-raw.lsp
-
-
-oslib/getpid.cert : acl2x = 0
-oslib/getpid.cert : no_pcert = 0
-
-oslib/getpid.cert : \
- oslib/read-acl2-oracle.cert \
- cutil/define.cert \
- tools/include-raw.cert \
- oslib/portcullis.cert \
- oslib/getpid.lisp \
- oslib/cert.acl2 \
- oslib/getpid-raw.lsp
-
-
-oslib/ls.cert : acl2x = 0
-oslib/ls.cert : no_pcert = 0
-
-oslib/ls.cert : \
- oslib/read-acl2-oracle.cert \
- cutil/define.cert \
- tools/include-raw.cert \
- oslib/portcullis.cert \
- oslib/ls.lisp \
- oslib/cert.acl2 \
- oslib/ls-raw.lsp
-
-
-oslib/portcullis.cert : acl2x = 0
-oslib/portcullis.cert : no_pcert = 0
-
-oslib/portcullis.cert : \
- oslib/portcullis.lisp \
- oslib/portcullis.acl2 \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-
-
-oslib/read-acl2-oracle.cert : acl2x = 0
-oslib/read-acl2-oracle.cert : no_pcert = 0
-
-oslib/read-acl2-oracle.cert : \
- oslib/portcullis.cert \
- oslib/read-acl2-oracle.lisp \
- oslib/cert.acl2
-
-
-oslib/tempfile.cert : acl2x = 0
-oslib/tempfile.cert : no_pcert = 0
-
-oslib/tempfile.cert : \
- oslib/getpid.cert \
- oslib/catpath.cert \
- str/natstr.cert \
- str/cat.cert \
- oslib/portcullis.cert \
- oslib/tempfile.lisp \
- oslib/cert.acl2
-
-
-oslib/top.cert : acl2x = 0
-oslib/top.cert : no_pcert = 0
-
-oslib/top.cert : \
- oslib/catpath.cert \
- oslib/date.cert \
- oslib/getpid.cert \
- oslib/ls.cert \
- oslib/tempfile.cert \
- oslib/portcullis.cert \
- oslib/top.lisp \
- oslib/cert.acl2
-
-
-paco/database.cert : acl2x = 0
-paco/database.cert : no_pcert = 0
-
-paco/database.cert : \
- paco/prove.cert \
- paco/database.lisp \
- paco/database.acl2 \
- paco/acl2-customization.lsp
-
-
-paco/elim-dest.cert : acl2x = 0
-paco/elim-dest.cert : no_pcert = 0
-
-paco/elim-dest.cert : \
- paco/simplify.cert \
- paco/elim-dest.lisp \
- paco/elim-dest.acl2 \
- paco/acl2-customization.lsp
-
-
-paco/foundations.cert : acl2x = 0
-paco/foundations.cert : no_pcert = 0
-
-paco/foundations.cert : \
- paco/output-module.cert \
- paco/foundations.lisp \
- paco/foundations.acl2 \
- paco/acl2-customization.lsp
-
-
-paco/induct.cert : acl2x = 0
-paco/induct.cert : no_pcert = 0
-
-paco/induct.cert : \
- paco/elim-dest.cert \
- paco/induct.lisp \
- paco/induct.acl2 \
- paco/acl2-customization.lsp
-
-
-paco/output-module.cert : acl2x = 0
-paco/output-module.cert : no_pcert = 0
-
-paco/output-module.cert : \
- paco/utilities.cert \
- paco/output-module.lisp \
- paco/output-module.acl2 \
- paco/acl2-customization.lsp
-
-
-paco/paco.cert : acl2x = 0
-paco/paco.cert : no_pcert = 0
-
-paco/paco.cert : \
- paco/utilities.cert \
- paco/foundations.cert \
- paco/type-set.cert \
- paco/rewrite.cert \
- paco/simplify.cert \
- paco/induct.cert \
- paco/prove.cert \
- paco/database.cert \
- paco/database.cert \
- paco/paco.lisp \
- paco/paco.acl2 \
- paco/acl2-customization.lsp
-
-
-paco/prove.cert : acl2x = 0
-paco/prove.cert : no_pcert = 0
-
-paco/prove.cert : \
- paco/induct.cert \
- paco/prove.lisp \
- paco/prove.acl2 \
- paco/acl2-customization.lsp
-
-
-paco/rewrite.cert : acl2x = 0
-paco/rewrite.cert : no_pcert = 0
-
-paco/rewrite.cert : \
- paco/type-set.cert \
- paco/rewrite.lisp \
- paco/rewrite.acl2 \
- paco/acl2-customization.lsp
-
-
-paco/simplify.cert : acl2x = 0
-paco/simplify.cert : no_pcert = 0
-
-paco/simplify.cert : \
- paco/rewrite.cert \
- paco/simplify.lisp \
- paco/simplify.acl2 \
- paco/acl2-customization.lsp
-
-
-paco/type-set.cert : acl2x = 0
-paco/type-set.cert : no_pcert = 0
-
-paco/type-set.cert : \
- ordinals/e0-ordinal.cert \
- arithmetic/top-with-meta.cert \
- paco/foundations.cert \
- paco/type-set.lisp \
- paco/type-set.acl2 \
- paco/acl2-customization.lsp
-
-
-paco/utilities.cert : acl2x = 0
-paco/utilities.cert : no_pcert = 0
-
-paco/utilities.cert : \
- ihs/ihs-lemmas.cert \
- paco/utilities.lisp \
- paco/utilities.acl2 \
- paco/acl2-customization.lsp
-
-
-parallel/fibonacci.cert : acl2x = 0
-parallel/fibonacci.cert : no_pcert = 0
-
-parallel/fibonacci.cert : \
- make-event/assert.cert \
- parallel/fibonacci.lisp
-
-
-parallel/hint-tests.cert : acl2x = 0
-parallel/hint-tests.cert : no_pcert = 0
-
-parallel/hint-tests.cert : \
- make-event/eval.cert \
- parallel/hint-tests.lisp \
- parallel/hint-tests.acl2
-
-
-parallel/matrix-multiplication-parallel.cert : acl2x = 0
-parallel/matrix-multiplication-parallel.cert : no_pcert = 0
-
-parallel/matrix-multiplication-parallel.cert : \
- make-event/assert.cert \
- make-event/embeddable-event-forms.cert \
- parallel/matrix-multiplication-setup.cert \
- parallel/matrix-multiplication-parallel.lisp
-
-
-parallel/matrix-multiplication-serial.cert : acl2x = 0
-parallel/matrix-multiplication-serial.cert : no_pcert = 0
-
-parallel/matrix-multiplication-serial.cert : \
- make-event/assert.cert \
- make-event/embeddable-event-forms.cert \
- parallel/matrix-multiplication-setup.cert \
- parallel/matrix-multiplication-serial.lisp
-
-
-parallel/matrix-multiplication-setup.cert : acl2x = 0
-parallel/matrix-multiplication-setup.cert : no_pcert = 0
-
-parallel/matrix-multiplication-setup.cert : \
- parallel/matrix-multiplication-setup.lisp
-
-
-parallel/spec-mv-let.cert : acl2x = 0
-parallel/spec-mv-let.cert : no_pcert = 0
-
-parallel/spec-mv-let.cert : \
- make-event/assert.cert \
- make-event/eval.cert \
- parallel/spec-mv-let.lisp
-
-
-parallel/stress-tests.cert : acl2x = 0
-parallel/stress-tests.cert : no_pcert = 0
-
-parallel/stress-tests.cert : \
- make-event/assert.cert \
- make-event/eval.cert \
- parallel/stress-tests.lisp
-
-
-parallel/syntax-tests.cert : acl2x = 0
-parallel/syntax-tests.cert : no_pcert = 0
-
-parallel/syntax-tests.cert : \
- make-event/assert.cert \
- make-event/eval.cert \
- parallel/syntax-tests.lisp
-
-
-parallel/with-waterfall-parallelism.cert : acl2x = 0
-parallel/with-waterfall-parallelism.cert : no_pcert = 0
-
-parallel/with-waterfall-parallelism.cert : \
- parallel/with-waterfall-parallelism.lisp
-
-
-parallel/without-waterfall-parallelism.cert : acl2x = 0
-parallel/without-waterfall-parallelism.cert : no_pcert = 0
-
-parallel/without-waterfall-parallelism.cert : \
- parallel/without-waterfall-parallelism.lisp
-
-
-powerlists/algebra.cert : acl2x = 0
-powerlists/algebra.cert : no_pcert = 0
-
-powerlists/algebra.cert : \
- data-structures/structures.cert \
- ordinals/e0-ordinal.cert \
- powerlists/algebra.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-
-
-powerlists/batcher-sort.cert : acl2x = 0
-powerlists/batcher-sort.cert : no_pcert = 0
-
-powerlists/batcher-sort.cert : \
- powerlists/merge-sort.cert \
- arithmetic/top.cert \
- powerlists/batcher-sort.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-
-
-powerlists/bitonic-sort.cert : acl2x = 0
-powerlists/bitonic-sort.cert : no_pcert = 0
-
-powerlists/bitonic-sort.cert : \
- powerlists/algebra.cert \
- powerlists/simple.cert \
- powerlists/sort.cert \
- powerlists/batcher-sort.cert \
- arithmetic/top.cert \
- powerlists/bitonic-sort.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-
-
-powerlists/cla-adder.cert : acl2x = 0
-powerlists/cla-adder.cert : no_pcert = 0
-
-powerlists/cla-adder.cert : \
- powerlists/prefix-sum.cert \
- powerlists/algebra.cert \
- arithmetic/top.cert \
- powerlists/cla-adder.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-
-
-powerlists/gray-code.cert : acl2x = 0
-powerlists/gray-code.cert : no_pcert = 0
-
-powerlists/gray-code.cert : \
- powerlists/algebra.cert \
- powerlists/simple.cert \
- powerlists/gray-code.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-
-
-powerlists/merge-sort.cert : acl2x = 0
-powerlists/merge-sort.cert : no_pcert = 0
-
-powerlists/merge-sort.cert : \
- powerlists/algebra.cert \
- powerlists/sort.cert \
- ordinals/e0-ordinal.cert \
- powerlists/merge-sort.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-
-
-powerlists/prefix-sum.cert : acl2x = 0
-powerlists/prefix-sum.cert : no_pcert = 0
-
-powerlists/prefix-sum.cert : \
- powerlists/algebra.cert \
- powerlists/simple.cert \
- arithmetic/top.cert \
- powerlists/prefix-sum.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-
-
-powerlists/simple.cert : acl2x = 0
-powerlists/simple.cert : no_pcert = 0
-
-powerlists/simple.cert : \
- powerlists/algebra.cert \
- arithmetic/top.cert \
- powerlists/simple.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-
-
-powerlists/sort.cert : acl2x = 0
-powerlists/sort.cert : no_pcert = 0
-
-powerlists/sort.cert : \
- powerlists/algebra.cert \
- powerlists/sort.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-
-
-proofstyles/completeness/assertions-partial.cert : acl2x = 0
-proofstyles/completeness/assertions-partial.cert : no_pcert = 0
-
-proofstyles/completeness/assertions-partial.cert : \
- misc/defpun.cert \
- ordinals/ordinals.cert \
- proofstyles/completeness/stepwise-invariants-partial.cert \
- proofstyles/completeness/assertions-partial.lisp
-
-
-proofstyles/completeness/assertions-total.cert : acl2x = 0
-proofstyles/completeness/assertions-total.cert : no_pcert = 0
-
-proofstyles/completeness/assertions-total.cert : \
- misc/defpun.cert \
- ordinals/ordinals.cert \
- proofstyles/completeness/stepwise-invariants-total.cert \
- proofstyles/completeness/assertions-total.lisp
-
-
-proofstyles/completeness/clock-partial.cert : acl2x = 0
-proofstyles/completeness/clock-partial.cert : no_pcert = 0
-
-proofstyles/completeness/clock-partial.cert : \
- proofstyles/completeness/generic-partial.cert \
- misc/defpun.cert \
- arithmetic/top-with-meta.cert \
- proofstyles/completeness/clock-partial.lisp
-
-
-proofstyles/completeness/clock-total.cert : acl2x = 0
-proofstyles/completeness/clock-total.cert : no_pcert = 0
-
-proofstyles/completeness/clock-total.cert : \
- proofstyles/completeness/generic-total.cert \
- misc/defpun.cert \
- arithmetic/top-with-meta.cert \
- proofstyles/completeness/clock-total.lisp
-
-
-proofstyles/completeness/generic-partial.cert : acl2x = 0
-proofstyles/completeness/generic-partial.cert : no_pcert = 0
-
-proofstyles/completeness/generic-partial.cert : \
- proofstyles/completeness/generic-partial.lisp
-
-
-proofstyles/completeness/generic-total.cert : acl2x = 0
-proofstyles/completeness/generic-total.cert : no_pcert = 0
-
-proofstyles/completeness/generic-total.cert : \
- proofstyles/completeness/generic-total.lisp
-
-
-proofstyles/completeness/stepwise-invariants-partial.cert : acl2x = 0
-proofstyles/completeness/stepwise-invariants-partial.cert : no_pcert = 0
-
-proofstyles/completeness/stepwise-invariants-partial.cert : \
- proofstyles/completeness/clock-partial.cert \
- arithmetic/top-with-meta.cert \
- proofstyles/completeness/stepwise-invariants-partial.lisp
-
-
-proofstyles/completeness/stepwise-invariants-total.cert : acl2x = 0
-proofstyles/completeness/stepwise-invariants-total.cert : no_pcert = 0
-
-proofstyles/completeness/stepwise-invariants-total.cert : \
- proofstyles/completeness/clock-total.cert \
- arithmetic/top-with-meta.cert \
- arithmetic/top-with-meta.cert \
- proofstyles/completeness/stepwise-invariants-total.lisp
-
-
-proofstyles/counterexamples/halt-flg.cert : acl2x = 0
-proofstyles/counterexamples/halt-flg.cert : no_pcert = 0
-
-proofstyles/counterexamples/halt-flg.cert : \
- misc/defpun.cert \
- proofstyles/counterexamples/halt-flg.lisp
-
-
-proofstyles/counterexamples/memory-clearing.cert : acl2x = 0
-proofstyles/counterexamples/memory-clearing.cert : no_pcert = 0
-
-proofstyles/counterexamples/memory-clearing.cert : \
- misc/defpun.cert \
- proofstyles/counterexamples/memory-clearing.lisp
-
-
-proofstyles/counterexamples/realistic.cert : acl2x = 0
-proofstyles/counterexamples/realistic.cert : no_pcert = 0
-
-proofstyles/counterexamples/realistic.cert : \
- misc/records.cert \
- misc/defpun.cert \
- proofstyles/counterexamples/realistic.lisp
-
-
-proofstyles/invclock/c2i/c2i-partial.cert : acl2x = 0
-proofstyles/invclock/c2i/c2i-partial.cert : no_pcert = 0
-
-proofstyles/invclock/c2i/c2i-partial.cert : \
- arithmetic-2/meta/top.cert \
- proofstyles/invclock/c2i/c2i-partial.lisp
-
-
-proofstyles/invclock/c2i/c2i-total.cert : acl2x = 0
-proofstyles/invclock/c2i/c2i-total.cert : no_pcert = 0
-
-proofstyles/invclock/c2i/c2i-total.cert : \
- ordinals/e0-ordinal.cert \
- arithmetic-2/meta/top.cert \
- proofstyles/invclock/c2i/c2i-total.lisp
-
-
-proofstyles/invclock/c2i/clock-to-inv.cert : acl2x = 0
-proofstyles/invclock/c2i/clock-to-inv.cert : no_pcert = 0
-
-proofstyles/invclock/c2i/clock-to-inv.cert : \
- ordinals/e0-ordinal.cert \
- proofstyles/invclock/c2i/c2i-total.cert \
- proofstyles/invclock/c2i/c2i-partial.cert \
- proofstyles/invclock/c2i/clock-to-inv.lisp
-
-
-proofstyles/invclock/compose/compose-c-c-partial.cert : acl2x = 0
-proofstyles/invclock/compose/compose-c-c-partial.cert : no_pcert = 0
-
-proofstyles/invclock/compose/compose-c-c-partial.cert : \
- ordinals/e0-ordinal.cert \
- arithmetic-2/meta/top.cert \
- proofstyles/invclock/compose/compose-c-c-partial.lisp
-
-
-proofstyles/invclock/compose/compose-c-c-total.cert : acl2x = 0
-proofstyles/invclock/compose/compose-c-c-total.cert : no_pcert = 0
-
-proofstyles/invclock/compose/compose-c-c-total.cert : \
- ordinals/e0-ordinal.cert \
- arithmetic-2/meta/top.cert \
- proofstyles/invclock/compose/compose-c-c-total.lisp
-
-
-proofstyles/invclock/i2c/i2c-partial.cert : acl2x = 0
-proofstyles/invclock/i2c/i2c-partial.cert : no_pcert = 0
-
-proofstyles/invclock/i2c/i2c-partial.cert : \
- arithmetic-2/meta/top.cert \
- proofstyles/invclock/i2c/i2c-partial.lisp
-
-
-proofstyles/invclock/i2c/i2c-total.cert : acl2x = 0
-proofstyles/invclock/i2c/i2c-total.cert : no_pcert = 0
-
-proofstyles/invclock/i2c/i2c-total.cert : \
- ordinals/e0-ordinal.cert \
- arithmetic-2/meta/top.cert \
- proofstyles/invclock/i2c/i2c-total.lisp
-
-
-proofstyles/invclock/i2c/inv-to-clock.cert : acl2x = 0
-proofstyles/invclock/i2c/inv-to-clock.cert : no_pcert = 0
-
-proofstyles/invclock/i2c/inv-to-clock.cert : \
- ordinals/e0-ordinal.cert \
- proofstyles/invclock/i2c/i2c-total.cert \
- proofstyles/invclock/i2c/i2c-partial.cert \
- proofstyles/invclock/i2c/inv-to-clock.lisp
-
-
-proofstyles/soundness/assertions-partial.cert : acl2x = 0
-proofstyles/soundness/assertions-partial.cert : no_pcert = 0
-
-proofstyles/soundness/assertions-partial.cert : \
- misc/defpun.cert \
- ordinals/ordinals.cert \
- proofstyles/soundness/assertions-partial.lisp
-
-
-proofstyles/soundness/assertions-total.cert : acl2x = 0
-proofstyles/soundness/assertions-total.cert : no_pcert = 0
-
-proofstyles/soundness/assertions-total.cert : \
- misc/defpun.cert \
- ordinals/ordinals.cert \
- proofstyles/soundness/assertions-total.lisp
-
-
-proofstyles/soundness/clock-partial.cert : acl2x = 0
-proofstyles/soundness/clock-partial.cert : no_pcert = 0
-
-proofstyles/soundness/clock-partial.cert : \
- proofstyles/soundness/clock-partial.lisp
-
-
-proofstyles/soundness/clock-total.cert : acl2x = 0
-proofstyles/soundness/clock-total.cert : no_pcert = 0
-
-proofstyles/soundness/clock-total.cert : \
- proofstyles/soundness/clock-total.lisp
-
-
-proofstyles/soundness/stepwise-invariants-partial.cert : acl2x = 0
-proofstyles/soundness/stepwise-invariants-partial.cert : no_pcert = 0
-
-proofstyles/soundness/stepwise-invariants-partial.cert : \
- arithmetic/top-with-meta.cert \
- proofstyles/soundness/stepwise-invariants-partial.lisp
-
-
-proofstyles/soundness/stepwise-invariants-total.cert : acl2x = 0
-proofstyles/soundness/stepwise-invariants-total.cert : no_pcert = 0
-
-proofstyles/soundness/stepwise-invariants-total.cert : \
- ordinals/ordinals.cert \
- proofstyles/soundness/stepwise-invariants-total.lisp
-
-
-quadratic-reciprocity/eisenstein.cert : acl2x = 0
-quadratic-reciprocity/eisenstein.cert : no_pcert = 0
-
-quadratic-reciprocity/eisenstein.cert : \
- quadratic-reciprocity/gauss.cert \
- quadratic-reciprocity/eisenstein.lisp
-
-
-quadratic-reciprocity/euclid.cert : acl2x = 0
-quadratic-reciprocity/euclid.cert : no_pcert = 0
-
-quadratic-reciprocity/euclid.cert : \
- rtl/rel8/lib/arith.cert \
- rtl/rel8/lib/basic.cert \
- quadratic-reciprocity/euclid.lisp
-
-
-quadratic-reciprocity/euler.cert : acl2x = 0
-quadratic-reciprocity/euler.cert : no_pcert = 0
-
-quadratic-reciprocity/euler.cert : \
- quadratic-reciprocity/fermat.cert \
- quadratic-reciprocity/euler.lisp
-
-
-quadratic-reciprocity/fermat.cert : acl2x = 0
-quadratic-reciprocity/fermat.cert : no_pcert = 0
-
-quadratic-reciprocity/fermat.cert : \
- quadratic-reciprocity/euclid.cert \
- quadratic-reciprocity/fermat.lisp
-
-
-quadratic-reciprocity/gauss.cert : acl2x = 0
-quadratic-reciprocity/gauss.cert : no_pcert = 0
-
-quadratic-reciprocity/gauss.cert : \
- quadratic-reciprocity/euler.cert \
- quadratic-reciprocity/gauss.lisp
-
-
-quadratic-reciprocity/mersenne.cert : acl2x = 0
-quadratic-reciprocity/mersenne.cert : no_pcert = 0
-
-quadratic-reciprocity/mersenne.cert : \
- quadratic-reciprocity/gauss.cert \
- quadratic-reciprocity/mersenne.lisp
-
-
-regex/defset-encapsulates.cert : acl2x = 0
-regex/defset-encapsulates.cert : no_pcert = 0
-
-regex/defset-encapsulates.cert : \
- regex/defset-macros.cert \
- regex/portcullis.cert \
- regex/defset-encapsulates.lisp \
- regex/cert.acl2
-
-
-regex/defset-macros.cert : acl2x = 0
-regex/defset-macros.cert : no_pcert = 0
-
-regex/defset-macros.cert : \
- regex/portcullis.cert \
- regex/defset-macros.lisp \
- regex/cert.acl2
-
-
-regex/equal-based-set.cert : acl2x = 0
-regex/equal-based-set.cert : no_pcert = 0
-
-regex/equal-based-set.cert : \
- regex/defset-macros.cert \
- regex/defset-encapsulates.cert \
- regex/portcullis.cert \
- regex/equal-based-set.lisp \
- regex/cert.acl2
-
-
-regex/grep-command-line.cert : acl2x = 0
-regex/grep-command-line.cert : no_pcert = 0
-
-regex/grep-command-line.cert : \
- tools/defsum.cert \
- regex/regex-fileio.cert \
- regex/regex-chartrans.cert \
- regex/portcullis.cert \
- regex/grep-command-line.lisp \
- regex/cert.acl2
-
-
-regex/input-list.cert : acl2x = 0
-regex/input-list.cert : no_pcert = 0
-
-regex/input-list.cert : \
- cutil/deflist.cert \
- regex/portcullis.cert \
- regex/input-list.lisp \
- regex/cert.acl2
-
-
-regex/portcullis.cert : acl2x = 0
-regex/portcullis.cert : no_pcert = 0
-
-regex/portcullis.cert : \
- xdoc/top.cert \
- regex/portcullis.lisp \
- regex/portcullis.acl2 \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- tools/flag-package.lsp
-
-
-regex/regex-chartrans.cert : acl2x = 0
-regex/regex-chartrans.cert : no_pcert = 0
-
-regex/regex-chartrans.cert : \
- regex/portcullis.cert \
- regex/regex-chartrans.lisp \
- regex/cert.acl2
-
-
-regex/regex-defs.cert : acl2x = 0
-regex/regex-defs.cert : no_pcert = 0
-
-regex/regex-defs.cert : \
- tools/defsum.cert \
- arithmetic/top-with-meta.cert \
- regex/portcullis.cert \
- regex/regex-defs.lisp \
- regex/cert.acl2
-
-
-regex/regex-exec.cert : acl2x = 0
-regex/regex-exec.cert : no_pcert = 0
-
-regex/regex-exec.cert : \
- regex/regex-defs.cert \
- regex/input-list.cert \
- tools/flag.cert \
- clause-processors/find-subterms.cert \
- regex/portcullis.cert \
- regex/regex-exec.lisp \
- regex/cert.acl2
-
-
-regex/regex-fileio.cert : acl2x = 0
-regex/regex-fileio.cert : no_pcert = 0
-
-regex/regex-fileio.cert : \
- regex/regex-exec.cert \
- regex/regex-parse.cert \
- regex/portcullis.cert \
- regex/regex-fileio.lisp \
- regex/cert.acl2
-
-
-regex/regex-parse-brace.cert : acl2x = 0
-regex/regex-parse-brace.cert : no_pcert = 0
-
-regex/regex-parse-brace.cert : \
- regex/regex-defs.cert \
- regex/input-list.cert \
- regex/portcullis.cert \
- regex/regex-parse-brace.lisp \
- regex/cert.acl2
-
-
-regex/regex-parse-bracket.cert : acl2x = 0
-regex/regex-parse-bracket.cert : no_pcert = 0
-
-regex/regex-parse-bracket.cert : \
- regex/regex-defs.cert \
- regex/input-list.cert \
- regex/portcullis.cert \
- regex/regex-parse-bracket.lisp \
- regex/cert.acl2
-
-
-regex/regex-parse.cert : acl2x = 0
-regex/regex-parse.cert : no_pcert = 0
-
-regex/regex-parse.cert : \
- regex/regex-parse-bracket.cert \
- regex/regex-parse-brace.cert \
- regex/portcullis.cert \
- regex/regex-parse.lisp \
- regex/cert.acl2
-
-
-regex/regex-tests.cert : acl2x = 0
-regex/regex-tests.cert : no_pcert = 0
-
-regex/regex-tests.cert : \
- regex/regex-parse.cert \
- regex/regex-exec.cert \
- regex/regex-chartrans.cert \
- regex/portcullis.cert \
- regex/regex-tests.lisp \
- regex/cert.acl2
-
-
-regex/regex-ui.cert : acl2x = 0
-regex/regex-ui.cert : no_pcert = 0
-
-regex/regex-ui.cert : \
- regex/regex-parse.cert \
- regex/regex-exec.cert \
- str/case-conversion.cert \
- tools/mv-nth.cert \
- misc/assert.cert \
- regex/portcullis.cert \
- regex/regex-ui.lisp \
- regex/cert.acl2
-
-
-rtl/rel1/lib1/basic.cert : acl2x = 0
-rtl/rel1/lib1/basic.cert : no_pcert = 0
-
-rtl/rel1/lib1/basic.cert : \
- rtl/rel1/support/proofs.cert \
- rtl/rel1/lib1/basic.lisp
-
-
-rtl/rel1/lib1/bits.cert : acl2x = 0
-rtl/rel1/lib1/bits.cert : no_pcert = 0
-
-rtl/rel1/lib1/bits.cert : \
- rtl/rel1/support/proofs.cert \
- rtl/rel1/lib1/bits.lisp
-
-
-rtl/rel1/lib1/brat.cert : acl2x = 0
-rtl/rel1/lib1/brat.cert : no_pcert = 0
-
-rtl/rel1/lib1/brat.cert : \
- rtl/rel1/support/fp.cert \
- rtl/rel1/lib1/brat.lisp
-
-
-rtl/rel1/lib1/float.cert : acl2x = 0
-rtl/rel1/lib1/float.cert : no_pcert = 0
-
-rtl/rel1/lib1/float.cert : \
- rtl/rel1/support/proofs.cert \
- rtl/rel1/lib1/float.lisp
-
-
-rtl/rel1/lib1/reps.cert : acl2x = 0
-rtl/rel1/lib1/reps.cert : no_pcert = 0
-
-rtl/rel1/lib1/reps.cert : \
- rtl/rel1/support/proofs.cert \
- rtl/rel1/lib1/float.cert \
- rtl/rel1/lib1/reps.lisp
-
-
-rtl/rel1/lib1/round.cert : acl2x = 0
-rtl/rel1/lib1/round.cert : no_pcert = 0
-
-rtl/rel1/lib1/round.cert : \
- rtl/rel1/support/proofs.cert \
- rtl/rel1/lib1/float.cert \
- rtl/rel1/lib1/round.lisp
-
-
-rtl/rel1/lib1/top.cert : acl2x = 0
-rtl/rel1/lib1/top.cert : no_pcert = 0
-
-rtl/rel1/lib1/top.cert : \
- rtl/rel1/lib1/basic.cert \
- rtl/rel1/lib1/bits.cert \
- rtl/rel1/lib1/float.cert \
- rtl/rel1/lib1/round.cert \
- rtl/rel1/lib1/reps.cert \
- rtl/rel1/lib1/brat.cert \
- rtl/rel1/lib1/top.lisp
-
-
-rtl/rel1/lib3/basic.cert : acl2x = 0
-rtl/rel1/lib3/basic.cert : no_pcert = 0
-
-rtl/rel1/lib3/basic.cert : \
- rtl/rel1/support/merge.cert \
- rtl/rel1/support/rewrite-theory.cert \
- rtl/rel1/lib3/basic.lisp
-
-
-rtl/rel1/lib3/bits.cert : acl2x = 0
-rtl/rel1/lib3/bits.cert : no_pcert = 0
-
-rtl/rel1/lib3/bits.cert : \
- rtl/rel1/support/merge.cert \
- rtl/rel1/support/rewrite-theory.cert \
- rtl/rel1/lib3/bits.lisp
-
-
-rtl/rel1/lib3/brat.cert : acl2x = 0
-rtl/rel1/lib3/brat.cert : no_pcert = 0
-
-rtl/rel1/lib3/brat.cert : \
- rtl/rel1/support/fp.cert \
- rtl/rel1/lib3/brat.lisp
-
-
-rtl/rel1/lib3/fadd.cert : acl2x = 0
-rtl/rel1/lib3/fadd.cert : no_pcert = 0
-
-rtl/rel1/lib3/fadd.cert : \
- rtl/rel1/support/fadd/add3.cert \
- rtl/rel1/lib3/float.cert \
- rtl/rel1/lib3/bits.cert \
- rtl/rel1/lib3/fadd.lisp
-
-
-rtl/rel1/lib3/float.cert : acl2x = 0
-rtl/rel1/lib3/float.cert : no_pcert = 0
-
-rtl/rel1/lib3/float.cert : \
- rtl/rel1/support/proofs.cert \
- rtl/rel1/lib3/float.lisp
-
-
-rtl/rel1/lib3/reps.cert : acl2x = 0
-rtl/rel1/lib3/reps.cert : no_pcert = 0
-
-rtl/rel1/lib3/reps.cert : \
- rtl/rel1/support/proofs.cert \
- rtl/rel1/lib3/float.cert \
- rtl/rel1/lib3/reps.lisp
-
-
-rtl/rel1/lib3/round.cert : acl2x = 0
-rtl/rel1/lib3/round.cert : no_pcert = 0
-
-rtl/rel1/lib3/round.cert : \
- rtl/rel1/support/proofs.cert \
- rtl/rel1/lib3/float.cert \
- rtl/rel1/lib3/round.lisp
-
-
-rtl/rel1/lib3/top.cert : acl2x = 0
-rtl/rel1/lib3/top.cert : no_pcert = 0
-
-rtl/rel1/lib3/top.cert : \
- rtl/rel1/lib3/basic.cert \
- rtl/rel1/lib3/bits.cert \
- rtl/rel1/lib3/float.cert \
- rtl/rel1/lib3/round.cert \
- rtl/rel1/lib3/reps.cert \
- rtl/rel1/lib3/fadd.cert \
- rtl/rel1/support/fp.cert \
- rtl/rel1/lib3/brat.cert \
- rtl/rel1/lib3/top.lisp
-
-
-rtl/rel1/support/add.cert : acl2x = 0
-rtl/rel1/support/add.cert : no_pcert = 0
-
-rtl/rel1/support/add.cert : \
- rtl/rel1/support/divsqrt.cert \
- rtl/rel1/support/logxor-lemmas.cert \
- rtl/rel1/support/rnd.cert \
- rtl/rel1/support/add.lisp
-
-
-rtl/rel1/support/away.cert : acl2x = 0
-rtl/rel1/support/away.cert : no_pcert = 0
-
-rtl/rel1/support/away.cert : \
- rtl/rel1/support/trunc.cert \
- rtl/rel1/support/away.lisp
-
-
-rtl/rel1/support/basic.cert : acl2x = 0
-rtl/rel1/support/basic.cert : no_pcert = 0
-
-rtl/rel1/support/basic.cert : \
- rtl/rel1/support/fp.cert \
- rtl/rel1/support/basic.lisp
-
-
-rtl/rel1/support/divsqrt.cert : acl2x = 0
-rtl/rel1/support/divsqrt.cert : no_pcert = 0
-
-rtl/rel1/support/divsqrt.cert : \
- rtl/rel1/support/odd.cert \
- rtl/rel1/support/loglemmas.cert \
- rtl/rel1/support/divsqrt.lisp
-
-
-rtl/rel1/support/fadd/add3.cert : acl2x = 0
-rtl/rel1/support/fadd/add3.cert : no_pcert = 0
-
-rtl/rel1/support/fadd/add3.cert : \
- rtl/rel1/support/fadd/stick.cert \
- rtl/rel1/support/fadd/add3.lisp
-
-
-rtl/rel1/support/fadd/lop1.cert : acl2x = 0
-rtl/rel1/support/fadd/lop1.cert : no_pcert = 0
-
-rtl/rel1/support/fadd/lop1.cert : \
- rtl/rel1/lib1/top.cert \
- rtl/rel1/support/fp.cert \
- rtl/rel1/support/fadd/lop1.lisp
-
-
-rtl/rel1/support/fadd/lop2.cert : acl2x = 0
-rtl/rel1/support/fadd/lop2.cert : no_pcert = 0
-
-rtl/rel1/support/fadd/lop2.cert : \
- rtl/rel1/support/fadd/lop1.cert \
- rtl/rel1/support/fadd/lop2.lisp
-
-
-rtl/rel1/support/fadd/lop3.cert : acl2x = 0
-rtl/rel1/support/fadd/lop3.cert : no_pcert = 0
-
-rtl/rel1/support/fadd/lop3.cert : \
- rtl/rel1/support/fadd/lop2.cert \
- rtl/rel1/support/fadd/lop3.lisp
-
-
-rtl/rel1/support/fadd/stick.cert : acl2x = 0
-rtl/rel1/support/fadd/stick.cert : no_pcert = 0
-
-rtl/rel1/support/fadd/stick.cert : \
- rtl/rel1/support/fadd/lop3.cert \
- rtl/rel1/support/fadd/stick.lisp
-
-
-rtl/rel1/support/fadd/top.cert : acl2x = 0
-rtl/rel1/support/fadd/top.cert : no_pcert = 0
-
-rtl/rel1/support/fadd/top.cert : \
- rtl/rel1/support/fadd/lop3.cert \
- rtl/rel1/support/fadd/top.lisp
-
-
-rtl/rel1/support/float.cert : acl2x = 0
-rtl/rel1/support/float.cert : no_pcert = 0
-
-rtl/rel1/support/float.cert : \
- rtl/rel1/support/basic.cert \
- rtl/rel1/support/x-2xx.cert \
- rtl/rel1/support/float.lisp
-
-
-rtl/rel1/support/floor.cert : acl2x = 0
-rtl/rel1/support/floor.cert : no_pcert = 0
-
-rtl/rel1/support/floor.cert : \
- rtl/rel1/support/basic.cert \
- rtl/rel1/support/floor.lisp
-
-
-rtl/rel1/support/fp.cert : acl2x = 0
-rtl/rel1/support/fp.cert : no_pcert = 0
-
-rtl/rel1/support/fp.cert : \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- rtl/rel1/support/fp.lisp
-
-
-rtl/rel1/support/logdefs.cert : acl2x = 0
-rtl/rel1/support/logdefs.cert : no_pcert = 0
-
-rtl/rel1/support/logdefs.cert : \
- rtl/rel1/support/floor.cert \
- rtl/rel1/support/logdefs.lisp
-
-
-rtl/rel1/support/loglemmas.cert : acl2x = 0
-rtl/rel1/support/loglemmas.cert : no_pcert = 0
-
-rtl/rel1/support/loglemmas.cert : \
- rtl/rel1/support/logdefs.cert \
- rtl/rel1/support/loglemmas.lisp
-
-
-rtl/rel1/support/logxor-def.cert : acl2x = 0
-rtl/rel1/support/logxor-def.cert : no_pcert = 0
-
-rtl/rel1/support/logxor-def.cert : \
- rtl/rel1/support/floor.cert \
- rtl/rel1/support/logxor-def.lisp
-
-
-rtl/rel1/support/logxor-lemmas.cert : acl2x = 0
-rtl/rel1/support/logxor-lemmas.cert : no_pcert = 0
-
-rtl/rel1/support/logxor-lemmas.cert : \
- rtl/rel1/support/logxor-def.cert \
- rtl/rel1/support/loglemmas.cert \
- rtl/rel1/support/logxor-lemmas.lisp
-
-
-rtl/rel1/support/merge.cert : acl2x = 0
-rtl/rel1/support/merge.cert : no_pcert = 0
-
-rtl/rel1/support/merge.cert : \
- rtl/rel1/support/proofs.cert \
- rtl/rel1/support/merge.lisp
-
-
-rtl/rel1/support/near.cert : acl2x = 0
-rtl/rel1/support/near.cert : no_pcert = 0
-
-rtl/rel1/support/near.cert : \
- rtl/rel1/support/away.cert \
- rtl/rel1/support/near.lisp
-
-
-rtl/rel1/support/odd.cert : acl2x = 0
-rtl/rel1/support/odd.cert : no_pcert = 0
-
-rtl/rel1/support/odd.cert : \
- rtl/rel1/support/near.cert \
- rtl/rel1/support/odd.lisp
-
-
-rtl/rel1/support/proofs.cert : acl2x = 0
-rtl/rel1/support/proofs.cert : no_pcert = 0
-
-rtl/rel1/support/proofs.cert : \
- rtl/rel1/support/basic.cert \
- rtl/rel1/support/x-2xx.cert \
- rtl/rel1/support/float.cert \
- rtl/rel1/support/trunc.cert \
- rtl/rel1/support/away.cert \
- rtl/rel1/support/near.cert \
- rtl/rel1/support/odd.cert \
- rtl/rel1/support/floor.cert \
- rtl/rel1/support/logdefs.cert \
- rtl/rel1/support/loglemmas.cert \
- rtl/rel1/support/divsqrt.cert \
- rtl/rel1/support/logxor-def.cert \
- rtl/rel1/support/logxor-lemmas.cert \
- rtl/rel1/support/reps.cert \
- rtl/rel1/support/sticky.cert \
- rtl/rel1/support/rnd.cert \
- rtl/rel1/support/add.cert \
- rtl/rel1/support/proofs.lisp
-
-
-rtl/rel1/support/reps.cert : acl2x = 0
-rtl/rel1/support/reps.cert : no_pcert = 0
-
-rtl/rel1/support/reps.cert : \
- rtl/rel1/support/logdefs.cert \
- rtl/rel1/support/float.cert \
- rtl/rel1/support/reps.lisp
-
-
-rtl/rel1/support/rewrite-theory.cert : acl2x = 0
-rtl/rel1/support/rewrite-theory.cert : no_pcert = 0
-
-rtl/rel1/support/rewrite-theory.cert : \
- rtl/rel1/support/rewrite-theory.lisp
-
-
-rtl/rel1/support/rnd.cert : acl2x = 0
-rtl/rel1/support/rnd.cert : no_pcert = 0
-
-rtl/rel1/support/rnd.cert : \
- rtl/rel1/support/sticky.cert \
- rtl/rel1/support/rnd.lisp
-
-
-rtl/rel1/support/sticky.cert : acl2x = 0
-rtl/rel1/support/sticky.cert : no_pcert = 0
-
-rtl/rel1/support/sticky.cert : \
- rtl/rel1/support/divsqrt.cert \
- rtl/rel1/support/sticky.lisp
-
-
-rtl/rel1/support/trunc.cert : acl2x = 0
-rtl/rel1/support/trunc.cert : no_pcert = 0
-
-rtl/rel1/support/trunc.cert : \
- rtl/rel1/support/float.cert \
- rtl/rel1/support/trunc.lisp
-
-
-rtl/rel1/support/x-2xx.cert : acl2x = 0
-rtl/rel1/support/x-2xx.cert : no_pcert = 0
-
-rtl/rel1/support/x-2xx.cert : \
- arithmetic/top.cert \
- rtl/rel1/support/x-2xx.lisp
-
-
-rtl/rel4/arithmetic/arith.cert : acl2x = 0
-rtl/rel4/arithmetic/arith.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/arith.cert : \
- rtl/rel4/arithmetic/arith2.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- meta/meta-times-equal.cert \
- rtl/rel4/arithmetic/arith.lisp
-
-
-rtl/rel4/arithmetic/arith2.cert : acl2x = 0
-rtl/rel4/arithmetic/arith2.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/arith2.cert : \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/product.cert \
- meta/meta-times-equal.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- meta/meta-times-equal.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel4/arithmetic/inverted-factor.cert \
- rtl/rel4/arithmetic/arith2.lisp
-
-
-rtl/rel4/arithmetic/basic.cert : acl2x = 0
-rtl/rel4/arithmetic/basic.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/basic.cert : \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/even-odd.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/arithmetic/basic.lisp
-
-
-rtl/rel4/arithmetic/cg.cert : acl2x = 0
-rtl/rel4/arithmetic/cg.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/cg.cert : \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/arithmetic/common-factor.cert \
- rtl/rel4/arithmetic/cg.lisp
-
-
-rtl/rel4/arithmetic/common-factor-defuns.cert : acl2x = 0
-rtl/rel4/arithmetic/common-factor-defuns.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/common-factor-defuns.cert : \
- rtl/rel4/arithmetic/inverted-factor.cert \
- rtl/rel4/arithmetic/common-factor-defuns.lisp
-
-
-rtl/rel4/arithmetic/common-factor.cert : acl2x = 0
-rtl/rel4/arithmetic/common-factor.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/common-factor.cert : \
- meta/meta-times-equal.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel4/arithmetic/common-factor-defuns.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/product.cert \
- rtl/rel4/arithmetic/common-factor.lisp
-
-
-rtl/rel4/arithmetic/complex-rationalp.cert : acl2x = 0
-rtl/rel4/arithmetic/complex-rationalp.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/complex-rationalp.cert : \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/complex-rationalp.lisp
-
-
-rtl/rel4/arithmetic/denominator.cert : acl2x = 0
-rtl/rel4/arithmetic/denominator.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/denominator.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/fp2.cert \
- arithmetic/mod-gcd.cert \
- rtl/rel4/arithmetic/denominator.lisp
-
-
-rtl/rel4/arithmetic/even-odd.cert : acl2x = 0
-rtl/rel4/arithmetic/even-odd.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/even-odd.cert : \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/even-odd.lisp
-
-
-rtl/rel4/arithmetic/even-odd2-proofs.cert : acl2x = 0
-rtl/rel4/arithmetic/even-odd2-proofs.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/even-odd2-proofs.cert : \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/arith.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/even-odd2-proofs.lisp
-
-
-rtl/rel4/arithmetic/even-odd2.cert : acl2x = 0
-rtl/rel4/arithmetic/even-odd2.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/even-odd2.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/even-odd2-proofs.cert \
- rtl/rel4/arithmetic/even-odd2.lisp
-
-
-rtl/rel4/arithmetic/expo-proofs.cert : acl2x = 0
-rtl/rel4/arithmetic/expo-proofs.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/expo-proofs.cert : \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/arithmetic/unary-divide.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/expt.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel4/arithmetic/common-factor-defuns.cert \
- rtl/rel4/arithmetic/common-factor.cert \
- rtl/rel4/arithmetic/expo-proofs.lisp
-
-
-rtl/rel4/arithmetic/expo.cert : acl2x = 0
-rtl/rel4/arithmetic/expo.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/expo.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/arithmetic/expo-proofs.cert \
- rtl/rel4/arithmetic/common-factor-defuns.cert \
- rtl/rel4/arithmetic/expo.lisp
-
-
-rtl/rel4/arithmetic/expt-proofs.cert : acl2x = 0
-rtl/rel4/arithmetic/expt-proofs.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/expt-proofs.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/numerator.cert \
- rtl/rel4/arithmetic/denominator.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/arith2.cert \
- arithmetic/top.cert \
- rtl/rel4/arithmetic/even-odd.cert \
- rtl/rel4/arithmetic/expt-proofs.lisp
-
-
-rtl/rel4/arithmetic/expt.cert : acl2x = 0
-rtl/rel4/arithmetic/expt.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/expt.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/expt-proofs.cert \
- rtl/rel4/arithmetic/expt.lisp
-
-
-rtl/rel4/arithmetic/extra-rules.cert : acl2x = 0
-rtl/rel4/arithmetic/extra-rules.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/extra-rules.cert : \
- rtl/rel4/arithmetic/basic.cert \
- rtl/rel4/arithmetic/extra-rules.lisp
-
-
-rtl/rel4/arithmetic/fl-expt.cert : acl2x = 0
-rtl/rel4/arithmetic/fl-expt.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/fl-expt.cert : \
- rtl/rel4/arithmetic/numerator.cert \
- rtl/rel4/arithmetic/denominator.cert \
- rtl/rel4/arithmetic/nniq.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/floor.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/rationalp.cert \
- rtl/rel4/arithmetic/unary-divide.cert \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/arithmetic/expo.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/fl-expt.lisp
-
-
-rtl/rel4/arithmetic/fl-hacks.cert : acl2x = 0
-rtl/rel4/arithmetic/fl-hacks.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/fl-hacks.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/inverted-factor.cert \
- rtl/rel4/arithmetic/nniq.cert \
- rtl/rel4/arithmetic/numerator.cert \
- rtl/rel4/arithmetic/denominator.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/product.cert \
- rtl/rel4/arithmetic/unary-divide.cert \
- rtl/rel4/arithmetic/rationalp.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/mod.cert \
- rtl/rel4/arithmetic/even-odd.cert \
- meta/meta-plus-equal.cert \
- rtl/rel4/arithmetic/arith.cert \
- rtl/rel4/arithmetic/fl-hacks.lisp
-
-
-rtl/rel4/arithmetic/fl-proofs.cert : acl2x = 0
-rtl/rel4/arithmetic/fl-proofs.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/fl-proofs.cert : \
- rtl/rel4/arithmetic/numerator.cert \
- rtl/rel4/arithmetic/denominator.cert \
- rtl/rel4/arithmetic/nniq.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/floor.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/rationalp.cert \
- rtl/rel4/arithmetic/unary-divide.cert \
- rtl/rel4/arithmetic/common-factor.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/fl-proofs.lisp
-
-
-rtl/rel4/arithmetic/fl.cert : acl2x = 0
-rtl/rel4/arithmetic/fl.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/fl.cert : \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/fl-proofs.cert \
- rtl/rel4/arithmetic/fl.lisp
-
-
-rtl/rel4/arithmetic/floor-proofs.cert : acl2x = 0
-rtl/rel4/arithmetic/floor-proofs.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/floor-proofs.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/denominator.cert \
- rtl/rel4/arithmetic/numerator.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/nniq.cert \
- rtl/rel4/arithmetic/product.cert \
- rtl/rel4/arithmetic/unary-divide.cert \
- rtl/rel4/arithmetic/rationalp.cert \
- rtl/rel4/arithmetic/inverted-factor.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel4/arithmetic/floor-proofs.lisp
-
-
-rtl/rel4/arithmetic/floor.cert : acl2x = 0
-rtl/rel4/arithmetic/floor.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/floor.cert : \
- rtl/rel4/arithmetic/floor-proofs.cert \
- rtl/rel4/arithmetic/floor.lisp
-
-
-rtl/rel4/arithmetic/fp.cert : acl2x = 0
-rtl/rel4/arithmetic/fp.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/fp.cert : \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/fp.lisp
-
-
-rtl/rel4/arithmetic/fp2.cert : acl2x = 0
-rtl/rel4/arithmetic/fp2.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/fp2.cert : \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- ihs/ihs-lemmas.cert \
- arithmetic-2/meta/non-linear.cert \
- rtl/rel4/arithmetic/inverted-factor.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel4/arithmetic/fp2.lisp
-
-
-rtl/rel4/arithmetic/ground-zero.cert : acl2x = 0
-rtl/rel4/arithmetic/ground-zero.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/ground-zero.cert : \
- rtl/rel4/arithmetic/ground-zero.lisp
-
-
-rtl/rel4/arithmetic/hacks.cert : acl2x = 0
-rtl/rel4/arithmetic/hacks.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/hacks.cert : \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/hacks.lisp
-
-
-rtl/rel4/arithmetic/induct.cert : acl2x = 0
-rtl/rel4/arithmetic/induct.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/induct.cert : \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/induct.lisp
-
-
-rtl/rel4/arithmetic/integerp.cert : acl2x = 0
-rtl/rel4/arithmetic/integerp.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/integerp.cert : \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/integerp.lisp
-
-
-rtl/rel4/arithmetic/inverted-factor.cert : acl2x = 0
-rtl/rel4/arithmetic/inverted-factor.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/inverted-factor.cert : \
- rtl/rel4/arithmetic/inverted-factor.lisp
-
-
-rtl/rel4/arithmetic/mod-expt.cert : acl2x = 0
-rtl/rel4/arithmetic/mod-expt.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/mod-expt.cert : \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/arithmetic/numerator.cert \
- rtl/rel4/arithmetic/denominator.cert \
- rtl/rel4/arithmetic/nniq.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/floor.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/rationalp.cert \
- rtl/rel4/arithmetic/unary-divide.cert \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/arithmetic/expo.cert \
- rtl/rel4/arithmetic/fl-expt.cert \
- rtl/rel4/arithmetic/mod.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/mod-expt.lisp
-
-
-rtl/rel4/arithmetic/mod-proofs.cert : acl2x = 0
-rtl/rel4/arithmetic/mod-proofs.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/mod-proofs.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/floor.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/arith.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/product.cert \
- rtl/rel4/arithmetic/complex-rationalp.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/rationalp.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/mod-proofs.lisp
-
-
-rtl/rel4/arithmetic/mod.cert : acl2x = 0
-rtl/rel4/arithmetic/mod.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/mod.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/mod-proofs.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/mod.lisp
-
-
-rtl/rel4/arithmetic/negative-syntaxp.cert : acl2x = 0
-rtl/rel4/arithmetic/negative-syntaxp.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/negative-syntaxp.cert : \
- rtl/rel4/arithmetic/negative-syntaxp.lisp
-
-
-rtl/rel4/arithmetic/nniq.cert : acl2x = 0
-rtl/rel4/arithmetic/nniq.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/nniq.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/denominator.cert \
- rtl/rel4/arithmetic/numerator.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/unary-divide.cert \
- rtl/rel4/arithmetic/product.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/arith.cert \
- arithmetic/rationals.cert \
- arithmetic/idiv.cert \
- arithmetic/idiv.cert \
- arithmetic/top-with-meta.cert \
- rtl/rel4/arithmetic/nniq.lisp
-
-
-rtl/rel4/arithmetic/numerator.cert : acl2x = 0
-rtl/rel4/arithmetic/numerator.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/numerator.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/denominator.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/numerator.lisp
-
-
-rtl/rel4/arithmetic/power2p.cert : acl2x = 0
-rtl/rel4/arithmetic/power2p.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/power2p.cert : \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/unary-divide.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel4/arithmetic/power2p.lisp
-
-
-rtl/rel4/arithmetic/predicate.cert : acl2x = 0
-rtl/rel4/arithmetic/predicate.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/predicate.cert : \
- rtl/rel4/arithmetic/predicate.lisp
-
-
-rtl/rel4/arithmetic/product-proofs.cert : acl2x = 0
-rtl/rel4/arithmetic/product-proofs.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/product-proofs.cert : \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/product-proofs.lisp
-
-
-rtl/rel4/arithmetic/product.cert : acl2x = 0
-rtl/rel4/arithmetic/product.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/product.cert : \
- rtl/rel4/arithmetic/product-proofs.cert \
- rtl/rel4/arithmetic/product.lisp
-
-
-rtl/rel4/arithmetic/rationalp.cert : acl2x = 0
-rtl/rel4/arithmetic/rationalp.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/rationalp.cert : \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/rationalp.lisp
-
-
-rtl/rel4/arithmetic/top.cert : acl2x = 0
-rtl/rel4/arithmetic/top.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/top.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/arithmetic/induct.cert \
- rtl/rel4/arithmetic/denominator.cert \
- rtl/rel4/arithmetic/numerator.cert \
- rtl/rel4/arithmetic/nniq.cert \
- rtl/rel4/arithmetic/complex-rationalp.cert \
- rtl/rel4/arithmetic/rationalp.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/arithmetic/arith.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/basic.cert \
- rtl/rel4/arithmetic/unary-divide.cert \
- rtl/rel4/arithmetic/product.cert \
- rtl/rel4/arithmetic/inverted-factor.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/x-2xx.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/arithmetic/expo.cert \
- rtl/rel4/arithmetic/even-odd2.cert \
- rtl/rel4/arithmetic/even-odd.cert \
- rtl/rel4/arithmetic/floor.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/cg.cert \
- rtl/rel4/arithmetic/mod.cert \
- rtl/rel4/arithmetic/fl-expt.cert \
- rtl/rel4/arithmetic/mod-expt.cert \
- rtl/rel4/arithmetic/common-factor.cert \
- rtl/rel4/arithmetic/top.lisp
-
-
-rtl/rel4/arithmetic/unary-divide.cert : acl2x = 0
-rtl/rel4/arithmetic/unary-divide.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/unary-divide.cert : \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/inverted-factor.cert \
- rtl/rel4/arithmetic/unary-divide.lisp
-
-
-rtl/rel4/arithmetic/x-2xx.cert : acl2x = 0
-rtl/rel4/arithmetic/x-2xx.cert : no_pcert = 0
-
-rtl/rel4/arithmetic/x-2xx.cert : \
- arithmetic/top.cert \
- rtl/rel4/arithmetic/x-2xx.lisp
-
-
-rtl/rel4/lib/arith.cert : acl2x = 0
-rtl/rel4/lib/arith.cert : no_pcert = 0
-
-rtl/rel4/lib/arith.cert : \
- rtl/rel4/arithmetic/fp.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/arithmetic/expo.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel4/lib/arith.lisp
-
-
-rtl/rel4/lib/basic.cert : acl2x = 0
-rtl/rel4/lib/basic.cert : no_pcert = 0
-
-rtl/rel4/lib/basic.cert : \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/arithmetic/hacks.cert \
- rtl/rel4/arithmetic/cg.cert \
- rtl/rel4/support/ash.cert \
- rtl/rel4/arithmetic/fl-hacks.cert \
- rtl/rel4/arithmetic/mod.cert \
- rtl/rel4/arithmetic/even-odd.cert \
- rtl/rel4/arithmetic/extra-rules.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/lib/rtl.cert \
- rtl/rel4/lib/rtlarr.cert \
- rtl/rel4/lib/basic.lisp
-
-
-rtl/rel4/lib/bits.cert : acl2x = 0
-rtl/rel4/lib/bits.cert : no_pcert = 0
-
-rtl/rel4/lib/bits.cert : \
- rtl/rel4/lib/basic.cert \
- rtl/rel4/support/top.cert \
- rtl/rel4/lib/bits.lisp
-
-
-rtl/rel4/lib/bvecp-helpers.cert : acl2x = 0
-rtl/rel4/lib/bvecp-helpers.cert : no_pcert = 0
-
-rtl/rel4/lib/bvecp-helpers.cert : \
- rtl/rel4/lib/rtl.cert \
- rtl/rel4/lib/rtlarr.cert \
- rtl/rel4/support/bvecp-helpers.cert \
- rtl/rel4/arithmetic/basic.cert \
- rtl/rel4/lib/bvecp-helpers.lisp
-
-
-rtl/rel4/lib/bvecp-raw-helpers.cert : acl2x = 0
-rtl/rel4/lib/bvecp-raw-helpers.cert : no_pcert = 0
-
-rtl/rel4/lib/bvecp-raw-helpers.cert : \
- rtl/rel4/lib/rtl.cert \
- rtl/rel4/lib/rtlarr.cert \
- rtl/rel4/support/bvecp-helpers.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/setbits.cert \
- rtl/rel4/support/setbitn.cert \
- rtl/rel4/support/logs.cert \
- rtl/rel4/support/lnot.cert \
- rtl/rel4/support/shft.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/mulcat.cert \
- rtl/rel4/support/encode.cert \
- rtl/rel4/support/decode.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/arithmetic/expo.cert \
- rtl/rel4/arithmetic/basic.cert \
- rtl/rel4/lib/bvecp-raw-helpers.lisp
-
-
-rtl/rel4/lib/clocks.cert : acl2x = 0
-rtl/rel4/lib/clocks.cert : no_pcert = 0
-
-rtl/rel4/lib/clocks.cert : \
- rtl/rel4/support/clocks.cert \
- rtl/rel4/lib/clocks.lisp
-
-
-rtl/rel4/lib/fadd.cert : acl2x = 0
-rtl/rel4/lib/fadd.cert : no_pcert = 0
-
-rtl/rel4/lib/fadd.cert : \
- rtl/rel4/support/fadd.cert \
- rtl/rel4/support/bits-extra.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/lib/float.cert \
- rtl/rel4/lib/fadd.lisp
-
-
-rtl/rel4/lib/float.cert : acl2x = 0
-rtl/rel4/lib/float.cert : no_pcert = 0
-
-rtl/rel4/lib/float.cert : \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/lib/bits.cert \
- rtl/rel4/lib/float.lisp
-
-
-rtl/rel4/lib/openers.cert : acl2x = 0
-rtl/rel4/lib/openers.cert : no_pcert = 0
-
-rtl/rel4/lib/openers.cert : \
- rtl/rel4/support/openers.cert \
- rtl/rel4/lib/openers.lisp
-
-
-rtl/rel4/lib/package-defs.cert : acl2x = 0
-rtl/rel4/lib/package-defs.cert : no_pcert = 0
-
-rtl/rel4/lib/package-defs.cert : \
- rtl/rel4/support/package-defs.cert \
- rtl/rel4/lib/package-defs.lisp
-
-
-rtl/rel4/lib/reps.cert : acl2x = 0
-rtl/rel4/lib/reps.cert : no_pcert = 0
-
-rtl/rel4/lib/reps.cert : \
- rtl/rel4/support/ereps.cert \
- rtl/rel4/support/ireps.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/lib/float.cert \
- rtl/rel4/lib/reps.lisp
-
-
-rtl/rel4/lib/rom-helpers.cert : acl2x = 0
-rtl/rel4/lib/rom-helpers.cert : no_pcert = 0
-
-rtl/rel4/lib/rom-helpers.cert : \
- rtl/rel4/support/rom-helpers.cert \
- rtl/rel4/lib/rom-helpers.lisp
-
-
-rtl/rel4/lib/round.cert : acl2x = 0
-rtl/rel4/lib/round.cert : no_pcert = 0
-
-rtl/rel4/lib/round.cert : \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/away.cert \
- rtl/rel4/support/near.cert \
- rtl/rel4/support/near+.cert \
- rtl/rel4/support/oddr.cert \
- rtl/rel4/support/rnd.cert \
- rtl/rel4/support/drnd.cert \
- rtl/rel4/support/bits-trunc.cert \
- rtl/rel4/support/sticky.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/lib/reps.cert \
- rtl/rel4/lib/round.lisp
-
-
-rtl/rel4/lib/rtl.cert : acl2x = 0
-rtl/rel4/lib/rtl.cert : no_pcert = 0
-
-rtl/rel4/lib/rtl.cert : \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/mulcat.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/lib/rtl.lisp
-
-
-rtl/rel4/lib/rtlarr.cert : acl2x = 0
-rtl/rel4/lib/rtlarr.cert : no_pcert = 0
-
-rtl/rel4/lib/rtlarr.cert : \
- rtl/rel4/support/rtlarr.cert \
- rtl/rel4/support/bvecp-helpers.cert \
- rtl/rel4/support/guards.cert \
- misc/total-order.cert \
- rtl/rel4/lib/rtl.cert \
- rtl/rel4/lib/rtlarr.lisp
-
-
-rtl/rel4/lib/simple-loop-helpers.cert : acl2x = 0
-rtl/rel4/lib/simple-loop-helpers.cert : no_pcert = 0
-
-rtl/rel4/lib/simple-loop-helpers.cert : \
- rtl/rel4/lib/rtl.cert \
- rtl/rel4/lib/rtlarr.cert \
- rtl/rel4/lib/arith.cert \
- rtl/rel4/lib/bits.cert \
- rtl/rel4/support/simple-loop-helpers.cert \
- rtl/rel4/lib/simple-loop-helpers.lisp
-
-
-rtl/rel4/lib/simplify-model-helpers.cert : acl2x = 0
-rtl/rel4/lib/simplify-model-helpers.cert : no_pcert = 0
-
-rtl/rel4/lib/simplify-model-helpers.cert : \
- rtl/rel4/lib/rtl.cert \
- rtl/rel4/lib/arith.cert \
- rtl/rel4/lib/bits.cert \
- rtl/rel4/support/simplify-model-helpers.cert \
- rtl/rel4/lib/simplify-model-helpers.lisp
-
-
-rtl/rel4/lib/top.cert : acl2x = 0
-rtl/rel4/lib/top.cert : no_pcert = 0
-
-rtl/rel4/lib/top.cert : \
- rtl/rel4/lib/rtl.cert \
- rtl/rel4/lib/rtlarr.cert \
- rtl/rel4/lib/basic.cert \
- rtl/rel4/lib/bits.cert \
- rtl/rel4/lib/float.cert \
- rtl/rel4/lib/reps.cert \
- rtl/rel4/lib/round.cert \
- rtl/rel4/lib/fadd.cert \
- rtl/rel4/lib/arith.cert \
- rtl/rel4/lib/util.cert \
- rtl/rel4/lib/top.lisp
-
-
-rtl/rel4/lib/util.cert : acl2x = 0
-rtl/rel4/lib/util.cert : no_pcert = 0
-
-rtl/rel4/lib/util.cert : \
- rtl/rel4/support/util.cert \
- rtl/rel4/lib/util.lisp
-
-
-rtl/rel4/support/add3-proofs.cert : acl2x = 0
-rtl/rel4/support/add3-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/add3-proofs.cert : \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/arithmetic/top.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/support/add3-proofs.lisp
-
-
-rtl/rel4/support/add3.cert : acl2x = 0
-rtl/rel4/support/add3.cert : no_pcert = 0
-
-rtl/rel4/support/add3.cert : \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/add3-proofs.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/support/add3.lisp
-
-
-rtl/rel4/support/all-ones.cert : acl2x = 0
-rtl/rel4/support/all-ones.cert : no_pcert = 0
-
-rtl/rel4/support/all-ones.cert : \
- rtl/rel4/support/all-ones.lisp
-
-
-rtl/rel4/support/ash.cert : acl2x = 0
-rtl/rel4/support/ash.cert : no_pcert = 0
-
-rtl/rel4/support/ash.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/arithmetic/expo.cert \
- rtl/rel4/support/ash.lisp
-
-
-rtl/rel4/support/away-proofs.cert : acl2x = 0
-rtl/rel4/support/away-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/away-proofs.cert : \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/away-proofs.lisp
-
-
-rtl/rel4/support/away.cert : acl2x = 0
-rtl/rel4/support/away.cert : no_pcert = 0
-
-rtl/rel4/support/away.cert : \
- rtl/rel4/support/away-proofs.cert \
- rtl/rel4/support/away.lisp
-
-
-rtl/rel4/support/badguys.cert : acl2x = 0
-rtl/rel4/support/badguys.cert : no_pcert = 0
-
-rtl/rel4/support/badguys.cert : \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/badguys.lisp
-
-
-rtl/rel4/support/bias-proofs.cert : acl2x = 0
-rtl/rel4/support/bias-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/bias-proofs.cert : \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/support/bias-proofs.lisp
-
-
-rtl/rel4/support/bias.cert : acl2x = 0
-rtl/rel4/support/bias.cert : no_pcert = 0
-
-rtl/rel4/support/bias.cert : \
- rtl/rel4/support/bias-proofs.cert \
- rtl/rel4/support/bias.lisp
-
-
-rtl/rel4/support/bitn-proofs.cert : acl2x = 0
-rtl/rel4/support/bitn-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/bitn-proofs.cert : \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/bitn-proofs.lisp
-
-
-rtl/rel4/support/bitn.cert : acl2x = 0
-rtl/rel4/support/bitn.cert : no_pcert = 0
-
-rtl/rel4/support/bitn.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/support/bitn-proofs.cert \
- rtl/rel4/support/bitn.lisp
-
-
-rtl/rel4/support/bits-extra.cert : acl2x = 0
-rtl/rel4/support/bits-extra.cert : no_pcert = 0
-
-rtl/rel4/support/bits-extra.cert : \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/fadd.cert \
- rtl/rel4/support/top1.cert \
- rtl/rel4/support/bits-extra.lisp
-
-
-rtl/rel4/support/bits-proofs.cert : acl2x = 0
-rtl/rel4/support/bits-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/bits-proofs.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/bits-proofs.lisp
-
-
-rtl/rel4/support/bits-trunc-proofs.cert : acl2x = 0
-rtl/rel4/support/bits-trunc-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/bits-trunc-proofs.cert : \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/log.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/bits-trunc-proofs.lisp
-
-
-rtl/rel4/support/bits-trunc.cert : acl2x = 0
-rtl/rel4/support/bits-trunc.cert : no_pcert = 0
-
-rtl/rel4/support/bits-trunc.cert : \
- rtl/rel4/support/log.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/bits-trunc-proofs.cert \
- rtl/rel4/support/bits-trunc.lisp
-
-
-rtl/rel4/support/bits.cert : acl2x = 0
-rtl/rel4/support/bits.cert : no_pcert = 0
-
-rtl/rel4/support/bits.cert : \
- rtl/rel4/support/bits-proofs.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/support/bits.lisp
-
-
-rtl/rel4/support/bvecp-helpers.cert : acl2x = 0
-rtl/rel4/support/bvecp-helpers.cert : no_pcert = 0
-
-rtl/rel4/support/bvecp-helpers.cert : \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/bvecp-lemmas.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bvecp-helpers.lisp
-
-
-rtl/rel4/support/bvecp-lemmas.cert : acl2x = 0
-rtl/rel4/support/bvecp-lemmas.cert : no_pcert = 0
-
-rtl/rel4/support/bvecp-lemmas.cert : \
- rtl/rel4/arithmetic/expo.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/setbits.cert \
- rtl/rel4/support/setbitn.cert \
- rtl/rel4/support/encode.cert \
- rtl/rel4/support/decode.cert \
- rtl/rel4/support/logs.cert \
- rtl/rel4/support/lnot.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/shft.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/mulcat.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/bvecp-lemmas.lisp
-
-
-rtl/rel4/support/bvecp-proofs.cert : acl2x = 0
-rtl/rel4/support/bvecp-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/bvecp-proofs.cert : \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bvecp-proofs.lisp
-
-
-rtl/rel4/support/bvecp.cert : acl2x = 0
-rtl/rel4/support/bvecp.cert : no_pcert = 0
-
-rtl/rel4/support/bvecp.cert : \
- rtl/rel4/support/bvecp-proofs.cert \
- rtl/rel4/support/bvecp.lisp
-
-
-rtl/rel4/support/cat-def.cert : acl2x = 0
-rtl/rel4/support/cat-def.cert : no_pcert = 0
-
-rtl/rel4/support/cat-def.cert : \
- rtl/rel4/support/cat-def.lisp
-
-
-rtl/rel4/support/cat-proofs.cert : acl2x = 0
-rtl/rel4/support/cat-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/cat-proofs.cert : \
- rtl/rel4/support/cat-def.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/cat-proofs.lisp
-
-
-rtl/rel4/support/cat.cert : acl2x = 0
-rtl/rel4/support/cat.cert : no_pcert = 0
-
-rtl/rel4/support/cat.cert : \
- rtl/rel4/support/cat-def.cert \
- rtl/rel4/support/cat-proofs.cert \
- rtl/rel4/support/cat.lisp
-
-
-rtl/rel4/support/clocks.cert : acl2x = 0
-rtl/rel4/support/clocks.cert : no_pcert = 0
-
-rtl/rel4/support/clocks.cert : \
- rtl/rel4/support/mod4.cert \
- rtl/rel4/arithmetic/even-odd2.cert \
- rtl/rel4/support/clocks.lisp
-
-
-rtl/rel4/support/decode-proofs.cert : acl2x = 0
-rtl/rel4/support/decode-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/decode-proofs.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/support/ash.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/decode-proofs.lisp
-
-
-rtl/rel4/support/decode.cert : acl2x = 0
-rtl/rel4/support/decode.cert : no_pcert = 0
-
-rtl/rel4/support/decode.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/decode-proofs.cert \
- rtl/rel4/support/decode.lisp
-
-
-rtl/rel4/support/drnd.cert : acl2x = 0
-rtl/rel4/support/drnd.cert : no_pcert = 0
-
-rtl/rel4/support/drnd.cert : \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/ireps.cert \
- rtl/rel4/support/rnd.cert \
- rtl/rel4/support/bias.cert \
- rtl/rel4/support/sgn.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/away.cert \
- rtl/rel4/support/near.cert \
- rtl/rel4/support/near+.cert \
- rtl/rel4/support/sticky.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/drnd.lisp
-
-
-rtl/rel4/support/encode.cert : acl2x = 0
-rtl/rel4/support/encode.cert : no_pcert = 0
-
-rtl/rel4/support/encode.cert : \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/ash.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/encode.lisp
-
-
-rtl/rel4/support/ereps-proofs.cert : acl2x = 0
-rtl/rel4/support/ereps-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/ereps-proofs.cert : \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/bias.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/mulcat.cert \
- rtl/rel4/support/ereps-proofs.lisp
-
-
-rtl/rel4/support/ereps.cert : acl2x = 0
-rtl/rel4/support/ereps.cert : no_pcert = 0
-
-rtl/rel4/support/ereps.cert : \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/ereps-proofs.cert \
- rtl/rel4/support/ereps.lisp
-
-
-rtl/rel4/support/fadd.cert : acl2x = 0
-rtl/rel4/support/fadd.cert : no_pcert = 0
-
-rtl/rel4/support/fadd.cert : \
- rtl/rel4/support/stick.cert \
- rtl/rel4/support/lop3.cert \
- rtl/rel4/support/add3.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/lextra.cert \
- rtl/rel4/support/fadd.lisp
-
-
-rtl/rel4/support/fast-and.cert : acl2x = 0
-rtl/rel4/support/fast-and.cert : no_pcert = 0
-
-rtl/rel4/support/fast-and.cert : \
- rtl/rel4/support/fast-and.lisp
-
-
-rtl/rel4/support/float.cert : acl2x = 0
-rtl/rel4/support/float.cert : no_pcert = 0
-
-rtl/rel4/support/float.cert : \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/basic.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/cg.cert \
- rtl/rel4/support/float.lisp
-
-
-rtl/rel4/support/ground-zero.cert : acl2x = 0
-rtl/rel4/support/ground-zero.cert : no_pcert = 0
-
-rtl/rel4/support/ground-zero.cert : \
- rtl/rel4/arithmetic/ground-zero.cert \
- rtl/rel4/support/util.cert \
- rtl/rel4/support/ground-zero.lisp
-
-
-rtl/rel4/support/guards.cert : acl2x = 0
-rtl/rel4/support/guards.cert : no_pcert = 0
-
-rtl/rel4/support/guards.cert : \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/top1.cert \
- rtl/rel4/support/guards.lisp
-
-
-rtl/rel4/support/ireps.cert : acl2x = 0
-rtl/rel4/support/ireps.cert : no_pcert = 0
-
-rtl/rel4/support/ireps.cert : \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/bias.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/ireps.lisp
-
-
-rtl/rel4/support/land-proofs.cert : acl2x = 0
-rtl/rel4/support/land-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/land-proofs.cert : \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/all-ones.cert \
- rtl/rel4/support/log.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/land-proofs.lisp
-
-
-rtl/rel4/support/land.cert : acl2x = 0
-rtl/rel4/support/land.cert : no_pcert = 0
-
-rtl/rel4/support/land.cert : \
- rtl/rel4/support/land-proofs.cert \
- rtl/rel4/support/land.lisp
-
-
-rtl/rel4/support/lextra-proofs.cert : acl2x = 0
-rtl/rel4/support/lextra-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/lextra-proofs.cert : \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/logior.cert \
- rtl/rel4/support/logxor.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/lextra-proofs.lisp
-
-
-rtl/rel4/support/lextra.cert : acl2x = 0
-rtl/rel4/support/lextra.cert : no_pcert = 0
-
-rtl/rel4/support/lextra.cert : \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/support/lextra-proofs.cert \
- rtl/rel4/support/lextra.lisp
-
-
-rtl/rel4/support/lior-proofs.cert : acl2x = 0
-rtl/rel4/support/lior-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/lior-proofs.cert : \
- rtl/rel4/support/all-ones.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/logior.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/lior-proofs.lisp
-
-
-rtl/rel4/support/lior.cert : acl2x = 0
-rtl/rel4/support/lior.cert : no_pcert = 0
-
-rtl/rel4/support/lior.cert : \
- rtl/rel4/support/lior-proofs.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/lior.lisp
-
-
-rtl/rel4/support/lnot-proofs.cert : acl2x = 0
-rtl/rel4/support/lnot-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/lnot-proofs.cert : \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/arithmetic/mod.cert \
- rtl/rel4/arithmetic/mod.cert \
- rtl/rel4/arithmetic/arith.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/lnot-proofs.lisp
-
-
-rtl/rel4/support/lnot.cert : acl2x = 0
-rtl/rel4/support/lnot.cert : no_pcert = 0
-
-rtl/rel4/support/lnot.cert : \
- rtl/rel4/support/lnot-proofs.cert \
- rtl/rel4/support/lnot.lisp
-
-
-rtl/rel4/support/log-equal.cert : acl2x = 0
-rtl/rel4/support/log-equal.cert : no_pcert = 0
-
-rtl/rel4/support/log-equal.cert : \
- rtl/rel4/support/log-equal.lisp
-
-
-rtl/rel4/support/log-proofs.cert : acl2x = 0
-rtl/rel4/support/log-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/log-proofs.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/lognot.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/lnot.cert \
- rtl/rel4/support/logior.cert \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/logxor.cert \
- rtl/rel4/support/log-proofs.lisp
-
-
-rtl/rel4/support/log.cert : acl2x = 0
-rtl/rel4/support/log.cert : no_pcert = 0
-
-rtl/rel4/support/log.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/log-proofs.cert \
- rtl/rel4/support/lnot.cert \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/logior.cert \
- rtl/rel4/support/logxor.cert \
- rtl/rel4/support/log.lisp
-
-
-rtl/rel4/support/logand-proofs.cert : acl2x = 0
-rtl/rel4/support/logand-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/logand-proofs.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/arithmetic/induct.cert \
- rtl/rel4/support/lognot.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/logand-proofs.lisp
-
-
-rtl/rel4/support/logand.cert : acl2x = 0
-rtl/rel4/support/logand.cert : no_pcert = 0
-
-rtl/rel4/support/logand.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/logand-proofs.cert \
- rtl/rel4/support/logand.lisp
-
-
-rtl/rel4/support/logeqv.cert : acl2x = 0
-rtl/rel4/support/logeqv.cert : no_pcert = 0
-
-rtl/rel4/support/logeqv.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/logior.cert \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/logorc1.cert \
- rtl/rel4/support/lognot.cert \
- rtl/rel4/support/logeqv.lisp
-
-
-rtl/rel4/support/logior-proofs.cert : acl2x = 0
-rtl/rel4/support/logior-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/logior-proofs.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/lognot.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/logior-proofs.lisp
-
-
-rtl/rel4/support/logior.cert : acl2x = 0
-rtl/rel4/support/logior.cert : no_pcert = 0
-
-rtl/rel4/support/logior.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/logior-proofs.cert \
- rtl/rel4/support/logior.lisp
-
-
-rtl/rel4/support/logior1-proofs.cert : acl2x = 0
-rtl/rel4/support/logior1-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/logior1-proofs.cert : \
- rtl/rel4/support/logior1-proofs.lisp
-
-
-rtl/rel4/support/logior1.cert : acl2x = 0
-rtl/rel4/support/logior1.cert : no_pcert = 0
-
-rtl/rel4/support/logior1.cert : \
- rtl/rel4/support/logior1-proofs.cert \
- rtl/rel4/support/logior1.lisp
-
-
-rtl/rel4/support/lognot.cert : acl2x = 0
-rtl/rel4/support/lognot.cert : no_pcert = 0
-
-rtl/rel4/support/lognot.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/lognot.lisp
-
-
-rtl/rel4/support/logorc1.cert : acl2x = 0
-rtl/rel4/support/logorc1.cert : no_pcert = 0
-
-rtl/rel4/support/logorc1.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/logior.cert \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/support/lognot.cert \
- rtl/rel4/support/logorc1.lisp
-
-
-rtl/rel4/support/logs.cert : acl2x = 0
-rtl/rel4/support/logs.cert : no_pcert = 0
-
-rtl/rel4/support/logs.cert : \
- rtl/rel4/support/logs.lisp
-
-
-rtl/rel4/support/logxor.cert : acl2x = 0
-rtl/rel4/support/logxor.cert : no_pcert = 0
-
-rtl/rel4/support/logxor.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/logeqv.cert \
- rtl/rel4/support/logorc1.cert \
- rtl/rel4/support/lognot.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/logxor.lisp
-
-
-rtl/rel4/support/lop1-proofs.cert : acl2x = 0
-rtl/rel4/support/lop1-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/lop1-proofs.cert : \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/lop1-proofs.lisp
-
-
-rtl/rel4/support/lop1.cert : acl2x = 0
-rtl/rel4/support/lop1.cert : no_pcert = 0
-
-rtl/rel4/support/lop1.cert : \
- rtl/rel4/support/lop1-proofs.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/lop1.lisp
-
-
-rtl/rel4/support/lop2-proofs.cert : acl2x = 0
-rtl/rel4/support/lop2-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/lop2-proofs.cert : \
- rtl/rel4/support/lop1.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/logior.cert \
- rtl/rel4/support/lop2-proofs.lisp
-
-
-rtl/rel4/support/lop2.cert : acl2x = 0
-rtl/rel4/support/lop2.cert : no_pcert = 0
-
-rtl/rel4/support/lop2.cert : \
- rtl/rel4/support/lop1.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lop2-proofs.cert \
- rtl/rel4/support/lop2.lisp
-
-
-rtl/rel4/support/lop3-proofs.cert : acl2x = 0
-rtl/rel4/support/lop3-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/lop3-proofs.cert : \
- rtl/rel4/support/lop2.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/support/lop3-proofs.lisp
-
-
-rtl/rel4/support/lop3.cert : acl2x = 0
-rtl/rel4/support/lop3.cert : no_pcert = 0
-
-rtl/rel4/support/lop3.cert : \
- rtl/rel4/support/lop2.cert \
- rtl/rel4/support/lop3-proofs.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/support/lop3.lisp
-
-
-rtl/rel4/support/lxor-proofs.cert : acl2x = 0
-rtl/rel4/support/lxor-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/lxor-proofs.cert : \
- rtl/rel4/support/all-ones.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/lxor-proofs.lisp
-
-
-rtl/rel4/support/lxor.cert : acl2x = 0
-rtl/rel4/support/lxor.cert : no_pcert = 0
-
-rtl/rel4/support/lxor.cert : \
- rtl/rel4/support/lxor-proofs.cert \
- rtl/rel4/support/lxor.lisp
-
-
-rtl/rel4/support/merge.cert : acl2x = 0
-rtl/rel4/support/merge.cert : no_pcert = 0
-
-rtl/rel4/support/merge.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/log.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/lnot.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/logior.cert \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/logxor.cert \
- rtl/rel4/support/ocat.cert \
- rtl/rel4/support/sumbits.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/merge.lisp
-
-
-rtl/rel4/support/merge2.cert : acl2x = 0
-rtl/rel4/support/merge2.cert : no_pcert = 0
-
-rtl/rel4/support/merge2.cert : \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/logs.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/merge2.lisp
-
-
-rtl/rel4/support/mod4.cert : acl2x = 0
-rtl/rel4/support/mod4.cert : no_pcert = 0
-
-rtl/rel4/support/mod4.cert : \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/mod4.lisp
-
-
-rtl/rel4/support/model-helpers.cert : acl2x = 0
-rtl/rel4/support/model-helpers.cert : no_pcert = 0
-
-rtl/rel4/support/model-helpers.cert : \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/model-helpers.lisp
-
-
-rtl/rel4/support/mulcat-proofs.cert : acl2x = 0
-rtl/rel4/support/mulcat-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/mulcat-proofs.cert : \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/cat-def.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/mulcat-proofs.lisp
-
-
-rtl/rel4/support/mulcat.cert : acl2x = 0
-rtl/rel4/support/mulcat.cert : no_pcert = 0
-
-rtl/rel4/support/mulcat.cert : \
- rtl/rel4/support/cat-def.cert \
- rtl/rel4/support/mulcat-proofs.cert \
- rtl/rel4/support/mulcat.lisp
-
-
-rtl/rel4/support/near+-proofs.cert : acl2x = 0
-rtl/rel4/support/near+-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/near+-proofs.cert : \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/away.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/arithmetic/predicate.cert \
- rtl/rel4/arithmetic/cg.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/near+-proofs.lisp
-
-
-rtl/rel4/support/near+.cert : acl2x = 0
-rtl/rel4/support/near+.cert : no_pcert = 0
-
-rtl/rel4/support/near+.cert : \
- rtl/rel4/support/near+-proofs.cert \
- rtl/rel4/support/near+.lisp
-
-
-rtl/rel4/support/near-proofs.cert : acl2x = 0
-rtl/rel4/support/near-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/near-proofs.cert : \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/away.cert \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/near-proofs.lisp
-
-
-rtl/rel4/support/near.cert : acl2x = 0
-rtl/rel4/support/near.cert : no_pcert = 0
-
-rtl/rel4/support/near.cert : \
- rtl/rel4/support/near-proofs.cert \
- rtl/rel4/support/near.lisp
-
-
-rtl/rel4/support/ocat.cert : acl2x = 0
-rtl/rel4/support/ocat.cert : no_pcert = 0
-
-rtl/rel4/support/ocat.cert : \
- rtl/rel4/arithmetic/expt.cert \
- rtl/rel4/arithmetic/expo.cert \
- rtl/rel4/arithmetic/arith2.cert \
- rtl/rel4/arithmetic/fp2.cert \
- rtl/rel4/arithmetic/integerp.cert \
- rtl/rel4/support/ocat.lisp
-
-
-rtl/rel4/support/oddr-proofs.cert : acl2x = 0
-rtl/rel4/support/oddr-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/oddr-proofs.cert : \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/away.cert \
- rtl/rel4/support/near.cert \
- rtl/rel4/support/oddr-proofs.lisp
-
-
-rtl/rel4/support/oddr.cert : acl2x = 0
-rtl/rel4/support/oddr.cert : no_pcert = 0
-
-rtl/rel4/support/oddr.cert : \
- rtl/rel4/support/oddr-proofs.cert \
- rtl/rel4/support/oddr.lisp
-
-
-rtl/rel4/support/openers.cert : acl2x = 0
-rtl/rel4/support/openers.cert : no_pcert = 0
-
-rtl/rel4/support/openers.cert : \
- rtl/rel4/support/openers.lisp
-
-
-rtl/rel4/support/package-defs.cert : acl2x = 0
-rtl/rel4/support/package-defs.cert : no_pcert = 0
-
-rtl/rel4/support/package-defs.cert : \
- rtl/rel4/support/package-defs.lisp
-
-
-rtl/rel4/support/rewrite-theory.cert : acl2x = 0
-rtl/rel4/support/rewrite-theory.cert : no_pcert = 0
-
-rtl/rel4/support/rewrite-theory.cert : \
- rtl/rel4/support/rewrite-theory.lisp
-
-
-rtl/rel4/support/rnd.cert : acl2x = 0
-rtl/rel4/support/rnd.cert : no_pcert = 0
-
-rtl/rel4/support/rnd.cert : \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/away.cert \
- rtl/rel4/support/near.cert \
- rtl/rel4/support/near+.cert \
- rtl/rel4/support/sticky.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/bits-trunc.cert \
- rtl/rel4/support/rnd.lisp
-
-
-rtl/rel4/support/rom-helpers.cert : acl2x = 0
-rtl/rel4/support/rom-helpers.cert : no_pcert = 0
-
-rtl/rel4/support/rom-helpers.cert : \
- rtl/rel4/support/rom-helpers.lisp
-
-
-rtl/rel4/support/rtl.cert : acl2x = 0
-rtl/rel4/support/rtl.cert : no_pcert = 0
-
-rtl/rel4/support/rtl.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/rtlarr.cert \
- rtl/rel4/support/cat-def.cert \
- rtl/rel4/support/rtl.lisp
-
-
-rtl/rel4/support/rtlarr.cert : acl2x = 0
-rtl/rel4/support/rtlarr.cert : no_pcert = 0
-
-rtl/rel4/support/rtlarr.cert : \
- misc/total-order.cert \
- rtl/rel4/support/rtlarr.lisp
-
-
-rtl/rel4/support/setbitn-proofs.cert : acl2x = 0
-rtl/rel4/support/setbitn-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/setbitn-proofs.cert : \
- rtl/rel4/support/cat-def.cert \
- rtl/rel4/support/setbits.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/setbitn-proofs.lisp
-
-
-rtl/rel4/support/setbitn.cert : acl2x = 0
-rtl/rel4/support/setbitn.cert : no_pcert = 0
-
-rtl/rel4/support/setbitn.cert : \
- rtl/rel4/support/cat-def.cert \
- rtl/rel4/support/setbitn-proofs.cert \
- rtl/rel4/support/setbitn.lisp
-
-
-rtl/rel4/support/setbits-proofs.cert : acl2x = 0
-rtl/rel4/support/setbits-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/setbits-proofs.cert : \
- rtl/rel4/support/cat-def.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/setbits-proofs.lisp
-
-
-rtl/rel4/support/setbits.cert : acl2x = 0
-rtl/rel4/support/setbits.cert : no_pcert = 0
-
-rtl/rel4/support/setbits.cert : \
- rtl/rel4/support/cat-def.cert \
- rtl/rel4/support/setbits-proofs.cert \
- rtl/rel4/support/setbits.lisp
-
-
-rtl/rel4/support/sgn.cert : acl2x = 0
-rtl/rel4/support/sgn.cert : no_pcert = 0
-
-rtl/rel4/support/sgn.cert : \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/sgn.lisp
-
-
-rtl/rel4/support/shft.cert : acl2x = 0
-rtl/rel4/support/shft.cert : no_pcert = 0
-
-rtl/rel4/support/shft.cert : \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/shft.lisp
-
-
-rtl/rel4/support/simple-loop-helpers.cert : acl2x = 0
-rtl/rel4/support/simple-loop-helpers.cert : no_pcert = 0
-
-rtl/rel4/support/simple-loop-helpers.cert : \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/setbitn.cert \
- rtl/rel4/support/simple-loop-helpers.lisp
-
-
-rtl/rel4/support/simplify-model-helpers.cert : acl2x = 0
-rtl/rel4/support/simplify-model-helpers.cert : no_pcert = 0
-
-rtl/rel4/support/simplify-model-helpers.cert : \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/simplify-model-helpers.lisp
-
-
-rtl/rel4/support/stick-proofs.cert : acl2x = 0
-rtl/rel4/support/stick-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/stick-proofs.cert : \
- rtl/rel4/support/merge.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/lnot.cert \
- rtl/rel4/support/stick-proofs.lisp
-
-
-rtl/rel4/support/stick.cert : acl2x = 0
-rtl/rel4/support/stick.cert : no_pcert = 0
-
-rtl/rel4/support/stick.cert : \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/stick-proofs.cert \
- rtl/rel4/support/stick.lisp
-
-
-rtl/rel4/support/sticky-proofs.cert : acl2x = 0
-rtl/rel4/support/sticky-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/sticky-proofs.cert : \
- rtl/rel4/arithmetic/arith.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/away.cert \
- rtl/rel4/support/near.cert \
- rtl/rel4/support/near+.cert \
- rtl/rel4/support/sticky-proofs.lisp
-
-
-rtl/rel4/support/sticky.cert : acl2x = 0
-rtl/rel4/support/sticky.cert : no_pcert = 0
-
-rtl/rel4/support/sticky.cert : \
- rtl/rel4/support/sticky-proofs.cert \
- rtl/rel4/support/sticky.lisp
-
-
-rtl/rel4/support/sumbits.cert : acl2x = 0
-rtl/rel4/support/sumbits.cert : no_pcert = 0
-
-rtl/rel4/support/sumbits.cert : \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/sumbits.lisp
-
-
-rtl/rel4/support/top.cert : acl2x = 0
-rtl/rel4/support/top.cert : no_pcert = 0
-
-rtl/rel4/support/top.cert : \
- rtl/rel4/support/top1.cert \
- rtl/rel4/support/bits-extra.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/support/top.lisp
-
-
-rtl/rel4/support/top1.cert : acl2x = 0
-rtl/rel4/support/top1.cert : no_pcert = 0
-
-rtl/rel4/support/top1.cert : \
- rtl/rel4/support/util.cert \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/rewrite-theory.cert \
- rtl/rel4/support/rtl.cert \
- rtl/rel4/support/rtlarr.cert \
- rtl/rel4/support/bvecp-lemmas.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/ocat.cert \
- rtl/rel4/support/cat-def.cert \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/support/ash.cert \
- rtl/rel4/support/decode.cert \
- rtl/rel4/support/encode.cert \
- rtl/rel4/support/mulcat.cert \
- rtl/rel4/support/shft.cert \
- rtl/rel4/support/all-ones.cert \
- rtl/rel4/support/merge2.cert \
- rtl/rel4/support/logior1.cert \
- rtl/rel4/support/setbits.cert \
- rtl/rel4/support/setbitn.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/support/bias.cert \
- rtl/rel4/support/ereps.cert \
- rtl/rel4/support/ireps.cert \
- rtl/rel4/support/logeqv.cert \
- rtl/rel4/support/logorc1.cert \
- rtl/rel4/support/lognot.cert \
- rtl/rel4/support/logand.cert \
- rtl/rel4/support/logior.cert \
- rtl/rel4/support/logxor.cert \
- rtl/rel4/support/log.cert \
- rtl/rel4/support/lnot.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/support/lextra.cert \
- rtl/rel4/support/logs.cert \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/support/away.cert \
- rtl/rel4/support/near.cert \
- rtl/rel4/support/near+.cert \
- rtl/rel4/support/oddr.cert \
- rtl/rel4/support/sticky.cert \
- rtl/rel4/support/rnd.cert \
- rtl/rel4/support/drnd.cert \
- rtl/rel4/support/bits-trunc.cert \
- rtl/rel4/support/add3.cert \
- rtl/rel4/support/lop1.cert \
- rtl/rel4/support/lop2.cert \
- rtl/rel4/support/lop3.cert \
- rtl/rel4/support/stick.cert \
- rtl/rel4/support/bvecp-helpers.cert \
- rtl/rel4/support/model-helpers.cert \
- rtl/rel4/support/rom-helpers.cert \
- rtl/rel4/support/simple-loop-helpers.cert \
- rtl/rel4/support/clocks.cert \
- rtl/rel4/support/openers.cert \
- rtl/rel4/support/package-defs.cert \
- rtl/rel4/support/simplify-model-helpers.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/arithmetic/fp.cert \
- rtl/rel4/support/fadd.cert \
- rtl/rel4/support/top1.lisp
-
-
-rtl/rel4/support/trunc-proofs.cert : acl2x = 0
-rtl/rel4/support/trunc-proofs.cert : no_pcert = 0
-
-rtl/rel4/support/trunc-proofs.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/float.cert \
- rtl/rel4/arithmetic/top.cert \
- rtl/rel4/support/trunc-proofs.lisp
-
-
-rtl/rel4/support/trunc.cert : acl2x = 0
-rtl/rel4/support/trunc.cert : no_pcert = 0
-
-rtl/rel4/support/trunc.cert : \
- rtl/rel4/support/ground-zero.cert \
- rtl/rel4/support/trunc-proofs.cert \
- rtl/rel4/support/trunc.lisp
-
-
-rtl/rel4/support/util.cert : acl2x = 0
-rtl/rel4/support/util.cert : no_pcert = 0
-
-rtl/rel4/support/util.cert : \
- rtl/rel4/support/util.lisp
-
-
-rtl/rel4/user/away.cert : acl2x = 0
-rtl/rel4/user/away.cert : no_pcert = 0
-
-rtl/rel4/user/away.cert : \
- rtl/rel4/user/trunc.cert \
- rtl/rel4/support/away.cert \
- rtl/rel4/user/away.lisp
-
-
-rtl/rel4/user/bias.cert : acl2x = 0
-rtl/rel4/user/bias.cert : no_pcert = 0
-
-rtl/rel4/user/bias.cert : \
- rtl/rel4/support/bias.cert \
- rtl/rel4/user/bias.lisp
-
-
-rtl/rel4/user/bitn.cert : acl2x = 0
-rtl/rel4/user/bitn.cert : no_pcert = 0
-
-rtl/rel4/user/bitn.cert : \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/support/bitn.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/user/bitn.lisp
-
-
-rtl/rel4/user/bits-trunc.cert : acl2x = 0
-rtl/rel4/user/bits-trunc.cert : no_pcert = 0
-
-rtl/rel4/user/bits-trunc.cert : \
- rtl/rel4/user/land.cert \
- rtl/rel4/support/bits-trunc.cert \
- rtl/rel4/user/bits-trunc.lisp
-
-
-rtl/rel4/user/bits.cert : acl2x = 0
-rtl/rel4/user/bits.cert : no_pcert = 0
-
-rtl/rel4/user/bits.cert : \
- rtl/rel4/arithmetic/negative-syntaxp.cert \
- rtl/rel4/arithmetic/power2p.cert \
- rtl/rel4/support/bits.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/user/bits.lisp
-
-
-rtl/rel4/user/brat.cert : acl2x = 0
-rtl/rel4/user/brat.cert : no_pcert = 0
-
-rtl/rel4/user/brat.cert : \
- rtl/rel4/arithmetic/fl.cert \
- rtl/rel4/user/brat.lisp
-
-
-rtl/rel4/user/bvecp.cert : acl2x = 0
-rtl/rel4/user/bvecp.cert : no_pcert = 0
-
-rtl/rel4/user/bvecp.cert : \
- rtl/rel4/support/bvecp.cert \
- rtl/rel4/user/bvecp.lisp
-
-
-rtl/rel4/user/cat.cert : acl2x = 0
-rtl/rel4/user/cat.cert : no_pcert = 0
-
-rtl/rel4/user/cat.cert : \
- rtl/rel4/support/cat.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/user/cat.lisp
-
-
-rtl/rel4/user/decode.cert : acl2x = 0
-rtl/rel4/user/decode.cert : no_pcert = 0
-
-rtl/rel4/user/decode.cert : \
- rtl/rel4/support/decode.cert \
- rtl/rel4/user/decode.lisp
-
-
-rtl/rel4/user/ereps.cert : acl2x = 0
-rtl/rel4/user/ereps.cert : no_pcert = 0
-
-rtl/rel4/user/ereps.cert : \
- rtl/rel4/support/ereps.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/user/ereps.lisp
-
-
-rtl/rel4/user/land.cert : acl2x = 0
-rtl/rel4/user/land.cert : no_pcert = 0
-
-rtl/rel4/user/land.cert : \
- rtl/rel4/support/guards.cert \
- rtl/rel4/support/land.cert \
- rtl/rel4/user/land.lisp
-
-
-rtl/rel4/user/lextra.cert : acl2x = 0
-rtl/rel4/user/lextra.cert : no_pcert = 0
-
-rtl/rel4/user/lextra.cert : \
- rtl/rel4/user/land.cert \
- rtl/rel4/user/lior.cert \
- rtl/rel4/user/lxor.cert \
- rtl/rel4/support/lextra.cert \
- rtl/rel4/user/lextra.lisp
-
-
-rtl/rel4/user/lior.cert : acl2x = 0
-rtl/rel4/user/lior.cert : no_pcert = 0
-
-rtl/rel4/user/lior.cert : \
- rtl/rel4/support/lior.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/user/lior.lisp
-
-
-rtl/rel4/user/lnot.cert : acl2x = 0
-rtl/rel4/user/lnot.cert : no_pcert = 0
-
-rtl/rel4/user/lnot.cert : \
- rtl/rel4/support/guards.cert \
- rtl/rel4/support/lnot.cert \
- rtl/rel4/user/lnot.lisp
-
-
-rtl/rel4/user/logior1.cert : acl2x = 0
-rtl/rel4/user/logior1.cert : no_pcert = 0
-
-rtl/rel4/user/logior1.cert : \
- rtl/rel4/support/logior1.cert \
- rtl/rel4/user/logior1.lisp
-
-
-rtl/rel4/user/lxor.cert : acl2x = 0
-rtl/rel4/user/lxor.cert : no_pcert = 0
-
-rtl/rel4/user/lxor.cert : \
- rtl/rel4/support/guards.cert \
- rtl/rel4/support/lxor.cert \
- rtl/rel4/user/lxor.lisp
-
-
-rtl/rel4/user/mulcat.cert : acl2x = 0
-rtl/rel4/user/mulcat.cert : no_pcert = 0
-
-rtl/rel4/user/mulcat.cert : \
- rtl/rel4/support/mulcat.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/user/mulcat.lisp
-
-
-rtl/rel4/user/near.cert : acl2x = 0
-rtl/rel4/user/near.cert : no_pcert = 0
-
-rtl/rel4/user/near.cert : \
- rtl/rel4/support/near.cert \
- rtl/rel4/user/near.lisp
-
-
-rtl/rel4/user/setbitn.cert : acl2x = 0
-rtl/rel4/user/setbitn.cert : no_pcert = 0
-
-rtl/rel4/user/setbitn.cert : \
- rtl/rel4/support/setbitn.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/user/setbitn.lisp
-
-
-rtl/rel4/user/setbits.cert : acl2x = 0
-rtl/rel4/user/setbits.cert : no_pcert = 0
-
-rtl/rel4/user/setbits.cert : \
- rtl/rel4/support/setbits.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/user/setbits.lisp
-
-
-rtl/rel4/user/stick.cert : acl2x = 0
-rtl/rel4/user/stick.cert : no_pcert = 0
-
-rtl/rel4/user/stick.cert : \
- rtl/rel4/user/land.cert \
- rtl/rel4/user/lior.cert \
- rtl/rel4/user/lxor.cert \
- rtl/rel4/user/lnot.cert \
- rtl/rel4/support/stick.cert \
- rtl/rel4/user/stick.lisp
-
-
-rtl/rel4/user/sumbits.cert : acl2x = 0
-rtl/rel4/user/sumbits.cert : no_pcert = 0
-
-rtl/rel4/user/sumbits.cert : \
- rtl/rel4/support/sumbits.cert \
- rtl/rel4/support/guards.cert \
- rtl/rel4/user/sumbits.lisp
-
-
-rtl/rel4/user/top.cert : acl2x = 0
-rtl/rel4/user/top.cert : no_pcert = 0
-
-rtl/rel4/user/top.cert : \
- rtl/rel4/user/bits.cert \
- rtl/rel4/user/bitn.cert \
- rtl/rel4/user/cat.cert \
- rtl/rel4/user/bvecp.cert \
- rtl/rel4/user/mulcat.cert \
- rtl/rel4/user/logior1.cert \
- rtl/rel4/user/setbits.cert \
- rtl/rel4/user/setbitn.cert \
- rtl/rel4/user/bias.cert \
- rtl/rel4/user/ereps.cert \
- rtl/rel4/user/lnot.cert \
- rtl/rel4/user/land.cert \
- rtl/rel4/user/lior.cert \
- rtl/rel4/user/lxor.cert \
- rtl/rel4/user/lextra.cert \
- rtl/rel4/user/trunc.cert \
- rtl/rel4/user/away.cert \
- rtl/rel4/user/near.cert \
- rtl/rel4/user/bits-trunc.cert \
- rtl/rel4/user/stick.cert \
- rtl/rel4/user/sumbits.cert \
- rtl/rel4/user/top.lisp
-
-
-rtl/rel4/user/trunc.cert : acl2x = 0
-rtl/rel4/user/trunc.cert : no_pcert = 0
-
-rtl/rel4/user/trunc.cert : \
- rtl/rel4/support/trunc.cert \
- rtl/rel4/user/trunc.lisp
-
-
-rtl/rel5/arithmetic/arith.cert : acl2x = 0
-rtl/rel5/arithmetic/arith.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/arith.cert : \
- rtl/rel5/arithmetic/arith2.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- meta/meta-times-equal.cert \
- rtl/rel5/arithmetic/arith.lisp
-
-
-rtl/rel5/arithmetic/arith2.cert : acl2x = 0
-rtl/rel5/arithmetic/arith2.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/arith2.cert : \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/product.cert \
- meta/meta-times-equal.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel5/arithmetic/inverted-factor.cert \
- rtl/rel5/arithmetic/arith2.lisp
-
-
-rtl/rel5/arithmetic/basic.cert : acl2x = 0
-rtl/rel5/arithmetic/basic.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/basic.cert : \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/even-odd.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/expt.cert \
- rtl/rel5/arithmetic/basic.lisp
-
-
-rtl/rel5/arithmetic/cg.cert : acl2x = 0
-rtl/rel5/arithmetic/cg.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/cg.cert : \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/arithmetic/common-factor.cert \
- rtl/rel5/arithmetic/cg.lisp
-
-
-rtl/rel5/arithmetic/common-factor-defuns.cert : acl2x = 0
-rtl/rel5/arithmetic/common-factor-defuns.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/common-factor-defuns.cert : \
- rtl/rel5/arithmetic/inverted-factor.cert \
- rtl/rel5/arithmetic/common-factor-defuns.lisp
-
-
-rtl/rel5/arithmetic/common-factor.cert : acl2x = 0
-rtl/rel5/arithmetic/common-factor.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/common-factor.cert : \
- meta/meta-times-equal.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel5/arithmetic/common-factor-defuns.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/product.cert \
- rtl/rel5/arithmetic/common-factor.lisp
-
-
-rtl/rel5/arithmetic/complex-rationalp.cert : acl2x = 0
-rtl/rel5/arithmetic/complex-rationalp.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/complex-rationalp.cert : \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/complex-rationalp.lisp
-
-
-rtl/rel5/arithmetic/denominator.cert : acl2x = 0
-rtl/rel5/arithmetic/denominator.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/denominator.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/fp2.cert \
- arithmetic/mod-gcd.cert \
- rtl/rel5/arithmetic/denominator.lisp
-
-
-rtl/rel5/arithmetic/even-odd.cert : acl2x = 0
-rtl/rel5/arithmetic/even-odd.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/even-odd.cert : \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/even-odd.lisp
-
-
-rtl/rel5/arithmetic/even-odd2-proofs.cert : acl2x = 0
-rtl/rel5/arithmetic/even-odd2-proofs.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/even-odd2-proofs.cert : \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/arith.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/even-odd2-proofs.lisp
-
-
-rtl/rel5/arithmetic/even-odd2.cert : acl2x = 0
-rtl/rel5/arithmetic/even-odd2.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/even-odd2.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/even-odd2-proofs.cert \
- rtl/rel5/arithmetic/even-odd2.lisp
-
-
-rtl/rel5/arithmetic/expo-proofs.cert : acl2x = 0
-rtl/rel5/arithmetic/expo-proofs.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/expo-proofs.cert : \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/arithmetic/unary-divide.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/expt.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel5/arithmetic/common-factor-defuns.cert \
- rtl/rel5/arithmetic/common-factor.cert \
- rtl/rel5/arithmetic/expo-proofs.lisp
-
-
-rtl/rel5/arithmetic/expo.cert : acl2x = 0
-rtl/rel5/arithmetic/expo.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/expo.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/arithmetic/expo-proofs.cert \
- rtl/rel5/arithmetic/common-factor-defuns.cert \
- rtl/rel5/arithmetic/expo.lisp
-
-
-rtl/rel5/arithmetic/expt-proofs.cert : acl2x = 0
-rtl/rel5/arithmetic/expt-proofs.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/expt-proofs.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/numerator.cert \
- rtl/rel5/arithmetic/denominator.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/arith2.cert \
- arithmetic/top.cert \
- rtl/rel5/arithmetic/even-odd.cert \
- rtl/rel5/arithmetic/expt-proofs.lisp
-
-
-rtl/rel5/arithmetic/expt.cert : acl2x = 0
-rtl/rel5/arithmetic/expt.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/expt.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/expt-proofs.cert \
- rtl/rel5/arithmetic/expt.lisp
-
-
-rtl/rel5/arithmetic/extra-rules.cert : acl2x = 0
-rtl/rel5/arithmetic/extra-rules.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/extra-rules.cert : \
- rtl/rel5/arithmetic/basic.cert \
- rtl/rel5/arithmetic/extra-rules.lisp
-
-
-rtl/rel5/arithmetic/fl-expt.cert : acl2x = 0
-rtl/rel5/arithmetic/fl-expt.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/fl-expt.cert : \
- rtl/rel5/arithmetic/numerator.cert \
- rtl/rel5/arithmetic/denominator.cert \
- rtl/rel5/arithmetic/nniq.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/floor.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/rationalp.cert \
- rtl/rel5/arithmetic/unary-divide.cert \
- rtl/rel5/arithmetic/expt.cert \
- rtl/rel5/arithmetic/expo.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/fl-expt.lisp
-
-
-rtl/rel5/arithmetic/fl-hacks.cert : acl2x = 0
-rtl/rel5/arithmetic/fl-hacks.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/fl-hacks.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/inverted-factor.cert \
- rtl/rel5/arithmetic/nniq.cert \
- rtl/rel5/arithmetic/numerator.cert \
- rtl/rel5/arithmetic/denominator.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/product.cert \
- rtl/rel5/arithmetic/unary-divide.cert \
- rtl/rel5/arithmetic/rationalp.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/mod.cert \
- rtl/rel5/arithmetic/even-odd.cert \
- meta/meta-plus-equal.cert \
- rtl/rel5/arithmetic/arith.cert \
- rtl/rel5/arithmetic/fl-hacks.lisp
-
-
-rtl/rel5/arithmetic/fl-proofs.cert : acl2x = 0
-rtl/rel5/arithmetic/fl-proofs.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/fl-proofs.cert : \
- rtl/rel5/arithmetic/numerator.cert \
- rtl/rel5/arithmetic/denominator.cert \
- rtl/rel5/arithmetic/nniq.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/floor.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/rationalp.cert \
- rtl/rel5/arithmetic/unary-divide.cert \
- rtl/rel5/arithmetic/common-factor.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/fl-proofs.lisp
-
-
-rtl/rel5/arithmetic/fl.cert : acl2x = 0
-rtl/rel5/arithmetic/fl.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/fl.cert : \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/fl-proofs.cert \
- rtl/rel5/arithmetic/fl.lisp
-
-
-rtl/rel5/arithmetic/floor-proofs.cert : acl2x = 0
-rtl/rel5/arithmetic/floor-proofs.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/floor-proofs.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/denominator.cert \
- rtl/rel5/arithmetic/numerator.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/nniq.cert \
- rtl/rel5/arithmetic/product.cert \
- rtl/rel5/arithmetic/unary-divide.cert \
- rtl/rel5/arithmetic/rationalp.cert \
- rtl/rel5/arithmetic/inverted-factor.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel5/arithmetic/floor-proofs.lisp
-
-
-rtl/rel5/arithmetic/floor.cert : acl2x = 0
-rtl/rel5/arithmetic/floor.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/floor.cert : \
- rtl/rel5/arithmetic/floor-proofs.cert \
- rtl/rel5/arithmetic/floor.lisp
-
-
-rtl/rel5/arithmetic/fp.cert : acl2x = 0
-rtl/rel5/arithmetic/fp.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/fp.cert : \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/fp.lisp
-
-
-rtl/rel5/arithmetic/fp2.cert : acl2x = 0
-rtl/rel5/arithmetic/fp2.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/fp2.cert : \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- ihs/ihs-lemmas.cert \
- arithmetic-2/meta/non-linear.cert \
- rtl/rel5/arithmetic/inverted-factor.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel5/arithmetic/fp2.lisp
-
-
-rtl/rel5/arithmetic/ground-zero.cert : acl2x = 0
-rtl/rel5/arithmetic/ground-zero.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/ground-zero.cert : \
- rtl/rel5/arithmetic/ground-zero.lisp
-
-
-rtl/rel5/arithmetic/hacks.cert : acl2x = 0
-rtl/rel5/arithmetic/hacks.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/hacks.cert : \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/hacks.lisp
-
-
-rtl/rel5/arithmetic/induct.cert : acl2x = 0
-rtl/rel5/arithmetic/induct.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/induct.cert : \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/induct.lisp
-
-
-rtl/rel5/arithmetic/integerp.cert : acl2x = 0
-rtl/rel5/arithmetic/integerp.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/integerp.cert : \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/integerp.lisp
-
-
-rtl/rel5/arithmetic/inverted-factor.cert : acl2x = 0
-rtl/rel5/arithmetic/inverted-factor.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/inverted-factor.cert : \
- rtl/rel5/arithmetic/inverted-factor.lisp
-
-
-rtl/rel5/arithmetic/mod-expt.cert : acl2x = 0
-rtl/rel5/arithmetic/mod-expt.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/mod-expt.cert : \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/arithmetic/numerator.cert \
- rtl/rel5/arithmetic/denominator.cert \
- rtl/rel5/arithmetic/nniq.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/floor.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/rationalp.cert \
- rtl/rel5/arithmetic/unary-divide.cert \
- rtl/rel5/arithmetic/expt.cert \
- rtl/rel5/arithmetic/expo.cert \
- rtl/rel5/arithmetic/fl-expt.cert \
- rtl/rel5/arithmetic/mod.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/mod-expt.lisp
-
-
-rtl/rel5/arithmetic/mod-proofs.cert : acl2x = 0
-rtl/rel5/arithmetic/mod-proofs.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/mod-proofs.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/floor.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/arith.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/product.cert \
- rtl/rel5/arithmetic/complex-rationalp.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/rationalp.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/mod-proofs.lisp
-
-
-rtl/rel5/arithmetic/mod.cert : acl2x = 0
-rtl/rel5/arithmetic/mod.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/mod.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/mod-proofs.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/mod.lisp
-
-
-rtl/rel5/arithmetic/negative-syntaxp.cert : acl2x = 0
-rtl/rel5/arithmetic/negative-syntaxp.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/negative-syntaxp.cert : \
- rtl/rel5/arithmetic/negative-syntaxp.lisp
-
-
-rtl/rel5/arithmetic/nniq.cert : acl2x = 0
-rtl/rel5/arithmetic/nniq.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/nniq.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/denominator.cert \
- rtl/rel5/arithmetic/numerator.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/unary-divide.cert \
- rtl/rel5/arithmetic/product.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/arith.cert \
- arithmetic/rationals.cert \
- arithmetic/idiv.cert \
- arithmetic/idiv.cert \
- arithmetic/top-with-meta.cert \
- rtl/rel5/arithmetic/nniq.lisp
-
-
-rtl/rel5/arithmetic/numerator.cert : acl2x = 0
-rtl/rel5/arithmetic/numerator.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/numerator.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/denominator.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/numerator.lisp
-
-
-rtl/rel5/arithmetic/power2p.cert : acl2x = 0
-rtl/rel5/arithmetic/power2p.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/power2p.cert : \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/unary-divide.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel5/arithmetic/power2p.lisp
-
-
-rtl/rel5/arithmetic/predicate.cert : acl2x = 0
-rtl/rel5/arithmetic/predicate.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/predicate.cert : \
- rtl/rel5/arithmetic/predicate.lisp
-
-
-rtl/rel5/arithmetic/product-proofs.cert : acl2x = 0
-rtl/rel5/arithmetic/product-proofs.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/product-proofs.cert : \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/product-proofs.lisp
-
-
-rtl/rel5/arithmetic/product.cert : acl2x = 0
-rtl/rel5/arithmetic/product.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/product.cert : \
- rtl/rel5/arithmetic/product-proofs.cert \
- rtl/rel5/arithmetic/product.lisp
-
-
-rtl/rel5/arithmetic/rationalp.cert : acl2x = 0
-rtl/rel5/arithmetic/rationalp.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/rationalp.cert : \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/rationalp.lisp
-
-
-rtl/rel5/arithmetic/top.cert : acl2x = 0
-rtl/rel5/arithmetic/top.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/top.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/arithmetic/induct.cert \
- rtl/rel5/arithmetic/denominator.cert \
- rtl/rel5/arithmetic/numerator.cert \
- rtl/rel5/arithmetic/nniq.cert \
- rtl/rel5/arithmetic/complex-rationalp.cert \
- rtl/rel5/arithmetic/rationalp.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/arithmetic/arith.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/basic.cert \
- rtl/rel5/arithmetic/unary-divide.cert \
- rtl/rel5/arithmetic/product.cert \
- rtl/rel5/arithmetic/inverted-factor.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/x-2xx.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/arithmetic/expt.cert \
- rtl/rel5/arithmetic/expo.cert \
- rtl/rel5/arithmetic/fl-hacks.cert \
- rtl/rel5/arithmetic/even-odd2.cert \
- rtl/rel5/arithmetic/even-odd.cert \
- rtl/rel5/arithmetic/floor.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/cg.cert \
- rtl/rel5/arithmetic/mod.cert \
- rtl/rel5/arithmetic/fl-expt.cert \
- rtl/rel5/arithmetic/mod-expt.cert \
- rtl/rel5/arithmetic/common-factor.cert \
- rtl/rel5/arithmetic/top.lisp
-
-
-rtl/rel5/arithmetic/unary-divide.cert : acl2x = 0
-rtl/rel5/arithmetic/unary-divide.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/unary-divide.cert : \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/inverted-factor.cert \
- rtl/rel5/arithmetic/unary-divide.lisp
-
-
-rtl/rel5/arithmetic/x-2xx.cert : acl2x = 0
-rtl/rel5/arithmetic/x-2xx.cert : no_pcert = 0
-
-rtl/rel5/arithmetic/x-2xx.cert : \
- arithmetic/top-with-meta.cert \
- arithmetic/mod-gcd.cert \
- rtl/rel5/arithmetic/x-2xx.lisp
-
-
-rtl/rel5/lib/add.cert : acl2x = 0
-rtl/rel5/lib/add.cert : no_pcert = 0
-
-rtl/rel5/lib/add.cert : \
- rtl/rel5/support/top.cert \
- rtl/rel5/lib/round.cert \
- rtl/rel5/lib/add.lisp
-
-
-rtl/rel5/lib/arith.cert : acl2x = 0
-rtl/rel5/lib/arith.cert : no_pcert = 0
-
-rtl/rel5/lib/arith.cert : \
- rtl/rel5/arithmetic/fp.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/expt.cert \
- rtl/rel5/arithmetic/expo.cert \
- rtl/rel5/arithmetic/extra-rules.cert \
- rtl/rel5/support/ash.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel5/lib/arith.lisp
-
-
-rtl/rel5/lib/basic.cert : acl2x = 0
-rtl/rel5/lib/basic.cert : no_pcert = 0
-
-rtl/rel5/lib/basic.cert : \
- rtl/rel5/support/top.cert \
- rtl/rel5/lib/basic.lisp
-
-
-rtl/rel5/lib/bits.cert : acl2x = 0
-rtl/rel5/lib/bits.cert : no_pcert = 0
-
-rtl/rel5/lib/bits.cert : \
- rtl/rel5/lib/basic.cert \
- rtl/rel5/support/top.cert \
- rtl/rel5/lib/bits.lisp
-
-
-rtl/rel5/lib/bvecp-helpers.cert : acl2x = 0
-rtl/rel5/lib/bvecp-helpers.cert : no_pcert = 0
-
-rtl/rel5/lib/bvecp-helpers.cert : \
- rtl/rel5/lib/rtl.cert \
- rtl/rel5/lib/rtlarr.cert \
- rtl/rel5/support/bvecp-helpers.cert \
- rtl/rel5/arithmetic/basic.cert \
- rtl/rel5/lib/bvecp-helpers.lisp
-
-
-rtl/rel5/lib/bvecp-raw-helpers.cert : acl2x = 0
-rtl/rel5/lib/bvecp-raw-helpers.cert : no_pcert = 0
-
-rtl/rel5/lib/bvecp-raw-helpers.cert : \
- rtl/rel5/lib/rtl.cert \
- rtl/rel5/lib/rtlarr.cert \
- rtl/rel5/support/bvecp-helpers.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/setbits.cert \
- rtl/rel5/support/setbitn.cert \
- rtl/rel5/support/logs.cert \
- rtl/rel5/support/lnot.cert \
- rtl/rel5/support/shft.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/mulcat.cert \
- rtl/rel5/support/encode.cert \
- rtl/rel5/support/decode.cert \
- rtl/rel5/support/land.cert \
- rtl/rel5/support/lior.cert \
- rtl/rel5/support/lxor.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/arithmetic/expo.cert \
- rtl/rel5/arithmetic/basic.cert \
- rtl/rel5/lib/bvecp-raw-helpers.lisp
-
-
-rtl/rel5/lib/clocks.cert : acl2x = 0
-rtl/rel5/lib/clocks.cert : no_pcert = 0
-
-rtl/rel5/lib/clocks.cert : \
- rtl/rel5/support/clocks.cert \
- rtl/rel5/lib/clocks.lisp
-
-
-rtl/rel5/lib/float.cert : acl2x = 0
-rtl/rel5/lib/float.cert : no_pcert = 0
-
-rtl/rel5/lib/float.cert : \
- rtl/rel5/support/top.cert \
- rtl/rel5/lib/log.cert \
- rtl/rel5/lib/float.lisp
-
-
-rtl/rel5/lib/log.cert : acl2x = 0
-rtl/rel5/lib/log.cert : no_pcert = 0
-
-rtl/rel5/lib/log.cert : \
- rtl/rel5/lib/bits.cert \
- rtl/rel5/support/top.cert \
- rtl/rel5/lib/log.lisp
-
-
-rtl/rel5/lib/openers.cert : acl2x = 0
-rtl/rel5/lib/openers.cert : no_pcert = 0
-
-rtl/rel5/lib/openers.cert : \
- rtl/rel5/support/openers.cert \
- rtl/rel5/lib/openers.lisp
-
-
-rtl/rel5/lib/package-defs.cert : acl2x = 0
-rtl/rel5/lib/package-defs.cert : no_pcert = 0
-
-rtl/rel5/lib/package-defs.cert : \
- rtl/rel5/support/package-defs.cert \
- rtl/rel5/lib/package-defs.lisp
-
-
-rtl/rel5/lib/reps.cert : acl2x = 0
-rtl/rel5/lib/reps.cert : no_pcert = 0
-
-rtl/rel5/lib/reps.cert : \
- rtl/rel5/support/ereps.cert \
- rtl/rel5/support/ireps.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/lib/log.cert \
- rtl/rel5/lib/float.cert \
- rtl/rel5/lib/reps.lisp
-
-
-rtl/rel5/lib/rom-helpers.cert : acl2x = 0
-rtl/rel5/lib/rom-helpers.cert : no_pcert = 0
-
-rtl/rel5/lib/rom-helpers.cert : \
- rtl/rel5/support/rom-helpers.cert \
- rtl/rel5/lib/rom-helpers.lisp
-
-
-rtl/rel5/lib/round.cert : acl2x = 0
-rtl/rel5/lib/round.cert : no_pcert = 0
-
-rtl/rel5/lib/round.cert : \
- rtl/rel5/support/top.cert \
- rtl/rel5/lib/reps.cert \
- rtl/rel5/lib/round.lisp
-
-
-rtl/rel5/lib/rtl.cert : acl2x = 0
-rtl/rel5/lib/rtl.cert : no_pcert = 0
-
-rtl/rel5/lib/rtl.cert : \
- rtl/rel5/support/top.cert \
- rtl/rel5/lib/rtl.lisp
-
-
-rtl/rel5/lib/rtlarr.cert : acl2x = 0
-rtl/rel5/lib/rtlarr.cert : no_pcert = 0
-
-rtl/rel5/lib/rtlarr.cert : \
- rtl/rel5/support/rtlarr.cert \
- rtl/rel5/support/bvecp-helpers.cert \
- rtl/rel5/support/guards.cert \
- misc/total-order.cert \
- rtl/rel5/lib/rtl.cert \
- rtl/rel5/lib/rtlarr.lisp
-
-
-rtl/rel5/lib/simple-loop-helpers.cert : acl2x = 0
-rtl/rel5/lib/simple-loop-helpers.cert : no_pcert = 0
-
-rtl/rel5/lib/simple-loop-helpers.cert : \
- rtl/rel5/lib/rtl.cert \
- rtl/rel5/lib/rtlarr.cert \
- rtl/rel5/lib/arith.cert \
- rtl/rel5/lib/log.cert \
- rtl/rel5/support/simple-loop-helpers.cert \
- rtl/rel5/lib/simple-loop-helpers.lisp
-
-
-rtl/rel5/lib/simplify-model-helpers.cert : acl2x = 0
-rtl/rel5/lib/simplify-model-helpers.cert : no_pcert = 0
-
-rtl/rel5/lib/simplify-model-helpers.cert : \
- rtl/rel5/lib/rtl.cert \
- rtl/rel5/lib/arith.cert \
- rtl/rel5/lib/bits.cert \
- rtl/rel5/support/simplify-model-helpers.cert \
- rtl/rel5/lib/simplify-model-helpers.lisp
-
-
-rtl/rel5/lib/top.cert : acl2x = 0
-rtl/rel5/lib/top.cert : no_pcert = 0
-
-rtl/rel5/lib/top.cert : \
- rtl/rel5/lib/rtl.cert \
- rtl/rel5/lib/rtlarr.cert \
- rtl/rel5/lib/basic.cert \
- rtl/rel5/lib/bits.cert \
- rtl/rel5/lib/log.cert \
- rtl/rel5/lib/float.cert \
- rtl/rel5/lib/reps.cert \
- rtl/rel5/lib/round.cert \
- rtl/rel5/lib/add.cert \
- rtl/rel5/lib/arith.cert \
- rtl/rel5/lib/util.cert \
- rtl/rel5/lib/top.lisp
-
-
-rtl/rel5/lib/util.cert : acl2x = 0
-rtl/rel5/lib/util.cert : no_pcert = 0
-
-rtl/rel5/lib/util.cert : \
- rtl/rel5/support/util.cert \
- rtl/rel5/lib/util.lisp
-
-
-rtl/rel5/support/add3-proofs.cert : acl2x = 0
-rtl/rel5/support/add3-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/add3-proofs.cert : \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/arithmetic/top.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/support/add3-proofs.lisp
-
-
-rtl/rel5/support/add3.cert : acl2x = 0
-rtl/rel5/support/add3.cert : no_pcert = 0
-
-rtl/rel5/support/add3.cert : \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/add3-proofs.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/support/add3.lisp
-
-
-rtl/rel5/support/all-ones.cert : acl2x = 0
-rtl/rel5/support/all-ones.cert : no_pcert = 0
-
-rtl/rel5/support/all-ones.cert : \
- rtl/rel5/support/all-ones.lisp
-
-
-rtl/rel5/support/ash.cert : acl2x = 0
-rtl/rel5/support/ash.cert : no_pcert = 0
-
-rtl/rel5/support/ash.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/expt.cert \
- rtl/rel5/arithmetic/expo.cert \
- rtl/rel5/support/ash.lisp
-
-
-rtl/rel5/support/away-proofs.cert : acl2x = 0
-rtl/rel5/support/away-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/away-proofs.cert : \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/away-proofs.lisp
-
-
-rtl/rel5/support/away.cert : acl2x = 0
-rtl/rel5/support/away.cert : no_pcert = 0
-
-rtl/rel5/support/away.cert : \
- rtl/rel5/support/away-proofs.cert \
- rtl/rel5/support/away.lisp
-
-
-rtl/rel5/support/badguys.cert : acl2x = 0
-rtl/rel5/support/badguys.cert : no_pcert = 0
-
-rtl/rel5/support/badguys.cert : \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/badguys.lisp
-
-
-rtl/rel5/support/bias-proofs.cert : acl2x = 0
-rtl/rel5/support/bias-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/bias-proofs.cert : \
- rtl/rel5/arithmetic/expt.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/support/bias-proofs.lisp
-
-
-rtl/rel5/support/bias.cert : acl2x = 0
-rtl/rel5/support/bias.cert : no_pcert = 0
-
-rtl/rel5/support/bias.cert : \
- rtl/rel5/support/bias-proofs.cert \
- rtl/rel5/support/bias.lisp
-
-
-rtl/rel5/support/bitn-proofs.cert : acl2x = 0
-rtl/rel5/support/bitn-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/bitn-proofs.cert : \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/bitn-proofs.lisp
-
-
-rtl/rel5/support/bitn.cert : acl2x = 0
-rtl/rel5/support/bitn.cert : no_pcert = 0
-
-rtl/rel5/support/bitn.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/support/bitn-proofs.cert \
- rtl/rel5/support/bitn.lisp
-
-
-rtl/rel5/support/bits-proofs.cert : acl2x = 0
-rtl/rel5/support/bits-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/bits-proofs.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/bits-proofs.lisp
-
-
-rtl/rel5/support/bits-trunc-proofs.cert : acl2x = 0
-rtl/rel5/support/bits-trunc-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/bits-trunc-proofs.cert : \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/support/log.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/bits-trunc-proofs.lisp
-
-
-rtl/rel5/support/bits-trunc.cert : acl2x = 0
-rtl/rel5/support/bits-trunc.cert : no_pcert = 0
-
-rtl/rel5/support/bits-trunc.cert : \
- rtl/rel5/support/log.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/bits-trunc-proofs.cert \
- rtl/rel5/support/bits-trunc.lisp
-
-
-rtl/rel5/support/bits.cert : acl2x = 0
-rtl/rel5/support/bits.cert : no_pcert = 0
-
-rtl/rel5/support/bits.cert : \
- rtl/rel5/support/bits-proofs.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/support/bits.lisp
-
-
-rtl/rel5/support/bvecp-helpers.cert : acl2x = 0
-rtl/rel5/support/bvecp-helpers.cert : no_pcert = 0
-
-rtl/rel5/support/bvecp-helpers.cert : \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/bvecp-lemmas.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bvecp-helpers.lisp
-
-
-rtl/rel5/support/bvecp-lemmas.cert : acl2x = 0
-rtl/rel5/support/bvecp-lemmas.cert : no_pcert = 0
-
-rtl/rel5/support/bvecp-lemmas.cert : \
- rtl/rel5/arithmetic/expo.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/setbits.cert \
- rtl/rel5/support/setbitn.cert \
- rtl/rel5/support/encode.cert \
- rtl/rel5/support/decode.cert \
- rtl/rel5/support/logs.cert \
- rtl/rel5/support/lnot.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/shft.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/logand.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/mulcat.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/bvecp-lemmas.lisp
-
-
-rtl/rel5/support/bvecp-proofs.cert : acl2x = 0
-rtl/rel5/support/bvecp-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/bvecp-proofs.cert : \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bvecp-proofs.lisp
-
-
-rtl/rel5/support/bvecp.cert : acl2x = 0
-rtl/rel5/support/bvecp.cert : no_pcert = 0
-
-rtl/rel5/support/bvecp.cert : \
- rtl/rel5/support/bvecp-proofs.cert \
- rtl/rel5/support/bvecp.lisp
-
-
-rtl/rel5/support/cat-def.cert : acl2x = 0
-rtl/rel5/support/cat-def.cert : no_pcert = 0
-
-rtl/rel5/support/cat-def.cert : \
- rtl/rel5/support/cat-def.lisp
-
-
-rtl/rel5/support/cat-proofs.cert : acl2x = 0
-rtl/rel5/support/cat-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/cat-proofs.cert : \
- rtl/rel5/support/cat-def.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/cat-proofs.lisp
-
-
-rtl/rel5/support/cat.cert : acl2x = 0
-rtl/rel5/support/cat.cert : no_pcert = 0
-
-rtl/rel5/support/cat.cert : \
- rtl/rel5/support/cat-def.cert \
- rtl/rel5/support/cat-proofs.cert \
- rtl/rel5/support/cat.lisp
-
-
-rtl/rel5/support/clocks.cert : acl2x = 0
-rtl/rel5/support/clocks.cert : no_pcert = 0
-
-rtl/rel5/support/clocks.cert : \
- rtl/rel5/support/mod4.cert \
- rtl/rel5/arithmetic/even-odd2.cert \
- rtl/rel5/support/clocks.lisp
-
-
-rtl/rel5/support/decode-proofs.cert : acl2x = 0
-rtl/rel5/support/decode-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/decode-proofs.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/support/ash.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/decode-proofs.lisp
-
-
-rtl/rel5/support/decode.cert : acl2x = 0
-rtl/rel5/support/decode.cert : no_pcert = 0
-
-rtl/rel5/support/decode.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/decode-proofs.cert \
- rtl/rel5/support/decode.lisp
-
-
-rtl/rel5/support/drnd.cert : acl2x = 0
-rtl/rel5/support/drnd.cert : no_pcert = 0
-
-rtl/rel5/support/drnd.cert : \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/ireps.cert \
- rtl/rel5/support/rnd.cert \
- rtl/rel5/support/bias.cert \
- rtl/rel5/support/sgn.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/support/away.cert \
- rtl/rel5/support/near.cert \
- rtl/rel5/support/near+.cert \
- rtl/rel5/support/sticky.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/drnd.lisp
-
-
-rtl/rel5/support/encode.cert : acl2x = 0
-rtl/rel5/support/encode.cert : no_pcert = 0
-
-rtl/rel5/support/encode.cert : \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/ash.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/encode.lisp
-
-
-rtl/rel5/support/ereps-proofs.cert : acl2x = 0
-rtl/rel5/support/ereps-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/ereps-proofs.cert : \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/bias.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/mulcat.cert \
- rtl/rel5/support/ereps-proofs.lisp
-
-
-rtl/rel5/support/ereps.cert : acl2x = 0
-rtl/rel5/support/ereps.cert : no_pcert = 0
-
-rtl/rel5/support/ereps.cert : \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/ereps-proofs.cert \
- rtl/rel5/support/ereps.lisp
-
-
-rtl/rel5/support/fadd-extra.cert : acl2x = 0
-rtl/rel5/support/fadd-extra.cert : no_pcert = 0
-
-rtl/rel5/support/fadd-extra.cert : \
- rtl/rel5/support/fadd-extra0.cert \
- rtl/rel5/support/land.cert \
- rtl/rel5/support/lior.cert \
- rtl/rel5/support/lxor.cert \
- rtl/rel5/support/top1.cert \
- rtl/rel5/support/fadd-extra.lisp
-
-
-rtl/rel5/support/fadd-extra0.cert : acl2x = 0
-rtl/rel5/support/fadd-extra0.cert : no_pcert = 0
-
-rtl/rel5/support/fadd-extra0.cert : \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/fadd.cert \
- rtl/rel5/support/top1.cert \
- rtl/rel5/support/fadd-extra0.lisp
-
-
-rtl/rel5/support/fadd.cert : acl2x = 0
-rtl/rel5/support/fadd.cert : no_pcert = 0
-
-rtl/rel5/support/fadd.cert : \
- rtl/rel5/support/stick.cert \
- rtl/rel5/support/lop3.cert \
- rtl/rel5/support/add3.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/lextra0.cert \
- rtl/rel5/support/fadd.lisp
-
-
-rtl/rel5/support/fast-and.cert : acl2x = 0
-rtl/rel5/support/fast-and.cert : no_pcert = 0
-
-rtl/rel5/support/fast-and.cert : \
- rtl/rel5/support/fast-and.lisp
-
-
-rtl/rel5/support/float-extra.cert : acl2x = 0
-rtl/rel5/support/float-extra.cert : no_pcert = 0
-
-rtl/rel5/support/float-extra.cert : \
- arithmetic/inequalities.cert \
- rtl/rel5/support/sticky.cert \
- rtl/rel5/support/util.cert \
- rtl/rel5/support/top1.cert \
- rtl/rel5/support/float-extra.lisp
-
-
-rtl/rel5/support/float.cert : acl2x = 0
-rtl/rel5/support/float.cert : no_pcert = 0
-
-rtl/rel5/support/float.cert : \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/basic.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/cg.cert \
- rtl/rel5/support/float.lisp
-
-
-rtl/rel5/support/ground-zero.cert : acl2x = 0
-rtl/rel5/support/ground-zero.cert : no_pcert = 0
-
-rtl/rel5/support/ground-zero.cert : \
- rtl/rel5/arithmetic/ground-zero.cert \
- rtl/rel5/support/util.cert \
- rtl/rel5/support/ground-zero.lisp
-
-
-rtl/rel5/support/guards.cert : acl2x = 0
-rtl/rel5/support/guards.cert : no_pcert = 0
-
-rtl/rel5/support/guards.cert : \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/top1.cert \
- rtl/rel5/support/land.cert \
- rtl/rel5/support/lior.cert \
- rtl/rel5/support/lxor.cert \
- rtl/rel5/support/guards.lisp
-
-
-rtl/rel5/support/ireps.cert : acl2x = 0
-rtl/rel5/support/ireps.cert : no_pcert = 0
-
-rtl/rel5/support/ireps.cert : \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/bias.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/ireps.lisp
-
-
-rtl/rel5/support/land.cert : acl2x = 0
-rtl/rel5/support/land.cert : no_pcert = 0
-
-rtl/rel5/support/land.cert : \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/top1.cert \
- rtl/rel5/support/land.lisp
-
-
-rtl/rel5/support/land0-proofs.cert : acl2x = 0
-rtl/rel5/support/land0-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/land0-proofs.cert : \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/all-ones.cert \
- rtl/rel5/support/log.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/logand.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/arithmetic/fl-hacks.cert \
- rtl/rel5/support/land0-proofs.lisp
-
-
-rtl/rel5/support/land0.cert : acl2x = 0
-rtl/rel5/support/land0.cert : no_pcert = 0
-
-rtl/rel5/support/land0.cert : \
- rtl/rel5/support/land0-proofs.cert \
- rtl/rel5/support/land0.lisp
-
-
-rtl/rel5/support/lextra-proofs.cert : acl2x = 0
-rtl/rel5/support/lextra-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/lextra-proofs.cert : \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/logand.cert \
- rtl/rel5/support/logior.cert \
- rtl/rel5/support/logxor.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/lextra-proofs.lisp
-
-
-rtl/rel5/support/lextra.cert : acl2x = 0
-rtl/rel5/support/lextra.cert : no_pcert = 0
-
-rtl/rel5/support/lextra.cert : \
- rtl/rel5/support/land.cert \
- rtl/rel5/support/lior.cert \
- rtl/rel5/support/lxor.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/lextra0.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/support/merge2.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bits-trunc.cert \
- rtl/rel5/support/fadd.cert \
- rtl/rel5/support/lextra.lisp
-
-
-rtl/rel5/support/lextra0.cert : acl2x = 0
-rtl/rel5/support/lextra0.cert : no_pcert = 0
-
-rtl/rel5/support/lextra0.cert : \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/support/lextra-proofs.cert \
- rtl/rel5/support/lextra0.lisp
-
-
-rtl/rel5/support/lior.cert : acl2x = 0
-rtl/rel5/support/lior.cert : no_pcert = 0
-
-rtl/rel5/support/lior.cert : \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/top1.cert \
- rtl/rel5/support/lior.lisp
-
-
-rtl/rel5/support/lior0-proofs.cert : acl2x = 0
-rtl/rel5/support/lior0-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/lior0-proofs.cert : \
- rtl/rel5/support/all-ones.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/logior.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/lior0-proofs.lisp
-
-
-rtl/rel5/support/lior0.cert : acl2x = 0
-rtl/rel5/support/lior0.cert : no_pcert = 0
-
-rtl/rel5/support/lior0.cert : \
- rtl/rel5/support/lior0-proofs.cert \
- rtl/rel5/support/lior0.lisp
-
-
-rtl/rel5/support/lnot-proofs.cert : acl2x = 0
-rtl/rel5/support/lnot-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/lnot-proofs.cert : \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/arithmetic/expt.cert \
- rtl/rel5/arithmetic/mod.cert \
- rtl/rel5/arithmetic/mod.cert \
- rtl/rel5/arithmetic/arith.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/lnot-proofs.lisp
-
-
-rtl/rel5/support/lnot.cert : acl2x = 0
-rtl/rel5/support/lnot.cert : no_pcert = 0
-
-rtl/rel5/support/lnot.cert : \
- rtl/rel5/support/lnot-proofs.cert \
- rtl/rel5/support/lnot.lisp
-
-
-rtl/rel5/support/log-equal.cert : acl2x = 0
-rtl/rel5/support/log-equal.cert : no_pcert = 0
-
-rtl/rel5/support/log-equal.cert : \
- rtl/rel5/support/log-equal.lisp
-
-
-rtl/rel5/support/log-proofs.cert : acl2x = 0
-rtl/rel5/support/log-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/log-proofs.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/lognot.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/lnot.cert \
- rtl/rel5/support/logior.cert \
- rtl/rel5/support/logand.cert \
- rtl/rel5/support/logxor.cert \
- rtl/rel5/support/log-proofs.lisp
-
-
-rtl/rel5/support/log.cert : acl2x = 0
-rtl/rel5/support/log.cert : no_pcert = 0
-
-rtl/rel5/support/log.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/log-proofs.cert \
- rtl/rel5/support/lnot.cert \
- rtl/rel5/support/logand.cert \
- rtl/rel5/support/logior.cert \
- rtl/rel5/support/logxor.cert \
- rtl/rel5/support/log.lisp
-
-
-rtl/rel5/support/logand-proofs.cert : acl2x = 0
-rtl/rel5/support/logand-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/logand-proofs.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/arithmetic/induct.cert \
- rtl/rel5/support/lognot.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/logand-proofs.lisp
-
-
-rtl/rel5/support/logand.cert : acl2x = 0
-rtl/rel5/support/logand.cert : no_pcert = 0
-
-rtl/rel5/support/logand.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/logand-proofs.cert \
- rtl/rel5/support/logand.lisp
-
-
-rtl/rel5/support/logeqv.cert : acl2x = 0
-rtl/rel5/support/logeqv.cert : no_pcert = 0
-
-rtl/rel5/support/logeqv.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/logior.cert \
- rtl/rel5/support/logand.cert \
- rtl/rel5/support/logorc1.cert \
- rtl/rel5/support/lognot.cert \
- rtl/rel5/support/logeqv.lisp
-
-
-rtl/rel5/support/logior-proofs.cert : acl2x = 0
-rtl/rel5/support/logior-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/logior-proofs.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/logand.cert \
- rtl/rel5/support/lognot.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/logior-proofs.lisp
-
-
-rtl/rel5/support/logior.cert : acl2x = 0
-rtl/rel5/support/logior.cert : no_pcert = 0
-
-rtl/rel5/support/logior.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/logior-proofs.cert \
- rtl/rel5/support/logior.lisp
-
-
-rtl/rel5/support/logior1-proofs.cert : acl2x = 0
-rtl/rel5/support/logior1-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/logior1-proofs.cert : \
- rtl/rel5/support/logior1-proofs.lisp
-
-
-rtl/rel5/support/logior1.cert : acl2x = 0
-rtl/rel5/support/logior1.cert : no_pcert = 0
-
-rtl/rel5/support/logior1.cert : \
- rtl/rel5/support/logior1-proofs.cert \
- rtl/rel5/support/logior1.lisp
-
-
-rtl/rel5/support/lognot.cert : acl2x = 0
-rtl/rel5/support/lognot.cert : no_pcert = 0
-
-rtl/rel5/support/lognot.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/lognot.lisp
-
-
-rtl/rel5/support/logorc1.cert : acl2x = 0
-rtl/rel5/support/logorc1.cert : no_pcert = 0
-
-rtl/rel5/support/logorc1.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/logior.cert \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/support/lognot.cert \
- rtl/rel5/support/logorc1.lisp
-
-
-rtl/rel5/support/logs.cert : acl2x = 0
-rtl/rel5/support/logs.cert : no_pcert = 0
-
-rtl/rel5/support/logs.cert : \
- rtl/rel5/support/logs.lisp
-
-
-rtl/rel5/support/logxor.cert : acl2x = 0
-rtl/rel5/support/logxor.cert : no_pcert = 0
-
-rtl/rel5/support/logxor.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/logeqv.cert \
- rtl/rel5/support/logorc1.cert \
- rtl/rel5/support/lognot.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/logxor.lisp
-
-
-rtl/rel5/support/lop1-proofs.cert : acl2x = 0
-rtl/rel5/support/lop1-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/lop1-proofs.cert : \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/lop1-proofs.lisp
-
-
-rtl/rel5/support/lop1.cert : acl2x = 0
-rtl/rel5/support/lop1.cert : no_pcert = 0
-
-rtl/rel5/support/lop1.cert : \
- rtl/rel5/support/lop1-proofs.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/lop1.lisp
-
-
-rtl/rel5/support/lop2-proofs.cert : acl2x = 0
-rtl/rel5/support/lop2-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/lop2-proofs.cert : \
- rtl/rel5/support/lop1.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/logior.cert \
- rtl/rel5/support/lop2-proofs.lisp
-
-
-rtl/rel5/support/lop2.cert : acl2x = 0
-rtl/rel5/support/lop2.cert : no_pcert = 0
-
-rtl/rel5/support/lop2.cert : \
- rtl/rel5/support/lop1.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lop2-proofs.cert \
- rtl/rel5/support/lop2.lisp
-
-
-rtl/rel5/support/lop3-proofs.cert : acl2x = 0
-rtl/rel5/support/lop3-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/lop3-proofs.cert : \
- rtl/rel5/support/lop2.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/support/lop3-proofs.lisp
-
-
-rtl/rel5/support/lop3.cert : acl2x = 0
-rtl/rel5/support/lop3.cert : no_pcert = 0
-
-rtl/rel5/support/lop3.cert : \
- rtl/rel5/support/lop2.cert \
- rtl/rel5/support/lop3-proofs.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/support/lop3.lisp
-
-
-rtl/rel5/support/lxor.cert : acl2x = 0
-rtl/rel5/support/lxor.cert : no_pcert = 0
-
-rtl/rel5/support/lxor.cert : \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/support/top1.cert \
- rtl/rel5/support/lxor.lisp
-
-
-rtl/rel5/support/lxor0-proofs.cert : acl2x = 0
-rtl/rel5/support/lxor0-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/lxor0-proofs.cert : \
- rtl/rel5/support/all-ones.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/logand.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/lxor0-proofs.lisp
-
-
-rtl/rel5/support/lxor0.cert : acl2x = 0
-rtl/rel5/support/lxor0.cert : no_pcert = 0
-
-rtl/rel5/support/lxor0.cert : \
- rtl/rel5/support/lxor0-proofs.cert \
- rtl/rel5/support/lxor0.lisp
-
-
-rtl/rel5/support/merge.cert : acl2x = 0
-rtl/rel5/support/merge.cert : no_pcert = 0
-
-rtl/rel5/support/merge.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/log.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/lnot.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/logior.cert \
- rtl/rel5/support/logand.cert \
- rtl/rel5/support/logxor.cert \
- rtl/rel5/support/ocat.cert \
- rtl/rel5/support/sumbits.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/merge.lisp
-
-
-rtl/rel5/support/merge2.cert : acl2x = 0
-rtl/rel5/support/merge2.cert : no_pcert = 0
-
-rtl/rel5/support/merge2.cert : \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/support/logs.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/merge2.lisp
-
-
-rtl/rel5/support/mod4.cert : acl2x = 0
-rtl/rel5/support/mod4.cert : no_pcert = 0
-
-rtl/rel5/support/mod4.cert : \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/mod4.lisp
-
-
-rtl/rel5/support/model-helpers.cert : acl2x = 0
-rtl/rel5/support/model-helpers.cert : no_pcert = 0
-
-rtl/rel5/support/model-helpers.cert : \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/model-helpers.lisp
-
-
-rtl/rel5/support/mulcat-proofs.cert : acl2x = 0
-rtl/rel5/support/mulcat-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/mulcat-proofs.cert : \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/cat-def.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/mulcat-proofs.lisp
-
-
-rtl/rel5/support/mulcat.cert : acl2x = 0
-rtl/rel5/support/mulcat.cert : no_pcert = 0
-
-rtl/rel5/support/mulcat.cert : \
- rtl/rel5/support/cat-def.cert \
- rtl/rel5/support/mulcat-proofs.cert \
- rtl/rel5/support/mulcat.lisp
-
-
-rtl/rel5/support/near+-proofs.cert : acl2x = 0
-rtl/rel5/support/near+-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/near+-proofs.cert : \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/support/away.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/arithmetic/predicate.cert \
- rtl/rel5/arithmetic/cg.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/near+-proofs.lisp
-
-
-rtl/rel5/support/near+.cert : acl2x = 0
-rtl/rel5/support/near+.cert : no_pcert = 0
-
-rtl/rel5/support/near+.cert : \
- rtl/rel5/support/near+-proofs.cert \
- rtl/rel5/support/near+.lisp
-
-
-rtl/rel5/support/near-proofs.cert : acl2x = 0
-rtl/rel5/support/near-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/near-proofs.cert : \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/away.cert \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/support/near-proofs.lisp
-
-
-rtl/rel5/support/near.cert : acl2x = 0
-rtl/rel5/support/near.cert : no_pcert = 0
-
-rtl/rel5/support/near.cert : \
- rtl/rel5/support/near-proofs.cert \
- rtl/rel5/support/near.lisp
-
-
-rtl/rel5/support/ocat.cert : acl2x = 0
-rtl/rel5/support/ocat.cert : no_pcert = 0
-
-rtl/rel5/support/ocat.cert : \
- rtl/rel5/arithmetic/expt.cert \
- rtl/rel5/arithmetic/expo.cert \
- rtl/rel5/arithmetic/arith2.cert \
- rtl/rel5/arithmetic/fp2.cert \
- rtl/rel5/arithmetic/integerp.cert \
- rtl/rel5/support/ocat.lisp
-
-
-rtl/rel5/support/oddr-proofs.cert : acl2x = 0
-rtl/rel5/support/oddr-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/oddr-proofs.cert : \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/support/away.cert \
- rtl/rel5/support/near.cert \
- rtl/rel5/support/oddr-proofs.lisp
-
-
-rtl/rel5/support/oddr.cert : acl2x = 0
-rtl/rel5/support/oddr.cert : no_pcert = 0
-
-rtl/rel5/support/oddr.cert : \
- rtl/rel5/support/oddr-proofs.cert \
- rtl/rel5/support/oddr.lisp
-
-
-rtl/rel5/support/openers.cert : acl2x = 0
-rtl/rel5/support/openers.cert : no_pcert = 0
-
-rtl/rel5/support/openers.cert : \
- rtl/rel5/support/openers.lisp
-
-
-rtl/rel5/support/package-defs.cert : acl2x = 0
-rtl/rel5/support/package-defs.cert : no_pcert = 0
-
-rtl/rel5/support/package-defs.cert : \
- rtl/rel5/support/package-defs.lisp
-
-
-rtl/rel5/support/rewrite-theory.cert : acl2x = 0
-rtl/rel5/support/rewrite-theory.cert : no_pcert = 0
-
-rtl/rel5/support/rewrite-theory.cert : \
- rtl/rel5/support/rewrite-theory.lisp
-
-
-rtl/rel5/support/rnd.cert : acl2x = 0
-rtl/rel5/support/rnd.cert : no_pcert = 0
-
-rtl/rel5/support/rnd.cert : \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/support/away.cert \
- rtl/rel5/support/near.cert \
- rtl/rel5/support/near+.cert \
- rtl/rel5/support/sticky.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/bits-trunc.cert \
- rtl/rel5/support/rnd.lisp
-
-
-rtl/rel5/support/rom-helpers.cert : acl2x = 0
-rtl/rel5/support/rom-helpers.cert : no_pcert = 0
-
-rtl/rel5/support/rom-helpers.cert : \
- rtl/rel5/support/rom-helpers.lisp
-
-
-rtl/rel5/support/round-extra.cert : acl2x = 0
-rtl/rel5/support/round-extra.cert : no_pcert = 0
-
-rtl/rel5/support/round-extra.cert : \
- rtl/rel5/support/sticky.cert \
- rtl/rel5/support/util.cert \
- rtl/rel5/support/top1.cert \
- rtl/rel5/support/round-extra.lisp
-
-
-rtl/rel5/support/rtl.cert : acl2x = 0
-rtl/rel5/support/rtl.cert : no_pcert = 0
-
-rtl/rel5/support/rtl.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/rtlarr.cert \
- rtl/rel5/support/cat-def.cert \
- rtl/rel5/support/rtl.lisp
-
-
-rtl/rel5/support/rtlarr.cert : acl2x = 0
-rtl/rel5/support/rtlarr.cert : no_pcert = 0
-
-rtl/rel5/support/rtlarr.cert : \
- misc/total-order.cert \
- rtl/rel5/support/rtlarr.lisp
-
-
-rtl/rel5/support/setbitn-proofs.cert : acl2x = 0
-rtl/rel5/support/setbitn-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/setbitn-proofs.cert : \
- rtl/rel5/support/cat-def.cert \
- rtl/rel5/support/setbits.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/setbitn-proofs.lisp
-
-
-rtl/rel5/support/setbitn.cert : acl2x = 0
-rtl/rel5/support/setbitn.cert : no_pcert = 0
-
-rtl/rel5/support/setbitn.cert : \
- rtl/rel5/support/cat-def.cert \
- rtl/rel5/support/setbitn-proofs.cert \
- rtl/rel5/support/setbitn.lisp
-
-
-rtl/rel5/support/setbits-proofs.cert : acl2x = 0
-rtl/rel5/support/setbits-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/setbits-proofs.cert : \
- rtl/rel5/support/cat-def.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/setbits-proofs.lisp
-
-
-rtl/rel5/support/setbits.cert : acl2x = 0
-rtl/rel5/support/setbits.cert : no_pcert = 0
-
-rtl/rel5/support/setbits.cert : \
- rtl/rel5/support/cat-def.cert \
- rtl/rel5/support/setbits-proofs.cert \
- rtl/rel5/support/setbits.lisp
-
-
-rtl/rel5/support/sgn.cert : acl2x = 0
-rtl/rel5/support/sgn.cert : no_pcert = 0
-
-rtl/rel5/support/sgn.cert : \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/sgn.lisp
-
-
-rtl/rel5/support/shft.cert : acl2x = 0
-rtl/rel5/support/shft.cert : no_pcert = 0
-
-rtl/rel5/support/shft.cert : \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/shft.lisp
-
-
-rtl/rel5/support/simple-loop-helpers.cert : acl2x = 0
-rtl/rel5/support/simple-loop-helpers.cert : no_pcert = 0
-
-rtl/rel5/support/simple-loop-helpers.cert : \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/setbitn.cert \
- rtl/rel5/support/simple-loop-helpers.lisp
-
-
-rtl/rel5/support/simplify-model-helpers.cert : acl2x = 0
-rtl/rel5/support/simplify-model-helpers.cert : no_pcert = 0
-
-rtl/rel5/support/simplify-model-helpers.cert : \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/simplify-model-helpers.lisp
-
-
-rtl/rel5/support/stick-proofs.cert : acl2x = 0
-rtl/rel5/support/stick-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/stick-proofs.cert : \
- rtl/rel5/support/merge.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/lnot.cert \
- rtl/rel5/support/stick-proofs.lisp
-
-
-rtl/rel5/support/stick.cert : acl2x = 0
-rtl/rel5/support/stick.cert : no_pcert = 0
-
-rtl/rel5/support/stick.cert : \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/stick-proofs.cert \
- rtl/rel5/support/stick.lisp
-
-
-rtl/rel5/support/sticky-proofs.cert : acl2x = 0
-rtl/rel5/support/sticky-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/sticky-proofs.cert : \
- rtl/rel5/arithmetic/arith.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/support/away.cert \
- rtl/rel5/support/near.cert \
- rtl/rel5/support/near+.cert \
- rtl/rel5/support/sticky-proofs.lisp
-
-
-rtl/rel5/support/sticky.cert : acl2x = 0
-rtl/rel5/support/sticky.cert : no_pcert = 0
-
-rtl/rel5/support/sticky.cert : \
- rtl/rel5/support/sticky-proofs.cert \
- rtl/rel5/support/sticky.lisp
-
-
-rtl/rel5/support/sumbits.cert : acl2x = 0
-rtl/rel5/support/sumbits.cert : no_pcert = 0
-
-rtl/rel5/support/sumbits.cert : \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/sumbits.lisp
-
-
-rtl/rel5/support/top.cert : acl2x = 0
-rtl/rel5/support/top.cert : no_pcert = 0
-
-rtl/rel5/support/top.cert : \
- rtl/rel5/support/top1.cert \
- rtl/rel5/support/lextra.cert \
- rtl/rel5/support/fadd-extra.cert \
- rtl/rel5/support/float-extra.cert \
- rtl/rel5/support/round-extra.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/support/badguys.cert \
- rtl/rel5/support/top.lisp
-
-
-rtl/rel5/support/top1.cert : acl2x = 0
-rtl/rel5/support/top1.cert : no_pcert = 0
-
-rtl/rel5/support/top1.cert : \
- rtl/rel5/support/util.cert \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/rewrite-theory.cert \
- rtl/rel5/support/rtl.cert \
- rtl/rel5/support/rtlarr.cert \
- rtl/rel5/support/bvecp-lemmas.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/ocat.cert \
- rtl/rel5/support/cat-def.cert \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/support/ash.cert \
- rtl/rel5/support/decode.cert \
- rtl/rel5/support/encode.cert \
- rtl/rel5/support/mulcat.cert \
- rtl/rel5/support/shft.cert \
- rtl/rel5/support/all-ones.cert \
- rtl/rel5/support/merge2.cert \
- rtl/rel5/support/logior1.cert \
- rtl/rel5/support/setbits.cert \
- rtl/rel5/support/setbitn.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/support/bias.cert \
- rtl/rel5/support/ereps.cert \
- rtl/rel5/support/ireps.cert \
- rtl/rel5/support/logeqv.cert \
- rtl/rel5/support/logorc1.cert \
- rtl/rel5/support/lognot.cert \
- rtl/rel5/support/logand.cert \
- rtl/rel5/support/logior.cert \
- rtl/rel5/support/logxor.cert \
- rtl/rel5/support/log.cert \
- rtl/rel5/support/lnot.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/support/lextra0.cert \
- rtl/rel5/support/logs.cert \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/support/away.cert \
- rtl/rel5/support/near.cert \
- rtl/rel5/support/near+.cert \
- rtl/rel5/support/oddr.cert \
- rtl/rel5/support/sticky.cert \
- rtl/rel5/support/rnd.cert \
- rtl/rel5/support/drnd.cert \
- rtl/rel5/support/bits-trunc.cert \
- rtl/rel5/support/add3.cert \
- rtl/rel5/support/lop1.cert \
- rtl/rel5/support/lop2.cert \
- rtl/rel5/support/lop3.cert \
- rtl/rel5/support/stick.cert \
- rtl/rel5/support/bvecp-helpers.cert \
- rtl/rel5/support/model-helpers.cert \
- rtl/rel5/support/rom-helpers.cert \
- rtl/rel5/support/simple-loop-helpers.cert \
- rtl/rel5/support/clocks.cert \
- rtl/rel5/support/openers.cert \
- rtl/rel5/support/package-defs.cert \
- rtl/rel5/support/simplify-model-helpers.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/arithmetic/fp.cert \
- rtl/rel5/support/fadd.cert \
- rtl/rel5/support/top1.lisp
-
-
-rtl/rel5/support/trunc-proofs.cert : acl2x = 0
-rtl/rel5/support/trunc-proofs.cert : no_pcert = 0
-
-rtl/rel5/support/trunc-proofs.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/float.cert \
- rtl/rel5/arithmetic/top.cert \
- rtl/rel5/support/trunc-proofs.lisp
-
-
-rtl/rel5/support/trunc.cert : acl2x = 0
-rtl/rel5/support/trunc.cert : no_pcert = 0
-
-rtl/rel5/support/trunc.cert : \
- rtl/rel5/support/ground-zero.cert \
- rtl/rel5/support/trunc-proofs.cert \
- rtl/rel5/support/trunc.lisp
-
-
-rtl/rel5/support/util.cert : acl2x = 0
-rtl/rel5/support/util.cert : no_pcert = 0
-
-rtl/rel5/support/util.cert : \
- rtl/rel5/support/util.lisp
-
-
-rtl/rel5/user/away.cert : acl2x = 0
-rtl/rel5/user/away.cert : no_pcert = 0
-
-rtl/rel5/user/away.cert : \
- rtl/rel5/user/trunc.cert \
- rtl/rel5/support/away.cert \
- rtl/rel5/user/away.lisp
-
-
-rtl/rel5/user/bias.cert : acl2x = 0
-rtl/rel5/user/bias.cert : no_pcert = 0
-
-rtl/rel5/user/bias.cert : \
- rtl/rel5/support/bias.cert \
- rtl/rel5/user/bias.lisp
-
-
-rtl/rel5/user/bitn.cert : acl2x = 0
-rtl/rel5/user/bitn.cert : no_pcert = 0
-
-rtl/rel5/user/bitn.cert : \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/support/bitn.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/user/bitn.lisp
-
-
-rtl/rel5/user/bits-trunc.cert : acl2x = 0
-rtl/rel5/user/bits-trunc.cert : no_pcert = 0
-
-rtl/rel5/user/bits-trunc.cert : \
- rtl/rel5/user/land.cert \
- rtl/rel5/support/bits-trunc.cert \
- rtl/rel5/user/bits-trunc.lisp
-
-
-rtl/rel5/user/bits.cert : acl2x = 0
-rtl/rel5/user/bits.cert : no_pcert = 0
-
-rtl/rel5/user/bits.cert : \
- rtl/rel5/arithmetic/negative-syntaxp.cert \
- rtl/rel5/arithmetic/power2p.cert \
- rtl/rel5/support/bits.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/user/bits.lisp
-
-
-rtl/rel5/user/brat.cert : acl2x = 0
-rtl/rel5/user/brat.cert : no_pcert = 0
-
-rtl/rel5/user/brat.cert : \
- rtl/rel5/arithmetic/fl.cert \
- rtl/rel5/user/brat.lisp
-
-
-rtl/rel5/user/bvecp.cert : acl2x = 0
-rtl/rel5/user/bvecp.cert : no_pcert = 0
-
-rtl/rel5/user/bvecp.cert : \
- rtl/rel5/support/bvecp.cert \
- rtl/rel5/user/bvecp.lisp
-
-
-rtl/rel5/user/cat.cert : acl2x = 0
-rtl/rel5/user/cat.cert : no_pcert = 0
-
-rtl/rel5/user/cat.cert : \
- rtl/rel5/support/cat.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/user/cat.lisp
-
-
-rtl/rel5/user/decode.cert : acl2x = 0
-rtl/rel5/user/decode.cert : no_pcert = 0
-
-rtl/rel5/user/decode.cert : \
- rtl/rel5/support/decode.cert \
- rtl/rel5/user/decode.lisp
-
-
-rtl/rel5/user/ereps.cert : acl2x = 0
-rtl/rel5/user/ereps.cert : no_pcert = 0
-
-rtl/rel5/user/ereps.cert : \
- rtl/rel5/support/ereps.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/user/ereps.lisp
-
-
-rtl/rel5/user/land.cert : acl2x = 0
-rtl/rel5/user/land.cert : no_pcert = 0
-
-rtl/rel5/user/land.cert : \
- rtl/rel5/support/guards.cert \
- rtl/rel5/support/land0.cert \
- rtl/rel5/user/land.lisp
-
-
-rtl/rel5/user/lextra.cert : acl2x = 0
-rtl/rel5/user/lextra.cert : no_pcert = 0
-
-rtl/rel5/user/lextra.cert : \
- rtl/rel5/user/land.cert \
- rtl/rel5/user/lior.cert \
- rtl/rel5/user/lxor.cert \
- rtl/rel5/support/lextra0.cert \
- rtl/rel5/user/lextra.lisp
-
-
-rtl/rel5/user/lior.cert : acl2x = 0
-rtl/rel5/user/lior.cert : no_pcert = 0
-
-rtl/rel5/user/lior.cert : \
- rtl/rel5/support/lior0.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/user/lior.lisp
-
-
-rtl/rel5/user/lnot.cert : acl2x = 0
-rtl/rel5/user/lnot.cert : no_pcert = 0
-
-rtl/rel5/user/lnot.cert : \
- rtl/rel5/support/guards.cert \
- rtl/rel5/support/lnot.cert \
- rtl/rel5/user/lnot.lisp
-
-
-rtl/rel5/user/logior1.cert : acl2x = 0
-rtl/rel5/user/logior1.cert : no_pcert = 0
-
-rtl/rel5/user/logior1.cert : \
- rtl/rel5/support/logior1.cert \
- rtl/rel5/user/logior1.lisp
-
-
-rtl/rel5/user/lxor.cert : acl2x = 0
-rtl/rel5/user/lxor.cert : no_pcert = 0
-
-rtl/rel5/user/lxor.cert : \
- rtl/rel5/support/guards.cert \
- rtl/rel5/support/lxor0.cert \
- rtl/rel5/user/lxor.lisp
-
-
-rtl/rel5/user/mulcat.cert : acl2x = 0
-rtl/rel5/user/mulcat.cert : no_pcert = 0
-
-rtl/rel5/user/mulcat.cert : \
- rtl/rel5/support/mulcat.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/user/mulcat.lisp
-
-
-rtl/rel5/user/near.cert : acl2x = 0
-rtl/rel5/user/near.cert : no_pcert = 0
-
-rtl/rel5/user/near.cert : \
- rtl/rel5/support/near.cert \
- rtl/rel5/user/near.lisp
-
-
-rtl/rel5/user/setbitn.cert : acl2x = 0
-rtl/rel5/user/setbitn.cert : no_pcert = 0
-
-rtl/rel5/user/setbitn.cert : \
- rtl/rel5/support/setbitn.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/user/setbitn.lisp
-
-
-rtl/rel5/user/setbits.cert : acl2x = 0
-rtl/rel5/user/setbits.cert : no_pcert = 0
-
-rtl/rel5/user/setbits.cert : \
- rtl/rel5/support/setbits.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/user/setbits.lisp
-
-
-rtl/rel5/user/stick.cert : acl2x = 0
-rtl/rel5/user/stick.cert : no_pcert = 0
-
-rtl/rel5/user/stick.cert : \
- rtl/rel5/user/land.cert \
- rtl/rel5/user/lior.cert \
- rtl/rel5/user/lxor.cert \
- rtl/rel5/user/lnot.cert \
- rtl/rel5/support/stick.cert \
- rtl/rel5/user/stick.lisp
-
-
-rtl/rel5/user/sumbits.cert : acl2x = 0
-rtl/rel5/user/sumbits.cert : no_pcert = 0
-
-rtl/rel5/user/sumbits.cert : \
- rtl/rel5/support/sumbits.cert \
- rtl/rel5/support/guards.cert \
- rtl/rel5/user/sumbits.lisp
-
-
-rtl/rel5/user/top.cert : acl2x = 0
-rtl/rel5/user/top.cert : no_pcert = 0
-
-rtl/rel5/user/top.cert : \
- rtl/rel5/user/bits.cert \
- rtl/rel5/user/bitn.cert \
- rtl/rel5/user/cat.cert \
- rtl/rel5/user/bvecp.cert \
- rtl/rel5/user/mulcat.cert \
- rtl/rel5/user/logior1.cert \
- rtl/rel5/user/setbits.cert \
- rtl/rel5/user/setbitn.cert \
- rtl/rel5/user/bias.cert \
- rtl/rel5/user/ereps.cert \
- rtl/rel5/user/lnot.cert \
- rtl/rel5/user/land.cert \
- rtl/rel5/user/lior.cert \
- rtl/rel5/user/lxor.cert \
- rtl/rel5/user/lextra.cert \
- rtl/rel5/user/trunc.cert \
- rtl/rel5/user/away.cert \
- rtl/rel5/user/near.cert \
- rtl/rel5/user/bits-trunc.cert \
- rtl/rel5/user/stick.cert \
- rtl/rel5/user/sumbits.cert \
- rtl/rel5/user/top.lisp
-
-
-rtl/rel5/user/trunc.cert : acl2x = 0
-rtl/rel5/user/trunc.cert : no_pcert = 0
-
-rtl/rel5/user/trunc.cert : \
- rtl/rel5/support/trunc.cert \
- rtl/rel5/user/trunc.lisp
-
-
-rtl/rel8/arithmetic/arith.cert : acl2x = 0
-rtl/rel8/arithmetic/arith.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/arith.cert : \
- rtl/rel8/arithmetic/arith2.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- meta/meta-times-equal.cert \
- rtl/rel8/arithmetic/arith.lisp
-
-
-rtl/rel8/arithmetic/arith2.cert : acl2x = 0
-rtl/rel8/arithmetic/arith2.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/arith2.cert : \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/product.cert \
- meta/meta-times-equal.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- meta/meta-times-equal.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel8/arithmetic/inverted-factor.cert \
- rtl/rel8/arithmetic/arith2.lisp
-
-
-rtl/rel8/arithmetic/basic.cert : acl2x = 0
-rtl/rel8/arithmetic/basic.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/basic.cert : \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/even-odd.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/arithmetic/basic.lisp
-
-
-rtl/rel8/arithmetic/cg.cert : acl2x = 0
-rtl/rel8/arithmetic/cg.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/cg.cert : \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/arithmetic/common-factor.cert \
- rtl/rel8/arithmetic/cg.lisp
-
-
-rtl/rel8/arithmetic/common-factor-defuns.cert : acl2x = 0
-rtl/rel8/arithmetic/common-factor-defuns.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/common-factor-defuns.cert : \
- rtl/rel8/arithmetic/inverted-factor.cert \
- rtl/rel8/arithmetic/common-factor-defuns.lisp
-
-
-rtl/rel8/arithmetic/common-factor.cert : acl2x = 0
-rtl/rel8/arithmetic/common-factor.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/common-factor.cert : \
- meta/meta-times-equal.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel8/arithmetic/common-factor-defuns.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/product.cert \
- rtl/rel8/arithmetic/common-factor.lisp
-
-
-rtl/rel8/arithmetic/complex-rationalp.cert : acl2x = 0
-rtl/rel8/arithmetic/complex-rationalp.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/complex-rationalp.cert : \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/complex-rationalp.lisp
-
-
-rtl/rel8/arithmetic/denominator.cert : acl2x = 0
-rtl/rel8/arithmetic/denominator.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/denominator.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/fp2.cert \
- arithmetic/mod-gcd.cert \
- rtl/rel8/arithmetic/denominator.lisp
-
-
-rtl/rel8/arithmetic/even-odd.cert : acl2x = 0
-rtl/rel8/arithmetic/even-odd.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/even-odd.cert : \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/even-odd.lisp
-
-
-rtl/rel8/arithmetic/even-odd2-proofs.cert : acl2x = 0
-rtl/rel8/arithmetic/even-odd2-proofs.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/even-odd2-proofs.cert : \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/arith.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/even-odd2-proofs.lisp
-
-
-rtl/rel8/arithmetic/even-odd2.cert : acl2x = 0
-rtl/rel8/arithmetic/even-odd2.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/even-odd2.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/even-odd2-proofs.cert \
- rtl/rel8/arithmetic/even-odd2.lisp
-
-
-rtl/rel8/arithmetic/expo-proofs.cert : acl2x = 0
-rtl/rel8/arithmetic/expo-proofs.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/expo-proofs.cert : \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/arithmetic/unary-divide.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/expt.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel8/arithmetic/common-factor-defuns.cert \
- rtl/rel8/arithmetic/common-factor.cert \
- rtl/rel8/arithmetic/expo-proofs.lisp
-
-
-rtl/rel8/arithmetic/expo.cert : acl2x = 0
-rtl/rel8/arithmetic/expo.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/expo.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/arithmetic/expo-proofs.cert \
- rtl/rel8/arithmetic/common-factor-defuns.cert \
- rtl/rel8/arithmetic/expo.lisp
-
-
-rtl/rel8/arithmetic/expt-proofs.cert : acl2x = 0
-rtl/rel8/arithmetic/expt-proofs.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/expt-proofs.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/numerator.cert \
- rtl/rel8/arithmetic/denominator.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/arith2.cert \
- arithmetic/top.cert \
- rtl/rel8/arithmetic/even-odd.cert \
- rtl/rel8/arithmetic/expt-proofs.lisp
-
-
-rtl/rel8/arithmetic/expt.cert : acl2x = 0
-rtl/rel8/arithmetic/expt.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/expt.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/expt-proofs.cert \
- rtl/rel8/arithmetic/expt.lisp
-
-
-rtl/rel8/arithmetic/extra-rules.cert : acl2x = 0
-rtl/rel8/arithmetic/extra-rules.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/extra-rules.cert : \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/arithmetic/extra-rules.lisp
-
-
-rtl/rel8/arithmetic/fl-expt.cert : acl2x = 0
-rtl/rel8/arithmetic/fl-expt.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/fl-expt.cert : \
- rtl/rel8/arithmetic/numerator.cert \
- rtl/rel8/arithmetic/denominator.cert \
- rtl/rel8/arithmetic/nniq.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/floor.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/rationalp.cert \
- rtl/rel8/arithmetic/unary-divide.cert \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/arithmetic/expo.cert \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/fl-expt.lisp
-
-
-rtl/rel8/arithmetic/fl-hacks.cert : acl2x = 0
-rtl/rel8/arithmetic/fl-hacks.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/fl-hacks.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/inverted-factor.cert \
- rtl/rel8/arithmetic/nniq.cert \
- rtl/rel8/arithmetic/numerator.cert \
- rtl/rel8/arithmetic/denominator.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/product.cert \
- rtl/rel8/arithmetic/unary-divide.cert \
- rtl/rel8/arithmetic/rationalp.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/mod.cert \
- rtl/rel8/arithmetic/even-odd.cert \
- meta/meta-plus-equal.cert \
- rtl/rel8/arithmetic/arith.cert \
- rtl/rel8/arithmetic/fl-hacks.lisp
-
-
-rtl/rel8/arithmetic/fl-proofs.cert : acl2x = 0
-rtl/rel8/arithmetic/fl-proofs.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/fl-proofs.cert : \
- rtl/rel8/arithmetic/numerator.cert \
- rtl/rel8/arithmetic/denominator.cert \
- rtl/rel8/arithmetic/nniq.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/floor.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/rationalp.cert \
- rtl/rel8/arithmetic/unary-divide.cert \
- rtl/rel8/arithmetic/common-factor.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/fl-proofs.lisp
-
-
-rtl/rel8/arithmetic/fl.cert : acl2x = 0
-rtl/rel8/arithmetic/fl.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/fl.cert : \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/fl-proofs.cert \
- rtl/rel8/arithmetic/fl.lisp
-
-
-rtl/rel8/arithmetic/floor-proofs.cert : acl2x = 0
-rtl/rel8/arithmetic/floor-proofs.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/floor-proofs.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/denominator.cert \
- rtl/rel8/arithmetic/numerator.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/nniq.cert \
- rtl/rel8/arithmetic/product.cert \
- rtl/rel8/arithmetic/unary-divide.cert \
- rtl/rel8/arithmetic/rationalp.cert \
- rtl/rel8/arithmetic/inverted-factor.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel8/arithmetic/floor-proofs.lisp
-
-
-rtl/rel8/arithmetic/floor.cert : acl2x = 0
-rtl/rel8/arithmetic/floor.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/floor.cert : \
- rtl/rel8/arithmetic/floor-proofs.cert \
- rtl/rel8/arithmetic/floor.lisp
-
-
-rtl/rel8/arithmetic/fp.cert : acl2x = 0
-rtl/rel8/arithmetic/fp.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/fp.cert : \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/fp.lisp
-
-
-rtl/rel8/arithmetic/fp2.cert : acl2x = 0
-rtl/rel8/arithmetic/fp2.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/fp2.cert : \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- ihs/ihs-lemmas.cert \
- arithmetic-2/meta/non-linear.cert \
- rtl/rel8/arithmetic/inverted-factor.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel8/arithmetic/fp2.lisp
-
-
-rtl/rel8/arithmetic/ground-zero.cert : acl2x = 0
-rtl/rel8/arithmetic/ground-zero.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/ground-zero.cert : \
- rtl/rel8/arithmetic/ground-zero.lisp
-
-
-rtl/rel8/arithmetic/hacks.cert : acl2x = 0
-rtl/rel8/arithmetic/hacks.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/hacks.cert : \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/hacks.lisp
-
-
-rtl/rel8/arithmetic/induct.cert : acl2x = 0
-rtl/rel8/arithmetic/induct.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/induct.cert : \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/induct.lisp
-
-
-rtl/rel8/arithmetic/integerp.cert : acl2x = 0
-rtl/rel8/arithmetic/integerp.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/integerp.cert : \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/integerp.lisp
-
-
-rtl/rel8/arithmetic/inverted-factor.cert : acl2x = 0
-rtl/rel8/arithmetic/inverted-factor.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/inverted-factor.cert : \
- rtl/rel8/arithmetic/inverted-factor.lisp
-
-
-rtl/rel8/arithmetic/mod-expt.cert : acl2x = 0
-rtl/rel8/arithmetic/mod-expt.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/mod-expt.cert : \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/arithmetic/numerator.cert \
- rtl/rel8/arithmetic/denominator.cert \
- rtl/rel8/arithmetic/nniq.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/floor.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/rationalp.cert \
- rtl/rel8/arithmetic/unary-divide.cert \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/arithmetic/expo.cert \
- rtl/rel8/arithmetic/fl-expt.cert \
- rtl/rel8/arithmetic/mod.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/mod-expt.lisp
-
-
-rtl/rel8/arithmetic/mod-proofs.cert : acl2x = 0
-rtl/rel8/arithmetic/mod-proofs.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/mod-proofs.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/floor.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/arith.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/product.cert \
- rtl/rel8/arithmetic/complex-rationalp.cert \
- meta/meta-plus-equal.cert \
- meta/meta-plus-lessp.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/rationalp.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/mod-proofs.lisp
-
-
-rtl/rel8/arithmetic/mod.cert : acl2x = 0
-rtl/rel8/arithmetic/mod.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/mod.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/mod-proofs.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/mod.lisp
-
-
-rtl/rel8/arithmetic/negative-syntaxp.cert : acl2x = 0
-rtl/rel8/arithmetic/negative-syntaxp.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/negative-syntaxp.cert : \
- rtl/rel8/arithmetic/negative-syntaxp.lisp
-
-
-rtl/rel8/arithmetic/nniq.cert : acl2x = 0
-rtl/rel8/arithmetic/nniq.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/nniq.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/denominator.cert \
- rtl/rel8/arithmetic/numerator.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/unary-divide.cert \
- rtl/rel8/arithmetic/product.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/arith.cert \
- arithmetic/rationals.cert \
- arithmetic/idiv.cert \
- arithmetic/idiv.cert \
- arithmetic/top-with-meta.cert \
- rtl/rel8/arithmetic/nniq.lisp
-
-
-rtl/rel8/arithmetic/numerator.cert : acl2x = 0
-rtl/rel8/arithmetic/numerator.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/numerator.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/denominator.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/numerator.lisp
-
-
-rtl/rel8/arithmetic/power2p.cert : acl2x = 0
-rtl/rel8/arithmetic/power2p.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/power2p.cert : \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/unary-divide.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel8/arithmetic/power2p.lisp
-
-
-rtl/rel8/arithmetic/predicate.cert : acl2x = 0
-rtl/rel8/arithmetic/predicate.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/predicate.cert : \
- rtl/rel8/arithmetic/predicate.lisp
-
-
-rtl/rel8/arithmetic/product-proofs.cert : acl2x = 0
-rtl/rel8/arithmetic/product-proofs.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/product-proofs.cert : \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/product-proofs.lisp
-
-
-rtl/rel8/arithmetic/product.cert : acl2x = 0
-rtl/rel8/arithmetic/product.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/product.cert : \
- rtl/rel8/arithmetic/product-proofs.cert \
- rtl/rel8/arithmetic/product.lisp
-
-
-rtl/rel8/arithmetic/rationalp.cert : acl2x = 0
-rtl/rel8/arithmetic/rationalp.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/rationalp.cert : \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/rationalp.lisp
-
-
-rtl/rel8/arithmetic/top.cert : acl2x = 0
-rtl/rel8/arithmetic/top.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/top.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/arithmetic/induct.cert \
- rtl/rel8/arithmetic/denominator.cert \
- rtl/rel8/arithmetic/numerator.cert \
- rtl/rel8/arithmetic/nniq.cert \
- rtl/rel8/arithmetic/complex-rationalp.cert \
- rtl/rel8/arithmetic/rationalp.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/arith.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/arithmetic/unary-divide.cert \
- rtl/rel8/arithmetic/product.cert \
- rtl/rel8/arithmetic/inverted-factor.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/x-2xx.cert \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/arithmetic/expo.cert \
- rtl/rel8/arithmetic/fl-hacks.cert \
- rtl/rel8/arithmetic/even-odd2.cert \
- rtl/rel8/arithmetic/even-odd.cert \
- rtl/rel8/arithmetic/floor.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/cg.cert \
- rtl/rel8/arithmetic/mod.cert \
- rtl/rel8/arithmetic/fl-expt.cert \
- rtl/rel8/arithmetic/mod-expt.cert \
- rtl/rel8/arithmetic/common-factor.cert \
- rtl/rel8/arithmetic/top.lisp
-
-
-rtl/rel8/arithmetic/unary-divide.cert : acl2x = 0
-rtl/rel8/arithmetic/unary-divide.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/unary-divide.cert : \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/inverted-factor.cert \
- rtl/rel8/arithmetic/unary-divide.lisp
-
-
-rtl/rel8/arithmetic/x-2xx.cert : acl2x = 0
-rtl/rel8/arithmetic/x-2xx.cert : no_pcert = 0
-
-rtl/rel8/arithmetic/x-2xx.cert : \
- arithmetic/top-with-meta.cert \
- arithmetic/mod-gcd.cert \
- rtl/rel8/arithmetic/x-2xx.lisp
-
-
-rtl/rel8/lib/add.cert : acl2x = 0
-rtl/rel8/lib/add.cert : no_pcert = 0
-
-rtl/rel8/lib/add.cert : \
- rtl/rel8/lib/round.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/add.lisp
-
-
-rtl/rel8/lib/arith.cert : acl2x = 0
-rtl/rel8/lib/arith.cert : no_pcert = 0
-
-rtl/rel8/lib/arith.cert : \
- rtl/rel8/support/top/top.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel8/lib/arith.lisp
-
-
-rtl/rel8/lib/basic.cert : acl2x = 0
-rtl/rel8/lib/basic.cert : no_pcert = 0
-
-rtl/rel8/lib/basic.cert : \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/basic.lisp
-
-
-rtl/rel8/lib/bits.cert : acl2x = 0
-rtl/rel8/lib/bits.cert : no_pcert = 0
-
-rtl/rel8/lib/bits.cert : \
- rtl/rel8/lib/basic.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/bits.lisp
-
-
-rtl/rel8/lib/bvecp-helpers.cert : acl2x = 0
-rtl/rel8/lib/bvecp-helpers.cert : no_pcert = 0
-
-rtl/rel8/lib/bvecp-helpers.cert : \
- rtl/rel8/lib/rtl.cert \
- rtl/rel8/lib/rtlarr.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/bvecp-helpers.lisp
-
-
-rtl/rel8/lib/bvecp-raw-helpers.cert : acl2x = 0
-rtl/rel8/lib/bvecp-raw-helpers.cert : no_pcert = 0
-
-rtl/rel8/lib/bvecp-raw-helpers.cert : \
- rtl/rel8/lib/rtl.cert \
- rtl/rel8/lib/rtlarr.cert \
- rtl/rel8/lib/bits.cert \
- rtl/rel8/lib/float.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/bvecp-raw-helpers.lisp
-
-
-rtl/rel8/lib/clocks.cert : acl2x = 0
-rtl/rel8/lib/clocks.cert : no_pcert = 0
-
-rtl/rel8/lib/clocks.cert : \
- rtl/rel8/support/support/clocks.cert \
- rtl/rel8/lib/clocks.lisp
-
-
-rtl/rel8/lib/float.cert : acl2x = 0
-rtl/rel8/lib/float.cert : no_pcert = 0
-
-rtl/rel8/lib/float.cert : \
- rtl/rel8/lib/log.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/float.lisp
-
-
-rtl/rel8/lib/log.cert : acl2x = 0
-rtl/rel8/lib/log.cert : no_pcert = 0
-
-rtl/rel8/lib/log.cert : \
- rtl/rel8/lib/basic.cert \
- rtl/rel8/lib/bits.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/log.lisp
-
-
-rtl/rel8/lib/logn.cert : acl2x = 0
-rtl/rel8/lib/logn.cert : no_pcert = 0
-
-rtl/rel8/lib/logn.cert : \
- rtl/rel8/lib/bits.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/logn.lisp
-
-
-rtl/rel8/lib/logn2log.cert : acl2x = 0
-rtl/rel8/lib/logn2log.cert : no_pcert = 0
-
-rtl/rel8/lib/logn2log.cert : \
- rtl/rel8/lib/log.cert \
- rtl/rel8/lib/logn.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/logn2log.lisp
-
-
-rtl/rel8/lib/mult.cert : acl2x = 0
-rtl/rel8/lib/mult.cert : no_pcert = 0
-
-rtl/rel8/lib/mult.cert : \
- rtl/rel8/lib/add.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/mult.lisp
-
-
-rtl/rel8/lib/openers.cert : acl2x = 0
-rtl/rel8/lib/openers.cert : no_pcert = 0
-
-rtl/rel8/lib/openers.cert : \
- rtl/rel8/support/support/openers.cert \
- rtl/rel8/lib/openers.lisp
-
-
-rtl/rel8/lib/package-defs.cert : acl2x = 0
-rtl/rel8/lib/package-defs.cert : no_pcert = 0
-
-rtl/rel8/lib/package-defs.cert : \
- rtl/rel8/support/support/package-defs.cert \
- rtl/rel8/lib/package-defs.lisp
-
-
-rtl/rel8/lib/reps.cert : acl2x = 0
-rtl/rel8/lib/reps.cert : no_pcert = 0
-
-rtl/rel8/lib/reps.cert : \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/log.cert \
- rtl/rel8/lib/float.cert \
- rtl/rel8/lib/reps.lisp
-
-
-rtl/rel8/lib/rom-helpers.cert : acl2x = 0
-rtl/rel8/lib/rom-helpers.cert : no_pcert = 0
-
-rtl/rel8/lib/rom-helpers.cert : \
- rtl/rel8/support/support/rom-helpers.cert \
- rtl/rel8/lib/rom-helpers.lisp
-
-
-rtl/rel8/lib/round.cert : acl2x = 0
-rtl/rel8/lib/round.cert : no_pcert = 0
-
-rtl/rel8/lib/round.cert : \
- rtl/rel8/lib/float.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/round.lisp
-
-
-rtl/rel8/lib/rtl.cert : acl2x = 0
-rtl/rel8/lib/rtl.cert : no_pcert = 0
-
-rtl/rel8/lib/rtl.cert : \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/rtl.lisp
-
-
-rtl/rel8/lib/rtlarr.cert : acl2x = 0
-rtl/rel8/lib/rtlarr.cert : no_pcert = 0
-
-rtl/rel8/lib/rtlarr.cert : \
- rtl/rel8/support/top/top.cert \
- misc/total-order.cert \
- rtl/rel8/lib/rtl.cert \
- rtl/rel8/lib/rtlarr.lisp
-
-
-rtl/rel8/lib/simple-loop-helpers.cert : acl2x = 0
-rtl/rel8/lib/simple-loop-helpers.cert : no_pcert = 0
-
-rtl/rel8/lib/simple-loop-helpers.cert : \
- rtl/rel8/lib/rtl.cert \
- rtl/rel8/lib/rtlarr.cert \
- rtl/rel8/lib/log.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/simple-loop-helpers.lisp
-
-
-rtl/rel8/lib/simplify-model-helpers.cert : acl2x = 0
-rtl/rel8/lib/simplify-model-helpers.cert : no_pcert = 0
-
-rtl/rel8/lib/simplify-model-helpers.cert : \
- rtl/rel8/lib/rtl.cert \
- rtl/rel8/lib/arith.cert \
- rtl/rel8/lib/bits.cert \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/simplify-model-helpers.lisp
-
-
-rtl/rel8/lib/top.cert : acl2x = 0
-rtl/rel8/lib/top.cert : no_pcert = 0
-
-rtl/rel8/lib/top.cert : \
- rtl/rel8/lib/rtl.cert \
- rtl/rel8/lib/rtlarr.cert \
- rtl/rel8/lib/basic.cert \
- rtl/rel8/lib/bits.cert \
- rtl/rel8/lib/log.cert \
- rtl/rel8/lib/float.cert \
- rtl/rel8/lib/reps.cert \
- rtl/rel8/lib/round.cert \
- rtl/rel8/lib/add.cert \
- rtl/rel8/lib/mult.cert \
- rtl/rel8/lib/arith.cert \
- rtl/rel8/lib/util.cert \
- rtl/rel8/lib/top.lisp
-
-
-rtl/rel8/lib/util.cert : acl2x = 0
-rtl/rel8/lib/util.cert : no_pcert = 0
-
-rtl/rel8/lib/util.cert : \
- rtl/rel8/support/top/top.cert \
- rtl/rel8/lib/util.lisp
-
-
-rtl/rel8/support/lib1.delta1/arith-extra.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/arith-extra.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/arith-extra.cert : \
- rtl/rel8/support/lib1/arith.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib1.delta1/arith-extra.lisp
-
-
-rtl/rel8/support/lib1.delta1/arith.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/arith.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/arith.cert : \
- rtl/rel8/support/lib1/arith.cert \
- rtl/rel8/support/lib1.delta1/arith-extra.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel8/support/lib1.delta1/arith.lisp
-
-
-rtl/rel8/support/lib1.delta1/basic-extra.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/basic-extra.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/basic-extra.cert : \
- rtl/rel8/support/lib1/basic.cert \
- rtl/rel8/arithmetic/floor.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib1.delta1/basic-extra.lisp
-
-
-rtl/rel8/support/lib1.delta1/basic.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/basic.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/basic.cert : \
- rtl/rel8/support/lib1/basic.cert \
- rtl/rel8/support/lib1.delta1/basic-extra.cert \
- rtl/rel8/support/lib1.delta1/basic.lisp
-
-
-rtl/rel8/support/lib1.delta1/bits-extra.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/bits-extra.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/bits-extra.cert : \
- rtl/rel8/support/lib1/top.cert \
- rtl/rel8/support/lib1.delta1/bits-extra.lisp
-
-
-rtl/rel8/support/lib1.delta1/bits.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/bits.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/bits.cert : \
- rtl/rel8/support/lib1/bits.cert \
- rtl/rel8/support/lib1.delta1/bits-extra.cert \
- rtl/rel8/support/lib1.delta1/bits.lisp
-
-
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.cert : \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/bits.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.lisp
-
-
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.cert : \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/rtlarr.cert \
- rtl/rel8/support/lib1/bvecp-raw-helpers.cert \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.cert \
- rtl/rel8/arithmetic/expo.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.lisp
-
-
-rtl/rel8/support/lib1.delta1/float-extra2.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/float-extra2.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/float-extra2.cert : \
- rtl/rel8/support/lib1/top.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/support/lib1.delta1/float-extra2.lisp
-
-
-rtl/rel8/support/lib1.delta1/float.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/float.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/float.cert : \
- rtl/rel8/support/lib1/log.cert \
- rtl/rel8/support/lib1/float.cert \
- rtl/rel8/support/lib1.delta1/float-extra2.cert \
- rtl/rel8/support/lib1.delta1/float.lisp
-
-
-rtl/rel8/support/lib1.delta1/mult-proofs.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/mult-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/mult-proofs.cert : \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/sumbits.cert \
- rtl/rel8/support/support/util.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/lior.cert \
- rtl/rel8/support/support/land.cert \
- rtl/rel8/support/support/lxor.cert \
- rtl/rel8/support/lib1.delta1/mult-proofs.lisp \
- rtl/rel8/support/lib1.delta1/mult-proofs.acl2
-
-
-rtl/rel8/support/lib1.delta1/mult.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/mult.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/mult.cert : \
- rtl/rel8/support/lib1/add.cert \
- rtl/rel8/support/lib1.delta1/mult-proofs.cert \
- rtl/rel8/support/lib1.delta1/mult.lisp
-
-
-rtl/rel8/support/lib1.delta1/round-extra2.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/round-extra2.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/round-extra2.cert : \
- rtl/rel8/support/lib1/top.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/arithmetic/even-odd.cert \
- rtl/rel8/support/support/away.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/support/lib1.delta1/float-extra2.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/support/lib1.delta1/round-extra2.lisp
-
-
-rtl/rel8/support/lib1.delta1/round.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/round.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/round.cert : \
- rtl/rel8/support/lib1.delta1/float.cert \
- rtl/rel8/support/lib1/round.cert \
- rtl/rel8/support/lib1.delta1/round-extra2.cert \
- rtl/rel8/support/lib1.delta1/round.lisp
-
-
-rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.cert : \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/rtlarr.cert \
- rtl/rel8/support/lib1/bits.cert \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.lisp
-
-
-rtl/rel8/support/lib1.delta1/simple-loop-helpers.cert : acl2x = 0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta1/simple-loop-helpers.cert : \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/rtlarr.cert \
- rtl/rel8/support/lib1.delta1/arith.cert \
- rtl/rel8/support/lib1/log.cert \
- rtl/rel8/support/lib1/simple-loop-helpers.cert \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.cert \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers.lisp
-
-
-rtl/rel8/support/lib1.delta2/float-extra.cert : acl2x = 0
-rtl/rel8/support/lib1.delta2/float-extra.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta2/float-extra.cert : \
- rtl/rel8/support/lib1/top.cert \
- rtl/rel8/support/lib1.delta2/float-extra.lisp
-
-
-rtl/rel8/support/lib1.delta2/float.cert : acl2x = 0
-rtl/rel8/support/lib1.delta2/float.cert : no_pcert = 0
-
-rtl/rel8/support/lib1.delta2/float.cert : \
- rtl/rel8/support/lib1/log.cert \
- rtl/rel8/support/lib1.delta1/float.cert \
- rtl/rel8/support/lib1.delta2/float-extra.cert \
- rtl/rel8/support/lib1.delta2/float.lisp
-
-
-rtl/rel8/support/lib1/add.cert : acl2x = 0
-rtl/rel8/support/lib1/add.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/add.cert : \
- rtl/rel8/support/lib1/round.cert \
- rtl/rel8/support/support/top.cert \
- rtl/rel8/support/lib1/add.lisp
-
-
-rtl/rel8/support/lib1/arith.cert : acl2x = 0
-rtl/rel8/support/lib1/arith.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/arith.cert : \
- rtl/rel8/arithmetic/fp.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/arithmetic/expo.cert \
- rtl/rel8/arithmetic/extra-rules.cert \
- rtl/rel8/support/support/ash.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel8/support/lib1/arith.lisp
-
-
-rtl/rel8/support/lib1/basic.cert : acl2x = 0
-rtl/rel8/support/lib1/basic.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/basic.cert : \
- rtl/rel8/support/support/top.cert \
- rtl/rel8/support/lib1/basic.lisp
-
-
-rtl/rel8/support/lib1/bits.cert : acl2x = 0
-rtl/rel8/support/lib1/bits.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/bits.cert : \
- rtl/rel8/support/lib1/basic.cert \
- rtl/rel8/support/support/top.cert \
- rtl/rel8/support/lib1/bits.lisp
-
-
-rtl/rel8/support/lib1/bvecp-helpers.cert : acl2x = 0
-rtl/rel8/support/lib1/bvecp-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/bvecp-helpers.cert : \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/rtlarr.cert \
- rtl/rel8/support/support/bvecp-helpers.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/support/lib1/bvecp-helpers.lisp
-
-
-rtl/rel8/support/lib1/bvecp-raw-helpers.cert : acl2x = 0
-rtl/rel8/support/lib1/bvecp-raw-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/bvecp-raw-helpers.cert : \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/rtlarr.cert \
- rtl/rel8/support/support/bvecp-helpers.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/setbits.cert \
- rtl/rel8/support/support/setbitn.cert \
- rtl/rel8/support/support/logs.cert \
- rtl/rel8/support/support/lnot.cert \
- rtl/rel8/support/support/shft.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/mulcat.cert \
- rtl/rel8/support/support/encode.cert \
- rtl/rel8/support/support/decode.cert \
- rtl/rel8/support/support/land.cert \
- rtl/rel8/support/support/lior.cert \
- rtl/rel8/support/support/lxor.cert \
- rtl/rel8/support/support/guards.cert \
- rtl/rel8/arithmetic/expo.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/support/lib1/bvecp-raw-helpers.lisp
-
-
-rtl/rel8/support/lib1/clocks.cert : acl2x = 0
-rtl/rel8/support/lib1/clocks.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/clocks.cert : \
- rtl/rel8/support/support/clocks.cert \
- rtl/rel8/support/lib1/clocks.lisp
-
-
-rtl/rel8/support/lib1/float.cert : acl2x = 0
-rtl/rel8/support/lib1/float.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/float.cert : \
- rtl/rel8/support/lib1/log.cert \
- rtl/rel8/support/support/top.cert \
- rtl/rel8/support/lib1/float.lisp
-
-
-rtl/rel8/support/lib1/log.cert : acl2x = 0
-rtl/rel8/support/lib1/log.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/log.cert : \
- rtl/rel8/support/lib1/bits.cert \
- rtl/rel8/support/support/top.cert \
- rtl/rel8/support/lib1/log.lisp
-
-
-rtl/rel8/support/lib1/openers.cert : acl2x = 0
-rtl/rel8/support/lib1/openers.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/openers.cert : \
- rtl/rel8/support/support/openers.cert \
- rtl/rel8/support/lib1/openers.lisp
-
-
-rtl/rel8/support/lib1/package-defs.cert : acl2x = 0
-rtl/rel8/support/lib1/package-defs.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/package-defs.cert : \
- rtl/rel8/support/support/package-defs.cert \
- rtl/rel8/support/lib1/package-defs.lisp
-
-
-rtl/rel8/support/lib1/reps.cert : acl2x = 0
-rtl/rel8/support/lib1/reps.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/reps.cert : \
- rtl/rel8/support/support/ereps.cert \
- rtl/rel8/support/support/ireps.cert \
- rtl/rel8/support/support/guards.cert \
- rtl/rel8/support/lib1/log.cert \
- rtl/rel8/support/lib1/float.cert \
- rtl/rel8/support/lib1/reps.lisp
-
-
-rtl/rel8/support/lib1/rom-helpers.cert : acl2x = 0
-rtl/rel8/support/lib1/rom-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/rom-helpers.cert : \
- rtl/rel8/support/support/rom-helpers.cert \
- rtl/rel8/support/lib1/rom-helpers.lisp
-
-
-rtl/rel8/support/lib1/round.cert : acl2x = 0
-rtl/rel8/support/lib1/round.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/round.cert : \
- rtl/rel8/support/support/top.cert \
- rtl/rel8/support/lib1/reps.cert \
- rtl/rel8/support/lib1/round.lisp
-
-
-rtl/rel8/support/lib1/rtl.cert : acl2x = 0
-rtl/rel8/support/lib1/rtl.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/rtl.cert : \
- rtl/rel8/support/support/top.cert \
- rtl/rel8/support/lib1/rtl.lisp
-
-
-rtl/rel8/support/lib1/rtlarr.cert : acl2x = 0
-rtl/rel8/support/lib1/rtlarr.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/rtlarr.cert : \
- rtl/rel8/support/support/rtlarr.cert \
- rtl/rel8/support/support/bvecp-helpers.cert \
- rtl/rel8/support/support/guards.cert \
- misc/total-order.cert \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/rtlarr.lisp
-
-
-rtl/rel8/support/lib1/simple-loop-helpers.cert : acl2x = 0
-rtl/rel8/support/lib1/simple-loop-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/simple-loop-helpers.cert : \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/rtlarr.cert \
- rtl/rel8/support/lib1/arith.cert \
- rtl/rel8/support/lib1/log.cert \
- rtl/rel8/support/support/simple-loop-helpers.cert \
- rtl/rel8/support/lib1/simple-loop-helpers.lisp
-
-
-rtl/rel8/support/lib1/simplify-model-helpers.cert : acl2x = 0
-rtl/rel8/support/lib1/simplify-model-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/simplify-model-helpers.cert : \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/arith.cert \
- rtl/rel8/support/lib1/bits.cert \
- rtl/rel8/support/support/simplify-model-helpers.cert \
- rtl/rel8/support/lib1/simplify-model-helpers.lisp
-
-
-rtl/rel8/support/lib1/top.cert : acl2x = 0
-rtl/rel8/support/lib1/top.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/top.cert : \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/rtlarr.cert \
- rtl/rel8/support/lib1/basic.cert \
- rtl/rel8/support/lib1/bits.cert \
- rtl/rel8/support/lib1/log.cert \
- rtl/rel8/support/lib1/float.cert \
- rtl/rel8/support/lib1/reps.cert \
- rtl/rel8/support/lib1/round.cert \
- rtl/rel8/support/lib1/add.cert \
- rtl/rel8/support/lib1/arith.cert \
- rtl/rel8/support/lib1/util.cert \
- rtl/rel8/support/lib1/top.lisp
-
-
-rtl/rel8/support/lib1/util.cert : acl2x = 0
-rtl/rel8/support/lib1/util.cert : no_pcert = 0
-
-rtl/rel8/support/lib1/util.cert : \
- rtl/rel8/support/support/util.cert \
- rtl/rel8/support/lib1/util.lisp
-
-
-rtl/rel8/support/lib2.delta1/add-new-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/add-new-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/add-new-proofs.cert : \
- rtl/rel8/support/lib2.delta1/round-new.cert \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2.delta1/log-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/add-new-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/add-new.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/add-new.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/add-new.cert : \
- rtl/rel8/support/lib2.delta1/round-new.cert \
- rtl/rel8/support/lib2.delta1/add-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/add-new.lisp
-
-
-rtl/rel8/support/lib2.delta1/add-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/add-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/add-proofs.cert : \
- rtl/rel8/support/lib2.delta1/round.cert \
- rtl/rel8/support/lib2.delta1/add-new.cert \
- rtl/rel8/support/lib2.delta1/add-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/add.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/add.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/add.cert : \
- rtl/rel8/support/lib2.delta1/round.cert \
- rtl/rel8/support/lib2.delta1/add-proofs.cert \
- rtl/rel8/support/lib2.delta1/add.lisp
-
-
-rtl/rel8/support/lib2.delta1/arith.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/arith.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/arith.cert : \
- rtl/rel8/support/lib2/top.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel8/support/lib2.delta1/arith.lisp
-
-
-rtl/rel8/support/lib2.delta1/bits-new-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits-new-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/bits-new-proofs.cert : \
- rtl/rel8/support/lib2/bits.cert \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/log.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/badguys.cert \
- rtl/rel8/support/lib2/bits.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/bits-new.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits-new.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/bits-new.cert : \
- rtl/rel8/support/lib2/basic.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/bits-new.lisp
-
-
-rtl/rel8/support/lib2.delta1/bits-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/bits-proofs.cert : \
- rtl/rel8/support/lib2/basic.cert \
- rtl/rel8/support/lib2.delta1/bits-new.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/lib2.delta1/bits-new.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib2.delta1/bits-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/bits.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/bits.cert : \
- rtl/rel8/support/lib2/basic.cert \
- rtl/rel8/support/lib2.delta1/bits-proofs.cert \
- rtl/rel8/support/lib2.delta1/bits.lisp
-
-
-rtl/rel8/support/lib2.delta1/bvecp-helpers.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/bvecp-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/bvecp-helpers.cert : \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/rtlarr.cert \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.cert \
- rtl/rel8/support/lib2.delta1/bvecp-helpers.lisp
-
-
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.cert : \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/rtlarr.cert \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/float.cert \
- rtl/rel8/support/lib2.delta1/logn.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/support/encode.cert \
- rtl/rel8/support/support/decode.cert \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.cert : \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/rtlarr.cert \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/float.cert \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.cert \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.lisp
-
-
-rtl/rel8/support/lib2.delta1/float-new-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/float-new-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/float-new-proofs.cert : \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/float-new-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/float-new.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/float-new.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/float-new.cert : \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2.delta1/float-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/float-new.lisp
-
-
-rtl/rel8/support/lib2.delta1/float-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/float-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/float-proofs.cert : \
- rtl/rel8/support/lib2.delta1/log.cert \
- rtl/rel8/support/lib2.delta1/float-new.cert \
- rtl/rel8/support/lib2.delta1/float-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/float.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/float.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/float.cert : \
- rtl/rel8/support/lib2.delta1/log.cert \
- rtl/rel8/support/lib2.delta1/float-proofs.cert \
- rtl/rel8/support/lib2.delta1/float.lisp
-
-
-rtl/rel8/support/lib2.delta1/log-new-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-new-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/log-new-proofs.cert : \
- rtl/rel8/support/lib2.delta1/bits-new.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/support/logxor.cert \
- rtl/rel8/support/support/log.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/lognot.cert \
- rtl/rel8/support/support/lognot.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/lib2.delta1/log-new-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/log-new.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-new.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/log-new.cert : \
- rtl/rel8/support/lib2.delta1/bits-new.cert \
- rtl/rel8/support/lib2.delta1/log-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-new.lisp
-
-
-rtl/rel8/support/lib2.delta1/log-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/log-proofs.cert : \
- rtl/rel8/support/lib2/basic.cert \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2.delta1/log-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/log-support-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-support-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/log-support-proofs.cert : \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/support/lib2.delta1/bits-new.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2.delta1/log-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2.delta1/log-support-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/log-support.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-support.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/log-support.cert : \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/support/lib2.delta1/log-support-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-support.lisp
-
-
-rtl/rel8/support/lib2.delta1/log.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/log.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/log.cert : \
- rtl/rel8/support/lib2/basic.cert \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/log-proofs.cert \
- rtl/rel8/support/lib2.delta1/log.lisp
-
-
-rtl/rel8/support/lib2.delta1/logn-new-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn-new-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/logn-new-proofs.cert : \
- rtl/rel8/support/lib2.delta1/bits-new.cert \
- rtl/rel8/support/lib2.delta1/rtl-new.cert \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2.delta1/logn-new-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/logn-new.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn-new.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/logn-new.cert : \
- rtl/rel8/support/lib2.delta1/bits-new.cert \
- rtl/rel8/support/lib2.delta1/rtl-new.cert \
- rtl/rel8/support/lib2.delta1/logn-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/logn-new.lisp
-
-
-rtl/rel8/support/lib2.delta1/logn-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/logn-proofs.cert : \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/logn-new.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2.delta1/logn-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/logn.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/logn.cert : \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/logn-proofs.cert \
- rtl/rel8/support/lib2.delta1/logn.lisp
-
-
-rtl/rel8/support/lib2.delta1/logn2log-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn2log-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/logn2log-proofs.cert : \
- rtl/rel8/support/lib2.delta1/log.cert \
- rtl/rel8/support/lib2.delta1/logn.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib2.delta1/log.cert \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.cert \
- rtl/rel8/support/lib2.delta1/logn2log-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/logn2log.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn2log.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/logn2log.cert : \
- rtl/rel8/support/lib2.delta1/log.cert \
- rtl/rel8/support/lib2.delta1/logn.cert \
- rtl/rel8/support/lib2.delta1/logn2log-proofs.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib2.delta1/logn2log.lisp
-
-
-rtl/rel8/support/lib2.delta1/mult-new-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult-new-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/mult-new-proofs.cert : \
- rtl/rel8/support/lib2.delta1/add-new.cert \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib2.delta1/log-support.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/mult-new-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/mult-new.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult-new.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/mult-new.cert : \
- rtl/rel8/support/lib2.delta1/add-new.cert \
- rtl/rel8/support/lib2.delta1/mult-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/mult-new.lisp
-
-
-rtl/rel8/support/lib2.delta1/mult-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/mult-proofs.cert : \
- rtl/rel8/support/lib2.delta1/add.cert \
- rtl/rel8/support/lib2.delta1/mult-new.cert \
- rtl/rel8/support/lib2.delta1/mult-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/mult.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/mult.cert : \
- rtl/rel8/support/lib2.delta1/add.cert \
- rtl/rel8/support/lib2.delta1/mult-proofs.cert \
- rtl/rel8/support/lib2.delta1/mult.lisp
-
-
-rtl/rel8/support/lib2.delta1/reps-new-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps-new-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/reps-new-proofs.cert : \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2.delta1/float-new.cert \
- rtl/rel8/support/lib2.delta1/log-support.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib2.delta1/reps-new-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/reps-new.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps-new.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/reps-new.cert : \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2.delta1/float-new.cert \
- rtl/rel8/support/lib2.delta1/reps-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/reps-new.lisp
-
-
-rtl/rel8/support/lib2.delta1/reps-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/reps-proofs.cert : \
- rtl/rel8/support/lib2.delta1/log.cert \
- rtl/rel8/support/lib2.delta1/float.cert \
- rtl/rel8/support/lib2.delta1/reps-new.cert \
- rtl/rel8/support/lib2.delta1/reps-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/reps.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/reps.cert : \
- rtl/rel8/support/lib2.delta1/reps-proofs.cert \
- rtl/rel8/support/lib2.delta1/log.cert \
- rtl/rel8/support/lib2.delta1/float.cert \
- rtl/rel8/support/lib2.delta1/reps.lisp
-
-
-rtl/rel8/support/lib2.delta1/round-new-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/round-new-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/round-new-proofs.cert : \
- rtl/rel8/support/lib2.delta1/float-new.cert \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/support/support/land.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib2.delta1/round-new-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/round-new.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/round-new.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/round-new.cert : \
- rtl/rel8/support/lib2.delta1/float-new.cert \
- rtl/rel8/support/lib2.delta1/round-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/round-new.lisp
-
-
-rtl/rel8/support/lib2.delta1/round-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/round-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/round-proofs.cert : \
- rtl/rel8/support/lib2.delta1/float.cert \
- rtl/rel8/support/lib2.delta1/round-new.cert \
- rtl/rel8/support/lib2.delta1/round-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/round.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/round.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/round.cert : \
- rtl/rel8/support/lib2.delta1/float.cert \
- rtl/rel8/support/lib2.delta1/round-proofs.cert \
- rtl/rel8/support/lib2.delta1/round.lisp
-
-
-rtl/rel8/support/lib2.delta1/rtl-new-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl-new-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/rtl-new-proofs.cert : \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/lib2.delta1/rtl-new-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/rtl-new.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl-new.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/rtl-new.cert : \
- rtl/rel8/support/lib2.delta1/rtl-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/rtl-new.lisp
-
-
-rtl/rel8/support/lib2.delta1/rtl-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/rtl-proofs.cert : \
- rtl/rel8/support/lib2.delta1/rtl-new.cert \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/bits-new.cert \
- rtl/rel8/support/lib2.delta1/log-new.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib2.delta1/rtl-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/rtl.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/rtl.cert : \
- rtl/rel8/support/lib2.delta1/rtl-proofs.cert \
- rtl/rel8/support/lib2.delta1/rtl.lisp
-
-
-rtl/rel8/support/lib2.delta1/rtlarr-new.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtlarr-new.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/rtlarr-new.cert : \
- rtl/rel8/support/lib2/top.cert \
- misc/total-order.cert \
- rtl/rel8/support/lib2.delta1/rtl-new.cert \
- rtl/rel8/support/lib2.delta1/rtlarr-new.lisp
-
-
-rtl/rel8/support/lib2.delta1/rtlarr.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtlarr.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/rtlarr.cert : \
- rtl/rel8/support/lib2.delta1/rtlarr-new.cert \
- misc/total-order.cert \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/rtlarr.lisp
-
-
-rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.cert : \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/rtlarr.cert \
- rtl/rel8/support/lib2.delta1/logn.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/simple-loop-helpers.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/simple-loop-helpers.cert : \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/rtlarr.cert \
- rtl/rel8/support/lib2.delta1/log.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.cert \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers.lisp
-
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.cert : \
- rtl/rel8/support/lib2.delta1/bits-new.cert \
- rtl/rel8/support/lib2.delta1/logn-new.cert \
- rtl/rel8/support/lib2.delta1/arith.cert \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.cert \
- rtl/rel8/support/lib2/simplify-model-helpers.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.cert : \
- rtl/rel8/support/lib2.delta1/bits-new.cert \
- rtl/rel8/support/lib2.delta1/logn-new.cert \
- rtl/rel8/support/lib2.delta1/arith.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.lisp
-
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.cert : \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/logn.cert \
- rtl/rel8/support/lib2.delta1/arith.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.lisp
-
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers.cert : \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/arith.cert \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers.lisp
-
-
-rtl/rel8/support/lib2.delta1/top.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/top.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/top.cert : \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/rtlarr.cert \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/log.cert \
- rtl/rel8/support/lib2.delta1/float.cert \
- rtl/rel8/support/lib2.delta1/reps.cert \
- rtl/rel8/support/lib2.delta1/round.cert \
- rtl/rel8/support/lib2.delta1/add.cert \
- rtl/rel8/support/lib2.delta1/mult.cert \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.cert \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers.cert \
- rtl/rel8/support/lib2.delta1/arith.cert \
- rtl/rel8/support/lib2.delta1/bvecp-helpers.cert \
- rtl/rel8/support/lib2.delta1/logn.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers.cert \
- rtl/rel8/support/lib2.delta1/top.lisp
-
-
-rtl/rel8/support/lib2.delta1/util.cert : acl2x = 0
-rtl/rel8/support/lib2.delta1/util.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta1/util.cert : \
- rtl/rel8/support/lib2/top.cert \
- rtl/rel8/support/lib2.delta1/util.lisp
-
-
-rtl/rel8/support/lib2.delta2/add-lib.cert : acl2x = 0
-rtl/rel8/support/lib2.delta2/add-lib.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta2/add-lib.cert : \
- rtl/rel8/support/lib2.delta2/base.cert \
- rtl/rel8/support/lib2.delta1/arith.cert \
- rtl/rel8/support/lib2.delta2/add-lib.lisp
-
-
-rtl/rel8/support/lib2.delta2/add.cert : acl2x = 0
-rtl/rel8/support/lib2.delta2/add.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta2/add.cert : \
- rtl/rel8/support/lib2.delta2/base.cert \
- rtl/rel8/support/lib2.delta2/add-lib.cert \
- rtl/rel8/support/lib2.delta2/add.lisp
-
-
-rtl/rel8/support/lib2.delta2/base.cert : acl2x = 0
-rtl/rel8/support/lib2.delta2/base.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta2/base.cert : \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/rtlarr.cert \
- rtl/rel8/support/lib2/basic.cert \
- rtl/rel8/support/lib2.delta1/bits.cert \
- rtl/rel8/support/lib2.delta1/log.cert \
- rtl/rel8/support/lib2.delta1/float.cert \
- rtl/rel8/support/lib2.delta1/reps.cert \
- rtl/rel8/support/lib2.delta1/round.cert \
- rtl/rel8/support/lib2.delta1/add.cert \
- rtl/rel8/support/lib2.delta1/mult.cert \
- rtl/rel8/support/lib2.delta1/util.cert \
- rtl/rel8/support/lib2.delta2/base.lisp
-
-
-rtl/rel8/support/lib2.delta2/bits.cert : acl2x = 0
-rtl/rel8/support/lib2.delta2/bits.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta2/bits.cert : \
- rtl/rel8/support/lib2.delta2/base.cert \
- rtl/rel8/support/lib2.delta2/add-lib.cert \
- rtl/rel8/support/lib2.delta2/bits.lisp
-
-
-rtl/rel8/support/lib2.delta2/log.cert : acl2x = 0
-rtl/rel8/support/lib2.delta2/log.cert : no_pcert = 0
-
-rtl/rel8/support/lib2.delta2/log.cert : \
- rtl/rel8/support/lib2.delta2/base.cert \
- rtl/rel8/support/lib2.delta2/add-lib.cert \
- rtl/rel8/support/lib2.delta2/log.lisp
-
-
-rtl/rel8/support/lib2/add.cert : acl2x = 0
-rtl/rel8/support/lib2/add.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/add.cert : \
- rtl/rel8/support/lib2/round.cert \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/add.lisp
-
-
-rtl/rel8/support/lib2/arith.cert : acl2x = 0
-rtl/rel8/support/lib2/arith.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/arith.cert : \
- rtl/rel8/support/lib2/base.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel8/support/lib2/arith.lisp
-
-
-rtl/rel8/support/lib2/base.cert : acl2x = 0
-rtl/rel8/support/lib2/base.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/base.cert : \
- rtl/rel8/support/lib1/rtl.cert \
- rtl/rel8/support/lib1/rtlarr.cert \
- rtl/rel8/support/lib1.delta1/basic.cert \
- rtl/rel8/support/lib1.delta1/bits.cert \
- rtl/rel8/support/lib1/log.cert \
- rtl/rel8/support/lib1.delta2/float.cert \
- rtl/rel8/support/lib1/reps.cert \
- rtl/rel8/support/lib1.delta1/round.cert \
- rtl/rel8/support/lib1/add.cert \
- rtl/rel8/support/lib1.delta1/mult.cert \
- rtl/rel8/support/lib1.delta1/arith.cert \
- rtl/rel8/support/lib1/util.cert \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.cert \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers.cert \
- rtl/rel8/support/lib2/base.lisp
-
-
-rtl/rel8/support/lib2/basic.cert : acl2x = 0
-rtl/rel8/support/lib2/basic.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/basic.cert : \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/basic.lisp
-
-
-rtl/rel8/support/lib2/bits.cert : acl2x = 0
-rtl/rel8/support/lib2/bits.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/bits.cert : \
- rtl/rel8/support/lib2/basic.cert \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/bits.lisp
-
-
-rtl/rel8/support/lib2/bvecp-helpers.cert : acl2x = 0
-rtl/rel8/support/lib2/bvecp-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/bvecp-helpers.cert : \
- rtl/rel8/support/lib2/rtl.cert \
- rtl/rel8/support/lib2/rtlarr.cert \
- rtl/rel8/support/support/bvecp-helpers.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/support/lib2/bvecp-helpers.lisp
-
-
-rtl/rel8/support/lib2/bvecp-raw-helpers.cert : acl2x = 0
-rtl/rel8/support/lib2/bvecp-raw-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/bvecp-raw-helpers.cert : \
- rtl/rel8/support/lib2/rtl.cert \
- rtl/rel8/support/lib2/rtlarr.cert \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/bvecp-raw-helpers.lisp
-
-
-rtl/rel8/support/lib2/clocks.cert : acl2x = 0
-rtl/rel8/support/lib2/clocks.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/clocks.cert : \
- rtl/rel8/support/support/clocks.cert \
- rtl/rel8/support/lib2/clocks.lisp
-
-
-rtl/rel8/support/lib2/float.cert : acl2x = 0
-rtl/rel8/support/lib2/float.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/float.cert : \
- rtl/rel8/support/lib2/log.cert \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/float.lisp
-
-
-rtl/rel8/support/lib2/log.cert : acl2x = 0
-rtl/rel8/support/lib2/log.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/log.cert : \
- rtl/rel8/support/lib2/bits.cert \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/log.lisp
-
-
-rtl/rel8/support/lib2/mult.cert : acl2x = 0
-rtl/rel8/support/lib2/mult.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/mult.cert : \
- rtl/rel8/support/lib2/add.cert \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/mult.lisp
-
-
-rtl/rel8/support/lib2/openers.cert : acl2x = 0
-rtl/rel8/support/lib2/openers.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/openers.cert : \
- rtl/rel8/support/support/openers.cert \
- rtl/rel8/support/lib2/openers.lisp
-
-
-rtl/rel8/support/lib2/package-defs.cert : acl2x = 0
-rtl/rel8/support/lib2/package-defs.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/package-defs.cert : \
- rtl/rel8/support/support/package-defs.cert \
- rtl/rel8/support/lib2/package-defs.lisp
-
-
-rtl/rel8/support/lib2/reps.cert : acl2x = 0
-rtl/rel8/support/lib2/reps.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/reps.cert : \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/log.cert \
- rtl/rel8/support/lib2/float.cert \
- rtl/rel8/support/lib2/reps.lisp
-
-
-rtl/rel8/support/lib2/rom-helpers.cert : acl2x = 0
-rtl/rel8/support/lib2/rom-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/rom-helpers.cert : \
- rtl/rel8/support/support/rom-helpers.cert \
- rtl/rel8/support/lib2/rom-helpers.lisp
-
-
-rtl/rel8/support/lib2/round.cert : acl2x = 0
-rtl/rel8/support/lib2/round.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/round.cert : \
- rtl/rel8/support/lib2/float.cert \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/round.lisp
-
-
-rtl/rel8/support/lib2/rtl.cert : acl2x = 0
-rtl/rel8/support/lib2/rtl.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/rtl.cert : \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/rtl.lisp
-
-
-rtl/rel8/support/lib2/rtlarr.cert : acl2x = 0
-rtl/rel8/support/lib2/rtlarr.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/rtlarr.cert : \
- rtl/rel8/support/lib2/base.cert \
- misc/total-order.cert \
- rtl/rel8/support/lib2/rtl.cert \
- rtl/rel8/support/lib2/rtlarr.lisp
-
-
-rtl/rel8/support/lib2/simple-loop-helpers.cert : acl2x = 0
-rtl/rel8/support/lib2/simple-loop-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/simple-loop-helpers.cert : \
- rtl/rel8/support/lib2/rtl.cert \
- rtl/rel8/support/lib2/rtlarr.cert \
- rtl/rel8/support/lib2/arith.cert \
- rtl/rel8/support/lib2/log.cert \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/simple-loop-helpers.lisp
-
-
-rtl/rel8/support/lib2/simplify-model-helpers.cert : acl2x = 0
-rtl/rel8/support/lib2/simplify-model-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/simplify-model-helpers.cert : \
- rtl/rel8/support/lib2/rtl.cert \
- rtl/rel8/support/lib2/arith.cert \
- rtl/rel8/support/lib2/bits.cert \
- rtl/rel8/support/support/simplify-model-helpers.cert \
- rtl/rel8/support/lib2/simplify-model-helpers.lisp
-
-
-rtl/rel8/support/lib2/top.cert : acl2x = 0
-rtl/rel8/support/lib2/top.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/top.cert : \
- rtl/rel8/support/lib2/rtl.cert \
- rtl/rel8/support/lib2/rtlarr.cert \
- rtl/rel8/support/lib2/basic.cert \
- rtl/rel8/support/lib2/bits.cert \
- rtl/rel8/support/lib2/log.cert \
- rtl/rel8/support/lib2/float.cert \
- rtl/rel8/support/lib2/reps.cert \
- rtl/rel8/support/lib2/round.cert \
- rtl/rel8/support/lib2/add.cert \
- rtl/rel8/support/lib2/mult.cert \
- rtl/rel8/support/lib2/arith.cert \
- rtl/rel8/support/lib2/util.cert \
- rtl/rel8/support/lib2/top.lisp
-
-
-rtl/rel8/support/lib2/util.cert : acl2x = 0
-rtl/rel8/support/lib2/util.cert : no_pcert = 0
-
-rtl/rel8/support/lib2/util.cert : \
- rtl/rel8/support/lib2/base.cert \
- rtl/rel8/support/lib2/util.lisp
-
-
-rtl/rel8/support/support/add3-proofs.cert : acl2x = 0
-rtl/rel8/support/support/add3-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/add3-proofs.cert : \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/arithmetic/top.cert \
- ordinals/e0-ordinal.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/support/support/add3-proofs.lisp
-
-
-rtl/rel8/support/support/add3.cert : acl2x = 0
-rtl/rel8/support/support/add3.cert : no_pcert = 0
-
-rtl/rel8/support/support/add3.cert : \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/add3-proofs.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/support/support/add3.lisp
-
-
-rtl/rel8/support/support/all-ones.cert : acl2x = 0
-rtl/rel8/support/support/all-ones.cert : no_pcert = 0
-
-rtl/rel8/support/support/all-ones.cert : \
- rtl/rel8/support/support/all-ones.lisp
-
-
-rtl/rel8/support/support/ash.cert : acl2x = 0
-rtl/rel8/support/support/ash.cert : no_pcert = 0
-
-rtl/rel8/support/support/ash.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/arithmetic/expo.cert \
- rtl/rel8/support/support/ash.lisp
-
-
-rtl/rel8/support/support/away-proofs.cert : acl2x = 0
-rtl/rel8/support/support/away-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/away-proofs.cert : \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/away-proofs.lisp
-
-
-rtl/rel8/support/support/away.cert : acl2x = 0
-rtl/rel8/support/support/away.cert : no_pcert = 0
-
-rtl/rel8/support/support/away.cert : \
- rtl/rel8/support/support/away-proofs.cert \
- rtl/rel8/support/support/away.lisp
-
-
-rtl/rel8/support/support/badguys.cert : acl2x = 0
-rtl/rel8/support/support/badguys.cert : no_pcert = 0
-
-rtl/rel8/support/support/badguys.cert : \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/badguys.lisp
-
-
-rtl/rel8/support/support/bias-proofs.cert : acl2x = 0
-rtl/rel8/support/support/bias-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/bias-proofs.cert : \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/support/support/bias-proofs.lisp
-
-
-rtl/rel8/support/support/bias.cert : acl2x = 0
-rtl/rel8/support/support/bias.cert : no_pcert = 0
-
-rtl/rel8/support/support/bias.cert : \
- rtl/rel8/support/support/bias-proofs.cert \
- rtl/rel8/support/support/bias.lisp
-
-
-rtl/rel8/support/support/bitn-proofs.cert : acl2x = 0
-rtl/rel8/support/support/bitn-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/bitn-proofs.cert : \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/bitn-proofs.lisp
-
-
-rtl/rel8/support/support/bitn.cert : acl2x = 0
-rtl/rel8/support/support/bitn.cert : no_pcert = 0
-
-rtl/rel8/support/support/bitn.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/support/support/bitn-proofs.cert \
- rtl/rel8/support/support/bitn.lisp
-
-
-rtl/rel8/support/support/bits-proofs.cert : acl2x = 0
-rtl/rel8/support/support/bits-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/bits-proofs.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/bits-proofs.lisp
-
-
-rtl/rel8/support/support/bits-trunc-proofs.cert : acl2x = 0
-rtl/rel8/support/support/bits-trunc-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/bits-trunc-proofs.cert : \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/log.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/bits-trunc-proofs.lisp
-
-
-rtl/rel8/support/support/bits-trunc.cert : acl2x = 0
-rtl/rel8/support/support/bits-trunc.cert : no_pcert = 0
-
-rtl/rel8/support/support/bits-trunc.cert : \
- rtl/rel8/support/support/log.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/bits-trunc-proofs.cert \
- rtl/rel8/support/support/bits-trunc.lisp
-
-
-rtl/rel8/support/support/bits.cert : acl2x = 0
-rtl/rel8/support/support/bits.cert : no_pcert = 0
-
-rtl/rel8/support/support/bits.cert : \
- rtl/rel8/support/support/bits-proofs.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/support/support/bits.lisp
-
-
-rtl/rel8/support/support/bvecp-helpers.cert : acl2x = 0
-rtl/rel8/support/support/bvecp-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/support/bvecp-helpers.cert : \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/bvecp-lemmas.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bvecp-helpers.lisp
-
-
-rtl/rel8/support/support/bvecp-lemmas.cert : acl2x = 0
-rtl/rel8/support/support/bvecp-lemmas.cert : no_pcert = 0
-
-rtl/rel8/support/support/bvecp-lemmas.cert : \
- rtl/rel8/arithmetic/expo.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/setbits.cert \
- rtl/rel8/support/support/setbitn.cert \
- rtl/rel8/support/support/encode.cert \
- rtl/rel8/support/support/decode.cert \
- rtl/rel8/support/support/logs.cert \
- rtl/rel8/support/support/lnot.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/shft.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/mulcat.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/bvecp-lemmas.lisp
-
-
-rtl/rel8/support/support/bvecp-proofs.cert : acl2x = 0
-rtl/rel8/support/support/bvecp-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/bvecp-proofs.cert : \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bvecp-proofs.lisp
-
-
-rtl/rel8/support/support/bvecp.cert : acl2x = 0
-rtl/rel8/support/support/bvecp.cert : no_pcert = 0
-
-rtl/rel8/support/support/bvecp.cert : \
- rtl/rel8/support/support/bvecp-proofs.cert \
- rtl/rel8/support/support/bvecp.lisp
-
-
-rtl/rel8/support/support/cat-def.cert : acl2x = 0
-rtl/rel8/support/support/cat-def.cert : no_pcert = 0
-
-rtl/rel8/support/support/cat-def.cert : \
- rtl/rel8/support/support/cat-def.lisp
-
-
-rtl/rel8/support/support/cat-proofs.cert : acl2x = 0
-rtl/rel8/support/support/cat-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/cat-proofs.cert : \
- rtl/rel8/support/support/cat-def.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/cat-proofs.lisp
-
-
-rtl/rel8/support/support/cat.cert : acl2x = 0
-rtl/rel8/support/support/cat.cert : no_pcert = 0
-
-rtl/rel8/support/support/cat.cert : \
- rtl/rel8/support/support/cat-def.cert \
- rtl/rel8/support/support/cat-proofs.cert \
- rtl/rel8/support/support/cat.lisp
-
-
-rtl/rel8/support/support/clocks.cert : acl2x = 0
-rtl/rel8/support/support/clocks.cert : no_pcert = 0
-
-rtl/rel8/support/support/clocks.cert : \
- rtl/rel8/support/support/mod4.cert \
- rtl/rel8/arithmetic/even-odd2.cert \
- rtl/rel8/support/support/clocks.lisp
-
-
-rtl/rel8/support/support/decode-proofs.cert : acl2x = 0
-rtl/rel8/support/support/decode-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/decode-proofs.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/support/support/ash.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/decode-proofs.lisp
-
-
-rtl/rel8/support/support/decode.cert : acl2x = 0
-rtl/rel8/support/support/decode.cert : no_pcert = 0
-
-rtl/rel8/support/support/decode.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/decode-proofs.cert \
- rtl/rel8/support/support/decode.lisp
-
-
-rtl/rel8/support/support/drnd-original.cert : acl2x = 0
-rtl/rel8/support/support/drnd-original.cert : no_pcert = 0
-
-rtl/rel8/support/support/drnd-original.cert : \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/ireps.cert \
- rtl/rel8/support/support/rnd.cert \
- rtl/rel8/support/support/bias.cert \
- rtl/rel8/support/support/sgn.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/away.cert \
- rtl/rel8/support/support/near.cert \
- rtl/rel8/support/support/near+.cert \
- rtl/rel8/support/support/sticky.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/drnd-original.lisp
-
-
-rtl/rel8/support/support/encode.cert : acl2x = 0
-rtl/rel8/support/support/encode.cert : no_pcert = 0
-
-rtl/rel8/support/support/encode.cert : \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/ash.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/encode.lisp
-
-
-rtl/rel8/support/support/ereps-proofs.cert : acl2x = 0
-rtl/rel8/support/support/ereps-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/ereps-proofs.cert : \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/bias.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/mulcat.cert \
- rtl/rel8/support/support/ereps-proofs.lisp
-
-
-rtl/rel8/support/support/ereps.cert : acl2x = 0
-rtl/rel8/support/support/ereps.cert : no_pcert = 0
-
-rtl/rel8/support/support/ereps.cert : \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/ereps-proofs.cert \
- rtl/rel8/support/support/ereps.lisp
-
-
-rtl/rel8/support/support/fadd-extra.cert : acl2x = 0
-rtl/rel8/support/support/fadd-extra.cert : no_pcert = 0
-
-rtl/rel8/support/support/fadd-extra.cert : \
- rtl/rel8/support/support/fadd-extra0.cert \
- rtl/rel8/support/support/land.cert \
- rtl/rel8/support/support/lior.cert \
- rtl/rel8/support/support/lxor.cert \
- rtl/rel8/support/support/top1.cert \
- rtl/rel8/support/support/fadd-extra.lisp
-
-
-rtl/rel8/support/support/fadd-extra0.cert : acl2x = 0
-rtl/rel8/support/support/fadd-extra0.cert : no_pcert = 0
-
-rtl/rel8/support/support/fadd-extra0.cert : \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/fadd.cert \
- rtl/rel8/support/support/top1.cert \
- rtl/rel8/support/support/fadd-extra0.lisp
-
-
-rtl/rel8/support/support/fadd.cert : acl2x = 0
-rtl/rel8/support/support/fadd.cert : no_pcert = 0
-
-rtl/rel8/support/support/fadd.cert : \
- rtl/rel8/support/support/stick.cert \
- rtl/rel8/support/support/lop3.cert \
- rtl/rel8/support/support/add3.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/lextra0.cert \
- rtl/rel8/support/support/fadd.lisp
-
-
-rtl/rel8/support/support/fast-and.cert : acl2x = 0
-rtl/rel8/support/support/fast-and.cert : no_pcert = 0
-
-rtl/rel8/support/support/fast-and.cert : \
- rtl/rel8/support/support/fast-and.lisp
-
-
-rtl/rel8/support/support/float-extra.cert : acl2x = 0
-rtl/rel8/support/support/float-extra.cert : no_pcert = 0
-
-rtl/rel8/support/support/float-extra.cert : \
- arithmetic/inequalities.cert \
- rtl/rel8/support/support/sticky.cert \
- rtl/rel8/support/support/util.cert \
- rtl/rel8/support/support/top1.cert \
- rtl/rel8/support/support/float-extra.lisp
-
-
-rtl/rel8/support/support/float.cert : acl2x = 0
-rtl/rel8/support/support/float.cert : no_pcert = 0
-
-rtl/rel8/support/support/float.cert : \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/arithmetic/negative-syntaxp.cert \
- rtl/rel8/arithmetic/basic.cert \
- rtl/rel8/arithmetic/power2p.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/cg.cert \
- rtl/rel8/support/support/float.lisp
-
-
-rtl/rel8/support/support/ground-zero.cert : acl2x = 0
-rtl/rel8/support/support/ground-zero.cert : no_pcert = 0
-
-rtl/rel8/support/support/ground-zero.cert : \
- rtl/rel8/arithmetic/ground-zero.cert \
- rtl/rel8/support/support/util.cert \
- rtl/rel8/support/support/ground-zero.lisp
-
-
-rtl/rel8/support/support/guards.cert : acl2x = 0
-rtl/rel8/support/support/guards.cert : no_pcert = 0
-
-rtl/rel8/support/support/guards.cert : \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/top1.cert \
- rtl/rel8/support/support/land.cert \
- rtl/rel8/support/support/lior.cert \
- rtl/rel8/support/support/lxor.cert \
- rtl/rel8/support/support/guards.lisp
-
-
-rtl/rel8/support/support/ireps.cert : acl2x = 0
-rtl/rel8/support/support/ireps.cert : no_pcert = 0
-
-rtl/rel8/support/support/ireps.cert : \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/bias.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/ireps.lisp
-
-
-rtl/rel8/support/support/land.cert : acl2x = 0
-rtl/rel8/support/support/land.cert : no_pcert = 0
-
-rtl/rel8/support/support/land.cert : \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/top1.cert \
- rtl/rel8/support/support/land.lisp
-
-
-rtl/rel8/support/support/land0-proofs.cert : acl2x = 0
-rtl/rel8/support/support/land0-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/land0-proofs.cert : \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/all-ones.cert \
- rtl/rel8/support/support/log.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/arithmetic/fl-hacks.cert \
- rtl/rel8/support/support/land0-proofs.lisp
-
-
-rtl/rel8/support/support/land0.cert : acl2x = 0
-rtl/rel8/support/support/land0.cert : no_pcert = 0
-
-rtl/rel8/support/support/land0.cert : \
- rtl/rel8/support/support/land0-proofs.cert \
- rtl/rel8/support/support/land0.lisp
-
-
-rtl/rel8/support/support/lextra-proofs.cert : acl2x = 0
-rtl/rel8/support/support/lextra-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/lextra-proofs.cert : \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/support/logxor.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/lextra-proofs.lisp
-
-
-rtl/rel8/support/support/lextra.cert : acl2x = 0
-rtl/rel8/support/support/lextra.cert : no_pcert = 0
-
-rtl/rel8/support/support/lextra.cert : \
- rtl/rel8/support/support/land.cert \
- rtl/rel8/support/support/lior.cert \
- rtl/rel8/support/support/lxor.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/lextra0.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/support/support/merge2.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bits-trunc.cert \
- rtl/rel8/support/support/fadd.cert \
- rtl/rel8/support/support/lextra.lisp
-
-
-rtl/rel8/support/support/lextra0.cert : acl2x = 0
-rtl/rel8/support/support/lextra0.cert : no_pcert = 0
-
-rtl/rel8/support/support/lextra0.cert : \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/support/support/lextra-proofs.cert \
- rtl/rel8/support/support/lextra0.lisp
-
-
-rtl/rel8/support/support/lior.cert : acl2x = 0
-rtl/rel8/support/support/lior.cert : no_pcert = 0
-
-rtl/rel8/support/support/lior.cert : \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/top1.cert \
- rtl/rel8/support/support/lior.lisp
-
-
-rtl/rel8/support/support/lior0-proofs.cert : acl2x = 0
-rtl/rel8/support/support/lior0-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/lior0-proofs.cert : \
- rtl/rel8/support/support/all-ones.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/lior0-proofs.lisp
-
-
-rtl/rel8/support/support/lior0.cert : acl2x = 0
-rtl/rel8/support/support/lior0.cert : no_pcert = 0
-
-rtl/rel8/support/support/lior0.cert : \
- rtl/rel8/support/support/lior0-proofs.cert \
- rtl/rel8/support/support/lior0.lisp
-
-
-rtl/rel8/support/support/lnot-proofs.cert : acl2x = 0
-rtl/rel8/support/support/lnot-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/lnot-proofs.cert : \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/arithmetic/mod.cert \
- rtl/rel8/arithmetic/mod.cert \
- rtl/rel8/arithmetic/arith.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/lnot-proofs.lisp
-
-
-rtl/rel8/support/support/lnot.cert : acl2x = 0
-rtl/rel8/support/support/lnot.cert : no_pcert = 0
-
-rtl/rel8/support/support/lnot.cert : \
- rtl/rel8/support/support/lnot-proofs.cert \
- rtl/rel8/support/support/lnot.lisp
-
-
-rtl/rel8/support/support/log-equal.cert : acl2x = 0
-rtl/rel8/support/support/log-equal.cert : no_pcert = 0
-
-rtl/rel8/support/support/log-equal.cert : \
- rtl/rel8/support/support/log-equal.lisp
-
-
-rtl/rel8/support/support/log-proofs.cert : acl2x = 0
-rtl/rel8/support/support/log-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/log-proofs.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/lognot.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/lnot.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/logxor.cert \
- rtl/rel8/support/support/log-proofs.lisp
-
-
-rtl/rel8/support/support/log.cert : acl2x = 0
-rtl/rel8/support/support/log.cert : no_pcert = 0
-
-rtl/rel8/support/support/log.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/log-proofs.cert \
- rtl/rel8/support/support/lnot.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/support/logxor.cert \
- rtl/rel8/support/support/log.lisp
-
-
-rtl/rel8/support/support/logand-proofs.cert : acl2x = 0
-rtl/rel8/support/support/logand-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/logand-proofs.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/induct.cert \
- rtl/rel8/support/support/lognot.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/logand-proofs.lisp
-
-
-rtl/rel8/support/support/logand.cert : acl2x = 0
-rtl/rel8/support/support/logand.cert : no_pcert = 0
-
-rtl/rel8/support/support/logand.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/logand-proofs.cert \
- rtl/rel8/support/support/logand.lisp
-
-
-rtl/rel8/support/support/logeqv.cert : acl2x = 0
-rtl/rel8/support/support/logeqv.cert : no_pcert = 0
-
-rtl/rel8/support/support/logeqv.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/logorc1.cert \
- rtl/rel8/support/support/lognot.cert \
- rtl/rel8/support/support/logeqv.lisp
-
-
-rtl/rel8/support/support/logior-proofs.cert : acl2x = 0
-rtl/rel8/support/support/logior-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/logior-proofs.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/lognot.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/logior-proofs.lisp
-
-
-rtl/rel8/support/support/logior.cert : acl2x = 0
-rtl/rel8/support/support/logior.cert : no_pcert = 0
-
-rtl/rel8/support/support/logior.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/logior-proofs.cert \
- rtl/rel8/support/support/logior.lisp
-
-
-rtl/rel8/support/support/logior1-proofs.cert : acl2x = 0
-rtl/rel8/support/support/logior1-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/logior1-proofs.cert : \
- rtl/rel8/support/support/logior1-proofs.lisp
-
-
-rtl/rel8/support/support/logior1.cert : acl2x = 0
-rtl/rel8/support/support/logior1.cert : no_pcert = 0
-
-rtl/rel8/support/support/logior1.cert : \
- rtl/rel8/support/support/logior1-proofs.cert \
- rtl/rel8/support/support/logior1.lisp
-
-
-rtl/rel8/support/support/lognot.cert : acl2x = 0
-rtl/rel8/support/support/lognot.cert : no_pcert = 0
-
-rtl/rel8/support/support/lognot.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/lognot.lisp
-
-
-rtl/rel8/support/support/logorc1.cert : acl2x = 0
-rtl/rel8/support/support/logorc1.cert : no_pcert = 0
-
-rtl/rel8/support/support/logorc1.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/support/support/lognot.cert \
- rtl/rel8/support/support/logorc1.lisp
-
-
-rtl/rel8/support/support/logs.cert : acl2x = 0
-rtl/rel8/support/support/logs.cert : no_pcert = 0
-
-rtl/rel8/support/support/logs.cert : \
- rtl/rel8/support/support/logs.lisp
-
-
-rtl/rel8/support/support/logxor.cert : acl2x = 0
-rtl/rel8/support/support/logxor.cert : no_pcert = 0
-
-rtl/rel8/support/support/logxor.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/logeqv.cert \
- rtl/rel8/support/support/logorc1.cert \
- rtl/rel8/support/support/lognot.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/logxor.lisp
-
-
-rtl/rel8/support/support/lop1-proofs.cert : acl2x = 0
-rtl/rel8/support/support/lop1-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/lop1-proofs.cert : \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/lop1-proofs.lisp
-
-
-rtl/rel8/support/support/lop1.cert : acl2x = 0
-rtl/rel8/support/support/lop1.cert : no_pcert = 0
-
-rtl/rel8/support/support/lop1.cert : \
- rtl/rel8/support/support/lop1-proofs.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/lop1.lisp
-
-
-rtl/rel8/support/support/lop2-proofs.cert : acl2x = 0
-rtl/rel8/support/support/lop2-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/lop2-proofs.cert : \
- rtl/rel8/support/support/lop1.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/support/lop2-proofs.lisp
-
-
-rtl/rel8/support/support/lop2.cert : acl2x = 0
-rtl/rel8/support/support/lop2.cert : no_pcert = 0
-
-rtl/rel8/support/support/lop2.cert : \
- rtl/rel8/support/support/lop1.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lop2-proofs.cert \
- rtl/rel8/support/support/lop2.lisp
-
-
-rtl/rel8/support/support/lop3-proofs.cert : acl2x = 0
-rtl/rel8/support/support/lop3-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/lop3-proofs.cert : \
- rtl/rel8/support/support/lop2.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/support/support/lop3-proofs.lisp
-
-
-rtl/rel8/support/support/lop3.cert : acl2x = 0
-rtl/rel8/support/support/lop3.cert : no_pcert = 0
-
-rtl/rel8/support/support/lop3.cert : \
- rtl/rel8/support/support/lop2.cert \
- rtl/rel8/support/support/lop3-proofs.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/support/support/lop3.lisp
-
-
-rtl/rel8/support/support/lxor.cert : acl2x = 0
-rtl/rel8/support/support/lxor.cert : no_pcert = 0
-
-rtl/rel8/support/support/lxor.cert : \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/support/support/top1.cert \
- rtl/rel8/support/support/lxor.lisp
-
-
-rtl/rel8/support/support/lxor0-proofs.cert : acl2x = 0
-rtl/rel8/support/support/lxor0-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/lxor0-proofs.cert : \
- rtl/rel8/support/support/all-ones.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/lxor0-proofs.lisp
-
-
-rtl/rel8/support/support/lxor0.cert : acl2x = 0
-rtl/rel8/support/support/lxor0.cert : no_pcert = 0
-
-rtl/rel8/support/support/lxor0.cert : \
- rtl/rel8/support/support/lxor0-proofs.cert \
- rtl/rel8/support/support/lxor0.lisp
-
-
-rtl/rel8/support/support/merge.cert : acl2x = 0
-rtl/rel8/support/support/merge.cert : no_pcert = 0
-
-rtl/rel8/support/support/merge.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/log.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/lnot.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/logxor.cert \
- rtl/rel8/support/support/ocat.cert \
- rtl/rel8/support/support/sumbits.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/merge.lisp
-
-
-rtl/rel8/support/support/merge2.cert : acl2x = 0
-rtl/rel8/support/support/merge2.cert : no_pcert = 0
-
-rtl/rel8/support/support/merge2.cert : \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/support/support/logs.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/merge2.lisp
-
-
-rtl/rel8/support/support/mod4.cert : acl2x = 0
-rtl/rel8/support/support/mod4.cert : no_pcert = 0
-
-rtl/rel8/support/support/mod4.cert : \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/mod4.lisp
-
-
-rtl/rel8/support/support/model-helpers.cert : acl2x = 0
-rtl/rel8/support/support/model-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/support/model-helpers.cert : \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/model-helpers.lisp
-
-
-rtl/rel8/support/support/mulcat-proofs.cert : acl2x = 0
-rtl/rel8/support/support/mulcat-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/mulcat-proofs.cert : \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/cat-def.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/mulcat-proofs.lisp
-
-
-rtl/rel8/support/support/mulcat.cert : acl2x = 0
-rtl/rel8/support/support/mulcat.cert : no_pcert = 0
-
-rtl/rel8/support/support/mulcat.cert : \
- rtl/rel8/support/support/cat-def.cert \
- rtl/rel8/support/support/mulcat-proofs.cert \
- rtl/rel8/support/support/mulcat.lisp
-
-
-rtl/rel8/support/support/near+-proofs.cert : acl2x = 0
-rtl/rel8/support/support/near+-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/near+-proofs.cert : \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/away.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/arithmetic/predicate.cert \
- rtl/rel8/arithmetic/cg.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/fl.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/near+-proofs.lisp
-
-
-rtl/rel8/support/support/near+.cert : acl2x = 0
-rtl/rel8/support/support/near+.cert : no_pcert = 0
-
-rtl/rel8/support/support/near+.cert : \
- rtl/rel8/support/support/near+-proofs.cert \
- rtl/rel8/support/support/near+.lisp
-
-
-rtl/rel8/support/support/near-proofs.cert : acl2x = 0
-rtl/rel8/support/support/near-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/near-proofs.cert : \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/away.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/near-proofs.lisp
-
-
-rtl/rel8/support/support/near.cert : acl2x = 0
-rtl/rel8/support/support/near.cert : no_pcert = 0
-
-rtl/rel8/support/support/near.cert : \
- rtl/rel8/support/support/near-proofs.cert \
- rtl/rel8/support/support/near.lisp
-
-
-rtl/rel8/support/support/ocat.cert : acl2x = 0
-rtl/rel8/support/support/ocat.cert : no_pcert = 0
-
-rtl/rel8/support/support/ocat.cert : \
- rtl/rel8/arithmetic/expt.cert \
- rtl/rel8/arithmetic/expo.cert \
- rtl/rel8/arithmetic/arith2.cert \
- rtl/rel8/arithmetic/fp2.cert \
- rtl/rel8/arithmetic/integerp.cert \
- rtl/rel8/support/support/ocat.lisp
-
-
-rtl/rel8/support/support/oddr-proofs.cert : acl2x = 0
-rtl/rel8/support/support/oddr-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/oddr-proofs.cert : \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/away.cert \
- rtl/rel8/support/support/near.cert \
- rtl/rel8/support/support/oddr-proofs.lisp
-
-
-rtl/rel8/support/support/oddr.cert : acl2x = 0
-rtl/rel8/support/support/oddr.cert : no_pcert = 0
-
-rtl/rel8/support/support/oddr.cert : \
- rtl/rel8/support/support/oddr-proofs.cert \
- rtl/rel8/support/support/oddr.lisp
-
-
-rtl/rel8/support/support/openers.cert : acl2x = 0
-rtl/rel8/support/support/openers.cert : no_pcert = 0
-
-rtl/rel8/support/support/openers.cert : \
- rtl/rel8/support/support/openers.lisp
-
-
-rtl/rel8/support/support/package-defs.cert : acl2x = 0
-rtl/rel8/support/support/package-defs.cert : no_pcert = 0
-
-rtl/rel8/support/support/package-defs.cert : \
- rtl/rel8/support/support/package-defs.lisp
-
-
-rtl/rel8/support/support/rewrite-theory.cert : acl2x = 0
-rtl/rel8/support/support/rewrite-theory.cert : no_pcert = 0
-
-rtl/rel8/support/support/rewrite-theory.cert : \
- rtl/rel8/support/support/rewrite-theory.lisp
-
-
-rtl/rel8/support/support/rnd.cert : acl2x = 0
-rtl/rel8/support/support/rnd.cert : no_pcert = 0
-
-rtl/rel8/support/support/rnd.cert : \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/away.cert \
- rtl/rel8/support/support/near.cert \
- rtl/rel8/support/support/near+.cert \
- rtl/rel8/support/support/sticky.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/bits-trunc.cert \
- rtl/rel8/support/support/rnd.lisp
-
-
-rtl/rel8/support/support/rom-helpers.cert : acl2x = 0
-rtl/rel8/support/support/rom-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/support/rom-helpers.cert : \
- rtl/rel8/support/support/rom-helpers.lisp
-
-
-rtl/rel8/support/support/round-extra.cert : acl2x = 0
-rtl/rel8/support/support/round-extra.cert : no_pcert = 0
-
-rtl/rel8/support/support/round-extra.cert : \
- rtl/rel8/support/support/sticky.cert \
- rtl/rel8/support/support/util.cert \
- rtl/rel8/support/support/top1.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/round-extra.lisp
-
-
-rtl/rel8/support/support/rtl.cert : acl2x = 0
-rtl/rel8/support/support/rtl.cert : no_pcert = 0
-
-rtl/rel8/support/support/rtl.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/rtlarr.cert \
- rtl/rel8/support/support/cat-def.cert \
- rtl/rel8/support/support/rtl.lisp
-
-
-rtl/rel8/support/support/rtlarr.cert : acl2x = 0
-rtl/rel8/support/support/rtlarr.cert : no_pcert = 0
-
-rtl/rel8/support/support/rtlarr.cert : \
- misc/total-order.cert \
- rtl/rel8/support/support/rtlarr.lisp
-
-
-rtl/rel8/support/support/setbitn-proofs.cert : acl2x = 0
-rtl/rel8/support/support/setbitn-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/setbitn-proofs.cert : \
- rtl/rel8/support/support/cat-def.cert \
- rtl/rel8/support/support/setbits.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/setbitn-proofs.lisp
-
-
-rtl/rel8/support/support/setbitn.cert : acl2x = 0
-rtl/rel8/support/support/setbitn.cert : no_pcert = 0
-
-rtl/rel8/support/support/setbitn.cert : \
- rtl/rel8/support/support/cat-def.cert \
- rtl/rel8/support/support/setbitn-proofs.cert \
- rtl/rel8/support/support/setbitn.lisp
-
-
-rtl/rel8/support/support/setbits-proofs.cert : acl2x = 0
-rtl/rel8/support/support/setbits-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/setbits-proofs.cert : \
- rtl/rel8/support/support/cat-def.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/setbits-proofs.lisp
-
-
-rtl/rel8/support/support/setbits.cert : acl2x = 0
-rtl/rel8/support/support/setbits.cert : no_pcert = 0
-
-rtl/rel8/support/support/setbits.cert : \
- rtl/rel8/support/support/cat-def.cert \
- rtl/rel8/support/support/setbits-proofs.cert \
- rtl/rel8/support/support/setbits.lisp
-
-
-rtl/rel8/support/support/sgn.cert : acl2x = 0
-rtl/rel8/support/support/sgn.cert : no_pcert = 0
-
-rtl/rel8/support/support/sgn.cert : \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/sgn.lisp
-
-
-rtl/rel8/support/support/shft.cert : acl2x = 0
-rtl/rel8/support/support/shft.cert : no_pcert = 0
-
-rtl/rel8/support/support/shft.cert : \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/shft.lisp
-
-
-rtl/rel8/support/support/simple-loop-helpers.cert : acl2x = 0
-rtl/rel8/support/support/simple-loop-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/support/simple-loop-helpers.cert : \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/setbitn.cert \
- rtl/rel8/support/support/simple-loop-helpers.lisp
-
-
-rtl/rel8/support/support/simplify-model-helpers.cert : acl2x = 0
-rtl/rel8/support/support/simplify-model-helpers.cert : no_pcert = 0
-
-rtl/rel8/support/support/simplify-model-helpers.cert : \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/simplify-model-helpers.lisp
-
-
-rtl/rel8/support/support/stick-proofs.cert : acl2x = 0
-rtl/rel8/support/support/stick-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/stick-proofs.cert : \
- rtl/rel8/support/support/merge.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/lnot.cert \
- rtl/rel8/support/support/stick-proofs.lisp
-
-
-rtl/rel8/support/support/stick.cert : acl2x = 0
-rtl/rel8/support/support/stick.cert : no_pcert = 0
-
-rtl/rel8/support/support/stick.cert : \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/stick-proofs.cert \
- rtl/rel8/support/support/stick.lisp
-
-
-rtl/rel8/support/support/sticky-proofs.cert : acl2x = 0
-rtl/rel8/support/support/sticky-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/sticky-proofs.cert : \
- rtl/rel8/arithmetic/arith.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/away.cert \
- rtl/rel8/support/support/near.cert \
- rtl/rel8/support/support/near+.cert \
- rtl/rel8/support/support/sticky-proofs.lisp
-
-
-rtl/rel8/support/support/sticky.cert : acl2x = 0
-rtl/rel8/support/support/sticky.cert : no_pcert = 0
-
-rtl/rel8/support/support/sticky.cert : \
- rtl/rel8/support/support/sticky-proofs.cert \
- rtl/rel8/support/support/sticky.lisp
-
-
-rtl/rel8/support/support/sumbits.cert : acl2x = 0
-rtl/rel8/support/support/sumbits.cert : no_pcert = 0
-
-rtl/rel8/support/support/sumbits.cert : \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/sumbits.lisp
-
-
-rtl/rel8/support/support/top.cert : acl2x = 0
-rtl/rel8/support/support/top.cert : no_pcert = 0
-
-rtl/rel8/support/support/top.cert : \
- rtl/rel8/support/support/top1.cert \
- rtl/rel8/support/support/lextra.cert \
- rtl/rel8/support/support/fadd-extra.cert \
- rtl/rel8/support/support/float-extra.cert \
- rtl/rel8/support/support/round-extra.cert \
- rtl/rel8/support/support/guards.cert \
- rtl/rel8/support/support/badguys.cert \
- rtl/rel8/support/support/top.lisp
-
-
-rtl/rel8/support/support/top1.cert : acl2x = 0
-rtl/rel8/support/support/top1.cert : no_pcert = 0
-
-rtl/rel8/support/support/top1.cert : \
- rtl/rel8/support/support/util.cert \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/rewrite-theory.cert \
- rtl/rel8/support/support/rtl.cert \
- rtl/rel8/support/support/rtlarr.cert \
- rtl/rel8/support/support/bvecp-lemmas.cert \
- rtl/rel8/support/support/bits.cert \
- rtl/rel8/support/support/bitn.cert \
- rtl/rel8/support/support/ocat.cert \
- rtl/rel8/support/support/cat-def.cert \
- rtl/rel8/support/support/cat.cert \
- rtl/rel8/support/support/bvecp.cert \
- rtl/rel8/support/support/ash.cert \
- rtl/rel8/support/support/decode.cert \
- rtl/rel8/support/support/encode.cert \
- rtl/rel8/support/support/mulcat.cert \
- rtl/rel8/support/support/shft.cert \
- rtl/rel8/support/support/all-ones.cert \
- rtl/rel8/support/support/merge2.cert \
- rtl/rel8/support/support/logior1.cert \
- rtl/rel8/support/support/setbits.cert \
- rtl/rel8/support/support/setbitn.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/support/support/bias.cert \
- rtl/rel8/support/support/ereps.cert \
- rtl/rel8/support/support/ireps.cert \
- rtl/rel8/support/support/logeqv.cert \
- rtl/rel8/support/support/logorc1.cert \
- rtl/rel8/support/support/lognot.cert \
- rtl/rel8/support/support/logand.cert \
- rtl/rel8/support/support/logior.cert \
- rtl/rel8/support/support/logxor.cert \
- rtl/rel8/support/support/log.cert \
- rtl/rel8/support/support/lnot.cert \
- rtl/rel8/support/support/land0.cert \
- rtl/rel8/support/support/lior0.cert \
- rtl/rel8/support/support/lxor0.cert \
- rtl/rel8/support/support/lextra0.cert \
- rtl/rel8/support/support/logs.cert \
- rtl/rel8/support/support/trunc.cert \
- rtl/rel8/support/support/away.cert \
- rtl/rel8/support/support/near.cert \
- rtl/rel8/support/support/near+.cert \
- rtl/rel8/support/support/oddr.cert \
- rtl/rel8/support/support/sticky.cert \
- rtl/rel8/support/support/rnd.cert \
- rtl/rel8/support/support/drnd-original.cert \
- rtl/rel8/support/support/bits-trunc.cert \
- rtl/rel8/support/support/add3.cert \
- rtl/rel8/support/support/lop1.cert \
- rtl/rel8/support/support/lop2.cert \
- rtl/rel8/support/support/lop3.cert \
- rtl/rel8/support/support/stick.cert \
- rtl/rel8/support/support/bvecp-helpers.cert \
- rtl/rel8/support/support/model-helpers.cert \
- rtl/rel8/support/support/rom-helpers.cert \
- rtl/rel8/support/support/simple-loop-helpers.cert \
- rtl/rel8/support/support/clocks.cert \
- rtl/rel8/support/support/openers.cert \
- rtl/rel8/support/support/package-defs.cert \
- rtl/rel8/support/support/simplify-model-helpers.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/arithmetic/fp.cert \
- rtl/rel8/support/support/fadd.cert \
- rtl/rel8/support/support/top1.lisp
-
-
-rtl/rel8/support/support/trunc-proofs.cert : acl2x = 0
-rtl/rel8/support/support/trunc-proofs.cert : no_pcert = 0
-
-rtl/rel8/support/support/trunc-proofs.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/float.cert \
- rtl/rel8/arithmetic/top.cert \
- rtl/rel8/support/support/trunc-proofs.lisp
-
-
-rtl/rel8/support/support/trunc.cert : acl2x = 0
-rtl/rel8/support/support/trunc.cert : no_pcert = 0
-
-rtl/rel8/support/support/trunc.cert : \
- rtl/rel8/support/support/ground-zero.cert \
- rtl/rel8/support/support/trunc-proofs.cert \
- rtl/rel8/support/support/trunc.lisp
-
-
-rtl/rel8/support/support/util.cert : acl2x = 0
-rtl/rel8/support/support/util.cert : no_pcert = 0
-
-rtl/rel8/support/support/util.cert : \
- rtl/rel8/support/support/util.lisp
-
-
-rtl/rel8/support/top/top.cert : acl2x = 0
-rtl/rel8/support/top/top.cert : no_pcert = 0
-
-rtl/rel8/support/top/top.cert : \
- rtl/rel8/support/lib2.delta1/rtl.cert \
- rtl/rel8/support/lib2.delta1/rtlarr.cert \
- rtl/rel8/support/lib2/basic.cert \
- rtl/rel8/support/lib2.delta2/bits.cert \
- rtl/rel8/support/lib2.delta2/log.cert \
- rtl/rel8/support/lib2.delta1/float.cert \
- rtl/rel8/support/lib2.delta1/reps.cert \
- rtl/rel8/support/lib2.delta1/round.cert \
- rtl/rel8/support/lib2.delta2/add.cert \
- rtl/rel8/support/lib2.delta1/mult.cert \
- rtl/rel8/support/lib2.delta1/arith.cert \
- rtl/rel8/support/lib2.delta1/util.cert \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.cert \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers.cert \
- rtl/rel8/support/lib2/rom-helpers.cert \
- rtl/rel8/support/lib2.delta1/bvecp-helpers.cert \
- rtl/rel8/support/lib2.delta1/logn.cert \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers.cert \
- rtl/rel8/support/lib2.delta1/logn2log.cert \
- rtl/rel8/support/top/top.lisp
-
-
-security/jfkr/diffie-helman.cert : acl2x = 0
-security/jfkr/diffie-helman.cert : no_pcert = 0
-
-security/jfkr/diffie-helman.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- security/jfkr/diffie-helman.lisp \
- security/jfkr/cert.acl2 \
- security/jfkr/package.lsp
-
-
-security/jfkr/encryption.cert : acl2x = 0
-security/jfkr/encryption.cert : no_pcert = 0
-
-security/jfkr/encryption.cert : \
- security/jfkr/encryption.lisp \
- security/jfkr/cert.acl2 \
- security/jfkr/package.lsp
-
-
-security/jfkr/jfkr.cert : acl2x = 0
-security/jfkr/jfkr.cert : no_pcert = 0
-
-security/jfkr/jfkr.cert : \
- security/jfkr/encryption.cert \
- security/jfkr/diffie-helman.cert \
- security/jfkr/random.cert \
- misc/assert.cert \
- misc/untranslate-patterns.cert \
- security/jfkr/jfkr.lisp \
- security/jfkr/cert.acl2 \
- security/jfkr/package.lsp
-
-
-security/jfkr/random.cert : acl2x = 0
-security/jfkr/random.cert : no_pcert = 0
-
-security/jfkr/random.cert : \
- arithmetic-3/floor-mod/floor-mod.cert \
- security/jfkr/random.lisp \
- security/jfkr/cert.acl2 \
- security/jfkr/package.lsp
-
-
-security/suite-b/sha-2.cert : acl2x = 0
-security/suite-b/sha-2.cert : no_pcert = 0
-
-security/suite-b/sha-2.cert : \
- security/util/byte-operations.cert \
- security/suite-b/sha-2.lisp
-
-
-security/util/byte-operations.cert : acl2x = 0
-security/util/byte-operations.cert : no_pcert = 0
-
-security/util/byte-operations.cert : \
- arithmetic-5/top.cert \
- security/util/byte-operations.lisp
-
-
-serialize/serialize-tests.cert : acl2x = 0
-serialize/serialize-tests.cert : no_pcert = 0
-
-serialize/serialize-tests.cert : \
- serialize/unsound-read.cert \
- tools/bstar.cert \
- serialize/serialize-tests.lisp \
- serialize/serialize-tests.acl2
-
-
-serialize/serialize-tests2.cert : acl2x = 0
-serialize/serialize-tests2.cert : no_pcert = 0
-
-serialize/serialize-tests2.cert : \
- serialize/serialize-tests.cert \
- serialize/serialize-tests2.lisp \
- serialize/serialize-tests2.acl2
-
-
-serialize/unsound-read.cert : acl2x = 0
-serialize/unsound-read.cert : no_pcert = 0
-
-serialize/unsound-read.cert : \
- tools/include-raw.cert \
- serialize/unsound-read.lisp \
- serialize/unsound-read.acl2 \
- serialize/unsound-read-raw.lsp
-
-
-sorting/bsort.cert : acl2x = 0
-sorting/bsort.cert : no_pcert = 0
-
-sorting/bsort.cert : \
- sorting/ordered-perms.cert \
- sorting/convert-perm-to-how-many.cert \
- sorting/bsort.lisp
-
-
-sorting/convert-perm-to-how-many.cert : acl2x = 0
-sorting/convert-perm-to-how-many.cert : no_pcert = 0
-
-sorting/convert-perm-to-how-many.cert : \
- sorting/perm.cert \
- sorting/convert-perm-to-how-many.lisp
-
-
-sorting/equisort.cert : acl2x = 0
-sorting/equisort.cert : no_pcert = 0
-
-sorting/equisort.cert : \
- sorting/perm.cert \
- sorting/ordered-perms.cert \
- sorting/convert-perm-to-how-many.cert \
- sorting/equisort.lisp
-
-
-sorting/equisort2.cert : acl2x = 0
-sorting/equisort2.cert : no_pcert = 0
-
-sorting/equisort2.cert : \
- sorting/perm.cert \
- sorting/ordered-perms.cert \
- sorting/convert-perm-to-how-many.cert \
- sorting/equisort2.lisp
-
-
-sorting/equisort3.cert : acl2x = 0
-sorting/equisort3.cert : no_pcert = 0
-
-sorting/equisort3.cert : \
- sorting/perm.cert \
- sorting/ordered-perms.cert \
- sorting/convert-perm-to-how-many.cert \
- sorting/equisort3.lisp
-
-
-sorting/isort.cert : acl2x = 0
-sorting/isort.cert : no_pcert = 0
-
-sorting/isort.cert : \
- sorting/perm.cert \
- sorting/ordered-perms.cert \
- sorting/convert-perm-to-how-many.cert \
- sorting/isort.lisp
-
-
-sorting/msort.cert : acl2x = 0
-sorting/msort.cert : no_pcert = 0
-
-sorting/msort.cert : \
- sorting/perm.cert \
- sorting/ordered-perms.cert \
- sorting/convert-perm-to-how-many.cert \
- sorting/msort.lisp
-
-
-sorting/no-dups-qsort.cert : acl2x = 0
-sorting/no-dups-qsort.cert : no_pcert = 0
-
-sorting/no-dups-qsort.cert : \
- sorting/qsort.cert \
- sorting/no-dups-qsort.lisp
-
-
-sorting/ordered-perms.cert : acl2x = 0
-sorting/ordered-perms.cert : no_pcert = 0
-
-sorting/ordered-perms.cert : \
- sorting/perm.cert \
- sorting/ordered-perms.lisp
-
-
-sorting/perm.cert : acl2x = 0
-sorting/perm.cert : no_pcert = 0
-
-sorting/perm.cert : \
- sorting/perm.lisp
-
-
-sorting/qsort.cert : acl2x = 0
-sorting/qsort.cert : no_pcert = 0
-
-sorting/qsort.cert : \
- sorting/perm.cert \
- sorting/ordered-perms.cert \
- sorting/convert-perm-to-how-many.cert \
- arithmetic-3/extra/top-ext.cert \
- sorting/qsort.lisp
-
-
-sorting/sorts-equivalent.cert : acl2x = 0
-sorting/sorts-equivalent.cert : no_pcert = 0
-
-sorting/sorts-equivalent.cert : \
- sorting/equisort.cert \
- sorting/isort.cert \
- sorting/msort.cert \
- sorting/qsort.cert \
- sorting/bsort.cert \
- sorting/sorts-equivalent.lisp
-
-
-sorting/sorts-equivalent2.cert : acl2x = 0
-sorting/sorts-equivalent2.cert : no_pcert = 0
-
-sorting/sorts-equivalent2.cert : \
- sorting/equisort2.cert \
- sorting/isort.cert \
- sorting/msort.cert \
- sorting/qsort.cert \
- sorting/bsort.cert \
- sorting/sorts-equivalent2.lisp
-
-
-sorting/sorts-equivalent3.cert : acl2x = 0
-sorting/sorts-equivalent3.cert : no_pcert = 0
-
-sorting/sorts-equivalent3.cert : \
- sorting/equisort3.cert \
- sorting/isort.cert \
- sorting/msort.cert \
- sorting/qsort.cert \
- sorting/bsort.cert \
- sorting/sorts-equivalent3.lisp
-
-
-std/io/base.cert : acl2x = 0
-std/io/base.cert : no_pcert = 0
-
-std/io/base.cert : \
- xdoc/top.cert \
- system/f-put-global.cert \
- ihs/quotient-remainder-lemmas.cert \
- std/io/base.lisp
-
-
-std/io/close-input-channel.cert : acl2x = 0
-std/io/close-input-channel.cert : no_pcert = 0
-
-std/io/close-input-channel.cert : \
- std/io/base.cert \
- std/io/close-input-channel.lisp
-
-
-std/io/combine.cert : acl2x = 0
-std/io/combine.cert : no_pcert = 0
-
-std/io/combine.cert : \
- std/io/sign-byte.cert \
- std/io/unsigned-byte-listp.cert \
- std/io/signed-byte-listp.cert \
- std/io/combine.lisp
-
-
-std/io/file-measure.cert : acl2x = 0
-std/io/file-measure.cert : no_pcert = 0
-
-std/io/file-measure.cert : \
- std/io/base.cert \
- std/io/file-measure.lisp
-
-
-std/io/nthcdr-bytes.cert : acl2x = 0
-std/io/nthcdr-bytes.cert : no_pcert = 0
-
-std/io/nthcdr-bytes.cert : \
- std/io/read-byte.cert \
- std/io/read-file-bytes.cert \
- tools/mv-nth.cert \
- std/io/nthcdr-bytes.lisp
-
-
-std/io/open-input-channel.cert : acl2x = 0
-std/io/open-input-channel.cert : no_pcert = 0
-
-std/io/open-input-channel.cert : \
- tools/mv-nth.cert \
- system/update-state.cert \
- std/io/open-input-channels.cert \
- arithmetic/top.cert \
- std/ks/explode-nonnegative-integer.cert \
- std/ks/intern-in-package-of-symbol.cert \
- std/lists/coerce.cert \
- std/io/open-input-channel.lisp
-
-
-std/io/open-input-channels.cert : acl2x = 0
-std/io/open-input-channels.cert : no_pcert = 0
-
-std/io/open-input-channels.cert : \
- std/io/open-input-channels.lisp
-
-
-std/io/peek-char.cert : acl2x = 0
-std/io/peek-char.cert : no_pcert = 0
-
-std/io/peek-char.cert : \
- std/io/base.cert \
- std/io/peek-char.lisp
-
-
-std/io/read-byte.cert : acl2x = 0
-std/io/read-byte.cert : no_pcert = 0
-
-std/io/read-byte.cert : \
- std/io/base.cert \
- std/io/read-byte.lisp
-
-
-std/io/read-char.cert : acl2x = 0
-std/io/read-char.cert : no_pcert = 0
-
-std/io/read-char.cert : \
- std/io/base.cert \
- std/io/read-char.lisp
-
-
-std/io/read-file-bytes.cert : acl2x = 0
-std/io/read-file-bytes.cert : no_pcert = 0
-
-std/io/read-file-bytes.cert : \
- std/io/base.cert \
- std/io/unsigned-byte-listp.cert \
- tools/mv-nth.cert \
- std/io/read-file-bytes.lisp
-
-
-std/io/read-file-characters-no-error.cert : acl2x = 0
-std/io/read-file-characters-no-error.cert : no_pcert = 0
-
-std/io/read-file-characters-no-error.cert : \
- std/io/read-file-characters.cert \
- tools/mv-nth.cert \
- std/io/read-file-characters-no-error.lisp \
- std/io/read-file-characters-no-error.acl2
-
-
-std/io/read-file-characters.cert : acl2x = 0
-std/io/read-file-characters.cert : no_pcert = 0
-
-std/io/read-file-characters.cert : \
- std/io/base.cert \
- std/lists/revappend.cert \
- tools/mv-nth.cert \
- std/lists/rev.cert \
- std/io/read-file-characters.lisp
-
-
-std/io/read-file-lines.cert : acl2x = 0
-std/io/read-file-lines.cert : no_pcert = 0
-
-std/io/read-file-lines.cert : \
- std/io/base.cert \
- std/lists/revappend.cert \
- std/lists/rev.cert \
- tools/mv-nth.cert \
- tools/bstar.cert \
- std/io/read-file-lines.lisp
-
-
-std/io/read-file-objects.cert : acl2x = 0
-std/io/read-file-objects.cert : no_pcert = 0
-
-std/io/read-file-objects.cert : \
- std/io/base.cert \
- tools/mv-nth.cert \
- std/io/read-file-objects.lisp
-
-
-std/io/read-ints.cert : acl2x = 0
-std/io/read-ints.cert : no_pcert = 0
-
-std/io/read-ints.cert : \
- std/io/read-byte.cert \
- std/io/unsigned-byte-listp.cert \
- std/io/signed-byte-listp.cert \
- std/io/sign-byte.cert \
- std/io/combine.cert \
- tools/mv-nth.cert \
- arithmetic-3/bind-free/top.cert \
- std/io/read-ints.lisp
-
-
-std/io/read-object.cert : acl2x = 0
-std/io/read-object.cert : no_pcert = 0
-
-std/io/read-object.cert : \
- std/io/base.cert \
- std/io/read-object.lisp
-
-
-std/io/sign-byte.cert : acl2x = 0
-std/io/sign-byte.cert : no_pcert = 0
-
-std/io/sign-byte.cert : \
- std/io/sign-byte.lisp
-
-
-std/io/signed-byte-listp.cert : acl2x = 0
-std/io/signed-byte-listp.cert : no_pcert = 0
-
-std/io/signed-byte-listp.cert : \
- ihs/logops-lemmas.cert \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- std/io/unsigned-byte-listp.cert \
- std/io/signed-byte-listp.lisp
-
-
-std/io/take-bytes.cert : acl2x = 0
-std/io/take-bytes.cert : no_pcert = 0
-
-std/io/take-bytes.cert : \
- std/io/read-byte.cert \
- std/io/read-file-bytes.cert \
- std/io/nthcdr-bytes.cert \
- std/io/take-bytes.lisp
-
-
-std/io/unsigned-byte-listp.cert : acl2x = 0
-std/io/unsigned-byte-listp.cert : no_pcert = 0
-
-std/io/unsigned-byte-listp.cert : \
- std/lists/take.cert \
- std/lists/nat-listp.cert \
- std/lists/repeat.cert \
- ihs/logops-lemmas.cert \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- std/io/unsigned-byte-listp.lisp
-
-
-std/ks/base10-digit-charp.cert : acl2x = 0
-std/ks/base10-digit-charp.cert : no_pcert = 0
-
-std/ks/base10-digit-charp.cert : \
- std/ks/base10-digit-charp.lisp
-
-
-std/ks/explode-atom.cert : acl2x = 0
-std/ks/explode-atom.cert : no_pcert = 0
-
-std/ks/explode-atom.cert : \
- std/ks/base10-digit-charp.cert \
- std/lists/append.cert \
- std/ks/explode-nonnegative-integer.cert \
- std/ks/explode-atom.lisp
-
-
-std/ks/explode-nonnegative-integer.cert : acl2x = 0
-std/ks/explode-nonnegative-integer.cert : no_pcert = 0
-
-std/ks/explode-nonnegative-integer.cert : \
- ihs/quotient-remainder-lemmas.cert \
- std/lists/revappend.cert \
- std/ks/base10-digit-charp.cert \
- std/lists/rev.cert \
- std/ks/explode-nonnegative-integer.lisp
-
-
-std/ks/intern-in-package-of-symbol.cert : acl2x = 0
-std/ks/intern-in-package-of-symbol.cert : no_pcert = 0
-
-std/ks/intern-in-package-of-symbol.cert : \
- std/ks/intern-in-package-of-symbol.lisp
-
-
-std/ks/string-append.cert : acl2x = 0
-std/ks/string-append.cert : no_pcert = 0
-
-std/ks/string-append.cert : \
- std/lists/append.cert \
- std/lists/coerce.cert \
- std/ks/string-append.lisp
-
-
-std/ks/two-nats-measure.cert : acl2x = 0
-std/ks/two-nats-measure.cert : no_pcert = 0
-
-std/ks/two-nats-measure.cert : \
- arithmetic/top-with-meta.cert \
- std/ks/two-nats-measure.lisp
-
-
-std/lists/app.cert : acl2x = 0
-std/lists/app.cert : no_pcert = 0
-
-std/lists/app.cert : \
- std/lists/list-fix.cert \
- std/lists/take.cert \
- std/lists/nthcdr.cert \
- arithmetic/top.cert \
- std/lists/app.lisp
-
-
-std/lists/append.cert : acl2x = 0
-std/lists/append.cert : no_pcert = 0
-
-std/lists/append.cert : \
- std/lists/list-fix.cert \
- arithmetic/top.cert \
- std/lists/append.lisp
-
-
-std/lists/coerce.cert : acl2x = 0
-std/lists/coerce.cert : no_pcert = 0
-
-std/lists/coerce.cert : \
- std/lists/make-character-list.cert \
- std/lists/coerce.lisp
-
-
-std/lists/consless-listp.cert : acl2x = 0
-std/lists/consless-listp.cert : no_pcert = 0
-
-std/lists/consless-listp.cert : \
- std/lists/app.cert \
- std/lists/consless-listp.lisp
-
-
-std/lists/equiv.cert : acl2x = 0
-std/lists/equiv.cert : no_pcert = 0
-
-std/lists/equiv.cert : \
- std/lists/list-fix.cert \
- std/lists/take.cert \
- arithmetic/top.cert \
- std/lists/equiv.lisp
-
-
-std/lists/final-cdr.cert : acl2x = 0
-std/lists/final-cdr.cert : no_pcert = 0
-
-std/lists/final-cdr.cert : \
- std/lists/nthcdr.cert \
- std/lists/final-cdr.lisp
-
-
-std/lists/flatten.cert : acl2x = 0
-std/lists/flatten.cert : no_pcert = 0
-
-std/lists/flatten.cert : \
- std/lists/app.cert \
- std/lists/consless-listp.cert \
- std/lists/flatten.lisp
-
-
-std/lists/list-defuns.cert : acl2x = 0
-std/lists/list-defuns.cert : no_pcert = 0
-
-std/lists/list-defuns.cert : \
- std/lists/app.cert \
- std/lists/append.cert \
- std/lists/list-fix.cert \
- std/lists/flatten.cert \
- std/lists/final-cdr.cert \
- std/lists/prefixp.cert \
- std/lists/take.cert \
- std/lists/repeat.cert \
- std/lists/revappend.cert \
- std/lists/rev.cert \
- std/lists/equiv.cert \
- std/lists/sets.cert \
- std/lists/list-defuns.lisp
-
-
-std/lists/list-fix.cert : acl2x = 0
-std/lists/list-fix.cert : no_pcert = 0
-
-std/lists/list-fix.cert : \
- std/lists/take.cert \
- arithmetic/top.cert \
- std/lists/list-fix.lisp
-
-
-std/lists/make-character-list.cert : acl2x = 0
-std/lists/make-character-list.cert : no_pcert = 0
-
-std/lists/make-character-list.cert : \
- std/lists/make-character-list.lisp
-
-
-std/lists/mfc-utils.cert : acl2x = 0
-std/lists/mfc-utils.cert : no_pcert = 0
-
-std/lists/mfc-utils.cert : \
- std/lists/mfc-utils.lisp
-
-
-std/lists/nat-listp.cert : acl2x = 0
-std/lists/nat-listp.cert : no_pcert = 0
-
-std/lists/nat-listp.cert : \
- std/lists/app.cert \
- arithmetic/nat-listp.cert \
- std/lists/nat-listp.lisp
-
-
-std/lists/nthcdr.cert : acl2x = 0
-std/lists/nthcdr.cert : no_pcert = 0
-
-std/lists/nthcdr.cert : \
- std/lists/nthcdr.lisp
-
-
-std/lists/prefixp.cert : acl2x = 0
-std/lists/prefixp.cert : no_pcert = 0
-
-std/lists/prefixp.cert : \
- std/lists/list-fix.cert \
- std/lists/take.cert \
- arithmetic/top.cert \
- std/lists/prefixp.lisp
-
-
-std/lists/repeat.cert : acl2x = 0
-std/lists/repeat.cert : no_pcert = 0
-
-std/lists/repeat.cert : \
- std/lists/take.cert \
- std/lists/append.cert \
- std/lists/repeat.lisp
-
-
-std/lists/rev.cert : acl2x = 0
-std/lists/rev.cert : no_pcert = 0
-
-std/lists/rev.cert : \
- std/lists/revappend.cert \
- std/lists/reverse.cert \
- std/lists/append.cert \
- std/lists/make-character-list.cert \
- std/lists/rev.lisp
-
-
-std/lists/revappend.cert : acl2x = 0
-std/lists/revappend.cert : no_pcert = 0
-
-std/lists/revappend.cert : \
- arithmetic/top.cert \
- std/lists/revappend.lisp
-
-
-std/lists/reverse.cert : acl2x = 0
-std/lists/reverse.cert : no_pcert = 0
-
-std/lists/reverse.cert : \
- std/lists/revappend.cert \
- std/lists/coerce.cert \
- std/lists/reverse.lisp
-
-
-std/lists/sets.cert : acl2x = 0
-std/lists/sets.cert : no_pcert = 0
-
-std/lists/sets.cert : \
- std/lists/equiv.cert \
- std/lists/mfc-utils.cert \
- std/lists/rev.cert \
- std/lists/sets.lisp
-
-
-std/lists/take.cert : acl2x = 0
-std/lists/take.cert : no_pcert = 0
-
-std/lists/take.cert : \
- arithmetic/top.cert \
- std/lists/take.lisp
-
-
-str/abbrevs.cert : acl2x = 0
-str/abbrevs.cert : no_pcert = 0
-
-str/abbrevs.cert : \
- str/top.cert \
- str/portcullis.cert \
- str/abbrevs.lisp \
- str/cert.acl2
-
-
-str/arithmetic.cert : acl2x = 0
-str/arithmetic.cert : no_pcert = 0
-
-str/arithmetic.cert : \
- arithmetic/top.cert \
- std/lists/nthcdr.cert \
- std/lists/append.cert \
- std/lists/repeat.cert \
- str/portcullis.cert \
- str/arithmetic.lisp \
- str/cert.acl2
-
-
-str/case-conversion.cert : acl2x = 0
-str/case-conversion.cert : no_pcert = 0
-
-str/case-conversion.cert : \
- str/char-case.cert \
- str/cat.cert \
- str/arithmetic.cert \
- std/lists/rev.cert \
- std/lists/coerce.cert \
- std/lists/take.cert \
- std/lists/nthcdr.cert \
- str/subseq.cert \
- str/portcullis.cert \
- str/case-conversion.lisp \
- str/cert.acl2
-
-
-str/cat.cert : acl2x = 0
-str/cat.cert : no_pcert = 0
-
-str/cat.cert : \
- xdoc/top.cert \
- misc/definline.cert \
- str/arithmetic.cert \
- std/lists/take.cert \
- str/portcullis.cert \
- str/cat.lisp \
- str/cert.acl2
-
-
-str/char-case.cert : acl2x = 0
-str/char-case.cert : no_pcert = 0
-
-str/char-case.cert : \
- str/eqv.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/char-case.lisp \
- str/cert.acl2
-
-
-str/digitp.cert : acl2x = 0
-str/digitp.cert : no_pcert = 0
-
-str/digitp.cert : \
- str/eqv.cert \
- std/lists/list-fix.cert \
- std/lists/rev.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/digitp.lisp \
- str/cert.acl2
-
-
-str/eqv.cert : acl2x = 0
-str/eqv.cert : no_pcert = 0
-
-str/eqv.cert : \
- xdoc/top.cert \
- std/lists/list-fix.cert \
- misc/definline.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/eqv.lisp \
- str/cert.acl2
-
-
-str/fast-cat.cert : acl2x = 0
-str/fast-cat.cert : no_pcert = 0
-
-str/fast-cat.cert : \
- str/cat.cert \
- str/portcullis.cert \
- str/fast-cat.lisp \
- str/fast-cat.acl2 \
- str/cert.acl2
-
-
-str/firstn-chars.cert : acl2x = 0
-str/firstn-chars.cert : no_pcert = 0
-
-str/firstn-chars.cert : \
- str/eqv.cert \
- str/arithmetic.cert \
- std/lists/take.cert \
- str/portcullis.cert \
- str/firstn-chars.lisp \
- str/cert.acl2
-
-
-str/hexify.cert : acl2x = 0
-str/hexify.cert : no_pcert = 0
-
-str/hexify.cert : \
- tools/bstar.cert \
- std/ks/explode-atom.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/hexify.lisp \
- str/cert.acl2
-
-
-str/html-encode.cert : acl2x = 0
-str/html-encode.cert : no_pcert = 0
-
-str/html-encode.cert : \
- str/cat.cert \
- tools/bstar.cert \
- misc/assert.cert \
- str/arithmetic.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- str/portcullis.cert \
- str/html-encode.lisp \
- str/cert.acl2
-
-
-str/ieqv.cert : acl2x = 0
-str/ieqv.cert : no_pcert = 0
-
-str/ieqv.cert : \
- str/char-case.cert \
- std/lists/nthcdr.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/ieqv.lisp \
- str/cert.acl2
-
-
-str/iless.cert : acl2x = 0
-str/iless.cert : no_pcert = 0
-
-str/iless.cert : \
- str/ieqv.cert \
- std/lists/nthcdr.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/iless.lisp \
- str/cert.acl2
-
-
-str/iprefixp.cert : acl2x = 0
-str/iprefixp.cert : no_pcert = 0
-
-str/iprefixp.cert : \
- str/ieqv.cert \
- std/lists/prefixp.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/iprefixp.lisp \
- str/cert.acl2
-
-
-str/isort.cert : acl2x = 0
-str/isort.cert : no_pcert = 0
-
-str/isort.cert : \
- str/iless.cert \
- defsort/defsort.cert \
- std/lists/list-fix.cert \
- str/portcullis.cert \
- str/isort.lisp \
- str/cert.acl2
-
-
-str/istrpos.cert : acl2x = 0
-str/istrpos.cert : no_pcert = 0
-
-str/istrpos.cert : \
- str/iprefixp.cert \
- str/istrprefixp.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/istrpos.lisp \
- str/cert.acl2
-
-
-str/istrprefixp.cert : acl2x = 0
-str/istrprefixp.cert : no_pcert = 0
-
-str/istrprefixp.cert : \
- str/ieqv.cert \
- str/iprefixp.cert \
- std/lists/nthcdr.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/istrprefixp.lisp \
- str/cert.acl2
-
-
-str/isubstrp.cert : acl2x = 0
-str/isubstrp.cert : no_pcert = 0
-
-str/isubstrp.cert : \
- str/istrpos.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/isubstrp.lisp \
- str/cert.acl2
-
-
-str/natstr.cert : acl2x = 0
-str/natstr.cert : no_pcert = 0
-
-str/natstr.cert : \
- str/digitp.cert \
- arithmetic/nat-listp.cert \
- std/lists/revappend.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- std/lists/rev.cert \
- std/lists/coerce.cert \
- str/portcullis.cert \
- str/natstr.lisp \
- str/cert.acl2
-
-
-str/pad.cert : acl2x = 0
-str/pad.cert : no_pcert = 0
-
-str/pad.cert : \
- str/cat.cert \
- std/lists/take.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/pad.lisp \
- str/cert.acl2
-
-
-str/portcullis.cert : acl2x = 0
-str/portcullis.cert : no_pcert = 0
-
-str/portcullis.cert : \
- str/portcullis.lisp \
- str/portcullis.acl2 \
- str/package.lsp \
- xdoc/package.lsp
-
-
-str/prefix-lines.cert : acl2x = 0
-str/prefix-lines.cert : no_pcert = 0
-
-str/prefix-lines.cert : \
- str/cat.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/prefix-lines.lisp \
- str/cert.acl2
-
-
-str/stringify.cert : acl2x = 0
-str/stringify.cert : no_pcert = 0
-
-str/stringify.cert : \
- str/natstr.cert \
- str/portcullis.cert \
- str/stringify.lisp \
- str/cert.acl2
-
-
-str/strline.cert : acl2x = 0
-str/strline.cert : no_pcert = 0
-
-str/strline.cert : \
- xdoc/top.cert \
- misc/assert.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/strline.lisp \
- str/cert.acl2
-
-
-str/strnatless.cert : acl2x = 0
-str/strnatless.cert : no_pcert = 0
-
-str/strnatless.cert : \
- str/digitp.cert \
- tools/mv-nth.cert \
- tools/bstar.cert \
- str/arithmetic.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- str/portcullis.cert \
- str/strnatless.lisp \
- str/cert.acl2
-
-
-str/strpos.cert : acl2x = 0
-str/strpos.cert : no_pcert = 0
-
-str/strpos.cert : \
- misc/definline.cert \
- str/strprefixp.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/strpos.lisp \
- str/cert.acl2
-
-
-str/strprefixp.cert : acl2x = 0
-str/strprefixp.cert : no_pcert = 0
-
-str/strprefixp.cert : \
- misc/definline.cert \
- xdoc/top.cert \
- std/lists/prefixp.cert \
- std/lists/nthcdr.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/strprefixp.lisp \
- str/cert.acl2
-
-
-str/strrpos.cert : acl2x = 0
-str/strrpos.cert : no_pcert = 0
-
-str/strrpos.cert : \
- str/strprefixp.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/strrpos.lisp \
- str/cert.acl2
-
-
-str/strsplit.cert : acl2x = 0
-str/strsplit.cert : no_pcert = 0
-
-str/strsplit.cert : \
- str/arithmetic.cert \
- tools/mv-nth.cert \
- misc/assert.cert \
- str/portcullis.cert \
- str/strsplit.lisp \
- str/cert.acl2
-
-
-str/strsubst.cert : acl2x = 0
-str/strsubst.cert : no_pcert = 0
-
-str/strsubst.cert : \
- str/cat.cert \
- str/strprefixp.cert \
- misc/assert.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/strsubst.lisp \
- str/cert.acl2
-
-
-str/strtok.cert : acl2x = 0
-str/strtok.cert : no_pcert = 0
-
-str/strtok.cert : \
- str/cat.cert \
- misc/assert.cert \
- str/arithmetic.cert \
- std/lists/revappend.cert \
- str/portcullis.cert \
- str/strtok.lisp \
- str/cert.acl2
-
-
-str/strval.cert : acl2x = 0
-str/strval.cert : no_pcert = 0
-
-str/strval.cert : \
- str/strnatless.cert \
- misc/definline.cert \
- str/arithmetic.cert \
- misc/assert.cert \
- str/portcullis.cert \
- str/strval.lisp \
- str/cert.acl2
-
-
-str/subseq.cert : acl2x = 0
-str/subseq.cert : no_pcert = 0
-
-str/subseq.cert : \
- str/arithmetic.cert \
- std/lists/take.cert \
- std/lists/nthcdr.cert \
- std/lists/coerce.cert \
- str/portcullis.cert \
- str/subseq.lisp \
- str/cert.acl2
-
-
-str/substrp.cert : acl2x = 0
-str/substrp.cert : no_pcert = 0
-
-str/substrp.cert : \
- str/strpos.cert \
- str/arithmetic.cert \
- str/portcullis.cert \
- str/substrp.lisp \
- str/cert.acl2
-
-
-str/suffixp.cert : acl2x = 0
-str/suffixp.cert : no_pcert = 0
-
-str/suffixp.cert : \
- str/strprefixp.cert \
- misc/assert.cert \
- str/portcullis.cert \
- str/suffixp.lisp \
- str/cert.acl2
-
-
-str/top.cert : acl2x = 0
-str/top.cert : no_pcert = 0
-
-str/top.cert : \
- str/case-conversion.cert \
- str/cat.cert \
- str/digitp.cert \
- str/eqv.cert \
- str/firstn-chars.cert \
- str/html-encode.cert \
- str/ieqv.cert \
- str/iprefixp.cert \
- str/iless.cert \
- str/isort.cert \
- str/istrpos.cert \
- str/istrprefixp.cert \
- str/isubstrp.cert \
- str/natstr.cert \
- str/strline.cert \
- str/pad.cert \
- str/prefix-lines.cert \
- str/strpos.cert \
- str/strrpos.cert \
- str/strprefixp.cert \
- str/strnatless.cert \
- str/strsplit.cert \
- str/strsubst.cert \
- str/strtok.cert \
- str/strval.cert \
- str/substrp.cert \
- str/subseq.cert \
- str/suffixp.cert \
- str/portcullis.cert \
- str/top.lisp \
- str/cert.acl2
-
-
-symbolic/generic/assertions.cert : acl2x = 0
-symbolic/generic/assertions.cert : no_pcert = 0
-
-symbolic/generic/assertions.cert : \
- ordinals/ordinals.cert \
- misc/defpun.cert \
- symbolic/generic/assertions.lisp
-
-
-symbolic/generic/defsimulate.cert : acl2x = 0
-symbolic/generic/defsimulate.cert : no_pcert = 0
-
-symbolic/generic/defsimulate.cert : \
- symbolic/generic/assertions.cert \
- symbolic/generic/measures.cert \
- symbolic/generic/partial-correctness.cert \
- symbolic/generic/total-correctness.cert \
- ordinals/ordinals-without-arithmetic.cert \
- misc/defpun.cert \
- symbolic/generic/assertions.cert \
- symbolic/generic/partial-correctness.cert \
- symbolic/generic/assertions.cert \
- symbolic/generic/measures.cert \
- symbolic/generic/total-correctness.cert \
- symbolic/generic/defsimulate.lisp
-
-
-symbolic/generic/factorial-jvm-correct.cert : acl2x = 0
-symbolic/generic/factorial-jvm-correct.cert : no_pcert = 0
-
-symbolic/generic/factorial-jvm-correct.cert : \
- symbolic/m5/demo.cert \
- ordinals/ordinals.cert \
- symbolic/generic/defsimulate.cert \
- symbolic/m5/utilities.cert \
- symbolic/generic/factorial-jvm-correct.lisp \
- symbolic/generic/factorial-jvm-correct.acl2
-
-
-symbolic/generic/measures.cert : acl2x = 0
-symbolic/generic/measures.cert : no_pcert = 0
-
-symbolic/generic/measures.cert : \
- misc/defpun.cert \
- ordinals/ordinals.cert \
- arithmetic-2/meta/top.cert \
- symbolic/generic/measures.lisp
-
-
-symbolic/generic/partial-correctness.cert : acl2x = 0
-symbolic/generic/partial-correctness.cert : no_pcert = 0
-
-symbolic/generic/partial-correctness.cert : \
- misc/defpun.cert \
- ordinals/ordinals.cert \
- symbolic/generic/partial-correctness.lisp
-
-
-symbolic/generic/tiny-fib-correct.cert : acl2x = 0
-symbolic/generic/tiny-fib-correct.cert : no_pcert = 0
-
-symbolic/generic/tiny-fib-correct.cert : \
- symbolic/tiny-fib/tiny-rewrites.cert \
- symbolic/tiny-fib/fib-def.cert \
- ordinals/ordinals.cert \
- symbolic/generic/defsimulate.cert \
- symbolic/generic/tiny-fib-correct.lisp
-
-
-symbolic/generic/total-correctness.cert : acl2x = 0
-symbolic/generic/total-correctness.cert : no_pcert = 0
-
-symbolic/generic/total-correctness.cert : \
- misc/defpun.cert \
- ordinals/ordinals-without-arithmetic.cert \
- arithmetic/top-with-meta.cert \
- symbolic/generic/total-correctness.lisp
-
-
-symbolic/m5/demo.cert : acl2x = 0
-symbolic/m5/demo.cert : no_pcert = 0
-
-symbolic/m5/demo.cert : \
- symbolic/m5/utilities.cert \
- symbolic/m5/utilities.cert \
- symbolic/m5/demo.lisp \
- symbolic/m5/demo.acl2
-
-
-symbolic/m5/utilities.cert : acl2x = 0
-symbolic/m5/utilities.cert : no_pcert = 0
-
-symbolic/m5/utilities.cert : \
- models/jvm/m5/m5.cert \
- arithmetic/top-with-meta.cert \
- ihs/quotient-remainder-lemmas.cert \
- models/jvm/m5/m5.cert \
- symbolic/m5/utilities.lisp \
- symbolic/m5/utilities.acl2
-
-
-symbolic/tiny-fib/defstobj+.cert : acl2x = 0
-symbolic/tiny-fib/defstobj+.cert : no_pcert = 0
-
-symbolic/tiny-fib/defstobj+.cert : \
- arithmetic-2/meta/top.cert \
- symbolic/tiny-fib/defstobj+.lisp
-
-
-symbolic/tiny-fib/fib-def.cert : acl2x = 0
-symbolic/tiny-fib/fib-def.cert : no_pcert = 0
-
-symbolic/tiny-fib/fib-def.cert : \
- symbolic/tiny-fib/tiny.cert \
- symbolic/tiny-fib/fib-def.lisp
-
-
-symbolic/tiny-fib/tiny-rewrites.cert : acl2x = 0
-symbolic/tiny-fib/tiny-rewrites.cert : no_pcert = 0
-
-symbolic/tiny-fib/tiny-rewrites.cert : \
- symbolic/tiny-fib/tiny.cert \
- arithmetic/top-with-meta.cert \
- symbolic/tiny-fib/tiny-rewrites.lisp
-
-
-symbolic/tiny-fib/tiny.cert : acl2x = 0
-symbolic/tiny-fib/tiny.cert : no_pcert = 0
-
-symbolic/tiny-fib/tiny.cert : \
- symbolic/tiny-fib/defstobj+.cert \
- arithmetic/top-with-meta.cert \
- data-structures/list-defthms.cert \
- ihs/logops-lemmas.cert \
- ihs/quotient-remainder-lemmas.cert \
- symbolic/tiny-fib/tiny.lisp
-
-
-symbolic/tiny-triangle/tiny-triangle-correct.cert : acl2x = 0
-symbolic/tiny-triangle/tiny-triangle-correct.cert : no_pcert = 0
-
-symbolic/tiny-triangle/tiny-triangle-correct.cert : \
- symbolic/tiny-fib/tiny-rewrites.cert \
- ordinals/ordinals.cert \
- symbolic/tiny-triangle/triangle-def.cert \
- symbolic/generic/defsimulate.cert \
- symbolic/tiny-triangle/tiny-triangle-correct.lisp
-
-
-symbolic/tiny-triangle/triangle-def.cert : acl2x = 0
-symbolic/tiny-triangle/triangle-def.cert : no_pcert = 0
-
-symbolic/tiny-triangle/triangle-def.cert : \
- symbolic/tiny-fib/tiny.cert \
- symbolic/tiny-triangle/triangle-def.lisp
-
-
-system/compare-out-files.cert : acl2x = 0
-system/compare-out-files.cert : no_pcert = 0
-
-system/compare-out-files.cert : \
- system/compare-out-files.lisp
-
-
-system/convert-normalized-term-to-pairs.cert : acl2x = 0
-system/convert-normalized-term-to-pairs.cert : no_pcert = 0
-
-system/convert-normalized-term-to-pairs.cert : \
- system/convert-normalized-term-to-pairs.lisp
-
-
-system/extend-pathname.cert : acl2x = 0
-system/extend-pathname.cert : no_pcert = 0
-
-system/extend-pathname.cert : \
- system/extend-pathname.lisp
-
-
-system/f-put-global.cert : acl2x = 0
-system/f-put-global.cert : no_pcert = 0
-
-system/f-put-global.cert : \
- system/f-put-global.lisp
-
-
-system/gather-dcls.cert : acl2x = 0
-system/gather-dcls.cert : no_pcert = 0
-
-system/gather-dcls.cert : \
- system/gather-dcls.lisp
-
-
-system/hl-addr-combine.cert : acl2x = 0
-system/hl-addr-combine.cert : no_pcert = 0
-
-system/hl-addr-combine.cert : \
- arithmetic-5/top.cert \
- system/hl-addr-combine.lisp
-
-
-system/io.cert : acl2x = 0
-system/io.cert : no_pcert = 0
-
-system/io.cert : \
- std/io/base.cert \
- system/io.lisp
-
-
-system/legal-variablep.cert : acl2x = 0
-system/legal-variablep.cert : no_pcert = 0
-
-system/legal-variablep.cert : \
- system/legal-variablep.lisp
-
-
-system/meta-extract.cert : acl2x = 0
-system/meta-extract.cert : no_pcert = 0
-
-system/meta-extract.cert : \
- system/sublis-var.cert \
- system/meta-extract.lisp
-
-
-system/pseudo-good-worldp.cert : acl2x = 0
-system/pseudo-good-worldp.cert : no_pcert = 0
-
-system/pseudo-good-worldp.cert : \
- system/pseudo-good-worldp.lisp
-
-
-system/pseudo-termp-lemmas.cert : acl2x = 0
-system/pseudo-termp-lemmas.cert : no_pcert = 0
-
-system/pseudo-termp-lemmas.cert : \
- system/pseudo-termp-lemmas.lisp
-
-
-system/subcor-var.cert : acl2x = 0
-system/subcor-var.cert : no_pcert = 0
-
-system/subcor-var.cert : \
- system/sublis-var.cert \
- system/pseudo-termp-lemmas.cert \
- system/subcor-var.lisp
-
-
-system/sublis-var.cert : acl2x = 0
-system/sublis-var.cert : no_pcert = 0
-
-system/sublis-var.cert : \
- system/sublis-var.lisp
-
-
-system/subst-expr.cert : acl2x = 0
-system/subst-expr.cert : no_pcert = 0
-
-system/subst-expr.cert : \
- system/sublis-var.cert \
- system/pseudo-termp-lemmas.cert \
- system/subst-var.cert \
- system/subst-expr.lisp
-
-
-system/subst-var.cert : acl2x = 0
-system/subst-var.cert : no_pcert = 0
-
-system/subst-var.cert : \
- system/sublis-var.cert \
- system/pseudo-termp-lemmas.cert \
- system/subst-var.lisp
-
-
-system/too-many-ifs.cert : acl2x = 0
-system/too-many-ifs.cert : no_pcert = 0
-
-system/too-many-ifs.cert : \
- tools/flag.cert \
- arithmetic/top-with-meta.cert \
- tools/flag.cert \
- system/too-many-ifs.lisp \
- system/too-many-ifs.acl2
-
-
-system/top.cert : acl2x = 0
-system/top.cert : no_pcert = 0
-
-system/top.cert : \
- system/hl-addr-combine.cert \
- system/extend-pathname.cert \
- system/too-many-ifs.cert \
- system/verified-termination-and-guards.cert \
- system/sublis-var.cert \
- system/subcor-var.cert \
- system/subst-expr.cert \
- system/convert-normalized-term-to-pairs.cert \
- system/gather-dcls.cert \
- system/meta-extract.cert \
- system/legal-variablep.cert \
- system/top.lisp
-
-
-system/update-state.cert : acl2x = 0
-system/update-state.cert : no_pcert = 0
-
-system/update-state.cert : \
- system/update-state.lisp
-
-
-system/verified-termination-and-guards.cert : acl2x = 0
-system/verified-termination-and-guards.cert : no_pcert = 0
-
-system/verified-termination-and-guards.cert : \
- system/verified-termination-and-guards.lisp
-
-
-system/worldp-check.cert : acl2x = 0
-system/worldp-check.cert : no_pcert = 0
-
-system/worldp-check.cert : \
- system/pseudo-good-worldp.cert \
- system/worldp-check.lisp \
- system/worldp-check.acl2
-
-
-taspi/code/brlens/brlens.cert : acl2x = 0
-taspi/code/brlens/brlens.cert : no_pcert = 0
-
-taspi/code/brlens/brlens.cert : \
- taspi/code/gen-helper/extra.cert \
- taspi/code/brlens/brlens.lisp
-
-
-taspi/code/brlens/trees-with-brlens.cert : acl2x = 0
-taspi/code/brlens/trees-with-brlens.cert : no_pcert = 0
-
-taspi/code/brlens/trees-with-brlens.cert : \
- taspi/code/brlens/brlens.cert \
- taspi/code/gen-trees/tree-predicates.cert \
- taspi/code/brlens/trees-with-brlens.lisp
-
-
-taspi/code/build/build-term-guards.cert : acl2x = 0
-taspi/code/build/build-term-guards.cert : no_pcert = 0
-
-taspi/code/build/build-term-guards.cert : \
- taspi/code/build/build-term.cert \
- taspi/code/fringes/fringes-guards.cert \
- taspi/code/build/build-term-guards.lisp
-
-
-taspi/code/build/build-term.cert : acl2x = 0
-taspi/code/build/build-term.cert : no_pcert = 0
-
-taspi/code/build/build-term.cert : \
- taspi/code/fringes/fringes.cert \
- taspi/code/build/build-term.lisp
-
-
-taspi/code/fringes/fringes-guards.cert : acl2x = 0
-taspi/code/fringes/fringes-guards.cert : no_pcert = 0
-
-taspi/code/fringes/fringes-guards.cert : \
- taspi/code/fringes/fringes.cert \
- taspi/code/replete/replete-guards.cert \
- taspi/code/gen-trees/btrees-bdds-sets.cert \
- taspi/code/gen-trees/app-rev-lists.cert \
- taspi/code/fringes/fringes-guards.lisp
-
-
-taspi/code/fringes/fringes-props.cert : acl2x = 0
-taspi/code/fringes/fringes-props.cert : no_pcert = 0
-
-taspi/code/fringes/fringes-props.cert : \
- taspi/code/fringes/fringes-guards.cert \
- taspi/code/fringes/fringes-props.lisp
-
-
-taspi/code/fringes/fringes.cert : acl2x = 0
-taspi/code/fringes/fringes.cert : no_pcert = 0
-
-taspi/code/fringes/fringes.cert : \
- taspi/code/gen-trees/sets-lists-trees.cert \
- taspi/code/replete/replete.cert \
- taspi/code/gen-trees/btrees-bdds.cert \
- taspi/code/fringes/fringes.lisp
-
-
-taspi/code/gen-helper/bdd-functions.cert : acl2x = 0
-taspi/code/gen-helper/bdd-functions.cert : no_pcert = 0
-
-taspi/code/gen-helper/bdd-functions.cert : \
- taspi/code/gen-helper/sets.cert \
- taspi/code/gen-helper/bdd-functions.lisp
-
-
-taspi/code/gen-helper/extra.cert : acl2x = 0
-taspi/code/gen-helper/extra.cert : no_pcert = 0
-
-taspi/code/gen-helper/extra.cert : \
- misc/hons-help2.cert \
- taspi/code/gen-helper/extra.lisp
-
-
-taspi/code/gen-helper/fast-lists.cert : acl2x = 0
-taspi/code/gen-helper/fast-lists.cert : no_pcert = 0
-
-taspi/code/gen-helper/fast-lists.cert : \
- taspi/code/gen-helper/extra.cert \
- taspi/code/gen-helper/fast-lists.lisp
-
-
-taspi/code/gen-helper/sets.cert : acl2x = 0
-taspi/code/gen-helper/sets.cert : no_pcert = 0
-
-taspi/code/gen-helper/sets.cert : \
- taspi/code/gen-helper/extra.cert \
- taspi/code/gen-helper/sets.lisp
-
-
-taspi/code/gen-helper/top.cert : acl2x = 0
-taspi/code/gen-helper/top.cert : no_pcert = 0
-
-taspi/code/gen-helper/top.cert : \
- taspi/code/gen-helper/sets.cert \
- taspi/code/gen-helper/fast-lists.cert \
- taspi/code/gen-helper/bdd-functions.cert \
- taspi/code/gen-helper/top.lisp
-
-
-taspi/code/gen-trees/app-rev-lists.cert : acl2x = 0
-taspi/code/gen-trees/app-rev-lists.cert : no_pcert = 0
-
-taspi/code/gen-trees/app-rev-lists.cert : \
- taspi/code/gen-trees/sets-lists-trees.cert \
- taspi/code/gen-trees/app-rev-lists.lisp
-
-
-taspi/code/gen-trees/btrees-bdds-sets.cert : acl2x = 0
-taspi/code/gen-trees/btrees-bdds-sets.cert : no_pcert = 0
-
-taspi/code/gen-trees/btrees-bdds-sets.cert : \
- taspi/code/gen-trees/btrees-bdds.cert \
- taspi/code/gen-trees/sets-lists-trees.cert \
- taspi/code/gen-trees/btrees-bdds-sets.lisp
-
-
-taspi/code/gen-trees/btrees-bdds.cert : acl2x = 0
-taspi/code/gen-trees/btrees-bdds.cert : no_pcert = 0
-
-taspi/code/gen-trees/btrees-bdds.cert : \
- taspi/code/gen-helper/extra.cert \
- taspi/code/gen-trees/btrees.cert \
- taspi/code/gen-helper/bdd-functions.cert \
- taspi/code/gen-trees/btrees-bdds.lisp
-
-
-taspi/code/gen-trees/btrees.cert : acl2x = 0
-taspi/code/gen-trees/btrees.cert : no_pcert = 0
-
-taspi/code/gen-trees/btrees.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- taspi/code/gen-helper/fast-lists.cert \
- taspi/code/gen-trees/btrees.lisp
-
-
-taspi/code/gen-trees/sets-lists-trees.cert : acl2x = 0
-taspi/code/gen-trees/sets-lists-trees.cert : no_pcert = 0
-
-taspi/code/gen-trees/sets-lists-trees.cert : \
- taspi/code/gen-helper/sets.cert \
- taspi/code/gen-helper/fast-lists.cert \
- taspi/code/gen-trees/tree-predicates.cert \
- taspi/code/gen-trees/sets-lists-trees.lisp
-
-
-taspi/code/gen-trees/top.cert : acl2x = 0
-taspi/code/gen-trees/top.cert : no_pcert = 0
-
-taspi/code/gen-trees/top.cert : \
- taspi/code/gen-trees/btrees-bdds-sets.cert \
- taspi/code/gen-trees/app-rev-lists.cert \
- taspi/code/gen-trees/sets-lists-trees.cert \
- taspi/code/gen-trees/tree-predicates.cert \
- taspi/code/gen-trees/top.lisp
-
-
-taspi/code/gen-trees/tree-predicates.cert : acl2x = 0
-taspi/code/gen-trees/tree-predicates.cert : no_pcert = 0
-
-taspi/code/gen-trees/tree-predicates.cert : \
- arithmetic-3/bind-free/top.cert \
- taspi/code/gen-helper/extra.cert \
- taspi/code/gen-trees/tree-predicates.lisp
-
-
-taspi/code/replete/replete-guards.cert : acl2x = 0
-taspi/code/replete/replete-guards.cert : no_pcert = 0
-
-taspi/code/replete/replete-guards.cert : \
- taspi/code/replete/replete.cert \
- taspi/code/brlens/trees-with-brlens.cert \
- taspi/code/replete/replete-guards.lisp
-
-
-taspi/code/replete/replete-helper.cert : acl2x = 0
-taspi/code/replete/replete-helper.cert : no_pcert = 0
-
-taspi/code/replete/replete-helper.cert : \
- taspi/code/gen-trees/sets-lists-trees.cert \
- taspi/code/replete/replete-helper.lisp
-
-
-taspi/code/replete/replete.cert : acl2x = 0
-taspi/code/replete/replete.cert : no_pcert = 0
-
-taspi/code/replete/replete.cert : \
- taspi/code/replete/replete-helper.cert \
- taspi/code/replete/replete.lisp
-
-
-taspi/code/sequences/align.cert : acl2x = 0
-taspi/code/sequences/align.cert : no_pcert = 0
-
-taspi/code/sequences/align.cert : \
- taspi/code/gen-helper/extra.cert \
- taspi/code/sequences/align.lisp
-
-
-taspi/code/sequences/p-inform.cert : acl2x = 0
-taspi/code/sequences/p-inform.cert : no_pcert = 0
-
-taspi/code/sequences/p-inform.cert : \
- taspi/code/sequences/seqs.cert \
- taspi/code/sequences/p-inform.lisp
-
-
-taspi/code/sequences/seqs.cert : acl2x = 0
-taspi/code/sequences/seqs.cert : no_pcert = 0
-
-taspi/code/sequences/seqs.cert : \
- misc/hons-help2.cert \
- taspi/code/gen-trees/top.cert \
- taspi/code/sequences/seqs.lisp
-
-
-taspi/code/tree-manip/insertion-based-sort.cert : acl2x = 0
-taspi/code/tree-manip/insertion-based-sort.cert : no_pcert = 0
-
-taspi/code/tree-manip/insertion-based-sort.cert : \
- taspi/code/tree-manip/sort-help.cert \
- taspi/code/tree-manip/insertion-based-sort.lisp
-
-
-taspi/code/tree-manip/merge-based-sort.cert : acl2x = 0
-taspi/code/tree-manip/merge-based-sort.cert : no_pcert = 0
-
-taspi/code/tree-manip/merge-based-sort.cert : \
- taspi/code/tree-manip/sort-help.cert \
- taspi/code/tree-manip/merge-based-sort.lisp
-
-
-taspi/code/tree-manip/mv-root.cert : acl2x = 0
-taspi/code/tree-manip/mv-root.cert : no_pcert = 0
-
-taspi/code/tree-manip/mv-root.cert : \
- taspi/code/build/build-term-guards.cert \
- taspi/code/tree-manip/mv-root.lisp
-
-
-taspi/code/tree-manip/quicksort.cert : acl2x = 0
-taspi/code/tree-manip/quicksort.cert : no_pcert = 0
-
-taspi/code/tree-manip/quicksort.cert : \
- taspi/code/tree-manip/quicksort.lisp
-
-
-taspi/code/tree-manip/sort-help.cert : acl2x = 0
-taspi/code/tree-manip/sort-help.cert : no_pcert = 0
-
-taspi/code/tree-manip/sort-help.cert : \
- taspi/code/gen-trees/sets-lists-trees.cert \
- taspi/code/tree-manip/sort-help.lisp
-
-
-taspi/code/tree-manip/top.cert : acl2x = 0
-taspi/code/tree-manip/top.cert : no_pcert = 0
-
-taspi/code/tree-manip/top.cert : \
- taspi/code/tree-manip/mv-root.cert \
- taspi/code/tree-manip/merge-based-sort.cert \
- taspi/code/tree-manip/insertion-based-sort.cert \
- taspi/code/tree-manip/top.lisp
-
-
-taspi/database/db-from-list.cert : acl2x = 0
-taspi/database/db-from-list.cert : no_pcert = 0
-
-taspi/database/db-from-list.cert : \
- taspi/database/db-from-list.lisp
-
-
-taspi/database/db.cert : acl2x = 0
-taspi/database/db.cert : no_pcert = 0
-
-taspi/database/db.cert : \
- taspi/database/entry.cert \
- taspi/code/tree-manip/top.cert \
- taspi/database/db.lisp
-
-
-taspi/database/entry.cert : acl2x = 0
-taspi/database/entry.cert : no_pcert = 0
-
-taspi/database/entry.cert : \
- taspi/database/props.cert \
- taspi/database/entry.lisp
-
-
-taspi/database/filters.cert : acl2x = 0
-taspi/database/filters.cert : no_pcert = 0
-
-taspi/database/filters.cert : \
- taspi/database/db.cert \
- taspi/database/filters.lisp
-
-
-taspi/database/props.cert : acl2x = 0
-taspi/database/props.cert : no_pcert = 0
-
-taspi/database/props.cert : \
- misc/hons-help2.cert \
- taspi/code/gen-trees/sets-lists-trees.cert \
- taspi/code/gen-trees/app-rev-lists.cert \
- taspi/code/tree-manip/sort-help.cert \
- taspi/database/props.lisp
-
-
-taspi/proofs/fringes-taspi.cert : acl2x = 0
-taspi/proofs/fringes-taspi.cert : no_pcert = 0
-
-taspi/proofs/fringes-taspi.cert : \
- taspi/proofs/omerge-good-order.cert \
- taspi/proofs/fringes-taspi.lisp \
- taspi/proofs/fringes-taspi.acl2
-
-
-taspi/proofs/omerge-good-order.cert : acl2x = 0
-taspi/proofs/omerge-good-order.cert : no_pcert = 0
-
-taspi/proofs/omerge-good-order.cert : \
- taspi/proofs/sets.cert \
- taspi/proofs/omerge-good-order.lisp \
- taspi/proofs/omerge-good-order.acl2
-
-
-taspi/proofs/sets.cert : acl2x = 0
-taspi/proofs/sets.cert : no_pcert = 0
-
-taspi/proofs/sets.cert : \
- taspi/proofs/sets.lisp \
- taspi/proofs/sets.acl2
-
-
-taspi/sets-input/consensus.cert : acl2x = 0
-taspi/sets-input/consensus.cert : no_pcert = 0
-
-taspi/sets-input/consensus.cert : \
- taspi/code/build/build-term-guards.cert \
- taspi/code/gen-trees/btrees-bdds.cert \
- taspi/sets-input/consensus.lisp
-
-
-taspi/sets-input/greedy.cert : acl2x = 0
-taspi/sets-input/greedy.cert : no_pcert = 0
-
-taspi/sets-input/greedy.cert : \
- taspi/sets-input/consensus.cert \
- taspi/sets-input/greedy.lisp
-
-
-taspi/sets-input/mast.cert : acl2x = 0
-taspi/sets-input/mast.cert : no_pcert = 0
-
-taspi/sets-input/mast.cert : \
- taspi/single-input/taxa-based.cert \
- taspi/sets-input/mast.lisp
-
-
-taspi/sets-input/mct.cert : acl2x = 0
-taspi/sets-input/mct.cert : no_pcert = 0
-
-taspi/sets-input/mct.cert : \
- taspi/sets-input/mast.cert \
- taspi/code/build/build-term-guards.cert \
- taspi/sets-input/mct.lisp
-
-
-taspi/sets-input/multipolar-loose.cert : acl2x = 0
-taspi/sets-input/multipolar-loose.cert : no_pcert = 0
-
-taspi/sets-input/multipolar-loose.cert : \
- taspi/sets-input/consensus.cert \
- taspi/sets-input/multipolar-loose.lisp
-
-
-taspi/sets-input/top.cert : acl2x = 0
-taspi/sets-input/top.cert : no_pcert = 0
-
-taspi/sets-input/top.cert : \
- taspi/sets-input/consensus.cert \
- taspi/sets-input/tree-compat.cert \
- taspi/sets-input/tree-support-in-set.cert \
- taspi/sets-input/mast.cert \
- taspi/sets-input/multipolar-loose.cert \
- taspi/sets-input/greedy.cert \
- taspi/sets-input/mct.cert \
- taspi/sets-input/top.lisp
-
-
-taspi/sets-input/tree-compat.cert : acl2x = 0
-taspi/sets-input/tree-compat.cert : no_pcert = 0
-
-taspi/sets-input/tree-compat.cert : \
- taspi/code/build/build-term-guards.cert \
- taspi/code/gen-trees/btrees-bdds.cert \
- taspi/code/fringes/fringes-props.cert \
- taspi/sets-input/tree-compat.lisp
-
-
-taspi/sets-input/tree-support-in-set.cert : acl2x = 0
-taspi/sets-input/tree-support-in-set.cert : no_pcert = 0
-
-taspi/sets-input/tree-support-in-set.cert : \
- taspi/code/build/build-term-guards.cert \
- taspi/sets-input/tree-support-in-set.lisp
-
-
-taspi/single-input/taxa-based.cert : acl2x = 0
-taspi/single-input/taxa-based.cert : no_pcert = 0
-
-taspi/single-input/taxa-based.cert : \
- taspi/code/fringes/fringes-guards.cert \
- taspi/code/tree-manip/merge-based-sort.cert \
- taspi/code/tree-manip/mv-root.cert \
- taspi/single-input/taxa-based.lisp
-
-
-taspi/single-input/tree-stats.cert : acl2x = 0
-taspi/single-input/tree-stats.cert : no_pcert = 0
-
-taspi/single-input/tree-stats.cert : \
- taspi/code/gen-trees/sets-lists-trees.cert \
- taspi/single-input/taxa-based.cert \
- taspi/single-input/tree-stats.lisp
-
-
-taspi/tree-distance/rf.cert : acl2x = 0
-taspi/tree-distance/rf.cert : no_pcert = 0
-
-taspi/tree-distance/rf.cert : \
- taspi/code/fringes/fringes-guards.cert \
- taspi/database/props.cert \
- taspi/tree-distance/rf.lisp
-
-
-taspi/tree-distance/symm-diff.cert : acl2x = 0
-taspi/tree-distance/symm-diff.cert : no_pcert = 0
-
-taspi/tree-distance/symm-diff.cert : \
- taspi/code/fringes/fringes-guards.cert \
- taspi/database/props.cert \
- taspi/tree-distance/symm-diff.lisp
-
-
-taspi/tree-generation/branch-and-bound/bandb.cert : acl2x = 0
-taspi/tree-generation/branch-and-bound/bandb.cert : no_pcert = 0
-
-taspi/tree-generation/branch-and-bound/bandb.cert : \
- taspi/tree-generation/tree-gen-helper/basics.cert \
- taspi/code/tree-manip/top.cert \
- taspi/tree-generation/branch-and-bound/bandb.lisp
-
-
-taspi/tree-generation/distance-based/naive-quartet-method.cert : acl2x = 0
-taspi/tree-generation/distance-based/naive-quartet-method.cert : no_pcert = 0
-
-taspi/tree-generation/distance-based/naive-quartet-method.cert : \
- taspi/tree-generation/distance-based/naive-quartet-method.lisp
-
-
-taspi/tree-generation/heuristics/do-search.cert : acl2x = 0
-taspi/tree-generation/heuristics/do-search.cert : no_pcert = 0
-
-taspi/tree-generation/heuristics/do-search.cert : \
- taspi/tree-generation/heuristics/tbr.cert \
- taspi/tree-generation/heuristics/do-search.lisp
-
-
-taspi/tree-generation/heuristics/spr.cert : acl2x = 0
-taspi/tree-generation/heuristics/spr.cert : no_pcert = 0
-
-taspi/tree-generation/heuristics/spr.cert : \
- taspi/tree-generation/tree-gen-helper/basics.cert \
- taspi/code/tree-manip/top.cert \
- taspi/tree-generation/heuristics/spr.lisp
-
-
-taspi/tree-generation/heuristics/tbr.cert : acl2x = 0
-taspi/tree-generation/heuristics/tbr.cert : no_pcert = 0
-
-taspi/tree-generation/heuristics/tbr.cert : \
- taspi/tree-generation/heuristics/spr.cert \
- taspi/tree-generation/heuristics/tbr.lisp
-
-
-taspi/tree-generation/tree-gen-helper/basics.cert : acl2x = 0
-taspi/tree-generation/tree-gen-helper/basics.cert : no_pcert = 0
-
-taspi/tree-generation/tree-gen-helper/basics.cert : \
- taspi/code/build/build-term-guards.cert \
- taspi/tree-score/pscores.cert \
- taspi/tree-generation/tree-gen-helper/basics.lisp
-
-
-taspi/tree-score/ambig-score.cert : acl2x = 0
-taspi/tree-score/ambig-score.cert : no_pcert = 0
-
-taspi/tree-score/ambig-score.cert : \
- taspi/tree-score/min-length.cert \
- taspi/tree-score/ambig-score.lisp
-
-
-taspi/tree-score/circle-scoring.cert : acl2x = 0
-taspi/tree-score/circle-scoring.cert : no_pcert = 0
-
-taspi/tree-score/circle-scoring.cert : \
- taspi/tree-score/min-length.cert \
- taspi/code/gen-trees/top.cert \
- taspi/tree-score/circle-scoring.lisp
-
-
-taspi/tree-score/costs.cert : acl2x = 0
-taspi/tree-score/costs.cert : no_pcert = 0
-
-taspi/tree-score/costs.cert : \
- taspi/code/sequences/seqs.cert \
- taspi/tree-score/costs.lisp
-
-
-taspi/tree-score/efficient-pscores-help.cert : acl2x = 0
-taspi/tree-score/efficient-pscores-help.cert : no_pcert = 0
-
-taspi/tree-score/efficient-pscores-help.cert : \
- taspi/tree-score/efficient-pscores-help.lisp
-
-
-taspi/tree-score/efficient-pscores.cert : acl2x = 0
-taspi/tree-score/efficient-pscores.cert : no_pcert = 0
-
-taspi/tree-score/efficient-pscores.cert : \
- taspi/code/gen-helper/extra.cert \
- taspi/tree-score/efficient-pscores-help.cert \
- taspi/tree-score/efficient-pscores.lisp
-
-
-taspi/tree-score/fitch-scoring.cert : acl2x = 0
-taspi/tree-score/fitch-scoring.cert : no_pcert = 0
-
-taspi/tree-score/fitch-scoring.cert : \
- taspi/tree-score/costs.cert \
- taspi/tree-score/fitch-scoring.lisp
-
-
-taspi/tree-score/min-length.cert : acl2x = 0
-taspi/tree-score/min-length.cert : no_pcert = 0
-
-taspi/tree-score/min-length.cert : \
- taspi/tree-score/efficient-pscores.cert \
- taspi/code/gen-helper/sets.cert \
- taspi/tree-score/min-length.lisp
-
-
-taspi/tree-score/opt-pairwise.cert : acl2x = 0
-taspi/tree-score/opt-pairwise.cert : no_pcert = 0
-
-taspi/tree-score/opt-pairwise.cert : \
- taspi/code/sequences/align.cert \
- taspi/code/gen-helper/extra.cert \
- taspi/tree-score/opt-pairwise.lisp
-
-
-taspi/tree-score/pscores.cert : acl2x = 0
-taspi/tree-score/pscores.cert : no_pcert = 0
-
-taspi/tree-score/pscores.cert : \
- taspi/tree-score/costs.cert \
- taspi/tree-score/pscores.lisp
-
-
-tau/bounders/elementary-bounders.cert : acl2x = 0
-tau/bounders/elementary-bounders.cert : no_pcert = 0
-
-tau/bounders/elementary-bounders.cert : \
- arithmetic-5/top.cert \
- tau/bounders/find-minimal-2d.cert \
- tau/bounders/find-maximal-2d.cert \
- tau/bounders/elementary-bounders.lisp
-
-
-tau/bounders/find-maximal-1d.cert : acl2x = 0
-tau/bounders/find-maximal-1d.cert : no_pcert = 0
-
-tau/bounders/find-maximal-1d.cert : \
- tau/bounders/find-maximal-1d.lisp
-
-
-tau/bounders/find-maximal-2d.cert : acl2x = 0
-tau/bounders/find-maximal-2d.cert : no_pcert = 0
-
-tau/bounders/find-maximal-2d.cert : \
- tau/bounders/find-maximal-2d.lisp
-
-
-tau/bounders/find-minimal-1d.cert : acl2x = 0
-tau/bounders/find-minimal-1d.cert : no_pcert = 0
-
-tau/bounders/find-minimal-1d.cert : \
- tau/bounders/find-minimal-1d.lisp
-
-
-tau/bounders/find-minimal-2d.cert : acl2x = 0
-tau/bounders/find-minimal-2d.cert : no_pcert = 0
-
-tau/bounders/find-minimal-2d.cert : \
- tau/bounders/find-minimal-2d.lisp
-
-
-textbook/chap10/ac-example.cert : acl2x = 0
-textbook/chap10/ac-example.cert : no_pcert = 0
-
-textbook/chap10/ac-example.cert : \
- textbook/chap10/ac-example.lisp
-
-
-textbook/chap10/adder.cert : acl2x = 0
-textbook/chap10/adder.cert : no_pcert = 0
-
-textbook/chap10/adder.cert : \
- textbook/chap10/adder.lisp
-
-
-textbook/chap10/compiler.cert : acl2x = 0
-textbook/chap10/compiler.cert : no_pcert = 0
-
-textbook/chap10/compiler.cert : \
- textbook/chap10/compiler.lisp \
- textbook/chap10/compiler.acl2
-
-
-textbook/chap10/fact.cert : acl2x = 0
-textbook/chap10/fact.cert : no_pcert = 0
-
-textbook/chap10/fact.cert : \
- textbook/chap10/fact.lisp
-
-
-textbook/chap10/insertion-sort.cert : acl2x = 0
-textbook/chap10/insertion-sort.cert : no_pcert = 0
-
-textbook/chap10/insertion-sort.cert : \
- textbook/chap10/insertion-sort.lisp
-
-
-textbook/chap10/tree.cert : acl2x = 0
-textbook/chap10/tree.cert : no_pcert = 0
-
-textbook/chap10/tree.cert : \
- textbook/chap10/tree.lisp
-
-
-textbook/chap11/compress.cert : acl2x = 0
-textbook/chap11/compress.cert : no_pcert = 0
-
-textbook/chap11/compress.cert : \
- textbook/chap11/compress.lisp
-
-
-textbook/chap11/encap.cert : acl2x = 0
-textbook/chap11/encap.cert : no_pcert = 0
-
-textbook/chap11/encap.cert : \
- textbook/chap10/ac-example.cert \
- textbook/chap11/encap.lisp
-
-
-textbook/chap11/finite-sets.cert : acl2x = 0
-textbook/chap11/finite-sets.cert : no_pcert = 0
-
-textbook/chap11/finite-sets.cert : \
- ordinals/e0-ordinal.cert \
- textbook/chap11/finite-sets.lisp
-
-
-textbook/chap11/how-many-soln1.cert : acl2x = 0
-textbook/chap11/how-many-soln1.cert : no_pcert = 0
-
-textbook/chap11/how-many-soln1.cert : \
- textbook/chap11/perm.cert \
- arithmetic/top.cert \
- textbook/chap11/how-many-soln1.lisp
-
-
-textbook/chap11/how-many-soln2.cert : acl2x = 0
-textbook/chap11/how-many-soln2.cert : no_pcert = 0
-
-textbook/chap11/how-many-soln2.cert : \
- textbook/chap11/perm.cert \
- textbook/chap11/how-many-soln2.lisp
-
-
-textbook/chap11/mergesort.cert : acl2x = 0
-textbook/chap11/mergesort.cert : no_pcert = 0
-
-textbook/chap11/mergesort.cert : \
- textbook/chap11/perm.cert \
- textbook/chap11/perm-append.cert \
- textbook/chap11/mergesort.lisp
-
-
-textbook/chap11/perm-append.cert : acl2x = 0
-textbook/chap11/perm-append.cert : no_pcert = 0
-
-textbook/chap11/perm-append.cert : \
- textbook/chap11/perm.cert \
- textbook/chap11/perm-append.lisp
-
-
-textbook/chap11/perm.cert : acl2x = 0
-textbook/chap11/perm.cert : no_pcert = 0
-
-textbook/chap11/perm.cert : \
- textbook/chap11/perm.lisp
-
-
-textbook/chap11/qsort.cert : acl2x = 0
-textbook/chap11/qsort.cert : no_pcert = 0
-
-textbook/chap11/qsort.cert : \
- textbook/chap11/perm-append.cert \
- textbook/chap11/qsort.lisp
-
-
-textbook/chap11/starters.cert : acl2x = 0
-textbook/chap11/starters.cert : no_pcert = 0
-
-textbook/chap11/starters.cert : \
- ordinals/e0-ordinal.cert \
- textbook/chap11/starters.lisp
-
-
-textbook/chap11/summations-book.cert : acl2x = 0
-textbook/chap11/summations-book.cert : no_pcert = 0
-
-textbook/chap11/summations-book.cert : \
- arithmetic/top-with-meta.cert \
- textbook/chap11/summations-book.lisp
-
-
-textbook/chap11/summations.cert : acl2x = 0
-textbook/chap11/summations.cert : no_pcert = 0
-
-textbook/chap11/summations.cert : \
- textbook/chap10/ac-example.cert \
- textbook/chap11/summations.lisp
-
-
-textbook/chap11/tautology.cert : acl2x = 0
-textbook/chap11/tautology.cert : no_pcert = 0
-
-textbook/chap11/tautology.cert : \
- ordinals/e0-ordinal.cert \
- arithmetic/top.cert \
- textbook/chap11/tautology.lisp
-
-
-textbook/chap11/xtr.cert : acl2x = 0
-textbook/chap11/xtr.cert : no_pcert = 0
-
-textbook/chap11/xtr.cert : \
- textbook/chap11/xtr.lisp
-
-
-textbook/chap11/xtr2.cert : acl2x = 0
-textbook/chap11/xtr2.cert : no_pcert = 0
-
-textbook/chap11/xtr2.cert : \
- arithmetic/top-with-meta.cert \
- textbook/chap11/xtr2.lisp
-
-
-textbook/chap3/programs.cert : acl2x = 0
-textbook/chap3/programs.cert : no_pcert = 0
-
-textbook/chap3/programs.cert : \
- textbook/chap3/programs.lisp
-
-
-textbook/chap4/solutions-logic-mode.cert : acl2x = 0
-textbook/chap4/solutions-logic-mode.cert : no_pcert = 0
-
-textbook/chap4/solutions-logic-mode.cert : \
- ihs/ihs-lemmas.cert \
- textbook/chap4/solutions-logic-mode.lisp
-
-
-textbook/chap4/solutions-program-mode.cert : acl2x = 0
-textbook/chap4/solutions-program-mode.cert : no_pcert = 0
-
-textbook/chap4/solutions-program-mode.cert : \
- textbook/chap4/solutions-program-mode.lisp
-
-
-textbook/chap5/solutions.cert : acl2x = 0
-textbook/chap5/solutions.cert : no_pcert = 0
-
-textbook/chap5/solutions.cert : \
- textbook/chap5/solutions.lisp
-
-
-textbook/chap6/selected-solutions.cert : acl2x = 0
-textbook/chap6/selected-solutions.cert : no_pcert = 0
-
-textbook/chap6/selected-solutions.cert : \
- ordinals/e0-ordinal.cert \
- arithmetic/top-with-meta.cert \
- textbook/chap6/selected-solutions.lisp
-
-
-tools/bstar.cert : acl2x = 0
-tools/bstar.cert : no_pcert = 0
-
-tools/bstar.cert : \
- tools/pack.cert \
- tools/bstar.lisp
-
-
-tools/case-splitting-rules.cert : acl2x = 0
-tools/case-splitting-rules.cert : no_pcert = 0
-
-tools/case-splitting-rules.cert : \
- tools/bstar.cert \
- tools/case-splitting-rules.lisp
-
-
-tools/clone-stobj.cert : acl2x = 0
-tools/clone-stobj.cert : no_pcert = 0
-
-tools/clone-stobj.cert : \
- tools/bstar.cert \
- tools/rulesets.cert \
- tools/templates.cert \
- xdoc/top.cert \
- tools/clone-stobj.lisp
-
-
-tools/cws.cert : acl2x = 0
-tools/cws.cert : no_pcert = 0
-
-tools/cws.cert : \
- tools/cws.lisp
-
-
-tools/def-functional-instance.cert : acl2x = 0
-tools/def-functional-instance.cert : no_pcert = 0
-
-tools/def-functional-instance.cert : \
- tools/bstar.cert \
- tools/def-functional-instance.lisp
-
-
-tools/defconsts.cert : acl2x = 0
-tools/defconsts.cert : no_pcert = 0
-
-tools/defconsts.cert : \
- tools/bstar.cert \
- tools/defconsts.lisp
-
-
-tools/defevaluator-fast.cert : acl2x = 0
-tools/defevaluator-fast.cert : no_pcert = 0
-
-tools/defevaluator-fast.cert : \
- tools/defevaluator-fast.lisp
-
-
-tools/define-keyed-function.cert : acl2x = 0
-tools/define-keyed-function.cert : no_pcert = 0
-
-tools/define-keyed-function.cert : \
- tools/define-keyed-function.lisp
-
-
-tools/defined-const.cert : acl2x = 0
-tools/defined-const.cert : no_pcert = 0
-
-tools/defined-const.cert : \
- tools/defined-const.lisp
-
-
-tools/defmacfun.cert : acl2x = 0
-tools/defmacfun.cert : no_pcert = 0
-
-tools/defmacfun.cert : \
- tools/defmacfun.lisp
-
-
-tools/defredundant.cert : acl2x = 0
-tools/defredundant.cert : no_pcert = 0
-
-tools/defredundant.cert : \
- tools/bstar.cert \
- tools/defredundant.lisp
-
-
-tools/defsum.cert : acl2x = 0
-tools/defsum.cert : no_pcert = 0
-
-tools/defsum.cert : \
- tools/pattern-match.cert \
- tools/types-misc.cert \
- tools/defsum.lisp
-
-
-tools/deftuple.cert : acl2x = 0
-tools/deftuple.cert : no_pcert = 0
-
-tools/deftuple.cert : \
- tools/types-misc.cert \
- tools/bstar.cert \
- tools/deftuple.lisp
-
-
-tools/do-not.cert : acl2x = 0
-tools/do-not.cert : no_pcert = 0
-
-tools/do-not.cert : \
- tools/bstar.cert \
- tools/do-not.lisp
-
-
-tools/easy-simplify.cert : acl2x = 0
-tools/easy-simplify.cert : no_pcert = 0
-
-tools/easy-simplify.cert : \
- tools/bstar.cert \
- tools/easy-simplify.lisp
-
-
-tools/fake-event.cert : acl2x = 0
-tools/fake-event.cert : no_pcert = 0
-
-tools/fake-event.cert : \
- tools/fake-event.lisp
-
-
-tools/flag.cert : acl2x = 0
-tools/flag.cert : no_pcert = 0
-
-tools/flag.cert : \
- xdoc/top.cert \
- tools/flag.lisp \
- tools/flag.acl2 \
- tools/flag-package.lsp
-
-
-tools/in-raw-mode.cert : acl2x = 0
-tools/in-raw-mode.cert : no_pcert = 0
-
-tools/in-raw-mode.cert : \
- tools/in-raw-mode.lisp \
- tools/in-raw-mode.acl2
-
-
-tools/include-raw.cert : acl2x = 0
-tools/include-raw.cert : no_pcert = 0
-
-tools/include-raw.cert : \
- xdoc/top.cert \
- tools/include-raw.lisp
-
-
-tools/mv-nth.cert : acl2x = 0
-tools/mv-nth.cert : no_pcert = 0
-
-tools/mv-nth.cert : \
- tools/mv-nth.lisp
-
-
-tools/oracle-eval-real.cert : acl2x = 0
-tools/oracle-eval-real.cert : no_pcert = 0
-
-tools/oracle-eval-real.cert : \
- tools/oracle-eval-real.lisp \
- tools/oracle-eval-real.acl2
-
-
-tools/oracle-eval.cert : acl2x = 0
-tools/oracle-eval.cert : no_pcert = 0
-
-tools/oracle-eval.cert : \
- tools/oracle-eval-real.cert \
- tools/oracle-eval.lisp
-
-
-tools/pack.cert : acl2x = 0
-tools/pack.cert : no_pcert = 0
-
-tools/pack.cert : \
- tools/pack.lisp
-
-
-tools/pattern-match.cert : acl2x = 0
-tools/pattern-match.cert : no_pcert = 0
-
-tools/pattern-match.cert : \
- tools/pattern-match.lisp
-
-
-tools/plev-ccl.cert : acl2x = 0
-tools/plev-ccl.cert : no_pcert = 0
-
-tools/plev-ccl.cert : \
- tools/plev.cert \
- tools/include-raw.cert \
- tools/plev-ccl.lisp \
- tools/plev-ccl.acl2
-
-
-tools/plev.cert : acl2x = 0
-tools/plev.cert : no_pcert = 0
-
-tools/plev.cert : \
- tools/plev.lisp
-
-
-tools/rulesets.cert : acl2x = 0
-tools/rulesets.cert : no_pcert = 0
-
-tools/rulesets.cert : \
- xdoc/top.cert \
- tools/rulesets.lisp
-
-
-tools/safe-case.cert : acl2x = 0
-tools/safe-case.cert : no_pcert = 0
-
-tools/safe-case.cert : \
- tools/safe-case.lisp
-
-
-tools/saved-errors.cert : acl2x = 0
-tools/saved-errors.cert : no_pcert = 0
-
-tools/saved-errors.cert : \
- tools/saved-errors.lisp
-
-
-tools/stobj-frame.cert : acl2x = 0
-tools/stobj-frame.cert : no_pcert = 0
-
-tools/stobj-frame.cert : \
- tools/rulesets.cert \
- tools/bstar.cert \
- data-structures/list-defthms.cert \
- tools/stobj-frame.lisp
-
-
-tools/stobj-help.cert : acl2x = 0
-tools/stobj-help.cert : no_pcert = 0
-
-tools/stobj-help.cert : \
- arithmetic-5/top.cert \
- misc/simplify-thm.cert \
- tools/stobj-help.lisp
-
-
-tools/templates.cert : acl2x = 0
-tools/templates.cert : no_pcert = 0
-
-tools/templates.cert : \
- tools/bstar.cert \
- tools/defmacfun.cert \
- xdoc/top.cert \
- tools/templates.lisp
-
-
-tools/theory-tools.cert : acl2x = 0
-tools/theory-tools.cert : no_pcert = 0
-
-tools/theory-tools.cert : \
- tools/theory-tools.lisp
-
-
-tools/time-dollar-with-gc.cert : acl2x = 0
-tools/time-dollar-with-gc.cert : no_pcert = 0
-
-tools/time-dollar-with-gc.cert : \
- tools/time-dollar-with-gc.lisp \
- tools/time-dollar-with-gc.acl2
-
-
-tools/types-misc.cert : acl2x = 0
-tools/types-misc.cert : no_pcert = 0
-
-tools/types-misc.cert : \
- tools/theory-tools.cert \
- tools/types-misc.lisp
-
-
-tools/with-arith5-help.cert : acl2x = 0
-tools/with-arith5-help.cert : no_pcert = 0
-
-tools/with-arith5-help.cert : \
- tools/rulesets.cert \
- arithmetic-5/top.cert \
- tools/with-arith5-help.lisp
-
-
-tools/with-quoted-forms.cert : acl2x = 0
-tools/with-quoted-forms.cert : no_pcert = 0
-
-tools/with-quoted-forms.cert : \
- tools/bstar.cert \
- tools/with-quoted-forms.lisp
-
-
-tutorial-problems/introductory-challenge-problem-4-athena.cert : acl2x = 0
-tutorial-problems/introductory-challenge-problem-4-athena.cert : no_pcert = 0
-
-tutorial-problems/introductory-challenge-problem-4-athena.cert : \
- tutorial-problems/introductory-challenge-problem-4-athena.lisp
-
-
-tutorial-problems/introductory-challenge-problem-4.cert : acl2x = 0
-tutorial-problems/introductory-challenge-problem-4.cert : no_pcert = 0
-
-tutorial-problems/introductory-challenge-problem-4.cert : \
- tutorial-problems/introductory-challenge-problem-4.lisp
-
-
-unicode/partition.cert : acl2x = 0
-unicode/partition.cert : no_pcert = 0
-
-unicode/partition.cert : \
- std/lists/flatten.cert \
- unicode/sum-list.cert \
- std/lists/take.cert \
- unicode/z-listp.cert \
- arithmetic/top-with-meta.cert \
- std/lists/nthcdr.cert \
- unicode/partition.lisp
-
-
-unicode/read-utf8.cert : acl2x = 0
-unicode/read-utf8.cert : no_pcert = 0
-
-unicode/read-utf8.cert : \
- unicode/utf8-decode.cert \
- std/io/take-bytes.cert \
- std/io/base.cert \
- tools/mv-nth.cert \
- std/io/signed-byte-listp.cert \
- arithmetic-3/bind-free/top.cert \
- unicode/read-utf8.lisp
-
-
-unicode/sum-list.cert : acl2x = 0
-unicode/sum-list.cert : no_pcert = 0
-
-unicode/sum-list.cert : \
- std/lists/nat-listp.cert \
- unicode/sum-list.lisp
-
-
-unicode/uchar.cert : acl2x = 0
-unicode/uchar.cert : no_pcert = 0
-
-unicode/uchar.cert : \
- unicode/uchar.lisp
-
-
-unicode/utf8-decode.cert : acl2x = 0
-unicode/utf8-decode.cert : no_pcert = 0
-
-unicode/utf8-decode.cert : \
- unicode/uchar.cert \
- unicode/utf8-table35.cert \
- unicode/utf8-table36.cert \
- unicode/utf8-encode.cert \
- unicode/partition.cert \
- std/lists/nthcdr.cert \
- std/io/signed-byte-listp.cert \
- tools/mv-nth.cert \
- arithmetic-3/bind-free/top.cert \
- std/lists/revappend.cert \
- unicode/utf8-decode.lisp
-
-
-unicode/utf8-encode.cert : acl2x = 0
-unicode/utf8-encode.cert : no_pcert = 0
-
-unicode/utf8-encode.cert : \
- unicode/utf8-table35.cert \
- unicode/utf8-table36.cert \
- std/lists/append.cert \
- std/io/signed-byte-listp.cert \
- unicode/utf8-encode.lisp
-
-
-unicode/utf8-table35.cert : acl2x = 0
-unicode/utf8-table35.cert : no_pcert = 0
-
-unicode/utf8-table35.cert : \
- unicode/uchar.cert \
- std/io/unsigned-byte-listp.cert \
- std/io/signed-byte-listp.cert \
- unicode/utf8-table35.lisp
-
-
-unicode/utf8-table36.cert : acl2x = 0
-unicode/utf8-table36.cert : no_pcert = 0
-
-unicode/utf8-table36.cert : \
- unicode/uchar.cert \
- std/io/unsigned-byte-listp.cert \
- std/io/signed-byte-listp.cert \
- unicode/utf8-table36.lisp
-
-
-unicode/z-listp.cert : acl2x = 0
-unicode/z-listp.cert : no_pcert = 0
-
-unicode/z-listp.cert : \
- std/lists/app.cert \
- unicode/z-listp.lisp
-
-
-workshops/1999/calculus/solutions/mesh-append.cert : acl2x = 0
-workshops/1999/calculus/solutions/mesh-append.cert : no_pcert = 0
-
-workshops/1999/calculus/solutions/mesh-append.cert : \
- workshops/1999/calculus/solutions/partition-defuns.cert \
- workshops/1999/calculus/solutions/mesh-append.lisp
-
-
-workshops/1999/calculus/solutions/mesh-make-partition.cert : acl2x = 0
-workshops/1999/calculus/solutions/mesh-make-partition.cert : no_pcert = 0
-
-workshops/1999/calculus/solutions/mesh-make-partition.cert : \
- workshops/1999/calculus/solutions/partition-defuns.cert \
- workshops/1999/calculus/solutions/mesh-make-partition.lisp
-
-
-workshops/1999/calculus/solutions/partition-defuns.cert : acl2x = 0
-workshops/1999/calculus/solutions/partition-defuns.cert : no_pcert = 0
-
-workshops/1999/calculus/solutions/partition-defuns.cert : \
- workshops/1999/calculus/solutions/partition-defuns.lisp
-
-
-workshops/1999/calculus/solutions/partitionp-make-partition-rec.cert : acl2x = 0
-workshops/1999/calculus/solutions/partitionp-make-partition-rec.cert : no_pcert = 0
-
-workshops/1999/calculus/solutions/partitionp-make-partition-rec.cert : \
- workshops/1999/calculus/solutions/partition-defuns.cert \
- workshops/1999/calculus/solutions/partitionp-make-partition-rec.lisp
-
-
-workshops/1999/calculus/solutions/partitionp-make-partition.cert : acl2x = 0
-workshops/1999/calculus/solutions/partitionp-make-partition.cert : no_pcert = 0
-
-workshops/1999/calculus/solutions/partitionp-make-partition.cert : \
- workshops/1999/calculus/solutions/partition-defuns.cert \
- workshops/1999/calculus/solutions/partitionp-make-partition-rec.cert \
- workshops/1999/calculus/solutions/partitionp-make-partition.lisp
-
-
-workshops/1999/calculus/solutions/riemann-rcfn-helpers.cert : acl2x = 0
-workshops/1999/calculus/solutions/riemann-rcfn-helpers.cert : no_pcert = 0
-
-workshops/1999/calculus/solutions/riemann-rcfn-helpers.cert : \
- workshops/1999/calculus/solutions/riemann-rcfn-helpers.lisp
-
-
-workshops/1999/compiler/compiler.cert : acl2x = 0
-workshops/1999/compiler/compiler.cert : no_pcert = 0
-
-workshops/1999/compiler/compiler.cert : \
- workshops/1999/compiler/machine.cert \
- workshops/1999/compiler/compiler.lisp
-
-
-workshops/1999/compiler/evaluator.cert : acl2x = 0
-workshops/1999/compiler/evaluator.cert : no_pcert = 0
-
-workshops/1999/compiler/evaluator.cert : \
- workshops/1999/compiler/compiler.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/compiler/evaluator.lisp
-
-
-workshops/1999/compiler/exercises.cert : acl2x = 0
-workshops/1999/compiler/exercises.cert : no_pcert = 0
-
-workshops/1999/compiler/exercises.cert : \
- workshops/1999/compiler/compiler.cert \
- workshops/1999/compiler/exercises.lisp
-
-
-workshops/1999/compiler/machine.cert : acl2x = 0
-workshops/1999/compiler/machine.cert : no_pcert = 0
-
-workshops/1999/compiler/machine.cert : \
- ordinals/e0-ordinal.cert \
- workshops/1999/compiler/machine.lisp
-
-
-workshops/1999/compiler/proof.cert : acl2x = 0
-workshops/1999/compiler/proof.cert : no_pcert = 0
-
-workshops/1999/compiler/proof.cert : \
- workshops/1999/compiler/proof1.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/compiler/proof.lisp
-
-
-workshops/1999/compiler/proof1.cert : acl2x = 0
-workshops/1999/compiler/proof1.cert : no_pcert = 0
-
-workshops/1999/compiler/proof1.cert : \
- workshops/1999/compiler/evaluator.cert \
- arithmetic/equalities.cert \
- workshops/1999/compiler/proof1.lisp
-
-
-workshops/1999/de-hdl/arity.cert : acl2x = 0
-workshops/1999/de-hdl/arity.cert : no_pcert = 0
-
-workshops/1999/de-hdl/arity.cert : \
- workshops/1999/de-hdl/syntax.cert \
- workshops/1999/de-hdl/arity.lisp
-
-
-workshops/1999/de-hdl/de4.cert : acl2x = 0
-workshops/1999/de-hdl/de4.cert : no_pcert = 0
-
-workshops/1999/de-hdl/de4.cert : \
- workshops/1999/de-hdl/sts-okp.cert \
- workshops/1999/de-hdl/de4.lisp
-
-
-workshops/1999/de-hdl/examples.cert : acl2x = 0
-workshops/1999/de-hdl/examples.cert : no_pcert = 0
-
-workshops/1999/de-hdl/examples.cert : \
- workshops/1999/de-hdl/de4.cert \
- workshops/1999/de-hdl/examples.lisp
-
-
-workshops/1999/de-hdl/help-defuns.cert : acl2x = 0
-workshops/1999/de-hdl/help-defuns.cert : no_pcert = 0
-
-workshops/1999/de-hdl/help-defuns.cert : \
- workshops/1999/de-hdl/help-defuns.lisp
-
-
-workshops/1999/de-hdl/measure.cert : acl2x = 0
-workshops/1999/de-hdl/measure.cert : no_pcert = 0
-
-workshops/1999/de-hdl/measure.cert : \
- workshops/1999/de-hdl/help-defuns.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/de-hdl/measure.lisp
-
-
-workshops/1999/de-hdl/primitives.cert : acl2x = 0
-workshops/1999/de-hdl/primitives.cert : no_pcert = 0
-
-workshops/1999/de-hdl/primitives.cert : \
- workshops/1999/de-hdl/measure.cert \
- workshops/1999/de-hdl/primitives.lisp
-
-
-workshops/1999/de-hdl/sts-okp.cert : acl2x = 0
-workshops/1999/de-hdl/sts-okp.cert : no_pcert = 0
-
-workshops/1999/de-hdl/sts-okp.cert : \
- workshops/1999/de-hdl/arity.cert \
- workshops/1999/de-hdl/sts-okp.lisp
-
-
-workshops/1999/de-hdl/syntax.cert : acl2x = 0
-workshops/1999/de-hdl/syntax.cert : no_pcert = 0
-
-workshops/1999/de-hdl/syntax.cert : \
- workshops/1999/de-hdl/primitives.cert \
- workshops/1999/de-hdl/syntax.lisp
-
-
-workshops/1999/de-hdl/thm-example.cert : acl2x = 0
-workshops/1999/de-hdl/thm-example.cert : no_pcert = 0
-
-workshops/1999/de-hdl/thm-example.cert : \
- workshops/1999/de-hdl/de4.cert \
- workshops/1999/de-hdl/thm-example.lisp
-
-
-workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.cert : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.cert : no_pcert = 0
-
-workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.cert : \
- workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.lisp
-
-
-workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.cert : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.cert : no_pcert = 0
-
-workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.cert : \
- arithmetic/mod-gcd.cert \
- rtl/rel1/lib1/basic.cert \
- rtl/rel1/support/fp.cert \
- arithmetic/top-with-meta.cert \
- workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.cert \
- workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.lisp
-
-
-workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.cert : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.cert : no_pcert = 0
-
-workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.cert : \
- workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.cert \
- workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.lisp
-
-
-workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.cert : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.cert : no_pcert = 0
-
-workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.cert : \
- ihs/ihs-init.cert \
- ihs/ihs-theories.cert \
- ihs/math-lemmas.cert \
- workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.lisp
-
-
-workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.cert : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.cert : no_pcert = 0
-
-workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.cert : \
- workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.lisp
-
-
-workshops/1999/embedded/Proof-Of-Contribution/CRT.cert : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/CRT.cert : no_pcert = 0
-
-workshops/1999/embedded/Proof-Of-Contribution/CRT.cert : \
- arithmetic/mod-gcd.cert \
- rtl/rel1/lib1/basic.cert \
- rtl/rel1/support/fp.cert \
- workshops/1999/embedded/Proof-Of-Contribution/CRT.lisp
-
-
-workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.cert : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.cert : no_pcert = 0
-
-workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.cert : \
- workshops/1999/embedded/Proof-Of-Contribution/CRT.cert \
- arithmetic/top-with-meta.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.cert \
- workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.lisp
-
-
-workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.cert : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.cert : no_pcert = 0
-
-workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.cert : \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.lisp
-
-
-workshops/1999/embedded/Proof-Of-Contribution/Generic.cert : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Generic.cert : no_pcert = 0
-
-workshops/1999/embedded/Proof-Of-Contribution/Generic.cert : \
- workshops/1999/embedded/Proof-Of-Contribution/Generic.lisp
-
-
-workshops/1999/embedded/Proof-Of-Contribution/Mapping.cert : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Mapping.cert : no_pcert = 0
-
-workshops/1999/embedded/Proof-Of-Contribution/Mapping.cert : \
- workshops/1999/embedded/Proof-Of-Contribution/Generic.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Mapping.lisp
-
-
-workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.cert : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.cert : no_pcert = 0
-
-workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.cert : \
- workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.lisp
-
-
-workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.cert : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.cert : no_pcert = 0
-
-workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.cert : \
- workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.lisp
-
-
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.cert : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.cert : no_pcert = 0
-
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.cert : \
- workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.lisp
-
-
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.cert : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.cert : no_pcert = 0
-
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.cert : \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.lisp
-
-
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.cert : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.cert : no_pcert = 0
-
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.cert : \
- workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Mapping.cert \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.lisp
-
-
-workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.cert : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.cert : no_pcert = 0
-
-workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.cert : \
- ihs/ihs-init.cert \
- ihs/ihs-theories.cert \
- ihs/math-lemmas.cert \
- workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.lisp
-
-
-workshops/1999/graph/find-path1.cert : acl2x = 0
-workshops/1999/graph/find-path1.cert : no_pcert = 0
-
-workshops/1999/graph/find-path1.cert : \
- arithmetic/top.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/graph/find-path1.lisp
-
-
-workshops/1999/graph/find-path2.cert : acl2x = 0
-workshops/1999/graph/find-path2.cert : no_pcert = 0
-
-workshops/1999/graph/find-path2.cert : \
- arithmetic/top.cert \
- workshops/1999/graph/helpers.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/graph/find-path2.lisp
-
-
-workshops/1999/graph/find-path3.cert : acl2x = 0
-workshops/1999/graph/find-path3.cert : no_pcert = 0
-
-workshops/1999/graph/find-path3.cert : \
- arithmetic/top.cert \
- workshops/1999/graph/helpers.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/graph/find-path3.lisp
-
-
-workshops/1999/graph/helpers.cert : acl2x = 0
-workshops/1999/graph/helpers.cert : no_pcert = 0
-
-workshops/1999/graph/helpers.cert : \
- workshops/1999/graph/helpers.lisp
-
-
-workshops/1999/graph/linear-find-path.cert : acl2x = 0
-workshops/1999/graph/linear-find-path.cert : no_pcert = 0
-
-workshops/1999/graph/linear-find-path.cert : \
- workshops/1999/graph/find-path3.cert \
- workshops/1999/graph/linear-find-path.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/alls.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/alls.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/alls.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/variables.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/alls.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.cert : \
- arithmetic/top.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/base.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/base.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/base.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sets.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/close.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/close.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/close.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/keval.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/cnf.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/cnf.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/cnf.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/cnf.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/derive.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/derive.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/derive.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/substitution.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/resolve.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/paramod.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/flip.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/derive.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/flip.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/flip.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/flip.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/paramod.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/flip.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/instance.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/instance.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/keval.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/keval.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/keval.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/keval.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/modeler.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/modeler.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/modeler.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/nnf.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/cnf.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/derive.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/modeler.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/nnf.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/nnf.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/nnf.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/nnf.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/paramod.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/paramod.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/paramod.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/paramod.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/permutations.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/permutations.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/permutations.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sets.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/prover.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/prover.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/prover.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/nnf.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/cnf.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/derive.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/simplify.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/prover.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/xeval.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/resolve.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/resolve.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/resolve.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/resolve.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sets.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sets.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sets.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sets.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/derive.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/simplify.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simplify.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/simplify.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/simplify.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/substitution.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/xeval.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/substitution.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/substitution.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/substitution.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/substitution.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sugar.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sugar.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sugar.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/sugar.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/top.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/top.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/top.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/prover.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/modeler.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/top.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/variables.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/variables.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/variables.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/variables.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/alls.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.lisp
-
-
-workshops/1999/ivy/ivy-v2/ivy-sources/xeval.cert : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/xeval.cert : no_pcert = 0
-
-workshops/1999/ivy/ivy-v2/ivy-sources/xeval.cert : \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/ivy/ivy-v2/ivy-sources/xeval.lisp
-
-
-workshops/1999/knuth-91/aof.cert : acl2x = 0
-workshops/1999/knuth-91/aof.cert : no_pcert = 0
-
-workshops/1999/knuth-91/aof.cert : \
- arithmetic/inequalities.cert \
- workshops/1999/knuth-91/aof.lisp \
- workshops/1999/knuth-91/aof.acl2
-
-
-workshops/1999/knuth-91/exercise1.cert : acl2x = 0
-workshops/1999/knuth-91/exercise1.cert : no_pcert = 0
-
-workshops/1999/knuth-91/exercise1.cert : \
- workshops/1999/knuth-91/exercise1.lisp \
- workshops/1999/knuth-91/exercise1.acl2
-
-
-workshops/1999/knuth-91/exercise2.cert : acl2x = 0
-workshops/1999/knuth-91/exercise2.cert : no_pcert = 0
-
-workshops/1999/knuth-91/exercise2.cert : \
- workshops/1999/knuth-91/exercise2.lisp
-
-
-workshops/1999/knuth-91/exercise3.cert : acl2x = 0
-workshops/1999/knuth-91/exercise3.cert : no_pcert = 0
-
-workshops/1999/knuth-91/exercise3.cert : \
- ordinals/e0-ordinal.cert \
- workshops/1999/knuth-91/exercise3.lisp
-
-
-workshops/1999/knuth-91/exercise4a.cert : acl2x = 0
-workshops/1999/knuth-91/exercise4a.cert : no_pcert = 0
-
-workshops/1999/knuth-91/exercise4a.cert : \
- workshops/1999/knuth-91/exercise4a.lisp
-
-
-workshops/1999/knuth-91/exercise4b.cert : acl2x = 0
-workshops/1999/knuth-91/exercise4b.cert : no_pcert = 0
-
-workshops/1999/knuth-91/exercise4b.cert : \
- workshops/1999/knuth-91/exercise4b.lisp
-
-
-workshops/1999/knuth-91/exercise5.cert : acl2x = 0
-workshops/1999/knuth-91/exercise5.cert : no_pcert = 0
-
-workshops/1999/knuth-91/exercise5.cert : \
- workshops/1999/knuth-91/exercise5.lisp
-
-
-workshops/1999/knuth-91/exercise6a.cert : acl2x = 0
-workshops/1999/knuth-91/exercise6a.cert : no_pcert = 0
-
-workshops/1999/knuth-91/exercise6a.cert : \
- workshops/1999/knuth-91/exercise6a.lisp
-
-
-workshops/1999/knuth-91/exercise6b.cert : acl2x = 0
-workshops/1999/knuth-91/exercise6b.cert : no_pcert = 0
-
-workshops/1999/knuth-91/exercise6b.cert : \
- workshops/1999/knuth-91/exercise6b.lisp
-
-
-workshops/1999/knuth-91/exercise7a.cert : acl2x = 0
-workshops/1999/knuth-91/exercise7a.cert : no_pcert = 0
-
-workshops/1999/knuth-91/exercise7a.cert : \
- workshops/1999/knuth-91/exercise7a.lisp
-
-
-workshops/1999/knuth-91/exercise7b.cert : acl2x = 0
-workshops/1999/knuth-91/exercise7b.cert : no_pcert = 0
-
-workshops/1999/knuth-91/exercise7b.cert : \
- workshops/1999/knuth-91/exercise7b.lisp
-
-
-workshops/1999/knuth-91/knuth-arch.cert : acl2x = 0
-workshops/1999/knuth-91/knuth-arch.cert : no_pcert = 0
-
-workshops/1999/knuth-91/knuth-arch.cert : \
- arithmetic/top-with-meta.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/knuth-91/aof.cert \
- workshops/1999/knuth-91/knuth-arch.lisp
-
-
-workshops/1999/mu-calculus/book/fast-sets.cert : acl2x = 0
-workshops/1999/mu-calculus/book/fast-sets.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/book/fast-sets.cert : \
- workshops/1999/mu-calculus/book/sets.cert \
- workshops/1999/mu-calculus/book/fast-sets.lisp \
- workshops/1999/mu-calculus/book/fast-sets.acl2
-
-
-workshops/1999/mu-calculus/book/fixpoints.cert : acl2x = 0
-workshops/1999/mu-calculus/book/fixpoints.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/book/fixpoints.cert : \
- workshops/1999/mu-calculus/book/sets.cert \
- workshops/1999/mu-calculus/book/fixpoints.lisp \
- workshops/1999/mu-calculus/book/fixpoints.acl2
-
-
-workshops/1999/mu-calculus/book/models.cert : acl2x = 0
-workshops/1999/mu-calculus/book/models.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/book/models.cert : \
- workshops/1999/mu-calculus/book/relations.cert \
- workshops/1999/mu-calculus/book/fixpoints.cert \
- workshops/1999/mu-calculus/book/models.lisp \
- workshops/1999/mu-calculus/book/models.acl2
-
-
-workshops/1999/mu-calculus/book/relations.cert : acl2x = 0
-workshops/1999/mu-calculus/book/relations.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/book/relations.cert : \
- workshops/1999/mu-calculus/book/fast-sets.cert \
- workshops/1999/mu-calculus/book/relations.lisp \
- workshops/1999/mu-calculus/book/relations.acl2
-
-
-workshops/1999/mu-calculus/book/semantics.cert : acl2x = 0
-workshops/1999/mu-calculus/book/semantics.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/book/semantics.cert : \
- workshops/1999/mu-calculus/book/syntax.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/mu-calculus/book/semantics.lisp \
- workshops/1999/mu-calculus/book/semantics.acl2
-
-
-workshops/1999/mu-calculus/book/sets.cert : acl2x = 0
-workshops/1999/mu-calculus/book/sets.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/book/sets.cert : \
- workshops/1999/mu-calculus/book/sets.lisp \
- workshops/1999/mu-calculus/book/sets.acl2
-
-
-workshops/1999/mu-calculus/book/syntax.cert : acl2x = 0
-workshops/1999/mu-calculus/book/syntax.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/book/syntax.cert : \
- workshops/1999/mu-calculus/book/models.cert \
- workshops/1999/mu-calculus/book/syntax.lisp \
- workshops/1999/mu-calculus/book/syntax.acl2
-
-
-workshops/1999/mu-calculus/solutions/ctl.cert : acl2x = 0
-workshops/1999/mu-calculus/solutions/ctl.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/solutions/ctl.cert : \
- workshops/1999/mu-calculus/solutions/semantics.cert \
- workshops/1999/mu-calculus/solutions/ctl.lisp \
- workshops/1999/mu-calculus/solutions/ctl.acl2
-
-
-workshops/1999/mu-calculus/solutions/defung.cert : acl2x = 0
-workshops/1999/mu-calculus/solutions/defung.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/solutions/defung.cert : \
- workshops/1999/mu-calculus/solutions/defung.lisp
-
-
-workshops/1999/mu-calculus/solutions/fast-sets.cert : acl2x = 0
-workshops/1999/mu-calculus/solutions/fast-sets.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/solutions/fast-sets.cert : \
- workshops/1999/mu-calculus/solutions/sets.cert \
- workshops/1999/mu-calculus/solutions/fast-sets.lisp \
- workshops/1999/mu-calculus/solutions/fast-sets.acl2
-
-
-workshops/1999/mu-calculus/solutions/fixpoints.cert : acl2x = 0
-workshops/1999/mu-calculus/solutions/fixpoints.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/solutions/fixpoints.cert : \
- workshops/1999/mu-calculus/solutions/sets.cert \
- workshops/1999/mu-calculus/solutions/fixpoints.lisp \
- workshops/1999/mu-calculus/solutions/fixpoints.acl2
-
-
-workshops/1999/mu-calculus/solutions/meta.cert : acl2x = 0
-workshops/1999/mu-calculus/solutions/meta.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/solutions/meta.cert : \
- arithmetic/top-with-meta.cert \
- workshops/1999/mu-calculus/solutions/meta.lisp
-
-
-workshops/1999/mu-calculus/solutions/models.cert : acl2x = 0
-workshops/1999/mu-calculus/solutions/models.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/solutions/models.cert : \
- workshops/1999/mu-calculus/solutions/relations.cert \
- workshops/1999/mu-calculus/solutions/models.lisp \
- workshops/1999/mu-calculus/solutions/models.acl2
-
-
-workshops/1999/mu-calculus/solutions/perm.cert : acl2x = 0
-workshops/1999/mu-calculus/solutions/perm.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/solutions/perm.cert : \
- workshops/1999/mu-calculus/solutions/defung.cert \
- workshops/1999/mu-calculus/solutions/perm.lisp
-
-
-workshops/1999/mu-calculus/solutions/relations.cert : acl2x = 0
-workshops/1999/mu-calculus/solutions/relations.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/solutions/relations.cert : \
- workshops/1999/mu-calculus/solutions/fast-sets.cert \
- workshops/1999/mu-calculus/solutions/relations.lisp \
- workshops/1999/mu-calculus/solutions/relations.acl2
-
-
-workshops/1999/mu-calculus/solutions/semantics.cert : acl2x = 0
-workshops/1999/mu-calculus/solutions/semantics.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/solutions/semantics.cert : \
- workshops/1999/mu-calculus/solutions/syntax.cert \
- workshops/1999/mu-calculus/solutions/fixpoints.cert \
- ordinals/e0-ordinal.cert \
- workshops/1999/mu-calculus/solutions/semantics.lisp \
- workshops/1999/mu-calculus/solutions/semantics.acl2
-
-
-workshops/1999/mu-calculus/solutions/sets.cert : acl2x = 0
-workshops/1999/mu-calculus/solutions/sets.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/solutions/sets.cert : \
- workshops/1999/mu-calculus/solutions/defung.cert \
- workshops/1999/mu-calculus/solutions/meta.cert \
- workshops/1999/mu-calculus/solutions/perm.cert \
- workshops/1999/mu-calculus/solutions/sets.lisp \
- workshops/1999/mu-calculus/solutions/sets.acl2
-
-
-workshops/1999/mu-calculus/solutions/syntax.cert : acl2x = 0
-workshops/1999/mu-calculus/solutions/syntax.cert : no_pcert = 0
-
-workshops/1999/mu-calculus/solutions/syntax.cert : \
- workshops/1999/mu-calculus/solutions/models.cert \
- workshops/1999/mu-calculus/solutions/syntax.lisp \
- workshops/1999/mu-calculus/solutions/syntax.acl2
-
-
-workshops/1999/pipeline/b-ops-aux-def.cert : acl2x = 0
-workshops/1999/pipeline/b-ops-aux-def.cert : no_pcert = 0
-
-workshops/1999/pipeline/b-ops-aux-def.cert : \
- workshops/1999/pipeline/trivia.cert \
- workshops/1999/pipeline/ihs.cert \
- workshops/1999/pipeline/b-ops-aux-def.lisp
-
-
-workshops/1999/pipeline/b-ops-aux.cert : acl2x = 0
-workshops/1999/pipeline/b-ops-aux.cert : no_pcert = 0
-
-workshops/1999/pipeline/b-ops-aux.cert : \
- workshops/1999/pipeline/b-ops-aux-def.cert \
- workshops/1999/pipeline/b-ops-aux.lisp
-
-
-workshops/1999/pipeline/basic-def.cert : acl2x = 0
-workshops/1999/pipeline/basic-def.cert : no_pcert = 0
-
-workshops/1999/pipeline/basic-def.cert : \
- data-structures/array1.cert \
- data-structures/deflist.cert \
- data-structures/list-defthms.cert \
- data-structures/structures.cert \
- workshops/1999/pipeline/ihs.cert \
- workshops/1999/pipeline/trivia.cert \
- workshops/1999/pipeline/b-ops-aux.cert \
- workshops/1999/pipeline/basic-def.lisp \
- workshops/1999/pipeline/basic-def.acl2 \
- workshops/1999/pipeline/define-u-package.lsp
-
-
-workshops/1999/pipeline/basic-lemmas.cert : acl2x = 0
-workshops/1999/pipeline/basic-lemmas.cert : no_pcert = 0
-
-workshops/1999/pipeline/basic-lemmas.cert : \
- workshops/1999/pipeline/basic-def.cert \
- workshops/1999/pipeline/model.cert \
- workshops/1999/pipeline/table-def.cert \
- workshops/1999/pipeline/basic-lemmas.lisp
-
-
-workshops/1999/pipeline/exercise.cert : acl2x = 0
-workshops/1999/pipeline/exercise.cert : no_pcert = 0
-
-workshops/1999/pipeline/exercise.cert : \
- workshops/1999/pipeline/exercise.lisp
-
-
-workshops/1999/pipeline/ihs.cert : acl2x = 0
-workshops/1999/pipeline/ihs.cert : no_pcert = 0
-
-workshops/1999/pipeline/ihs.cert : \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- workshops/1999/pipeline/ihs.lisp
-
-
-workshops/1999/pipeline/model.cert : acl2x = 0
-workshops/1999/pipeline/model.cert : no_pcert = 0
-
-workshops/1999/pipeline/model.cert : \
- workshops/1999/pipeline/basic-def.cert \
- workshops/1999/pipeline/model.lisp
-
-
-workshops/1999/pipeline/proof.cert : acl2x = 0
-workshops/1999/pipeline/proof.cert : no_pcert = 0
-
-workshops/1999/pipeline/proof.cert : \
- workshops/1999/pipeline/basic-def.cert \
- workshops/1999/pipeline/model.cert \
- workshops/1999/pipeline/table-def.cert \
- workshops/1999/pipeline/basic-lemmas.cert \
- workshops/1999/pipeline/proof.lisp
-
-
-workshops/1999/pipeline/table-def.cert : acl2x = 0
-workshops/1999/pipeline/table-def.cert : no_pcert = 0
-
-workshops/1999/pipeline/table-def.cert : \
- workshops/1999/pipeline/utils.cert \
- workshops/1999/pipeline/basic-def.cert \
- workshops/1999/pipeline/model.cert \
- workshops/1999/pipeline/table-def.lisp
-
-
-workshops/1999/pipeline/trivia.cert : acl2x = 0
-workshops/1999/pipeline/trivia.cert : no_pcert = 0
-
-workshops/1999/pipeline/trivia.cert : \
- data-structures/array1.cert \
- arithmetic/top.cert \
- workshops/1999/pipeline/trivia.lisp
-
-
-workshops/1999/pipeline/utils.cert : acl2x = 0
-workshops/1999/pipeline/utils.cert : no_pcert = 0
-
-workshops/1999/pipeline/utils.cert : \
- data-structures/utilities.cert \
- workshops/1999/pipeline/utils.lisp \
- workshops/1999/pipeline/utils.acl2 \
- workshops/1999/pipeline/define-u-package.lsp
-
-
-workshops/1999/simulator/exercises.cert : acl2x = 0
-workshops/1999/simulator/exercises.cert : no_pcert = 0
-
-workshops/1999/simulator/exercises.cert : \
- workshops/1999/simulator/tiny.cert \
- workshops/1999/simulator/exercises.lisp
-
-
-workshops/1999/simulator/tiny.cert : acl2x = 0
-workshops/1999/simulator/tiny.cert : no_pcert = 0
-
-workshops/1999/simulator/tiny.cert : \
- arithmetic/top.cert \
- data-structures/list-defthms.cert \
- meta/meta.cert \
- ihs/logops-lemmas.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/1999/simulator/tiny.lisp
-
-
-workshops/1999/ste/assertion.cert : acl2x = 0
-workshops/1999/ste/assertion.cert : no_pcert = 0
-
-workshops/1999/ste/assertion.cert : \
- workshops/1999/ste/trajectory.cert \
- workshops/1999/ste/assertion.lisp
-
-
-workshops/1999/ste/boolean.cert : acl2x = 0
-workshops/1999/ste/boolean.cert : no_pcert = 0
-
-workshops/1999/ste/boolean.cert : \
- workshops/1999/ste/util.cert \
- workshops/1999/ste/boolean.lisp
-
-
-workshops/1999/ste/circuit.cert : acl2x = 0
-workshops/1999/ste/circuit.cert : no_pcert = 0
-
-workshops/1999/ste/circuit.cert : \
- workshops/1999/ste/expression.cert \
- workshops/1999/ste/circuit.lisp
-
-
-workshops/1999/ste/example.cert : acl2x = 0
-workshops/1999/ste/example.cert : no_pcert = 0
-
-workshops/1999/ste/example.cert : \
- workshops/1999/ste/inference.cert \
- workshops/1999/ste/example.lisp
-
-
-workshops/1999/ste/expression.cert : acl2x = 0
-workshops/1999/ste/expression.cert : no_pcert = 0
-
-workshops/1999/ste/expression.cert : \
- workshops/1999/ste/run.cert \
- workshops/1999/ste/expression.lisp
-
-
-workshops/1999/ste/fundamental.cert : acl2x = 0
-workshops/1999/ste/fundamental.cert : no_pcert = 0
-
-workshops/1999/ste/fundamental.cert : \
- workshops/1999/ste/lemma-4.cert \
- workshops/1999/ste/fundamental.lisp
-
-
-workshops/1999/ste/inference.cert : acl2x = 0
-workshops/1999/ste/inference.cert : no_pcert = 0
-
-workshops/1999/ste/inference.cert : \
- workshops/1999/ste/fundamental.cert \
- workshops/1999/ste/inference.lisp
-
-
-workshops/1999/ste/lemma-4.cert : acl2x = 0
-workshops/1999/ste/lemma-4.cert : no_pcert = 0
-
-workshops/1999/ste/lemma-4.cert : \
- workshops/1999/ste/assertion.cert \
- workshops/1999/ste/lemma-4.lisp
-
-
-workshops/1999/ste/run.cert : acl2x = 0
-workshops/1999/ste/run.cert : no_pcert = 0
-
-workshops/1999/ste/run.cert : \
- workshops/1999/ste/state.cert \
- workshops/1999/ste/run.lisp
-
-
-workshops/1999/ste/state.cert : acl2x = 0
-workshops/1999/ste/state.cert : no_pcert = 0
-
-workshops/1999/ste/state.cert : \
- workshops/1999/ste/boolean.cert \
- workshops/1999/ste/state.lisp
-
-
-workshops/1999/ste/trajectory.cert : acl2x = 0
-workshops/1999/ste/trajectory.cert : no_pcert = 0
-
-workshops/1999/ste/trajectory.cert : \
- workshops/1999/ste/circuit.cert \
- workshops/1999/ste/trajectory.lisp
-
-
-workshops/1999/ste/util.cert : acl2x = 0
-workshops/1999/ste/util.cert : no_pcert = 0
-
-workshops/1999/ste/util.cert : \
- data-structures/utilities.cert \
- data-structures/list-theory.cert \
- arithmetic/top-with-meta.cert \
- workshops/1999/ste/util.lisp
-
-
-workshops/1999/vhdl/exercises.cert : acl2x = 0
-workshops/1999/vhdl/exercises.cert : no_pcert = 0
-
-workshops/1999/vhdl/exercises.cert : \
- workshops/1999/vhdl/fact.cert \
- workshops/1999/vhdl/exercises.lisp
-
-
-workshops/1999/vhdl/fact-proof.cert : acl2x = 0
-workshops/1999/vhdl/fact-proof.cert : no_pcert = 0
-
-workshops/1999/vhdl/fact-proof.cert : \
- arithmetic/top.cert \
- workshops/1999/vhdl/fact.cert \
- workshops/1999/vhdl/fact-proof.lisp
-
-
-workshops/1999/vhdl/fact.cert : acl2x = 0
-workshops/1999/vhdl/fact.cert : no_pcert = 0
-
-workshops/1999/vhdl/fact.cert : \
- workshops/1999/vhdl/vhdl.cert \
- workshops/1999/vhdl/fact.lisp
-
-
-workshops/1999/vhdl/vhdl.cert : acl2x = 0
-workshops/1999/vhdl/vhdl.cert : no_pcert = 0
-
-workshops/1999/vhdl/vhdl.cert : \
- workshops/1999/vhdl/vhdl.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/base.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/base.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/base.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/util.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/base.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/compile.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/compile.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/compile.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/pstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/compile.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/cstate.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/cstate.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/cstate.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/expr.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/cstate.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/expr.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/expr.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/expr.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/base.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/expr.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/lstate.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/lstate.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/lstate.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/base.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/cstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/lstate.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/mstate.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/mstate.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/mstate.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/cstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/pstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/lstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/mstate.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/pstate.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/pstate.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/pstate.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/expr.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/pstate.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/setup.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/setup.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/setup.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/mstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/setup.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/simulator.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/simulator.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/simulator.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.cert \
- arithmetic/mod-gcd.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/simulator.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/mstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/mstate.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/setup.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.cert \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.lisp
-
-
-workshops/2000/lusk-mccune/lusk-mccune-final/util.cert : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/util.cert : no_pcert = 0
-
-workshops/2000/lusk-mccune/lusk-mccune-final/util.cert : \
- workshops/2000/lusk-mccune/lusk-mccune-final/util.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.cert : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.cert : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.cert : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.cert \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.cert : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.cert : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.cert \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/top/meta.cert \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/ihs.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/top/meta.cert \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.cert : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/top/meta.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/top/meta.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.cert \
- ordinals/e0-ordinal.cert \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.cert : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.cert : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.cert : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.cert : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.cert : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.cert : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.cert \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/top/meta.cert \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.cert : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.cert \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/top/meta.cert \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.cert : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/top/meta.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.cert : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/top/meta.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.cert : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.cert \
- ordinals/e0-ordinal.cert \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.cert : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/top/ihs.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/ihs.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/top/ihs.cert : \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- workshops/2000/manolios/pipeline/pipeline/top/ihs.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/top/meta.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/meta.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/top/meta.cert : \
- arithmetic/top-with-meta.cert \
- workshops/2000/manolios/pipeline/pipeline/top/meta.lisp
-
-
-workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.cert : \
- workshops/2000/manolios/pipeline/trivial/trivia.cert \
- workshops/2000/manolios/pipeline/trivial/ihs.cert \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/b-ops-aux.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/b-ops-aux.cert : \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.cert \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/basic-def.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/basic-def.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/basic-def.cert : \
- data-structures/array1.cert \
- data-structures/deflist.cert \
- data-structures/list-defthms.cert \
- data-structures/structures.cert \
- workshops/2000/manolios/pipeline/trivial/ihs.cert \
- workshops/2000/manolios/pipeline/trivial/trivia.cert \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux.cert \
- workshops/2000/manolios/pipeline/trivial/basic-def.lisp \
- workshops/2000/manolios/pipeline/trivial/basic-def.acl2 \
- workshops/2000/manolios/pipeline/trivial/define-u-package.lsp
-
-
-workshops/2000/manolios/pipeline/trivial/basic-lemmas.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/basic-lemmas.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/basic-lemmas.cert : \
- workshops/2000/manolios/pipeline/trivial/basic-def.cert \
- workshops/2000/manolios/pipeline/trivial/model.cert \
- workshops/2000/manolios/pipeline/trivial/table-def.cert \
- workshops/2000/manolios/pipeline/trivial/basic-lemmas.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/ihs.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/ihs.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/ihs.cert : \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- workshops/2000/manolios/pipeline/trivial/ihs.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/model.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/model.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/model.cert : \
- workshops/2000/manolios/pipeline/trivial/basic-def.cert \
- workshops/2000/manolios/pipeline/trivial/model.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/proof.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/proof.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/proof.cert : \
- workshops/2000/manolios/pipeline/trivial/model.cert \
- workshops/2000/manolios/pipeline/trivial/proof.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.cert : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.cert : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.cert : \
- data-structures/array1.cert \
- data-structures/deflist.cert \
- data-structures/list-defthms.cert \
- data-structures/structures.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.acl2 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/define-u-package.lsp
-
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.cert : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/model.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.cert : \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/model.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/model.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/model.cert : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/model.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/proof.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/proof.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/proof.cert : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/model.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/proof.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.cert : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/utils.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/model.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.cert : \
- data-structures/array1.cert \
- arithmetic/top.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/utils.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/utils.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/utils.cert : \
- data-structures/utilities.cert \
- workshops/2000/manolios/pipeline/trivial/sawada-model/utils.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/utils.acl2 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/define-u-package.lsp
-
-
-workshops/2000/manolios/pipeline/trivial/table-def.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/table-def.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/table-def.cert : \
- workshops/2000/manolios/pipeline/trivial/utils.cert \
- workshops/2000/manolios/pipeline/trivial/basic-def.cert \
- workshops/2000/manolios/pipeline/trivial/model.cert \
- workshops/2000/manolios/pipeline/trivial/table-def.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/trivia.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/trivia.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/trivia.cert : \
- data-structures/array1.cert \
- arithmetic/top.cert \
- workshops/2000/manolios/pipeline/trivial/trivia.lisp
-
-
-workshops/2000/manolios/pipeline/trivial/utils.cert : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/utils.cert : no_pcert = 0
-
-workshops/2000/manolios/pipeline/trivial/utils.cert : \
- data-structures/utilities.cert \
- workshops/2000/manolios/pipeline/trivial/utils.lisp \
- workshops/2000/manolios/pipeline/trivial/utils.acl2 \
- workshops/2000/manolios/pipeline/trivial/define-u-package.lsp
-
-
-workshops/2000/medina/polynomials/addition.cert : acl2x = 0
-workshops/2000/medina/polynomials/addition.cert : no_pcert = 0
-
-workshops/2000/medina/polynomials/addition.cert : \
- workshops/2000/medina/polynomials/normal-form.cert \
- workshops/2000/medina/polynomials/addition.lisp \
- workshops/2000/medina/polynomials/addition.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-
-
-workshops/2000/medina/polynomials/congruences-1.cert : acl2x = 0
-workshops/2000/medina/polynomials/congruences-1.cert : no_pcert = 0
-
-workshops/2000/medina/polynomials/congruences-1.cert : \
- workshops/2000/medina/polynomials/negation.cert \
- workshops/2000/medina/polynomials/congruences-1.lisp \
- workshops/2000/medina/polynomials/congruences-1.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-
-
-workshops/2000/medina/polynomials/congruences-2.cert : acl2x = 0
-workshops/2000/medina/polynomials/congruences-2.cert : no_pcert = 0
-
-workshops/2000/medina/polynomials/congruences-2.cert : \
- workshops/2000/medina/polynomials/multiplication.cert \
- workshops/2000/medina/polynomials/congruences-2.lisp \
- workshops/2000/medina/polynomials/congruences-2.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-
-
-workshops/2000/medina/polynomials/examples.cert : acl2x = 0
-workshops/2000/medina/polynomials/examples.cert : no_pcert = 0
-
-workshops/2000/medina/polynomials/examples.cert : \
- workshops/2000/medina/polynomials/congruences-2.cert \
- workshops/2000/medina/polynomials/examples.lisp \
- workshops/2000/medina/polynomials/examples.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-
-
-workshops/2000/medina/polynomials/lexicographical-ordering.cert : acl2x = 0
-workshops/2000/medina/polynomials/lexicographical-ordering.cert : no_pcert = 0
-
-workshops/2000/medina/polynomials/lexicographical-ordering.cert : \
- workshops/2000/medina/polynomials/term.cert \
- ordinals/ordinals-without-arithmetic.cert \
- workshops/2000/medina/polynomials/lexicographical-ordering.lisp \
- workshops/2000/medina/polynomials/lexicographical-ordering.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-
-
-workshops/2000/medina/polynomials/monomial.cert : acl2x = 0
-workshops/2000/medina/polynomials/monomial.cert : no_pcert = 0
-
-workshops/2000/medina/polynomials/monomial.cert : \
- workshops/2000/medina/polynomials/term.cert \
- workshops/2000/medina/polynomials/monomial.lisp \
- workshops/2000/medina/polynomials/monomial.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-
-
-workshops/2000/medina/polynomials/multiplication.cert : acl2x = 0
-workshops/2000/medina/polynomials/multiplication.cert : no_pcert = 0
-
-workshops/2000/medina/polynomials/multiplication.cert : \
- workshops/2000/medina/polynomials/congruences-1.cert \
- workshops/2000/medina/polynomials/multiplication.lisp \
- workshops/2000/medina/polynomials/multiplication.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-
-
-workshops/2000/medina/polynomials/negation.cert : acl2x = 0
-workshops/2000/medina/polynomials/negation.cert : no_pcert = 0
-
-workshops/2000/medina/polynomials/negation.cert : \
- workshops/2000/medina/polynomials/addition.cert \
- workshops/2000/medina/polynomials/negation.lisp \
- workshops/2000/medina/polynomials/negation.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-
-
-workshops/2000/medina/polynomials/normal-form.cert : acl2x = 0
-workshops/2000/medina/polynomials/normal-form.cert : no_pcert = 0
-
-workshops/2000/medina/polynomials/normal-form.cert : \
- workshops/2000/medina/polynomials/polynomial.cert \
- workshops/2000/medina/polynomials/lexicographical-ordering.cert \
- workshops/2000/medina/polynomials/normal-form.lisp \
- workshops/2000/medina/polynomials/normal-form.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-
-
-workshops/2000/medina/polynomials/polynomial.cert : acl2x = 0
-workshops/2000/medina/polynomials/polynomial.cert : no_pcert = 0
-
-workshops/2000/medina/polynomials/polynomial.cert : \
- workshops/2000/medina/polynomials/monomial.cert \
- workshops/2000/medina/polynomials/polynomial.lisp \
- workshops/2000/medina/polynomials/polynomial.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-
-
-workshops/2000/medina/polynomials/term.cert : acl2x = 0
-workshops/2000/medina/polynomials/term.cert : no_pcert = 0
-
-workshops/2000/medina/polynomials/term.cert : \
- workshops/2000/medina/polynomials/term.lisp \
- workshops/2000/medina/polynomials/term.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-
-
-workshops/2000/moore-manolios/partial-functions/defpun-original.cert : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/defpun-original.cert : no_pcert = 0
-
-workshops/2000/moore-manolios/partial-functions/defpun-original.cert : \
- workshops/2000/moore-manolios/partial-functions/defpun-original.lisp
-
-
-workshops/2000/moore-manolios/partial-functions/defpun.cert : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/defpun.cert : no_pcert = 0
-
-workshops/2000/moore-manolios/partial-functions/defpun.cert : \
- misc/defpun.cert \
- workshops/2000/moore-manolios/partial-functions/defpun.lisp
-
-
-workshops/2000/moore-manolios/partial-functions/examples.cert : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/examples.cert : no_pcert = 0
-
-workshops/2000/moore-manolios/partial-functions/examples.cert : \
- workshops/2000/moore-manolios/partial-functions/tjvm.cert \
- workshops/2000/moore-manolios/partial-functions/tjvm.cert \
- workshops/2000/moore-manolios/partial-functions/examples.lisp \
- workshops/2000/moore-manolios/partial-functions/examples.acl2
-
-
-workshops/2000/moore-manolios/partial-functions/mod-1-property.cert : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/mod-1-property.cert : no_pcert = 0
-
-workshops/2000/moore-manolios/partial-functions/mod-1-property.cert : \
- ihs/quotient-remainder-lemmas.cert \
- arithmetic/top-with-meta.cert \
- workshops/2000/moore-manolios/partial-functions/mod-1-property.lisp
-
-
-workshops/2000/moore-manolios/partial-functions/report.cert : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/report.cert : no_pcert = 0
-
-workshops/2000/moore-manolios/partial-functions/report.cert : \
- workshops/2000/moore-manolios/partial-functions/defpun.cert \
- ihs/quotient-remainder-lemmas.cert \
- arithmetic/top-with-meta.cert \
- workshops/2000/moore-manolios/partial-functions/mod-1-property.cert \
- workshops/2000/moore-manolios/partial-functions/tjvm-examples.cert \
- workshops/2000/moore-manolios/partial-functions/report.lisp
-
-
-workshops/2000/moore-manolios/partial-functions/tjvm-examples.cert : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/tjvm-examples.cert : no_pcert = 0
-
-workshops/2000/moore-manolios/partial-functions/tjvm-examples.cert : \
- workshops/2000/moore-manolios/partial-functions/defpun.cert \
- workshops/2000/moore-manolios/partial-functions/examples.cert \
- workshops/2000/moore-manolios/partial-functions/tjvm-examples.lisp \
- workshops/2000/moore-manolios/partial-functions/tjvm-examples.acl2
-
-
-workshops/2000/moore-manolios/partial-functions/tjvm.cert : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/tjvm.cert : no_pcert = 0
-
-workshops/2000/moore-manolios/partial-functions/tjvm.cert : \
- workshops/2000/moore-manolios/partial-functions/tjvm.lisp \
- workshops/2000/moore-manolios/partial-functions/tjvm.acl2
-
-
-workshops/2000/ruiz/multiset/defmul.cert : acl2x = 0
-workshops/2000/ruiz/multiset/defmul.cert : no_pcert = 0
-
-workshops/2000/ruiz/multiset/defmul.cert : \
- workshops/2000/ruiz/multiset/multiset.cert \
- workshops/2000/ruiz/multiset/defmul.lisp \
- workshops/2000/ruiz/multiset/defmul.acl2
-
-
-workshops/2000/ruiz/multiset/examples/ackermann/ackermann.cert : acl2x = 0
-workshops/2000/ruiz/multiset/examples/ackermann/ackermann.cert : no_pcert = 0
-
-workshops/2000/ruiz/multiset/examples/ackermann/ackermann.cert : \
- workshops/2000/ruiz/multiset/defmul.cert \
- workshops/2000/ruiz/multiset/examples/ackermann/ackermann.lisp
-
-
-workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.cert : acl2x = 0
-workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.cert : no_pcert = 0
-
-workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.cert : \
- workshops/2000/ruiz/multiset/defmul.cert \
- workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.lisp
-
-
-workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.cert : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.cert : no_pcert = 0
-
-workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.cert : \
- data-structures/structures.cert \
- ordinals/e0-ordinal.cert \
- workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.lisp
-
-
-workshops/2000/ruiz/multiset/examples/newman/confluence-v0.cert : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/confluence-v0.cert : no_pcert = 0
-
-workshops/2000/ruiz/multiset/examples/newman/confluence-v0.cert : \
- workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.cert \
- workshops/2000/ruiz/multiset/examples/newman/confluence-v0.lisp \
- workshops/2000/ruiz/multiset/examples/newman/confluence-v0.acl2
-
-
-workshops/2000/ruiz/multiset/examples/newman/confluence.cert : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/confluence.cert : no_pcert = 0
-
-workshops/2000/ruiz/multiset/examples/newman/confluence.cert : \
- workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.cert \
- workshops/2000/ruiz/multiset/examples/newman/confluence.lisp \
- workshops/2000/ruiz/multiset/examples/newman/confluence.acl2
-
-
-workshops/2000/ruiz/multiset/examples/newman/local-confluence.cert : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/local-confluence.cert : no_pcert = 0
-
-workshops/2000/ruiz/multiset/examples/newman/local-confluence.cert : \
- workshops/2000/ruiz/multiset/examples/newman/confluence.cert \
- workshops/2000/ruiz/multiset/examples/newman/newman.cert \
- workshops/2000/ruiz/multiset/examples/newman/local-confluence.lisp \
- workshops/2000/ruiz/multiset/examples/newman/local-confluence.acl2
-
-
-workshops/2000/ruiz/multiset/examples/newman/newman.cert : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/newman.cert : no_pcert = 0
-
-workshops/2000/ruiz/multiset/examples/newman/newman.cert : \
- workshops/2000/ruiz/multiset/defmul.cert \
- ordinals/ordinals-without-arithmetic.cert \
- workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.cert \
- workshops/2000/ruiz/multiset/examples/newman/newman.lisp \
- workshops/2000/ruiz/multiset/examples/newman/newman.acl2
-
-
-workshops/2000/ruiz/multiset/multiset.cert : acl2x = 0
-workshops/2000/ruiz/multiset/multiset.cert : no_pcert = 0
-
-workshops/2000/ruiz/multiset/multiset.cert : \
- ordinals/e0-ordinal.cert \
- workshops/2000/ruiz/multiset/multiset.lisp \
- workshops/2000/ruiz/multiset/multiset.acl2
-
-
-workshops/2000/russinoff-kaufmann/supporting-materials/constants.cert : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/constants.cert : no_pcert = 0
-
-workshops/2000/russinoff-kaufmann/supporting-materials/constants.cert : \
- workshops/2000/russinoff-kaufmann/supporting-materials/exec.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/declarations.cert \
- rtl/rel1/lib3/top.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/constants.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/constants.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-
-
-workshops/2000/russinoff-kaufmann/supporting-materials/declarations.cert : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/declarations.cert : no_pcert = 0
-
-workshops/2000/russinoff-kaufmann/supporting-materials/declarations.cert : \
- rtl/rel1/lib3/top.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/declarations.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/declarations.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-
-
-workshops/2000/russinoff-kaufmann/supporting-materials/exec.cert : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/exec.cert : no_pcert = 0
-
-workshops/2000/russinoff-kaufmann/supporting-materials/exec.cert : \
- rtl/rel1/lib3/top.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/exec.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/exec.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-
-
-workshops/2000/russinoff-kaufmann/supporting-materials/inputs.cert : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/inputs.cert : no_pcert = 0
-
-workshops/2000/russinoff-kaufmann/supporting-materials/inputs.cert : \
- workshops/2000/russinoff-kaufmann/supporting-materials/model.cert \
- rtl/rel1/lib3/top.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/inputs.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/inputs.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-
-
-workshops/2000/russinoff-kaufmann/supporting-materials/main.cert : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/main.cert : no_pcert = 0
-
-workshops/2000/russinoff-kaufmann/supporting-materials/main.cert : \
- workshops/2000/russinoff-kaufmann/supporting-materials/constants.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/inputs.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/pipe.cert \
- rtl/rel1/lib3/top.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/main.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/main.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-
-
-workshops/2000/russinoff-kaufmann/supporting-materials/model.cert : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/model.cert : no_pcert = 0
-
-workshops/2000/russinoff-kaufmann/supporting-materials/model.cert : \
- rtl/rel1/lib3/top.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/model.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/model.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-
-
-workshops/2000/russinoff-kaufmann/supporting-materials/pipe.cert : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/pipe.cert : no_pcert = 0
-
-workshops/2000/russinoff-kaufmann/supporting-materials/pipe.cert : \
- workshops/2000/russinoff-kaufmann/supporting-materials/model.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/constants.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/inputs.cert \
- rtl/rel1/lib3/top.cert \
- workshops/2000/russinoff-kaufmann/supporting-materials/pipe.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/pipe.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-
-
-workshops/2000/russinoff-short/crt.cert : acl2x = 0
-workshops/2000/russinoff-short/crt.cert : no_pcert = 0
-
-workshops/2000/russinoff-short/crt.cert : \
- rtl/rel1/lib1/basic.cert \
- rtl/rel1/support/fp.cert \
- workshops/2000/russinoff-short/crt.lisp
-
-
-workshops/2000/russinoff-short/summary.cert : acl2x = 0
-workshops/2000/russinoff-short/summary.cert : no_pcert = 0
-
-workshops/2000/russinoff-short/summary.cert : \
- workshops/2000/russinoff-short/crt.cert \
- workshops/2000/russinoff-short/summary.lisp
-
-
-workshops/2000/sumners1/cdeq/cdeq-defs.cert : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-defs.cert : no_pcert = 0
-
-workshops/2000/sumners1/cdeq/cdeq-defs.cert : \
- workshops/2000/sumners1/cdeq/records.cert \
- ordinals/e0-ordinal.cert \
- workshops/2000/sumners1/cdeq/cdeq-defs.lisp
-
-
-workshops/2000/sumners1/cdeq/cdeq-phase1.cert : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase1.cert : no_pcert = 0
-
-workshops/2000/sumners1/cdeq/cdeq-phase1.cert : \
- workshops/2000/sumners1/cdeq/cdeq-defs.cert \
- workshops/2000/sumners1/cdeq/cdeq-phase1.lisp
-
-
-workshops/2000/sumners1/cdeq/cdeq-phase2.cert : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase2.cert : no_pcert = 0
-
-workshops/2000/sumners1/cdeq/cdeq-phase2.cert : \
- workshops/2000/sumners1/cdeq/cdeq-defs.cert \
- workshops/2000/sumners1/cdeq/cdeq-phase2.lisp
-
-
-workshops/2000/sumners1/cdeq/cdeq-phase3.cert : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase3.cert : no_pcert = 0
-
-workshops/2000/sumners1/cdeq/cdeq-phase3.cert : \
- workshops/2000/sumners1/cdeq/cdeq-defs.cert \
- workshops/2000/sumners1/cdeq/cdeq-phase3.lisp
-
-
-workshops/2000/sumners1/cdeq/cdeq-phase4.cert : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase4.cert : no_pcert = 0
-
-workshops/2000/sumners1/cdeq/cdeq-phase4.cert : \
- workshops/2000/sumners1/cdeq/cdeq-defs.cert \
- workshops/2000/sumners1/cdeq/cdeq-phase4.lisp
-
-
-workshops/2000/sumners1/cdeq/records.cert : acl2x = 0
-workshops/2000/sumners1/cdeq/records.cert : no_pcert = 0
-
-workshops/2000/sumners1/cdeq/records.cert : \
- misc/total-order.cert \
- workshops/2000/sumners1/cdeq/records.lisp
-
-
-workshops/2000/sumners2/bdds/bdd-mgr.cert : acl2x = 0
-workshops/2000/sumners2/bdds/bdd-mgr.cert : no_pcert = 0
-
-workshops/2000/sumners2/bdds/bdd-mgr.cert : \
- workshops/2000/sumners2/bdds/bdd-mgr.lisp
-
-
-workshops/2000/sumners2/bdds/bdd-prf.cert : acl2x = 0
-workshops/2000/sumners2/bdds/bdd-prf.cert : no_pcert = 0
-
-workshops/2000/sumners2/bdds/bdd-prf.cert : \
- workshops/2000/sumners2/bdds/bdd-spec.cert \
- workshops/2000/sumners2/bdds/bdd-prf.lisp
-
-
-workshops/2000/sumners2/bdds/bdd-spec.cert : acl2x = 0
-workshops/2000/sumners2/bdds/bdd-spec.cert : no_pcert = 0
-
-workshops/2000/sumners2/bdds/bdd-spec.cert : \
- workshops/2000/sumners2/bdds/bdd-mgr.cert \
- workshops/2000/sumners2/bdds/bdd-spec.lisp
-
-
-workshops/2002/cowles-flat/support/flat-ackermann.cert : acl2x = 0
-workshops/2002/cowles-flat/support/flat-ackermann.cert : no_pcert = 0
-
-workshops/2002/cowles-flat/support/flat-ackermann.cert : \
- workshops/2002/cowles-flat/support/flat.cert \
- workshops/2002/cowles-flat/support/flat-ackermann.lisp \
- workshops/2002/cowles-flat/support/flat-ackermann.acl2
-
-
-workshops/2002/cowles-flat/support/flat-nested.cert : acl2x = 0
-workshops/2002/cowles-flat/support/flat-nested.cert : no_pcert = 0
-
-workshops/2002/cowles-flat/support/flat-nested.cert : \
- workshops/2002/cowles-flat/support/flat.cert \
- workshops/2002/cowles-flat/support/flat-nested.lisp \
- workshops/2002/cowles-flat/support/flat-nested.acl2
-
-
-workshops/2002/cowles-flat/support/flat-primitive.cert : acl2x = 0
-workshops/2002/cowles-flat/support/flat-primitive.cert : no_pcert = 0
-
-workshops/2002/cowles-flat/support/flat-primitive.cert : \
- workshops/2002/cowles-flat/support/flat.cert \
- workshops/2002/cowles-flat/support/flat-primitive.lisp \
- workshops/2002/cowles-flat/support/flat-primitive.acl2
-
-
-workshops/2002/cowles-flat/support/flat-reverse.cert : acl2x = 0
-workshops/2002/cowles-flat/support/flat-reverse.cert : no_pcert = 0
-
-workshops/2002/cowles-flat/support/flat-reverse.cert : \
- workshops/2002/cowles-flat/support/flat.cert \
- workshops/2002/cowles-flat/support/flat-reverse.lisp \
- workshops/2002/cowles-flat/support/flat-reverse.acl2
-
-
-workshops/2002/cowles-flat/support/flat-tail.cert : acl2x = 0
-workshops/2002/cowles-flat/support/flat-tail.cert : no_pcert = 0
-
-workshops/2002/cowles-flat/support/flat-tail.cert : \
- workshops/2002/cowles-flat/support/flat.cert \
- workshops/2002/cowles-flat/support/flat-tail.lisp \
- workshops/2002/cowles-flat/support/flat-tail.acl2
-
-
-workshops/2002/cowles-flat/support/flat-z.cert : acl2x = 0
-workshops/2002/cowles-flat/support/flat-z.cert : no_pcert = 0
-
-workshops/2002/cowles-flat/support/flat-z.cert : \
- workshops/2002/cowles-flat/support/flat.cert \
- workshops/2002/cowles-flat/support/flat-z.lisp \
- workshops/2002/cowles-flat/support/flat-z.acl2
-
-
-workshops/2002/cowles-flat/support/flat.cert : acl2x = 0
-workshops/2002/cowles-flat/support/flat.cert : no_pcert = 0
-
-workshops/2002/cowles-flat/support/flat.cert : \
- workshops/2002/cowles-flat/support/flat.lisp \
- workshops/2002/cowles-flat/support/flat.acl2
-
-
-workshops/2002/cowles-primrec/support/bad-def.cert : acl2x = 0
-workshops/2002/cowles-primrec/support/bad-def.cert : no_pcert = 0
-
-workshops/2002/cowles-primrec/support/bad-def.cert : \
- workshops/2002/cowles-primrec/support/bad-def.lisp \
- workshops/2002/cowles-primrec/support/bad-def.acl2
-
-
-workshops/2002/cowles-primrec/support/bad-def1.cert : acl2x = 0
-workshops/2002/cowles-primrec/support/bad-def1.cert : no_pcert = 0
-
-workshops/2002/cowles-primrec/support/bad-def1.cert : \
- workshops/2002/cowles-primrec/support/bad-def1.lisp \
- workshops/2002/cowles-primrec/support/bad-def1.acl2
-
-
-workshops/2002/cowles-primrec/support/defpr.cert : acl2x = 0
-workshops/2002/cowles-primrec/support/defpr.cert : no_pcert = 0
-
-workshops/2002/cowles-primrec/support/defpr.cert : \
- workshops/2002/cowles-primrec/support/defpr.lisp
-
-
-workshops/2002/cowles-primrec/support/fix.cert : acl2x = 0
-workshops/2002/cowles-primrec/support/fix.cert : no_pcert = 0
-
-workshops/2002/cowles-primrec/support/fix.cert : \
- workshops/2002/cowles-primrec/support/fix.lisp
-
-
-workshops/2002/cowles-primrec/support/primitive.cert : acl2x = 0
-workshops/2002/cowles-primrec/support/primitive.cert : no_pcert = 0
-
-workshops/2002/cowles-primrec/support/primitive.cert : \
- workshops/2002/cowles-primrec/support/primitive.lisp
-
-
-workshops/2002/cowles-primrec/support/tail.cert : acl2x = 0
-workshops/2002/cowles-primrec/support/tail.cert : no_pcert = 0
-
-workshops/2002/cowles-primrec/support/tail.cert : \
- workshops/2002/cowles-primrec/support/tail.lisp
-
-
-workshops/2002/georgelin-borrione-ostier/support/acl2-transl.cert : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/acl2-transl.cert : no_pcert = 0
-
-workshops/2002/georgelin-borrione-ostier/support/acl2-transl.cert : \
- workshops/2002/georgelin-borrione-ostier/support/utils.cert \
- workshops/2002/georgelin-borrione-ostier/support/generates-functions.cert \
- workshops/2002/georgelin-borrione-ostier/support/generates-theorems.cert \
- workshops/2002/georgelin-borrione-ostier/support/acl2-transl.lisp
-
-
-workshops/2002/georgelin-borrione-ostier/support/generates-functions.cert : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/generates-functions.cert : no_pcert = 0
-
-workshops/2002/georgelin-borrione-ostier/support/generates-functions.cert : \
- workshops/2002/georgelin-borrione-ostier/support/utils.cert \
- workshops/2002/georgelin-borrione-ostier/support/generates-functions.lisp
-
-
-workshops/2002/georgelin-borrione-ostier/support/generates-theorems.cert : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/generates-theorems.cert : no_pcert = 0
-
-workshops/2002/georgelin-borrione-ostier/support/generates-theorems.cert : \
- workshops/2002/georgelin-borrione-ostier/support/utils.cert \
- workshops/2002/georgelin-borrione-ostier/support/generates-theorems.lisp
-
-
-workshops/2002/georgelin-borrione-ostier/support/utils.cert : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/utils.cert : no_pcert = 0
-
-workshops/2002/georgelin-borrione-ostier/support/utils.cert : \
- arithmetic/top.cert \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- misc/expander.cert \
- workshops/2002/georgelin-borrione-ostier/support/utils.lisp
-
-
-workshops/2002/kaufmann-sumners/support/records.cert : acl2x = 0
-workshops/2002/kaufmann-sumners/support/records.cert : no_pcert = 0
-
-workshops/2002/kaufmann-sumners/support/records.cert : \
- misc/total-order.cert \
- workshops/2002/kaufmann-sumners/support/records.lisp
-
-
-workshops/2002/kaufmann-sumners/support/records0.cert : acl2x = 0
-workshops/2002/kaufmann-sumners/support/records0.cert : no_pcert = 0
-
-workshops/2002/kaufmann-sumners/support/records0.cert : \
- misc/total-order.cert \
- workshops/2002/kaufmann-sumners/support/records0.lisp
-
-
-workshops/2002/kaufmann-sumners/support/sets.cert : acl2x = 0
-workshops/2002/kaufmann-sumners/support/sets.cert : no_pcert = 0
-
-workshops/2002/kaufmann-sumners/support/sets.cert : \
- misc/total-order.cert \
- workshops/2002/kaufmann-sumners/support/sets.lisp
-
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.cert : \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.cert \
- arithmetic/top-with-meta.cert \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.lisp \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.acl2
-
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.cert : \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.cert \
- arithmetic/top-with-meta.cert \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.lisp \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.acl2
-
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.cert : \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.lisp
-
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.cert : \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.lisp
-
-
-workshops/2002/manolios-kaufmann/support/records/records-original.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/records/records-original.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/records/records-original.cert : \
- workshops/2002/manolios-kaufmann/support/records/records-original.lisp
-
-
-workshops/2002/manolios-kaufmann/support/records/records.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/records/records.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/records/records.cert : \
- workshops/2002/manolios-kaufmann/support/records/total-order.cert \
- workshops/2002/manolios-kaufmann/support/records/records.lisp
-
-
-workshops/2002/manolios-kaufmann/support/records/total-order.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/records/total-order.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/records/total-order.cert : \
- misc/total-order.cert \
- workshops/2002/manolios-kaufmann/support/records/total-order.lisp
-
-
-workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.cert : \
- workshops/2002/manolios-kaufmann/support/sorting/perm-order.cert \
- workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.lisp
-
-
-workshops/2002/manolios-kaufmann/support/sorting/perm-order.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/perm-order.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/sorting/perm-order.cert : \
- workshops/2002/manolios-kaufmann/support/sorting/perm.cert \
- workshops/2002/manolios-kaufmann/support/sorting/total-order.cert \
- workshops/2002/manolios-kaufmann/support/sorting/perm-order.lisp
-
-
-workshops/2002/manolios-kaufmann/support/sorting/perm.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/perm.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/sorting/perm.cert : \
- workshops/2002/manolios-kaufmann/support/sorting/perm.lisp
-
-
-workshops/2002/manolios-kaufmann/support/sorting/quicksort.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/quicksort.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/sorting/quicksort.cert : \
- workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.cert \
- workshops/2002/manolios-kaufmann/support/sorting/quicksort.lisp
-
-
-workshops/2002/manolios-kaufmann/support/sorting/total-order.cert : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/total-order.cert : no_pcert = 0
-
-workshops/2002/manolios-kaufmann/support/sorting/total-order.cert : \
- misc/total-order.cert \
- workshops/2002/manolios-kaufmann/support/sorting/total-order.lisp
-
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.cert : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.cert : no_pcert = 0
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.cert : \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.cert \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.lisp
-
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.cert : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.cert : no_pcert = 0
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.cert : \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.lisp
-
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.cert : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.cert : no_pcert = 0
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.cert : \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.cert \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.lisp
-
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.cert : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.cert : no_pcert = 0
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.cert : \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.cert \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.lisp
-
-
-workshops/2002/martin-alonso-perez-sancho/support/Adleman.cert : acl2x = 0
-workshops/2002/martin-alonso-perez-sancho/support/Adleman.cert : no_pcert = 0
-
-workshops/2002/martin-alonso-perez-sancho/support/Adleman.cert : \
- workshops/2002/martin-alonso-perez-sancho/support/Adleman.lisp
-
-
-workshops/2002/medina-palomo-alonso/support/section-2/npol.cert : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-2/npol.cert : no_pcert = 0
-
-workshops/2002/medina-palomo-alonso/support/section-2/npol.cert : \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-2.cert \
- workshops/2002/medina-palomo-alonso/support/section-2/npol.lisp \
- workshops/2002/medina-palomo-alonso/support/section-2/npol.acl2
-
-
-workshops/2002/medina-palomo-alonso/support/section-2/upol-1.cert : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-1.cert : no_pcert = 0
-
-workshops/2002/medina-palomo-alonso/support/section-2/upol-1.cert : \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-1.lisp \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-1.acl2
-
-
-workshops/2002/medina-palomo-alonso/support/section-2/upol-2.cert : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-2.cert : no_pcert = 0
-
-workshops/2002/medina-palomo-alonso/support/section-2/upol-2.cert : \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-2.lisp \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-2.acl2
-
-
-workshops/2002/medina-palomo-alonso/support/section-3/monomial.cert : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/monomial.cert : no_pcert = 0
-
-workshops/2002/medina-palomo-alonso/support/section-3/monomial.cert : \
- workshops/2002/medina-palomo-alonso/support/section-3/term.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/monomial.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/monomial.acl2
-
-
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.cert : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.cert : no_pcert = 0
-
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.cert : \
- workshops/2002/medina-palomo-alonso/support/section-3/upol.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.cert \
- ordinals/ordinals-without-arithmetic.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.acl2
-
-
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.cert : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.cert : no_pcert = 0
-
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.cert : \
- workshops/2002/medina-palomo-alonso/support/section-3/upol.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.cert \
- ordinals/ordinals-without-arithmetic.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.acl2
-
-
-workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.cert : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.cert : no_pcert = 0
-
-workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.cert : \
- workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.acl2
-
-
-workshops/2002/medina-palomo-alonso/support/section-3/term.cert : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/term.cert : no_pcert = 0
-
-workshops/2002/medina-palomo-alonso/support/section-3/term.cert : \
- workshops/2002/medina-palomo-alonso/support/section-3/term.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/term.acl2
-
-
-workshops/2002/medina-palomo-alonso/support/section-3/upol.cert : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/upol.cert : no_pcert = 0
-
-workshops/2002/medina-palomo-alonso/support/section-3/upol.cert : \
- workshops/2002/medina-palomo-alonso/support/section-3/monomial.cert \
- workshops/2002/medina-palomo-alonso/support/section-3/upol.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/upol.acl2
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.cert : \
- arithmetic/top-with-meta.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.cert \
- ordinals/e0-ordinal.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.cert \
- ordinals/ordinals-without-arithmetic.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.cert \
- ordinals/e0-ordinal.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.cert \
- ordinals/e0-ordinal.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.lisp
-
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.cert : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.cert : no_pcert = 0
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.cert : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.cert \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.lisp
-
-
-workshops/2003/austel/support/abs-type.cert : acl2x = 0
-workshops/2003/austel/support/abs-type.cert : no_pcert = 0
-
-workshops/2003/austel/support/abs-type.cert : \
- workshops/2003/austel/support/abs-type.lisp
-
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.cert : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.cert : no_pcert = 0
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.cert : \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.lisp
-
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.cert : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.cert : no_pcert = 0
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.cert : \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.lisp
-
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.cert : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.cert : no_pcert = 0
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.cert : \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.cert \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.cert \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.lisp
-
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.cert : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.cert : no_pcert = 0
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.cert : \
- arithmetic/top.cert \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.cert \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.cert \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.lisp
-
-
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.cert : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.cert : no_pcert = 0
-
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.cert : \
- workshops/2003/gamboa-cowles-van-baalen/support/linalg.cert \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.lisp \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.acl2 \
- workshops/2003/gamboa-cowles-van-baalen/support/defpkg.lsp
-
-
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.cert : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.cert : no_pcert = 0
-
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.cert : \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.cert \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.lisp \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.acl2 \
- workshops/2003/gamboa-cowles-van-baalen/support/defpkg.lsp
-
-
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.cert : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.cert : no_pcert = 0
-
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.cert : \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.cert \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.lisp \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.acl2 \
- workshops/2003/gamboa-cowles-van-baalen/support/defpkg.lsp
-
-
-workshops/2003/gamboa-cowles-van-baalen/support/linalg.cert : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/linalg.cert : no_pcert = 0
-
-workshops/2003/gamboa-cowles-van-baalen/support/linalg.cert : \
- arithmetic/top.cert \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.cert \
- workshops/2003/gamboa-cowles-van-baalen/support/linalg.lisp
-
-
-workshops/2003/greve-wilding_defrecord/support/defrecord.cert : acl2x = 0
-workshops/2003/greve-wilding_defrecord/support/defrecord.cert : no_pcert = 0
-
-workshops/2003/greve-wilding_defrecord/support/defrecord.cert : \
- misc/records.cert \
- workshops/2003/greve-wilding_defrecord/support/defrecord.lisp
-
-
-workshops/2003/greve-wilding_mbe/support/fpst.cert : acl2x = 0
-workshops/2003/greve-wilding_mbe/support/fpst.cert : no_pcert = 0
-
-workshops/2003/greve-wilding_mbe/support/fpst.cert : \
- workshops/1999/graph/linear-find-path.cert \
- ordinals/e0-ordinal.cert \
- workshops/2003/greve-wilding_mbe/support/fpst.lisp
-
-
-workshops/2003/greve-wilding_mbe/support/run-fpst.cert : acl2x = 0
-workshops/2003/greve-wilding_mbe/support/run-fpst.cert : no_pcert = 0
-
-workshops/2003/greve-wilding_mbe/support/run-fpst.cert : \
- workshops/2003/greve-wilding_mbe/support/fpst.cert \
- workshops/2003/greve-wilding_mbe/support/run-fpst.lisp
-
-
-workshops/2003/hbl/support/sol1.cert : acl2x = 0
-workshops/2003/hbl/support/sol1.cert : no_pcert = 0
-
-workshops/2003/hbl/support/sol1.cert : \
- misc/records.cert \
- arithmetic/top-with-meta.cert \
- workshops/2003/hbl/support/sol1.lisp
-
-
-workshops/2003/hbl/support/sol2.cert : acl2x = 0
-workshops/2003/hbl/support/sol2.cert : no_pcert = 0
-
-workshops/2003/hbl/support/sol2.cert : \
- misc/records.cert \
- arithmetic/top-with-meta.cert \
- ordinals/e0-ordinal.cert \
- workshops/2003/hbl/support/sol2.lisp
-
-
-workshops/2003/hendrix/support/madd.cert : acl2x = 0
-workshops/2003/hendrix/support/madd.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/madd.cert : \
- workshops/2003/hendrix/support/mdefthms.cert \
- workshops/2003/hendrix/support/mzero.cert \
- workshops/2003/hendrix/support/mentry.cert \
- workshops/2003/hendrix/support/madd.lisp
-
-
-workshops/2003/hendrix/support/matrices.cert : acl2x = 0
-workshops/2003/hendrix/support/matrices.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/matrices.cert : \
- workshops/2003/hendrix/support/vector.cert \
- workshops/2003/hendrix/support/mdefuns.cert \
- workshops/2003/hendrix/support/mdefthms.cert \
- workshops/2003/hendrix/support/mentry.cert \
- workshops/2003/hendrix/support/mzero.cert \
- workshops/2003/hendrix/support/madd.cert \
- workshops/2003/hendrix/support/mscal.cert \
- workshops/2003/hendrix/support/msub.cert \
- workshops/2003/hendrix/support/mid.cert \
- workshops/2003/hendrix/support/mmult.cert \
- workshops/2003/hendrix/support/mtrans.cert \
- workshops/2003/hendrix/support/matrices.lisp
-
-
-workshops/2003/hendrix/support/mdefthms.cert : acl2x = 0
-workshops/2003/hendrix/support/mdefthms.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/mdefthms.cert : \
- workshops/2003/hendrix/support/mdefuns.cert \
- workshops/2003/hendrix/support/mdefthms.lisp
-
-
-workshops/2003/hendrix/support/mdefuns.cert : acl2x = 0
-workshops/2003/hendrix/support/mdefuns.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/mdefuns.cert : \
- workshops/2003/hendrix/support/vector.cert \
- workshops/2003/hendrix/support/mdefuns.lisp
-
-
-workshops/2003/hendrix/support/mentry.cert : acl2x = 0
-workshops/2003/hendrix/support/mentry.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/mentry.cert : \
- workshops/2003/hendrix/support/mdefthms.cert \
- workshops/2003/hendrix/support/mentry.lisp
-
-
-workshops/2003/hendrix/support/mid.cert : acl2x = 0
-workshops/2003/hendrix/support/mid.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/mid.cert : \
- workshops/2003/hendrix/support/mdefthms.cert \
- workshops/2003/hendrix/support/mid.lisp
-
-
-workshops/2003/hendrix/support/mmult.cert : acl2x = 0
-workshops/2003/hendrix/support/mmult.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/mmult.cert : \
- workshops/2003/hendrix/support/mdefthms.cert \
- workshops/2003/hendrix/support/mzero.cert \
- workshops/2003/hendrix/support/madd.cert \
- workshops/2003/hendrix/support/mscal.cert \
- workshops/2003/hendrix/support/mid.cert \
- workshops/2003/hendrix/support/mentry.cert \
- workshops/2003/hendrix/support/mmult.lisp
-
-
-workshops/2003/hendrix/support/mscal.cert : acl2x = 0
-workshops/2003/hendrix/support/mscal.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/mscal.cert : \
- workshops/2003/hendrix/support/mdefthms.cert \
- workshops/2003/hendrix/support/mzero.cert \
- workshops/2003/hendrix/support/madd.cert \
- workshops/2003/hendrix/support/mentry.cert \
- workshops/2003/hendrix/support/mscal.lisp
-
-
-workshops/2003/hendrix/support/msub.cert : acl2x = 0
-workshops/2003/hendrix/support/msub.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/msub.cert : \
- workshops/2003/hendrix/support/mdefthms.cert \
- workshops/2003/hendrix/support/madd.cert \
- workshops/2003/hendrix/support/mscal.cert \
- workshops/2003/hendrix/support/msub.lisp
-
-
-workshops/2003/hendrix/support/mtrans.cert : acl2x = 0
-workshops/2003/hendrix/support/mtrans.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/mtrans.cert : \
- workshops/2003/hendrix/support/mdefthms.cert \
- workshops/2003/hendrix/support/mzero.cert \
- workshops/2003/hendrix/support/madd.cert \
- workshops/2003/hendrix/support/mid.cert \
- workshops/2003/hendrix/support/mscal.cert \
- workshops/2003/hendrix/support/mmult.cert \
- workshops/2003/hendrix/support/mentry.cert \
- workshops/2003/hendrix/support/mtrans.lisp
-
-
-workshops/2003/hendrix/support/mzero.cert : acl2x = 0
-workshops/2003/hendrix/support/mzero.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/mzero.cert : \
- workshops/2003/hendrix/support/mdefthms.cert \
- workshops/2003/hendrix/support/mzero.lisp
-
-
-workshops/2003/hendrix/support/vector.cert : acl2x = 0
-workshops/2003/hendrix/support/vector.cert : no_pcert = 0
-
-workshops/2003/hendrix/support/vector.cert : \
- arithmetic/top-with-meta.cert \
- workshops/2003/hendrix/support/vector.lisp
-
-
-workshops/2003/matlin-mccune/support/simp.cert : acl2x = 0
-workshops/2003/matlin-mccune/support/simp.cert : no_pcert = 0
-
-workshops/2003/matlin-mccune/support/simp.cert : \
- ordinals/e0-ordinal.cert \
- arithmetic/top-with-meta.cert \
- workshops/2003/matlin-mccune/support/simp.lisp
-
-
-workshops/2003/moore_rockwell/support/memory-taggings.cert : acl2x = 0
-workshops/2003/moore_rockwell/support/memory-taggings.cert : no_pcert = 0
-
-workshops/2003/moore_rockwell/support/memory-taggings.cert : \
- misc/records.cert \
- arithmetic/top-with-meta.cert \
- ordinals/e0-ordinal.cert \
- workshops/2003/moore_rockwell/support/memory-taggings.lisp
-
-
-workshops/2003/moore_vcg/support/demo.cert : acl2x = 0
-workshops/2003/moore_vcg/support/demo.cert : no_pcert = 0
-
-workshops/2003/moore_vcg/support/demo.cert : \
- workshops/2003/moore_vcg/support/utilities.cert \
- workshops/2003/moore_vcg/support/demo.lisp \
- workshops/2003/moore_vcg/support/demo.acl2
-
-
-workshops/2003/moore_vcg/support/m5.cert : acl2x = 0
-workshops/2003/moore_vcg/support/m5.cert : no_pcert = 0
-
-workshops/2003/moore_vcg/support/m5.cert : \
- ordinals/e0-ordinal.cert \
- workshops/2003/moore_vcg/support/m5.lisp \
- workshops/2003/moore_vcg/support/m5.acl2
-
-
-workshops/2003/moore_vcg/support/utilities.cert : acl2x = 0
-workshops/2003/moore_vcg/support/utilities.cert : no_pcert = 0
-
-workshops/2003/moore_vcg/support/utilities.cert : \
- arithmetic/top-with-meta.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2003/moore_vcg/support/m5.cert \
- workshops/2003/moore_vcg/support/utilities.lisp \
- workshops/2003/moore_vcg/support/utilities.acl2
-
-
-workshops/2003/moore_vcg/support/vcg-examples.cert : acl2x = 0
-workshops/2003/moore_vcg/support/vcg-examples.cert : no_pcert = 0
-
-workshops/2003/moore_vcg/support/vcg-examples.cert : \
- misc/defpun.cert \
- workshops/2003/moore_vcg/support/demo.cert \
- workshops/2003/moore_vcg/support/utilities.cert \
- workshops/2003/moore_vcg/support/vcg-examples.lisp \
- workshops/2003/moore_vcg/support/vcg-examples.acl2
-
-
-workshops/2003/ray-matthews-tuttle/support/apply-total-order.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/apply-total-order.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/apply-total-order.cert : \
- workshops/2003/ray-matthews-tuttle/support/total-order.cert \
- workshops/2003/ray-matthews-tuttle/support/apply-total-order.lisp
-
-
-workshops/2003/ray-matthews-tuttle/support/bisimilarity.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/bisimilarity.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/bisimilarity.cert : \
- workshops/2003/ray-matthews-tuttle/support/ltl.cert \
- arithmetic-2/meta/top.cert \
- workshops/2003/ray-matthews-tuttle/support/bisimilarity.lisp
-
-
-workshops/2003/ray-matthews-tuttle/support/circuit-bisim.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/circuit-bisim.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/circuit-bisim.cert : \
- workshops/2003/ray-matthews-tuttle/support/ltl.cert \
- workshops/2003/ray-matthews-tuttle/support/bisimilarity.cert \
- workshops/2003/ray-matthews-tuttle/support/circuit-bisim.lisp
-
-
-workshops/2003/ray-matthews-tuttle/support/circuits.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/circuits.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/circuits.cert : \
- workshops/2003/ray-matthews-tuttle/support/circuit-bisim.cert \
- workshops/2003/ray-matthews-tuttle/support/circuits.lisp
-
-
-workshops/2003/ray-matthews-tuttle/support/concrete-ltl.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/concrete-ltl.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/concrete-ltl.cert : \
- workshops/2003/ray-matthews-tuttle/support/ltl.cert \
- ordinals/e0-ordinal.cert \
- workshops/2003/ray-matthews-tuttle/support/concrete-ltl.lisp
-
-
-workshops/2003/ray-matthews-tuttle/support/cone-of-influence.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/cone-of-influence.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/cone-of-influence.cert : \
- workshops/2003/ray-matthews-tuttle/support/circuits.cert \
- arithmetic-2/meta/top.cert \
- workshops/2003/ray-matthews-tuttle/support/cone-of-influence.lisp
-
-
-workshops/2003/ray-matthews-tuttle/support/conjunction.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/conjunction.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/conjunction.cert : \
- workshops/2003/ray-matthews-tuttle/support/ltl.cert \
- workshops/2003/ray-matthews-tuttle/support/conjunction.lisp
-
-
-workshops/2003/ray-matthews-tuttle/support/impl-hack.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/impl-hack.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/impl-hack.cert : \
- workshops/2003/ray-matthews-tuttle/support/reductions.cert \
- workshops/2003/ray-matthews-tuttle/support/impl-hack.lisp \
- workshops/2003/ray-matthews-tuttle/support/impl-hack.acl2
-
-
-workshops/2003/ray-matthews-tuttle/support/ltl.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/ltl.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/ltl.cert : \
- workshops/2003/ray-matthews-tuttle/support/sets.cert \
- arithmetic-2/meta/top.cert \
- workshops/2003/ray-matthews-tuttle/support/ltl.lisp
-
-
-workshops/2003/ray-matthews-tuttle/support/records.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/records.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/records.cert : \
- workshops/2003/ray-matthews-tuttle/support/apply-total-order.cert \
- workshops/2003/ray-matthews-tuttle/support/records.lisp
-
-
-workshops/2003/ray-matthews-tuttle/support/reductions.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/reductions.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/reductions.cert : \
- workshops/2003/ray-matthews-tuttle/support/conjunction.cert \
- workshops/2003/ray-matthews-tuttle/support/cone-of-influence.cert \
- workshops/2003/ray-matthews-tuttle/support/reductions.lisp
-
-
-workshops/2003/ray-matthews-tuttle/support/sets.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/sets.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/sets.cert : \
- workshops/2003/ray-matthews-tuttle/support/records.cert \
- workshops/2003/ray-matthews-tuttle/support/sets.lisp
-
-
-workshops/2003/ray-matthews-tuttle/support/total-order.cert : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/total-order.cert : no_pcert = 0
-
-workshops/2003/ray-matthews-tuttle/support/total-order.cert : \
- workshops/2003/ray-matthews-tuttle/support/total-order.lisp
-
-
-workshops/2003/schmaltz-al-sammane-et-al/support/consistency.cert : acl2x = 0
-workshops/2003/schmaltz-al-sammane-et-al/support/consistency.cert : no_pcert = 0
-
-workshops/2003/schmaltz-al-sammane-et-al/support/consistency.cert : \
- misc/expander.cert \
- workshops/2003/schmaltz-al-sammane-et-al/support/consistency.lisp
-
-
-workshops/2003/schmaltz-borrione/support/arbiter.cert : acl2x = 0
-workshops/2003/schmaltz-borrione/support/arbiter.cert : no_pcert = 0
-
-workshops/2003/schmaltz-borrione/support/arbiter.cert : \
- workshops/2003/schmaltz-borrione/support/inequalities.cert \
- workshops/2003/schmaltz-borrione/support/decoder.cert \
- workshops/2003/schmaltz-borrione/support/predicates.cert \
- workshops/2003/schmaltz-borrione/support/arbiter.lisp
-
-
-workshops/2003/schmaltz-borrione/support/decoder.cert : acl2x = 0
-workshops/2003/schmaltz-borrione/support/decoder.cert : no_pcert = 0
-
-workshops/2003/schmaltz-borrione/support/decoder.cert : \
- arithmetic/top.cert \
- arithmetic-2/floor-mod/floor-mod.cert \
- workshops/2003/schmaltz-borrione/support/decoder.lisp
-
-
-workshops/2003/schmaltz-borrione/support/inequalities.cert : acl2x = 0
-workshops/2003/schmaltz-borrione/support/inequalities.cert : no_pcert = 0
-
-workshops/2003/schmaltz-borrione/support/inequalities.cert : \
- arithmetic/top.cert \
- workshops/2003/schmaltz-borrione/support/inequalities.lisp
-
-
-workshops/2003/schmaltz-borrione/support/predicates.cert : acl2x = 0
-workshops/2003/schmaltz-borrione/support/predicates.cert : no_pcert = 0
-
-workshops/2003/schmaltz-borrione/support/predicates.cert : \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- workshops/2003/schmaltz-borrione/support/predicates.lisp
-
-
-workshops/2003/schmaltz-borrione/support/transfers.cert : acl2x = 0
-workshops/2003/schmaltz-borrione/support/transfers.cert : no_pcert = 0
-
-workshops/2003/schmaltz-borrione/support/transfers.cert : \
- workshops/2003/schmaltz-borrione/support/decoder.cert \
- workshops/2003/schmaltz-borrione/support/arbiter.cert \
- workshops/2003/schmaltz-borrione/support/transfers.lisp
-
-
-workshops/2003/sumners/support/cfair.cert : acl2x = 0
-workshops/2003/sumners/support/cfair.cert : no_pcert = 0
-
-workshops/2003/sumners/support/cfair.cert : \
- workshops/2003/sumners/support/n2n.cert \
- ordinals/e0-ordinal.cert \
- workshops/2003/sumners/support/cfair.lisp
-
-
-workshops/2003/sumners/support/example1.cert : acl2x = 0
-workshops/2003/sumners/support/example1.cert : no_pcert = 0
-
-workshops/2003/sumners/support/example1.cert : \
- workshops/2003/sumners/support/fair1.cert \
- workshops/2003/sumners/support/example1.lisp
-
-
-workshops/2003/sumners/support/example2.cert : acl2x = 0
-workshops/2003/sumners/support/example2.cert : no_pcert = 0
-
-workshops/2003/sumners/support/example2.cert : \
- workshops/2003/sumners/support/fair2.cert \
- workshops/2003/sumners/support/example2.lisp
-
-
-workshops/2003/sumners/support/example3.cert : acl2x = 0
-workshops/2003/sumners/support/example3.cert : no_pcert = 0
-
-workshops/2003/sumners/support/example3.cert : \
- workshops/2003/sumners/support/fair2.cert \
- ordinals/e0-ordinal.cert \
- workshops/2003/sumners/support/example3.lisp
-
-
-workshops/2003/sumners/support/fair1.cert : acl2x = 0
-workshops/2003/sumners/support/fair1.cert : no_pcert = 0
-
-workshops/2003/sumners/support/fair1.cert : \
- ordinals/e0-ordinal.cert \
- workshops/2003/sumners/support/fair1.lisp
-
-
-workshops/2003/sumners/support/fair2.cert : acl2x = 0
-workshops/2003/sumners/support/fair2.cert : no_pcert = 0
-
-workshops/2003/sumners/support/fair2.cert : \
- ordinals/e0-ordinal.cert \
- workshops/2003/sumners/support/n2n.cert \
- workshops/2003/sumners/support/fair2.lisp
-
-
-workshops/2003/sumners/support/n2n.cert : acl2x = 0
-workshops/2003/sumners/support/n2n.cert : no_pcert = 0
-
-workshops/2003/sumners/support/n2n.cert : \
- workshops/2003/sumners/support/n2n.lisp
-
-
-workshops/2003/sumners/support/simple.cert : acl2x = 0
-workshops/2003/sumners/support/simple.cert : no_pcert = 0
-
-workshops/2003/sumners/support/simple.cert : \
- workshops/2003/sumners/support/simple.lisp
-
-
-workshops/2003/sustik/support/dickson.cert : acl2x = 0
-workshops/2003/sustik/support/dickson.cert : no_pcert = 0
-
-workshops/2003/sustik/support/dickson.cert : \
- ordinals/ordinals.cert \
- workshops/2003/sustik/support/dickson.lisp
-
-
-workshops/2003/toma-borrione/support/bv-op-defthms.cert : acl2x = 0
-workshops/2003/toma-borrione/support/bv-op-defthms.cert : no_pcert = 0
-
-workshops/2003/toma-borrione/support/bv-op-defthms.cert : \
- workshops/2003/toma-borrione/support/bv-op-defuns.cert \
- workshops/2003/toma-borrione/support/bv-op-defthms.lisp
-
-
-workshops/2003/toma-borrione/support/bv-op-defuns.cert : acl2x = 0
-workshops/2003/toma-borrione/support/bv-op-defuns.cert : no_pcert = 0
-
-workshops/2003/toma-borrione/support/bv-op-defuns.cert : \
- workshops/2003/toma-borrione/support/misc.cert \
- workshops/2003/toma-borrione/support/bv-op-defuns.lisp
-
-
-workshops/2003/toma-borrione/support/misc.cert : acl2x = 0
-workshops/2003/toma-borrione/support/misc.cert : no_pcert = 0
-
-workshops/2003/toma-borrione/support/misc.cert : \
- arithmetic/equalities.cert \
- arithmetic/inequalities.cert \
- arithmetic-2/floor-mod/floor-mod.cert \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- workshops/2003/toma-borrione/support/misc.lisp
-
-
-workshops/2003/toma-borrione/support/padding-1-256.cert : acl2x = 0
-workshops/2003/toma-borrione/support/padding-1-256.cert : no_pcert = 0
-
-workshops/2003/toma-borrione/support/padding-1-256.cert : \
- workshops/2003/toma-borrione/support/bv-op-defthms.cert \
- workshops/2003/toma-borrione/support/padding-1-256.lisp
-
-
-workshops/2003/toma-borrione/support/padding-384-512.cert : acl2x = 0
-workshops/2003/toma-borrione/support/padding-384-512.cert : no_pcert = 0
-
-workshops/2003/toma-borrione/support/padding-384-512.cert : \
- workshops/2003/toma-borrione/support/bv-op-defthms.cert \
- workshops/2003/toma-borrione/support/padding-384-512.lisp
-
-
-workshops/2003/toma-borrione/support/parsing.cert : acl2x = 0
-workshops/2003/toma-borrione/support/parsing.cert : no_pcert = 0
-
-workshops/2003/toma-borrione/support/parsing.cert : \
- workshops/2003/toma-borrione/support/padding-1-256.cert \
- workshops/2003/toma-borrione/support/padding-384-512.cert \
- workshops/2003/toma-borrione/support/parsing.lisp
-
-
-workshops/2003/toma-borrione/support/sha-1.cert : acl2x = 0
-workshops/2003/toma-borrione/support/sha-1.cert : no_pcert = 0
-
-workshops/2003/toma-borrione/support/sha-1.cert : \
- workshops/2003/toma-borrione/support/parsing.cert \
- workshops/2003/toma-borrione/support/sha-functions.cert \
- workshops/2003/toma-borrione/support/sha-1.lisp
-
-
-workshops/2003/toma-borrione/support/sha-256.cert : acl2x = 0
-workshops/2003/toma-borrione/support/sha-256.cert : no_pcert = 0
-
-workshops/2003/toma-borrione/support/sha-256.cert : \
- workshops/2003/toma-borrione/support/parsing.cert \
- workshops/2003/toma-borrione/support/sha-functions.cert \
- workshops/2003/toma-borrione/support/sha-256.lisp
-
-
-workshops/2003/toma-borrione/support/sha-384-512.cert : acl2x = 0
-workshops/2003/toma-borrione/support/sha-384-512.cert : no_pcert = 0
-
-workshops/2003/toma-borrione/support/sha-384-512.cert : \
- workshops/2003/toma-borrione/support/parsing.cert \
- workshops/2003/toma-borrione/support/sha-functions.cert \
- workshops/2003/toma-borrione/support/sha-384-512.lisp
-
-
-workshops/2003/toma-borrione/support/sha-functions.cert : acl2x = 0
-workshops/2003/toma-borrione/support/sha-functions.cert : no_pcert = 0
-
-workshops/2003/toma-borrione/support/sha-functions.cert : \
- workshops/2003/toma-borrione/support/bv-op-defthms.cert \
- workshops/2003/toma-borrione/support/sha-functions.lisp
-
-
-workshops/2003/tsong/support/shim.cert : acl2x = 0
-workshops/2003/tsong/support/shim.cert : no_pcert = 0
-
-workshops/2003/tsong/support/shim.cert : \
- data-structures/structures.cert \
- workshops/2003/tsong/support/shim.lisp
-
-
-workshops/2004/cowles-gamboa/support/WyoM1-correct.cert : acl2x = 0
-workshops/2004/cowles-gamboa/support/WyoM1-correct.cert : no_pcert = 0
-
-workshops/2004/cowles-gamboa/support/WyoM1-correct.cert : \
- workshops/2004/cowles-gamboa/support/WyoM1-utilities.cert \
- misc/defpun.cert \
- workshops/2004/cowles-gamboa/support/WyoM1-utilities.cert \
- workshops/2004/cowles-gamboa/support/WyoM1-correct.lisp \
- workshops/2004/cowles-gamboa/support/WyoM1-correct.acl2
-
-
-workshops/2004/cowles-gamboa/support/WyoM1-utilities.cert : acl2x = 0
-workshops/2004/cowles-gamboa/support/WyoM1-utilities.cert : no_pcert = 0
-
-workshops/2004/cowles-gamboa/support/WyoM1-utilities.cert : \
- workshops/2004/cowles-gamboa/support/WyoM1.cert \
- arithmetic/top.cert \
- workshops/2004/cowles-gamboa/support/WyoM1.cert \
- workshops/2004/cowles-gamboa/support/WyoM1-utilities.lisp \
- workshops/2004/cowles-gamboa/support/WyoM1-utilities.acl2
-
-
-workshops/2004/cowles-gamboa/support/WyoM1.cert : acl2x = 0
-workshops/2004/cowles-gamboa/support/WyoM1.cert : no_pcert = 0
-
-workshops/2004/cowles-gamboa/support/WyoM1.cert : \
- workshops/2004/cowles-gamboa/support/WyoM1.lisp \
- workshops/2004/cowles-gamboa/support/WyoM1.acl2
-
-
-workshops/2004/cowles-gamboa/support/knuth.cert : acl2x = 0
-workshops/2004/cowles-gamboa/support/knuth.cert : no_pcert = 0
-
-workshops/2004/cowles-gamboa/support/knuth.cert : \
- arithmetic/top.cert \
- workshops/2004/cowles-gamboa/support/knuth.lisp
-
-
-workshops/2004/cowles-gamboa/support/tail-rec.cert : acl2x = 0
-workshops/2004/cowles-gamboa/support/tail-rec.cert : no_pcert = 0
-
-workshops/2004/cowles-gamboa/support/tail-rec.cert : \
- misc/defpun.cert \
- workshops/2004/cowles-gamboa/support/tail-rec.lisp \
- workshops/2004/cowles-gamboa/support/tail-rec.acl2
-
-
-workshops/2004/davis/support/computed-hints.cert : acl2x = 0
-workshops/2004/davis/support/computed-hints.cert : no_pcert = 0
-
-workshops/2004/davis/support/computed-hints.cert : \
- workshops/2004/davis/support/instance.cert \
- workshops/2004/davis/support/computed-hints.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-
-
-workshops/2004/davis/support/fast.cert : acl2x = 0
-workshops/2004/davis/support/fast.cert : no_pcert = 0
-
-workshops/2004/davis/support/fast.cert : \
- workshops/2004/davis/support/membership.cert \
- workshops/2004/davis/support/fast.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-
-
-workshops/2004/davis/support/instance.cert : acl2x = 0
-workshops/2004/davis/support/instance.cert : no_pcert = 0
-
-workshops/2004/davis/support/instance.cert : \
- workshops/2004/davis/support/instance.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-
-
-workshops/2004/davis/support/map.cert : acl2x = 0
-workshops/2004/davis/support/map.cert : no_pcert = 0
-
-workshops/2004/davis/support/map.cert : \
- workshops/2004/davis/support/quantify.cert \
- workshops/2004/davis/support/map.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-
-
-workshops/2004/davis/support/membership.cert : acl2x = 0
-workshops/2004/davis/support/membership.cert : no_pcert = 0
-
-workshops/2004/davis/support/membership.cert : \
- workshops/2004/davis/support/primitives.cert \
- workshops/2004/davis/support/computed-hints.cert \
- workshops/2004/davis/support/membership.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-
-
-workshops/2004/davis/support/outer.cert : acl2x = 0
-workshops/2004/davis/support/outer.cert : no_pcert = 0
-
-workshops/2004/davis/support/outer.cert : \
- workshops/2004/davis/support/fast.cert \
- workshops/2004/davis/support/outer.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-
-
-workshops/2004/davis/support/primitives.cert : acl2x = 0
-workshops/2004/davis/support/primitives.cert : no_pcert = 0
-
-workshops/2004/davis/support/primitives.cert : \
- workshops/2004/davis/support/primitives.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-
-
-workshops/2004/davis/support/quantify.cert : acl2x = 0
-workshops/2004/davis/support/quantify.cert : no_pcert = 0
-
-workshops/2004/davis/support/quantify.cert : \
- workshops/2004/davis/support/sets.cert \
- workshops/2004/davis/support/sets.cert \
- workshops/2004/davis/support/quantify.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-
-
-workshops/2004/davis/support/set-order.cert : acl2x = 0
-workshops/2004/davis/support/set-order.cert : no_pcert = 0
-
-workshops/2004/davis/support/set-order.cert : \
- workshops/2004/davis/support/primitives.cert \
- workshops/2004/davis/support/membership.cert \
- workshops/2004/davis/support/fast.cert \
- workshops/2004/davis/support/sets.cert \
- workshops/2004/davis/support/set-order.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-
-
-workshops/2004/davis/support/sets.cert : acl2x = 0
-workshops/2004/davis/support/sets.cert : no_pcert = 0
-
-workshops/2004/davis/support/sets.cert : \
- workshops/2004/davis/support/computed-hints.cert \
- workshops/2004/davis/support/primitives.cert \
- workshops/2004/davis/support/membership.cert \
- workshops/2004/davis/support/fast.cert \
- workshops/2004/davis/support/outer.cert \
- workshops/2004/davis/support/sort.cert \
- workshops/2004/davis/support/sets.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-
-
-workshops/2004/davis/support/sort.cert : acl2x = 0
-workshops/2004/davis/support/sort.cert : no_pcert = 0
-
-workshops/2004/davis/support/sort.cert : \
- workshops/2004/davis/support/outer.cert \
- workshops/2004/davis/support/sort.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-
-
-workshops/2004/gameiro-manolios/support/interval.cert : acl2x = 0
-workshops/2004/gameiro-manolios/support/interval.cert : no_pcert = 0
-
-workshops/2004/gameiro-manolios/support/interval.cert : \
- workshops/2004/gameiro-manolios/support/top-with-meta.cert \
- workshops/2004/gameiro-manolios/support/nth-thms.cert \
- workshops/2004/gameiro-manolios/support/interval.lisp
-
-
-workshops/2004/gameiro-manolios/support/nth-thms.cert : acl2x = 0
-workshops/2004/gameiro-manolios/support/nth-thms.cert : no_pcert = 0
-
-workshops/2004/gameiro-manolios/support/nth-thms.cert : \
- workshops/2004/gameiro-manolios/support/nth-thms.lisp
-
-
-workshops/2004/gameiro-manolios/support/top-with-meta.cert : acl2x = 0
-workshops/2004/gameiro-manolios/support/top-with-meta.cert : no_pcert = 0
-
-workshops/2004/gameiro-manolios/support/top-with-meta.cert : \
- arithmetic/top-with-meta.cert \
- workshops/2004/gameiro-manolios/support/top-with-meta.lisp
-
-
-workshops/2004/gameiro-manolios/support/transversality.cert : acl2x = 0
-workshops/2004/gameiro-manolios/support/transversality.cert : no_pcert = 0
-
-workshops/2004/gameiro-manolios/support/transversality.cert : \
- workshops/2004/gameiro-manolios/support/interval.cert \
- workshops/2004/gameiro-manolios/support/transversality.lisp
-
-
-workshops/2004/greve/support/defrecord.cert : acl2x = 0
-workshops/2004/greve/support/defrecord.cert : no_pcert = 0
-
-workshops/2004/greve/support/defrecord.cert : \
- misc/records.cert \
- workshops/2004/greve/support/defrecord.lisp
-
-
-workshops/2004/greve/support/mark.cert : acl2x = 0
-workshops/2004/greve/support/mark.cert : no_pcert = 0
-
-workshops/2004/greve/support/mark.cert : \
- workshops/2004/greve/support/defrecord.cert \
- arithmetic/top-with-meta.cert \
- workshops/2004/greve/support/mark.lisp
-
-
-workshops/2004/legato/support/generic-theories.cert : acl2x = 0
-workshops/2004/legato/support/generic-theories.cert : no_pcert = 0
-
-workshops/2004/legato/support/generic-theories.cert : \
- workshops/2004/legato/support/generic-theories.lisp
-
-
-workshops/2004/legato/support/generic-theory-alternative-induction-mult.cert : acl2x = 0
-workshops/2004/legato/support/generic-theory-alternative-induction-mult.cert : no_pcert = 0
-
-workshops/2004/legato/support/generic-theory-alternative-induction-mult.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/legato/support/generic-theories.cert \
- workshops/2004/legato/support/generic-theory-alternative-induction-mult.lisp
-
-
-workshops/2004/legato/support/generic-theory-alternative-induction-sum.cert : acl2x = 0
-workshops/2004/legato/support/generic-theory-alternative-induction-sum.cert : no_pcert = 0
-
-workshops/2004/legato/support/generic-theory-alternative-induction-sum.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/legato/support/generic-theories.cert \
- workshops/2004/legato/support/generic-theory-alternative-induction-sum.lisp
-
-
-workshops/2004/legato/support/generic-theory-loop-invariant-mult.cert : acl2x = 0
-workshops/2004/legato/support/generic-theory-loop-invariant-mult.cert : no_pcert = 0
-
-workshops/2004/legato/support/generic-theory-loop-invariant-mult.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/legato/support/generic-theories.cert \
- workshops/2004/legato/support/generic-theory-loop-invariant-mult.lisp
-
-
-workshops/2004/legato/support/generic-theory-loop-invariant-sum.cert : acl2x = 0
-workshops/2004/legato/support/generic-theory-loop-invariant-sum.cert : no_pcert = 0
-
-workshops/2004/legato/support/generic-theory-loop-invariant-sum.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/legato/support/generic-theories.cert \
- workshops/2004/legato/support/generic-theory-loop-invariant-sum.lisp
-
-
-workshops/2004/legato/support/generic-theory-tail-recursion-mult.cert : acl2x = 0
-workshops/2004/legato/support/generic-theory-tail-recursion-mult.cert : no_pcert = 0
-
-workshops/2004/legato/support/generic-theory-tail-recursion-mult.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/legato/support/generic-theories.cert \
- workshops/2004/legato/support/generic-theory-tail-recursion-mult.lisp
-
-
-workshops/2004/legato/support/generic-theory-tail-recursion-sum.cert : acl2x = 0
-workshops/2004/legato/support/generic-theory-tail-recursion-sum.cert : no_pcert = 0
-
-workshops/2004/legato/support/generic-theory-tail-recursion-sum.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/legato/support/generic-theories.cert \
- workshops/2004/legato/support/generic-theory-tail-recursion-sum.lisp
-
-
-workshops/2004/legato/support/proof-by-generalization-mult.cert : acl2x = 0
-workshops/2004/legato/support/proof-by-generalization-mult.cert : no_pcert = 0
-
-workshops/2004/legato/support/proof-by-generalization-mult.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/legato/support/proof-by-generalization-mult.lisp
-
-
-workshops/2004/legato/support/proof-by-generalization-sum.cert : acl2x = 0
-workshops/2004/legato/support/proof-by-generalization-sum.cert : no_pcert = 0
-
-workshops/2004/legato/support/proof-by-generalization-sum.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/legato/support/proof-by-generalization-sum.lisp
-
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.cert : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.cert : no_pcert = 0
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.cert : \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.lisp
-
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.cert : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.cert : no_pcert = 0
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.cert : \
- arithmetic/top-with-meta.cert \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.lisp
-
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/records.cert : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/records.cert : no_pcert = 0
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/records.cert : \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.cert \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/records.lisp
-
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.cert : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.cert : no_pcert = 0
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.cert : \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.lisp
-
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.cert : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.cert : no_pcert = 0
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.cert : \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.lisp
-
-
-workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.cert : acl2x = 0
-workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.cert : no_pcert = 0
-
-workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.cert : \
- workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.cert \
- workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.lisp
-
-
-workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.cert : acl2x = 0
-workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.cert : no_pcert = 0
-
-workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.cert : \
- workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.cert \
- rtl/rel4/arithmetic/top.cert \
- arithmetic/top-with-meta.cert \
- misc/defpun.cert \
- ordinals/ordinals.cert \
- workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.lisp
-
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.cert : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.cert : no_pcert = 0
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.cert : \
- arithmetic-2/meta/top.cert \
- workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.lisp
-
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.cert : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.cert : no_pcert = 0
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.cert : \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.cert \
- workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.lisp
-
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.cert : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.cert : no_pcert = 0
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.cert : \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.cert \
- workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.cert \
- misc/defpun.cert \
- ordinals/ordinals.cert \
- workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.lisp
-
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.cert : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.cert : no_pcert = 0
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.cert : \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.cert \
- arithmetic/top-with-meta.cert \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.lisp
-
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.cert : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.cert : no_pcert = 0
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.cert : \
- workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.cert \
- arithmetic/top-with-meta.cert \
- data-structures/list-defthms.cert \
- ihs/logops-lemmas.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.lisp
-
-
-workshops/2004/ray/support/defcoerce.cert : acl2x = 0
-workshops/2004/ray/support/defcoerce.cert : no_pcert = 0
-
-workshops/2004/ray/support/defcoerce.cert : \
- arithmetic-2/meta/top.cert \
- workshops/2004/ray/support/generic.cert \
- workshops/2004/ray/support/defcoerce.lisp
-
-
-workshops/2004/ray/support/defpun-exec.cert : acl2x = 0
-workshops/2004/ray/support/defpun-exec.cert : no_pcert = 0
-
-workshops/2004/ray/support/defpun-exec.cert : \
- misc/defpun.cert \
- workshops/2004/ray/support/defpun-exec.lisp
-
-
-workshops/2004/ray/support/generic.cert : acl2x = 0
-workshops/2004/ray/support/generic.cert : no_pcert = 0
-
-workshops/2004/ray/support/generic.cert : \
- arithmetic-2/meta/top.cert \
- workshops/2004/ray/support/generic.lisp
-
-
-workshops/2004/roach-fraij/support/roach-fraij-script.cert : acl2x = 0
-workshops/2004/roach-fraij/support/roach-fraij-script.cert : no_pcert = 0
-
-workshops/2004/roach-fraij/support/roach-fraij-script.cert : \
- workshops/2004/roach-fraij/support/roach-fraij-script.lisp
-
-
-workshops/2004/ruiz-et-al/support/basic.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/basic.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/basic.cert : \
- arithmetic/top-with-meta.cert \
- workshops/2004/ruiz-et-al/support/basic.lisp
-
-
-workshops/2004/ruiz-et-al/support/dag-unification-rules.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/dag-unification-rules.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/dag-unification-rules.cert : \
- workshops/2004/ruiz-et-al/support/dags.cert \
- workshops/2004/ruiz-et-al/support/prefix-unification-rules.cert \
- workshops/2004/ruiz-et-al/support/dag-unification-rules.lisp
-
-
-workshops/2004/ruiz-et-al/support/dags.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/dags.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/dags.cert : \
- workshops/2004/ruiz-et-al/support/basic.cert \
- workshops/2004/ruiz-et-al/support/lists.cert \
- workshops/2004/ruiz-et-al/support/dags.lisp
-
-
-workshops/2004/ruiz-et-al/support/lists.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/lists.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/lists.cert : \
- workshops/2004/ruiz-et-al/support/lists.lisp
-
-
-workshops/2004/ruiz-et-al/support/matching.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/matching.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/matching.cert : \
- workshops/2004/ruiz-et-al/support/terms.cert \
- workshops/2004/ruiz-et-al/support/matching.lisp
-
-
-workshops/2004/ruiz-et-al/support/prefix-unification-rules.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/prefix-unification-rules.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/prefix-unification-rules.cert : \
- workshops/2004/ruiz-et-al/support/subsumption-subst.cert \
- workshops/2004/ruiz-et-al/support/prefix-unification-rules.lisp
-
-
-workshops/2004/ruiz-et-al/support/q-dag-unification-rules.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification-rules.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/q-dag-unification-rules.cert : \
- workshops/2004/ruiz-et-al/support/dag-unification-rules.cert \
- workshops/2004/ruiz-et-al/support/q-dag-unification-rules.lisp
-
-
-workshops/2004/ruiz-et-al/support/q-dag-unification-st.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification-st.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/q-dag-unification-st.cert : \
- workshops/2004/ruiz-et-al/support/q-dag-unification.cert \
- workshops/2004/ruiz-et-al/support/q-dag-unification-st.lisp
-
-
-workshops/2004/ruiz-et-al/support/q-dag-unification.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/q-dag-unification.cert : \
- workshops/2004/ruiz-et-al/support/q-dag-unification-rules.cert \
- workshops/2004/ruiz-et-al/support/terms-as-dag.cert \
- workshops/2004/ruiz-et-al/support/q-dag-unification.lisp
-
-
-workshops/2004/ruiz-et-al/support/subsumption-subst.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/subsumption-subst.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/subsumption-subst.cert : \
- workshops/2004/ruiz-et-al/support/subsumption.cert \
- workshops/2004/ruiz-et-al/support/subsumption-subst.lisp
-
-
-workshops/2004/ruiz-et-al/support/subsumption.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/subsumption.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/subsumption.cert : \
- workshops/2004/ruiz-et-al/support/matching.cert \
- workshops/2004/ruiz-et-al/support/terms.cert \
- workshops/2004/ruiz-et-al/support/subsumption.lisp
-
-
-workshops/2004/ruiz-et-al/support/terms-as-dag.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/terms-as-dag.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/terms-as-dag.cert : \
- workshops/2004/ruiz-et-al/support/dag-unification-rules.cert \
- workshops/2004/ruiz-et-al/support/terms-as-dag.lisp
-
-
-workshops/2004/ruiz-et-al/support/terms.cert : acl2x = 0
-workshops/2004/ruiz-et-al/support/terms.cert : no_pcert = 0
-
-workshops/2004/ruiz-et-al/support/terms.cert : \
- workshops/2004/ruiz-et-al/support/basic.cert \
- workshops/2004/ruiz-et-al/support/terms.lisp
-
-
-workshops/2004/sawada/support/bv.cert : acl2x = 0
-workshops/2004/sawada/support/bv.cert : no_pcert = 0
-
-workshops/2004/sawada/support/bv.cert : \
- workshops/2004/sawada/support/ihs.cert \
- arithmetic-2/pass1/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2004/sawada/support/bv.lisp \
- workshops/2004/sawada/support/bv.acl2 \
- workshops/2004/sawada/support/defpkg.lsp
-
-
-workshops/2004/sawada/support/ihs.cert : acl2x = 0
-workshops/2004/sawada/support/ihs.cert : no_pcert = 0
-
-workshops/2004/sawada/support/ihs.cert : \
- ihs/ihs-definitions.cert \
- ihs/logops-lemmas.cert \
- workshops/2004/sawada/support/ihs.lisp
-
-
-workshops/2004/schmaltz-borrione/support/collect_msg_book.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/collect_msg_book.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/collect_msg_book.cert : \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.cert \
- workshops/2004/schmaltz-borrione/support/node.cert \
- workshops/2004/schmaltz-borrione/support/collect_msg_book.lisp
-
-
-workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.cert : \
- workshops/2004/schmaltz-borrione/support/routing_defuns.cert \
- workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.lisp
-
-
-workshops/2004/schmaltz-borrione/support/intersect.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/intersect.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/intersect.cert : \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.cert \
- workshops/2004/schmaltz-borrione/support/intersect.lisp
-
-
-workshops/2004/schmaltz-borrione/support/local_trip_book.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/local_trip_book.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/local_trip_book.cert : \
- workshops/2004/schmaltz-borrione/support/trip_book.cert \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/schmaltz-borrione/support/local_trip_book.lisp
-
-
-workshops/2004/schmaltz-borrione/support/make_travel_list_book.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/make_travel_list_book.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/make_travel_list_book.cert : \
- workshops/2004/schmaltz-borrione/support/routing_main.cert \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/schmaltz-borrione/support/make_travel_list_book.lisp
-
-
-workshops/2004/schmaltz-borrione/support/mod_lemmas.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/mod_lemmas.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/mod_lemmas.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/schmaltz-borrione/support/mod_lemmas.lisp
-
-
-workshops/2004/schmaltz-borrione/support/node.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/node.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/node.cert : \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.cert \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2004/schmaltz-borrione/support/node.lisp
-
-
-workshops/2004/schmaltz-borrione/support/octagon_book.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/octagon_book.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/octagon_book.cert : \
- workshops/2004/schmaltz-borrione/support/collect_msg_book.cert \
- workshops/2004/schmaltz-borrione/support/make_travel_list_book.cert \
- workshops/2004/schmaltz-borrione/support/scheduler_book.cert \
- workshops/2004/schmaltz-borrione/support/trip_thms.cert \
- workshops/2004/schmaltz-borrione/support/octagon_book.lisp
-
-
-workshops/2004/schmaltz-borrione/support/predicatesNCie.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/predicatesNCie.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/predicatesNCie.cert : \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.lisp
-
-
-workshops/2004/schmaltz-borrione/support/routing_defuns.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/routing_defuns.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/routing_defuns.cert : \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.cert \
- workshops/2004/schmaltz-borrione/support/mod_lemmas.cert \
- workshops/2004/schmaltz-borrione/support/routing_defuns.lisp
-
-
-workshops/2004/schmaltz-borrione/support/routing_local_lemmas.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/routing_local_lemmas.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/routing_local_lemmas.cert : \
- workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.cert \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- workshops/2004/schmaltz-borrione/support/routing_local_lemmas.lisp
-
-
-workshops/2004/schmaltz-borrione/support/routing_main.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/routing_main.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/routing_main.cert : \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.cert \
- workshops/2004/schmaltz-borrione/support/routing_local_lemmas.cert \
- workshops/2004/schmaltz-borrione/support/routing_main.lisp
-
-
-workshops/2004/schmaltz-borrione/support/scheduler_book.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/scheduler_book.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/scheduler_book.cert : \
- workshops/2004/schmaltz-borrione/support/intersect.cert \
- workshops/2004/schmaltz-borrione/support/scheduler_book.lisp
-
-
-workshops/2004/schmaltz-borrione/support/switch.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/switch.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/switch.cert : \
- workshops/2004/schmaltz-borrione/support/switch.lisp
-
-
-workshops/2004/schmaltz-borrione/support/trip_book.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/trip_book.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/trip_book.cert : \
- workshops/2004/schmaltz-borrione/support/switch.cert \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.cert \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- workshops/2004/schmaltz-borrione/support/trip_book.lisp
-
-
-workshops/2004/schmaltz-borrione/support/trip_thms.cert : acl2x = 0
-workshops/2004/schmaltz-borrione/support/trip_thms.cert : no_pcert = 0
-
-workshops/2004/schmaltz-borrione/support/trip_thms.cert : \
- workshops/2004/schmaltz-borrione/support/local_trip_book.cert \
- workshops/2004/schmaltz-borrione/support/trip_thms.lisp
-
-
-workshops/2004/smith-et-al/support/bags/bag-exports.cert : acl2x = 0
-workshops/2004/smith-et-al/support/bags/bag-exports.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/bags/bag-exports.cert : \
- workshops/2004/smith-et-al/support/bags/bag-pkg.cert \
- workshops/2004/smith-et-al/support/bags/bag-exports.lisp \
- workshops/2004/smith-et-al/support/bags/bag-exports.acl2
-
-
-workshops/2004/smith-et-al/support/bags/bag-pkg.cert : acl2x = 0
-workshops/2004/smith-et-al/support/bags/bag-pkg.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/bags/bag-pkg.cert : \
- workshops/2004/smith-et-al/support/lists/list-exports.cert \
- workshops/2004/smith-et-al/support/syntax/syn-pkg.cert \
- workshops/2004/smith-et-al/support/bags/bag-pkg.lisp \
- workshops/2004/smith-et-al/support/bags/bag-pkg.acl2
-
-
-workshops/2004/smith-et-al/support/bags/basic.cert : acl2x = 0
-workshops/2004/smith-et-al/support/bags/basic.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/bags/basic.cert : \
- arithmetic/top-with-meta.cert \
- workshops/2004/smith-et-al/support/lists/lists.cert \
- workshops/2004/smith-et-al/support/bags/bag-exports.cert \
- workshops/2004/smith-et-al/support/bags/basic.lisp \
- workshops/2004/smith-et-al/support/bags/basic.acl2
-
-
-workshops/2004/smith-et-al/support/bags/bind-free-rules.cert : acl2x = 0
-workshops/2004/smith-et-al/support/bags/bind-free-rules.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/bags/bind-free-rules.cert : \
- workshops/2004/smith-et-al/support/bags/meta.cert \
- workshops/2004/smith-et-al/support/bags/bag-exports.cert \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.lisp \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.acl2
-
-
-workshops/2004/smith-et-al/support/bags/cons.cert : acl2x = 0
-workshops/2004/smith-et-al/support/bags/cons.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/bags/cons.cert : \
- workshops/2004/smith-et-al/support/bags/cons.lisp
-
-
-workshops/2004/smith-et-al/support/bags/eric-meta.cert : acl2x = 0
-workshops/2004/smith-et-al/support/bags/eric-meta.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/bags/eric-meta.cert : \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.cert \
- rtl/rel4/support/logand.cert \
- workshops/2004/smith-et-al/support/bags/bag-exports.cert \
- workshops/2004/smith-et-al/support/bags/eric-meta.lisp \
- workshops/2004/smith-et-al/support/bags/eric-meta.acl2
-
-
-workshops/2004/smith-et-al/support/bags/meta.cert : acl2x = 0
-workshops/2004/smith-et-al/support/bags/meta.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/bags/meta.cert : \
- workshops/2004/smith-et-al/support/bags/basic.cert \
- ordinals/e0-ordinal.cert \
- workshops/2004/smith-et-al/support/bags/bag-exports.cert \
- workshops/2004/smith-et-al/support/lists/mv-nth.cert \
- workshops/2004/smith-et-al/support/syntax/syntax.cert \
- workshops/2004/smith-et-al/support/bags/meta.lisp \
- workshops/2004/smith-et-al/support/bags/meta.acl2
-
-
-workshops/2004/smith-et-al/support/bags/neq.cert : acl2x = 0
-workshops/2004/smith-et-al/support/bags/neq.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/bags/neq.cert : \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.cert \
- workshops/2004/smith-et-al/support/bags/bag-exports.cert \
- workshops/2004/smith-et-al/support/bags/neq.lisp \
- workshops/2004/smith-et-al/support/bags/neq.acl2
-
-
-workshops/2004/smith-et-al/support/bags/top.cert : acl2x = 0
-workshops/2004/smith-et-al/support/bags/top.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/bags/top.cert : \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.cert \
- workshops/2004/smith-et-al/support/bags/cons.cert \
- workshops/2004/smith-et-al/support/bags/neq.cert \
- workshops/2004/smith-et-al/support/bags/eric-meta.cert \
- workshops/2004/smith-et-al/support/bags/bag-exports.cert \
- workshops/2004/smith-et-al/support/bags/top.lisp \
- workshops/2004/smith-et-al/support/bags/top.acl2
-
-
-workshops/2004/smith-et-al/support/bags/two-level-meta.cert : acl2x = 0
-workshops/2004/smith-et-al/support/bags/two-level-meta.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/bags/two-level-meta.cert : \
- workshops/2004/smith-et-al/support/bags/two-level.cert \
- workshops/2004/smith-et-al/support/bags/bag-exports.cert \
- workshops/2004/smith-et-al/support/bags/two-level-meta.lisp \
- workshops/2004/smith-et-al/support/bags/two-level-meta.acl2
-
-
-workshops/2004/smith-et-al/support/bags/two-level.cert : acl2x = 0
-workshops/2004/smith-et-al/support/bags/two-level.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/bags/two-level.cert : \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.cert \
- workshops/2004/smith-et-al/support/bags/bag-exports.cert \
- workshops/2004/smith-et-al/support/bags/two-level.lisp \
- workshops/2004/smith-et-al/support/bags/two-level.acl2
-
-
-workshops/2004/smith-et-al/support/lists/list-exports.cert : acl2x = 0
-workshops/2004/smith-et-al/support/lists/list-exports.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/lists/list-exports.cert : \
- workshops/2004/smith-et-al/support/lists/list-exports.lisp \
- workshops/2004/smith-et-al/support/lists/cert.acl2
-
-
-workshops/2004/smith-et-al/support/lists/list-top.cert : acl2x = 0
-workshops/2004/smith-et-al/support/lists/list-top.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/lists/list-top.cert : \
- workshops/2004/smith-et-al/support/lists/lists.cert \
- workshops/2004/smith-et-al/support/lists/list-exports.cert \
- workshops/2004/smith-et-al/support/lists/mv-nth.cert \
- workshops/2004/smith-et-al/support/lists/list-top.lisp \
- workshops/2004/smith-et-al/support/lists/list-top.acl2
-
-
-workshops/2004/smith-et-al/support/lists/lists.cert : acl2x = 0
-workshops/2004/smith-et-al/support/lists/lists.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/lists/lists.cert : \
- arithmetic/top-with-meta.cert \
- workshops/2004/smith-et-al/support/lists/lists.lisp \
- workshops/2004/smith-et-al/support/lists/cert.acl2
-
-
-workshops/2004/smith-et-al/support/lists/mv-nth.cert : acl2x = 0
-workshops/2004/smith-et-al/support/lists/mv-nth.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/lists/mv-nth.cert : \
- workshops/2004/smith-et-al/support/lists/mv-nth.lisp \
- workshops/2004/smith-et-al/support/lists/cert.acl2
-
-
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.cert : acl2x = 0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.cert : \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.lisp \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.acl2
-
-
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.cert : acl2x = 0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.cert : \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.cert \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.lisp \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.acl2
-
-
-workshops/2004/smith-et-al/support/syntax/auxilary.cert : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/auxilary.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/syntax/auxilary.cert : \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.cert \
- workshops/2004/smith-et-al/support/syntax/auxilary.lisp \
- workshops/2004/smith-et-al/support/syntax/auxilary.acl2
-
-
-workshops/2004/smith-et-al/support/syntax/syn-pkg.cert : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/syn-pkg.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/syntax/syn-pkg.cert : \
- workshops/2004/smith-et-al/support/syntax/syn-pkg.lisp \
- workshops/2004/smith-et-al/support/syntax/syn-pkg.acl2
-
-
-workshops/2004/smith-et-al/support/syntax/syntax-extensions.cert : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/syntax-extensions.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/syntax/syntax-extensions.cert : \
- workshops/2004/smith-et-al/support/syntax/auxilary.cert \
- workshops/2004/smith-et-al/support/syntax/syn-pkg.cert \
- workshops/2004/smith-et-al/support/lists/list-top.cert \
- workshops/2004/smith-et-al/support/syntax/syntax-extensions.lisp \
- workshops/2004/smith-et-al/support/syntax/syntax-extensions.acl2
-
-
-workshops/2004/smith-et-al/support/syntax/syntax.cert : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/syntax.cert : no_pcert = 0
-
-workshops/2004/smith-et-al/support/syntax/syntax.cert : \
- workshops/2004/smith-et-al/support/syntax/syntax-extensions.cert \
- workshops/2004/smith-et-al/support/syntax/syntax.lisp \
- workshops/2004/smith-et-al/support/syntax/syntax.acl2
-
-
-workshops/2004/sumners-ray/support/basis.cert : acl2x = 0
-workshops/2004/sumners-ray/support/basis.cert : no_pcert = 0
-
-workshops/2004/sumners-ray/support/basis.cert : \
- workshops/2004/sumners-ray/support/basis.lisp
-
-
-workshops/2004/sumners-ray/support/crit.cert : acl2x = 0
-workshops/2004/sumners-ray/support/crit.cert : no_pcert = 0
-
-workshops/2004/sumners-ray/support/crit.cert : \
- workshops/2004/sumners-ray/support/basis.cert \
- workshops/2004/sumners-ray/support/crit.lisp
-
-
-workshops/2004/sumners-ray/support/mesi.cert : acl2x = 0
-workshops/2004/sumners-ray/support/mesi.cert : no_pcert = 0
-
-workshops/2004/sumners-ray/support/mesi.cert : \
- workshops/2004/sumners-ray/support/basis.cert \
- workshops/2004/sumners-ray/support/records.cert \
- workshops/2004/sumners-ray/support/mesi.lisp
-
-
-workshops/2004/sumners-ray/support/records.cert : acl2x = 0
-workshops/2004/sumners-ray/support/records.cert : no_pcert = 0
-
-workshops/2004/sumners-ray/support/records.cert : \
- workshops/2004/sumners-ray/support/sets.cert \
- workshops/2004/sumners-ray/support/records.lisp
-
-
-workshops/2004/sumners-ray/support/sets.cert : acl2x = 0
-workshops/2004/sumners-ray/support/sets.cert : no_pcert = 0
-
-workshops/2004/sumners-ray/support/sets.cert : \
- workshops/2004/sumners-ray/support/total-order.cert \
- workshops/2004/sumners-ray/support/sets.lisp
-
-
-workshops/2004/sumners-ray/support/total-order.cert : acl2x = 0
-workshops/2004/sumners-ray/support/total-order.cert : no_pcert = 0
-
-workshops/2004/sumners-ray/support/total-order.cert : \
- workshops/2004/sumners-ray/support/total-order.lisp
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed1.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed1.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed1.cert : \
- arithmetic/top.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed1.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed1.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.cert : \
- arithmetic/top.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.lisp
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.cert : \
- arithmetic/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.lisp
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert : \
- arithmetic/top.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.cert : \
- arithmetic/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.cert : \
- arithmetic/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.cert : \
- arithmetic/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.cert : \
- arithmetic/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.cert : \
- arithmetic/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.cert : \
- arithmetic/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.cert : \
- arithmetic/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.cert : \
- arithmetic/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.cert : \
- arithmetic/top.cert \
- ihs/quotient-remainder-lemmas.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.cert : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.acl2
-
-
-workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.cert : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.cert : no_pcert = 0
-
-workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.cert : \
- arithmetic/top-with-meta.cert \
- arithmetic/mod-gcd.cert \
- workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.acl2
-
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.cert : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.cert : no_pcert = 0
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.cert : \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.cert \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.lisp
-
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.cert : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.cert : no_pcert = 0
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.cert : \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.lisp
-
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.cert : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.cert : no_pcert = 0
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.cert : \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.cert \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.lisp
-
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.cert : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.cert : no_pcert = 0
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.cert : \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.cert \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.lisp
-
-
-workshops/2006/greve/nary/example.cert : acl2x = 0
-workshops/2006/greve/nary/example.cert : no_pcert = 0
-
-workshops/2006/greve/nary/example.cert : \
- workshops/2006/greve/nary/nary.cert \
- ihs/ihs-definitions.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- ihs/ihs-lemmas.cert \
- ihs/ihs-lemmas.cert \
- workshops/2006/greve/nary/nth-rules.cert \
- workshops/2006/greve/nary/example.lisp
-
-
-workshops/2006/greve/nary/nary.cert : acl2x = 0
-workshops/2006/greve/nary/nary.cert : no_pcert = 0
-
-workshops/2006/greve/nary/nary.cert : \
- workshops/2006/greve/nary/nary.lisp
-
-
-workshops/2006/greve/nary/nth-rules.cert : acl2x = 0
-workshops/2006/greve/nary/nth-rules.cert : no_pcert = 0
-
-workshops/2006/greve/nary/nth-rules.cert : \
- workshops/2006/greve/nary/nth-rules.lisp
-
-
-workshops/2006/hunt-reeber/support/acl2.cert : acl2x = 0
-workshops/2006/hunt-reeber/support/acl2.cert : no_pcert = 0
-
-workshops/2006/hunt-reeber/support/acl2.cert : \
- workshops/2006/hunt-reeber/support/acl2.lisp
-
-
-workshops/2006/hunt-reeber/support/bdd.cert : acl2x = 0
-workshops/2006/hunt-reeber/support/bdd.cert : no_pcert = 0
-
-workshops/2006/hunt-reeber/support/bdd.cert : \
- workshops/2006/hunt-reeber/support/bdd.lisp
-
-
-workshops/2006/hunt-reeber/support/sat.cert : acl2x = 0
-workshops/2006/hunt-reeber/support/sat.cert : no_pcert = 0
-
-workshops/2006/hunt-reeber/support/sat.cert : \
- workshops/2006/hunt-reeber/support/sat.lisp
-
-
-workshops/2006/kaufmann-moore/support/austel.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/austel.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/austel.cert : \
- workshops/2006/kaufmann-moore/support/austel.lisp
-
-
-workshops/2006/kaufmann-moore/support/greve1.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/greve1.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/greve1.cert : \
- workshops/2006/kaufmann-moore/support/greve1.lisp
-
-
-workshops/2006/kaufmann-moore/support/greve2.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/greve2.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/greve2.cert : \
- workshops/2006/kaufmann-moore/support/greve2.lisp
-
-
-workshops/2006/kaufmann-moore/support/greve3.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/greve3.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/greve3.cert : \
- workshops/2006/kaufmann-moore/support/greve3.lisp
-
-
-workshops/2006/kaufmann-moore/support/mini-proveall-plus.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/mini-proveall-plus.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/mini-proveall-plus.cert : \
- workshops/2006/kaufmann-moore/support/mini-proveall.cert \
- workshops/2006/kaufmann-moore/support/mini-proveall-plus.lisp
-
-
-workshops/2006/kaufmann-moore/support/mini-proveall.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/mini-proveall.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/mini-proveall.cert : \
- workshops/2006/kaufmann-moore/support/mini-proveall.lisp
-
-
-workshops/2006/kaufmann-moore/support/rhs1-iff.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/rhs1-iff.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/rhs1-iff.cert : \
- workshops/2006/kaufmann-moore/support/rhs1-iff.lisp \
- workshops/2006/kaufmann-moore/support/rhs1-iff.acl2
-
-
-workshops/2006/kaufmann-moore/support/rhs1.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/rhs1.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/rhs1.cert : \
- workshops/2006/kaufmann-moore/support/rhs1.lisp \
- workshops/2006/kaufmann-moore/support/rhs1.acl2
-
-
-workshops/2006/kaufmann-moore/support/rhs2.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/rhs2.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/rhs2.cert : \
- workshops/2006/kaufmann-moore/support/rhs2.lisp \
- workshops/2006/kaufmann-moore/support/rhs2.acl2
-
-
-workshops/2006/kaufmann-moore/support/smith1.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/smith1.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/smith1.cert : \
- workshops/2006/kaufmann-moore/support/smith1.lisp
-
-
-workshops/2006/kaufmann-moore/support/sumners1.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/sumners1.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/sumners1.cert : \
- workshops/2006/kaufmann-moore/support/sumners1.lisp
-
-
-workshops/2006/kaufmann-moore/support/warnings.cert : acl2x = 0
-workshops/2006/kaufmann-moore/support/warnings.cert : no_pcert = 0
-
-workshops/2006/kaufmann-moore/support/warnings.cert : \
- workshops/2006/kaufmann-moore/support/warnings.lisp \
- workshops/2006/kaufmann-moore/support/warnings.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/AES/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/AES/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.cert \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.cert \
- workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/AES/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.cert \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.cert \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.cert \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.cert \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.cert \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.cert \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.cert : \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- misc/priorities.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- coi/super-ihs/super-ihs.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.cert : \
- data-structures/list-defthms.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.cert \
- data-structures/list-defthms.cert \
- arithmetic/top-with-meta.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- coi/super-ihs/super-ihs.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert : \
- arithmetic/mod-gcd.cert \
- ordinals/ordinals.cert \
- ihs/ihs-definitions.cert \
- ihs/ihs-lemmas.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.cert : \
- data-structures/number-list-defuns.cert \
- data-structures/list-defthms.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/cert.acl2
-
-
-workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.cert : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.cert : no_pcert = 0
-
-workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.cert : \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.cert \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.cert \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.cert \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/cert.acl2
-
-
-workshops/2006/rager/support/ptest-fib.cert : acl2x = 0
-workshops/2006/rager/support/ptest-fib.cert : no_pcert = 0
-
-workshops/2006/rager/support/ptest-fib.cert : \
- workshops/2006/rager/support/ptest-fib.lisp
-
-
-workshops/2006/rager/support/ptest-if-normalization.cert : acl2x = 0
-workshops/2006/rager/support/ptest-if-normalization.cert : no_pcert = 0
-
-workshops/2006/rager/support/ptest-if-normalization.cert : \
- workshops/2006/rager/support/ptest-if-normalization.lisp
-
-
-workshops/2006/rager/support/ptest-mergesort.cert : acl2x = 0
-workshops/2006/rager/support/ptest-mergesort.cert : no_pcert = 0
-
-workshops/2006/rager/support/ptest-mergesort.cert : \
- finite-set-theory/osets/sets.cert \
- workshops/2006/rager/support/ptest-mergesort.lisp \
- workshops/2006/rager/support/ptest-mergesort.acl2 \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-
-
-workshops/2006/ray/tail/exists.cert : acl2x = 0
-workshops/2006/ray/tail/exists.cert : no_pcert = 0
-
-workshops/2006/ray/tail/exists.cert : \
- workshops/2006/ray/tail/exists.lisp
-
-
-workshops/2006/ray/tail/forall.cert : acl2x = 0
-workshops/2006/ray/tail/forall.cert : no_pcert = 0
-
-workshops/2006/ray/tail/forall.cert : \
- workshops/2006/ray/tail/forall.lisp
-
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.cert : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.cert : no_pcert = 0
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.cert : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.lisp
-
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.cert : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.cert : no_pcert = 0
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.cert : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.lisp
-
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.cert : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.cert : no_pcert = 0
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.cert : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.lisp
-
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.cert : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.cert : no_pcert = 0
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.cert : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.lisp
-
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.cert : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.cert : no_pcert = 0
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.cert : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.lisp
-
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.cert : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.cert : no_pcert = 0
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.cert : \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- textbook/chap11/qsort.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.lisp
-
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.cert : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.cert : no_pcert = 0
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.cert : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.cert \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.lisp
-
-
-workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.cert : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.cert : no_pcert = 0
-
-workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.cert : \
- data-structures/list-theory.cert \
- workshops/2006/swords-cook/lcsoundness/defsum.cert \
- workshops/2006/swords-cook/lcsoundness/defsum-thms.cert \
- workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.lisp
-
-
-workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.cert : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.cert : no_pcert = 0
-
-workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.cert : \
- workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.cert \
- workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.lisp
-
-
-workshops/2006/swords-cook/lcsoundness/defsum-thms.cert : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/defsum-thms.cert : no_pcert = 0
-
-workshops/2006/swords-cook/lcsoundness/defsum-thms.cert : \
- arithmetic-3/bind-free/top.cert \
- workshops/2006/swords-cook/lcsoundness/defsum-thms.lisp
-
-
-workshops/2006/swords-cook/lcsoundness/defsum.cert : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/defsum.cert : no_pcert = 0
-
-workshops/2006/swords-cook/lcsoundness/defsum.cert : \
- workshops/2006/swords-cook/lcsoundness/pattern-match.cert \
- workshops/2006/swords-cook/lcsoundness/defsum.lisp
-
-
-workshops/2006/swords-cook/lcsoundness/pattern-match.cert : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/pattern-match.cert : no_pcert = 0
-
-workshops/2006/swords-cook/lcsoundness/pattern-match.cert : \
- workshops/2006/swords-cook/lcsoundness/pattern-match.lisp
-
-
-workshops/2007/cowles-et-al/support/cowles/while-loop.cert : acl2x = 0
-workshops/2007/cowles-et-al/support/cowles/while-loop.cert : no_pcert = 0
-
-workshops/2007/cowles-et-al/support/cowles/while-loop.cert : \
- arithmetic/top-with-meta.cert \
- workshops/2007/cowles-et-al/support/cowles/while-loop.lisp
-
-
-workshops/2007/cowles-et-al/support/greve/ack.cert : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/ack.cert : no_pcert = 0
-
-workshops/2007/cowles-et-al/support/greve/ack.cert : \
- workshops/2007/cowles-et-al/support/greve/defminterm.cert \
- workshops/2007/cowles-et-al/support/greve/ack.lisp
-
-
-workshops/2007/cowles-et-al/support/greve/defminterm.cert : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/defminterm.cert : no_pcert = 0
-
-workshops/2007/cowles-et-al/support/greve/defminterm.cert : \
- workshops/2007/cowles-et-al/support/greve/defxch.cert \
- workshops/2007/cowles-et-al/support/greve/defpun.cert \
- workshops/2007/cowles-et-al/support/greve/defminterm.lisp
-
-
-workshops/2007/cowles-et-al/support/greve/defpun.cert : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/defpun.cert : no_pcert = 0
-
-workshops/2007/cowles-et-al/support/greve/defpun.cert : \
- workshops/2007/cowles-et-al/support/greve/defpun.lisp
-
-
-workshops/2007/cowles-et-al/support/greve/defxch.cert : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/defxch.cert : no_pcert = 0
-
-workshops/2007/cowles-et-al/support/greve/defxch.cert : \
- arithmetic-2/meta/top.cert \
- misc/defpun.cert \
- workshops/2007/cowles-et-al/support/greve/defxch.lisp
-
-
-workshops/2007/cowles-et-al/support/greve/while.cert : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/while.cert : no_pcert = 0
-
-workshops/2007/cowles-et-al/support/greve/while.cert : \
- workshops/2007/cowles-et-al/support/greve/defminterm.cert \
- workshops/2007/cowles-et-al/support/greve/ack.cert \
- workshops/2007/cowles-et-al/support/greve/while.lisp
-
-
-workshops/2007/cowles-et-al/support/ray/reflexive-macros.cert : acl2x = 0
-workshops/2007/cowles-et-al/support/ray/reflexive-macros.cert : no_pcert = 0
-
-workshops/2007/cowles-et-al/support/ray/reflexive-macros.cert : \
- workshops/2007/cowles-et-al/support/ray/reflexive.cert \
- workshops/2007/cowles-et-al/support/ray/reflexive-macros.lisp
-
-
-workshops/2007/cowles-et-al/support/ray/reflexive.cert : acl2x = 0
-workshops/2007/cowles-et-al/support/ray/reflexive.cert : no_pcert = 0
-
-workshops/2007/cowles-et-al/support/ray/reflexive.cert : \
- arithmetic/top-with-meta.cert \
- workshops/2007/cowles-et-al/support/ray/reflexive.lisp
-
-
-workshops/2007/dillinger-et-al/code/all.cert : acl2x = 0
-workshops/2007/dillinger-et-al/code/all.cert : no_pcert = 0
-
-workshops/2007/dillinger-et-al/code/all.cert : \
- workshops/2007/dillinger-et-al/code/hacker.cert \
- workshops/2007/dillinger-et-al/code/defcode-macro.cert \
- workshops/2007/dillinger-et-al/code/defcode.cert \
- workshops/2007/dillinger-et-al/code/defstruct-parsing.cert \
- workshops/2007/dillinger-et-al/code/raw.cert \
- workshops/2007/dillinger-et-al/code/rewrite-code.cert \
- workshops/2007/dillinger-et-al/code/redefun.cert \
- workshops/2007/dillinger-et-al/code/bridge.cert \
- workshops/2007/dillinger-et-al/code/subsumption.cert \
- workshops/2007/dillinger-et-al/code/table-guard.cert \
- workshops/2007/dillinger-et-al/code/all.lisp \
- workshops/2007/dillinger-et-al/code/all.acl2
-
-
-workshops/2007/dillinger-et-al/code/bridge.cert : acl2x = 0
-workshops/2007/dillinger-et-al/code/bridge.cert : no_pcert = 0
-
-workshops/2007/dillinger-et-al/code/bridge.cert : \
- workshops/2007/dillinger-et-al/code/defcode.cert \
- workshops/2007/dillinger-et-al/code/bridge.lisp \
- workshops/2007/dillinger-et-al/code/bridge.acl2 \
- workshops/2007/dillinger-et-al/code/hacker-pkg.lsp
-
-
-workshops/2007/dillinger-et-al/code/defcode-macro.cert : acl2x = 0
-workshops/2007/dillinger-et-al/code/defcode-macro.cert : no_pcert = 0
-
-workshops/2007/dillinger-et-al/code/defcode-macro.cert : \
- workshops/2007/dillinger-et-al/code/hacker.cert \
- workshops/2007/dillinger-et-al/code/hacker.cert \
- workshops/2007/dillinger-et-al/code/defcode-macro.lisp \
- workshops/2007/dillinger-et-al/code/defcode-macro.acl2
-
-
-workshops/2007/dillinger-et-al/code/defcode.cert : acl2x = 0
-workshops/2007/dillinger-et-al/code/defcode.cert : no_pcert = 0
-
-workshops/2007/dillinger-et-al/code/defcode.cert : \
- workshops/2007/dillinger-et-al/code/hacker.cert \
- workshops/2007/dillinger-et-al/code/defcode-macro.cert \
- workshops/2007/dillinger-et-al/code/hacker.cert \
- workshops/2007/dillinger-et-al/code/defcode.lisp \
- workshops/2007/dillinger-et-al/code/defcode.acl2
-
-
-workshops/2007/dillinger-et-al/code/defstruct-parsing.cert : acl2x = 0
-workshops/2007/dillinger-et-al/code/defstruct-parsing.cert : no_pcert = 0
-
-workshops/2007/dillinger-et-al/code/defstruct-parsing.cert : \
- workshops/2007/dillinger-et-al/code/defstruct-parsing.lisp \
- workshops/2007/dillinger-et-al/code/defstruct-parsing.acl2 \
- workshops/2007/dillinger-et-al/code/hacker-pkg.lsp
-
-
-workshops/2007/dillinger-et-al/code/hacker.cert : acl2x = 0
-workshops/2007/dillinger-et-al/code/hacker.cert : no_pcert = 0
-
-workshops/2007/dillinger-et-al/code/hacker.cert : \
- workshops/2007/dillinger-et-al/code/hacker.lisp \
- workshops/2007/dillinger-et-al/code/hacker.acl2 \
- workshops/2007/dillinger-et-al/code/hacker-pkg.lsp
-
-
-workshops/2007/dillinger-et-al/code/raw.cert : acl2x = 0
-workshops/2007/dillinger-et-al/code/raw.cert : no_pcert = 0
-
-workshops/2007/dillinger-et-al/code/raw.cert : \
- workshops/2007/dillinger-et-al/code/defstruct-parsing.cert \
- workshops/2007/dillinger-et-al/code/defcode.cert \
- workshops/2007/dillinger-et-al/code/raw.lisp \
- workshops/2007/dillinger-et-al/code/raw.acl2 \
- workshops/2007/dillinger-et-al/code/hacker-pkg.lsp
-
-
-workshops/2007/dillinger-et-al/code/redefun.cert : acl2x = 0
-workshops/2007/dillinger-et-al/code/redefun.cert : no_pcert = 0
-
-workshops/2007/dillinger-et-al/code/redefun.cert : \
- workshops/2007/dillinger-et-al/code/defcode.cert \
- workshops/2007/dillinger-et-al/code/rewrite-code.cert \
- workshops/2007/dillinger-et-al/code/defcode.cert \
- workshops/2007/dillinger-et-al/code/redefun.lisp \
- workshops/2007/dillinger-et-al/code/redefun.acl2
-
-
-workshops/2007/dillinger-et-al/code/rewrite-code.cert : acl2x = 0
-workshops/2007/dillinger-et-al/code/rewrite-code.cert : no_pcert = 0
-
-workshops/2007/dillinger-et-al/code/rewrite-code.cert : \
- workshops/2007/dillinger-et-al/code/rewrite-code.lisp \
- workshops/2007/dillinger-et-al/code/rewrite-code.acl2
-
-
-workshops/2007/dillinger-et-al/code/subsumption.cert : acl2x = 0
-workshops/2007/dillinger-et-al/code/subsumption.cert : no_pcert = 0
-
-workshops/2007/dillinger-et-al/code/subsumption.cert : \
- workshops/2007/dillinger-et-al/code/defcode.cert \
- workshops/2007/dillinger-et-al/code/subsumption.lisp \
- workshops/2007/dillinger-et-al/code/subsumption.acl2 \
- workshops/2007/dillinger-et-al/code/hacker-pkg.lsp
-
-
-workshops/2007/dillinger-et-al/code/table-guard.cert : acl2x = 0
-workshops/2007/dillinger-et-al/code/table-guard.cert : no_pcert = 0
-
-workshops/2007/dillinger-et-al/code/table-guard.cert : \
- workshops/2007/dillinger-et-al/code/defcode.cert \
- workshops/2007/dillinger-et-al/code/redefun.cert \
- workshops/2007/dillinger-et-al/code/defcode.cert \
- workshops/2007/dillinger-et-al/code/redefun.cert \
- workshops/2007/dillinger-et-al/code/table-guard.lisp \
- workshops/2007/dillinger-et-al/code/table-guard.acl2
-
-
-workshops/2007/erickson/bprove/bash.cert : acl2x = 0
-workshops/2007/erickson/bprove/bash.cert : no_pcert = 0
-
-workshops/2007/erickson/bprove/bash.cert : \
- workshops/2007/erickson/bprove/bash.lisp
-
-
-workshops/2007/erickson/bprove/exdefs.cert : acl2x = 0
-workshops/2007/erickson/bprove/exdefs.cert : no_pcert = 0
-
-workshops/2007/erickson/bprove/exdefs.cert : \
- workshops/2007/erickson/bprove/lemgen.cert \
- workshops/2007/erickson/bprove/exdefs.lisp
-
-
-workshops/2007/erickson/bprove/gen.cert : acl2x = 0
-workshops/2007/erickson/bprove/gen.cert : no_pcert = 0
-
-workshops/2007/erickson/bprove/gen.cert : \
- workshops/2007/erickson/bprove/gen.lisp
-
-
-workshops/2007/erickson/bprove/lemgen.cert : acl2x = 0
-workshops/2007/erickson/bprove/lemgen.cert : no_pcert = 0
-
-workshops/2007/erickson/bprove/lemgen.cert : \
- workshops/2007/erickson/bprove/refute.cert \
- workshops/2007/erickson/bprove/gen.cert \
- workshops/2007/erickson/bprove/lemgen.lisp
-
-
-workshops/2007/erickson/bprove/refute.cert : acl2x = 0
-workshops/2007/erickson/bprove/refute.cert : no_pcert = 0
-
-workshops/2007/erickson/bprove/refute.cert : \
- workshops/2007/erickson/bprove/bash.cert \
- workshops/2007/erickson/bprove/refute.lisp
-
-
-workshops/2007/rimlinger/support/Rimlinger.cert : acl2x = 0
-workshops/2007/rimlinger/support/Rimlinger.cert : no_pcert = 0
-
-workshops/2007/rimlinger/support/Rimlinger.cert : \
- workshops/2007/rimlinger/support/Rimlinger.lisp
-
-
-workshops/2007/rubio/support/abstract-reductions/abstract-proofs.cert : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/abstract-proofs.cert : no_pcert = 0
-
-workshops/2007/rubio/support/abstract-reductions/abstract-proofs.cert : \
- data-structures/structures.cert \
- workshops/2007/rubio/support/abstract-reductions/abstract-proofs.lisp
-
-
-workshops/2007/rubio/support/abstract-reductions/confluence.cert : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/confluence.cert : no_pcert = 0
-
-workshops/2007/rubio/support/abstract-reductions/confluence.cert : \
- workshops/2007/rubio/support/abstract-reductions/abstract-proofs.cert \
- workshops/2007/rubio/support/abstract-reductions/confluence.lisp \
- workshops/2007/rubio/support/abstract-reductions/confluence.acl2
-
-
-workshops/2007/rubio/support/abstract-reductions/convergent.cert : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/convergent.cert : no_pcert = 0
-
-workshops/2007/rubio/support/abstract-reductions/convergent.cert : \
- workshops/2007/rubio/support/abstract-reductions/confluence.cert \
- workshops/2007/rubio/support/abstract-reductions/newman.cert \
- workshops/2007/rubio/support/abstract-reductions/convergent.lisp \
- workshops/2007/rubio/support/abstract-reductions/convergent.acl2
-
-
-workshops/2007/rubio/support/abstract-reductions/newman.cert : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/newman.cert : no_pcert = 0
-
-workshops/2007/rubio/support/abstract-reductions/newman.cert : \
- workshops/2007/rubio/support/multisets/defmul.cert \
- workshops/2007/rubio/support/abstract-reductions/abstract-proofs.cert \
- workshops/2007/rubio/support/abstract-reductions/newman.lisp \
- workshops/2007/rubio/support/abstract-reductions/newman.acl2
-
-
-workshops/2007/rubio/support/multisets/defmul.cert : acl2x = 0
-workshops/2007/rubio/support/multisets/defmul.cert : no_pcert = 0
-
-workshops/2007/rubio/support/multisets/defmul.cert : \
- workshops/2007/rubio/support/multisets/multiset.cert \
- workshops/2007/rubio/support/multisets/defmul.lisp \
- workshops/2007/rubio/support/multisets/defmul.acl2
-
-
-workshops/2007/rubio/support/multisets/multiset.cert : acl2x = 0
-workshops/2007/rubio/support/multisets/multiset.cert : no_pcert = 0
-
-workshops/2007/rubio/support/multisets/multiset.cert : \
- ordinals/e0-ordinal.cert \
- workshops/2007/rubio/support/multisets/multiset.lisp \
- workshops/2007/rubio/support/multisets/multiset.acl2
-
-
-workshops/2007/rubio/support/simplicial-topology/generate-degenerate.cert : acl2x = 0
-workshops/2007/rubio/support/simplicial-topology/generate-degenerate.cert : no_pcert = 0
-
-workshops/2007/rubio/support/simplicial-topology/generate-degenerate.cert : \
- workshops/2007/rubio/support/abstract-reductions/convergent.cert \
- arithmetic/top-with-meta.cert \
- workshops/2007/rubio/support/simplicial-topology/generate-degenerate.lisp \
- workshops/2007/rubio/support/simplicial-topology/generate-degenerate.acl2
-
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.cert : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.cert : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.cert : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.cert : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.cert : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.cert : \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- textbook/chap11/qsort.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.cert : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.cert : \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- arithmetic-3/bind-free/top.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.cert : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.cert : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.cert : \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.cert : \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.cert : \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.cert : \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.cert : \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.cert : \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.cert \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.cert : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.cert \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.cert : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.cert : \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.lisp
-
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.cert : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.cert : no_pcert = 0
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.cert : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.cert \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.lisp
-
-
-workshops/2009/fraij-roach/support/functions.cert : acl2x = 0
-workshops/2009/fraij-roach/support/functions.cert : no_pcert = 0
-
-workshops/2009/fraij-roach/support/functions.cert : \
- ordinals/lexicographic-ordering.cert \
- workshops/2009/fraij-roach/support/functions.lisp
-
-
-workshops/2009/fraij-roach/support/theorems.cert : acl2x = 0
-workshops/2009/fraij-roach/support/theorems.cert : no_pcert = 0
-
-workshops/2009/fraij-roach/support/theorems.cert : \
- workshops/2009/fraij-roach/support/functions.cert \
- workshops/2009/fraij-roach/support/theorems.lisp
-
-
-workshops/2009/hardin/deque-stobj/deque-stobj.cert : acl2x = 0
-workshops/2009/hardin/deque-stobj/deque-stobj.cert : no_pcert = 0
-
-workshops/2009/hardin/deque-stobj/deque-stobj.cert : \
- workshops/2009/hardin/deque-stobj/deque-stobj.lisp
-
-
-workshops/2009/hardin/deque-stobj/deque-thms.cert : acl2x = 0
-workshops/2009/hardin/deque-stobj/deque-thms.cert : no_pcert = 0
-
-workshops/2009/hardin/deque-stobj/deque-thms.cert : \
- workshops/2009/hardin/deque-stobj/deque-stobj.cert \
- arithmetic-5/top.cert \
- workshops/2009/hardin/deque-stobj/deque-thms.lisp
-
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.cert : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.cert : no_pcert = 0
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.cert : \
- workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.lisp \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.acl2
-
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.cert : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.cert : no_pcert = 0
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.cert : \
- workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.lisp \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.acl2
-
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.cert : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.cert : no_pcert = 0
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.cert : \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.lisp
-
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.cert : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.cert : no_pcert = 0
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.cert : \
- defexec/other-apps/records/records.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.lisp
-
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.cert : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.cert : no_pcert = 0
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.cert : \
- defexec/other-apps/records/records.cert \
- defexec/other-apps/records/records.cert \
- workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.lisp \
- workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.acl2
-
-
-workshops/2009/liu/support/error-analysis-tool3.cert : acl2x = 0
-workshops/2009/liu/support/error-analysis-tool3.cert : no_pcert = 0
-
-workshops/2009/liu/support/error-analysis-tool3.cert : \
- rtl/rel8/arithmetic/top.cert \
- workshops/2009/liu/support/mylet.cert \
- workshops/2009/liu/support/error-analysis-tool3.lisp
-
-
-workshops/2009/liu/support/mylet.cert : acl2x = 0
-workshops/2009/liu/support/mylet.cert : no_pcert = 0
-
-workshops/2009/liu/support/mylet.cert : \
- workshops/2009/liu/support/mylet.lisp
-
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.cert : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.cert : no_pcert = 0
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.cert : \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.lisp
-
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.cert : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.cert : no_pcert = 0
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.cert : \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.lisp
-
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.cert : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.cert : no_pcert = 0
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.cert : \
- arithmetic-3/top.cert \
- make-event/defspec.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.lisp
-
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.cert : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.cert : no_pcert = 0
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.cert : \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.lisp
-
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.cert : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.cert : no_pcert = 0
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.cert : \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.lisp
-
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.cert : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.cert : no_pcert = 0
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.cert : \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.cert \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.lisp
-
-
-workshops/2009/sumners/support/kas.cert : acl2x = 0
-workshops/2009/sumners/support/kas.cert : no_pcert = 0
-
-workshops/2009/sumners/support/kas.cert : \
- workshops/2009/sumners/support/kas.lisp \
- workshops/2009/sumners/support/kas.acl2
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.cert : \
- make-event/defspec.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.cert : \
- make-event/defspec.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.cert : \
- make-event/defspec.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.cert : \
- make-event/defspec.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.cert : \
- make-event/defspec.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.cert : \
- make-event/defspec.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.lisp
-
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.cert : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.cert : no_pcert = 0
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.cert : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.cert \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.cert : \
- make-event/defspec.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.cert \
- make-event/defspec.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.cert : \
- make-event/defspec.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.cert \
- make-event/defspec.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.cert : \
- make-event/defspec.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.cert : \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.cert : \
- ordinals/lexicographic-ordering.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.cert : \
- make-event/defspec.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.cert : \
- make-event/defspec.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.cert \
- ordinals/lexicographic-ordering.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.cert : \
- ordinals/lexicographic-ordering.cert \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.cert \
- arithmetic-3/bind-free/top.cert \
- arithmetic-3/floor-mod/floor-mod.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.cert : \
- data-structures/list-defuns.cert \
- data-structures/list-defthms.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.lisp
-
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.cert : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.cert : no_pcert = 0
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.cert : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.cert \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.lisp
-
-
-workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.cert : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.cert : no_pcert = 0
-
-workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.cert : \
- arithmetic-3/top.cert \
- workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.lisp
-
-
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.cert : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.cert : no_pcert = 0
-
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.cert : \
- arithmetic-3/top.cert \
- workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.lisp
-
-
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.cert : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.cert : no_pcert = 0
-
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.cert : \
- arithmetic-3/top.cert \
- workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.lisp
-
-
-workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.cert : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.cert : no_pcert = 0
-
-workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.cert : \
- arithmetic-3/top.cert \
- data-structures/utilities.cert \
- workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.lisp \
- workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.acl2
-
-
-wp-gen/mutrec/mutrec.cert : acl2x = 0
-wp-gen/mutrec/mutrec.cert : no_pcert = 0
-
-wp-gen/mutrec/mutrec.cert : \
- ordinals/lexicographic-ordering.cert \
- wp-gen/mutrec/mutrec.lisp
-
-
-wp-gen/shared.cert : acl2x = 0
-wp-gen/shared.cert : no_pcert = 0
-
-wp-gen/shared.cert : \
- wp-gen/shared.lisp
-
-
-wp-gen/wp-gen.cert : acl2x = 0
-wp-gen/wp-gen.cert : no_pcert = 0
-
-wp-gen/wp-gen.cert : \
- wp-gen/shared.cert \
- wp-gen/mutrec/mutrec.cert \
- wp-gen/wp-gen.lisp \
- wp-gen/wp-gen.acl2
-
-
-xdoc-impl/autolink.cert : acl2x = 0
-xdoc-impl/autolink.cert : no_pcert = 0
-
-xdoc-impl/autolink.cert : \
- xdoc-impl/fmt-to-str.cert \
- xdoc/names.cert \
- misc/assert.cert \
- xdoc-impl/portcullis.cert \
- xdoc-impl/autolink.lisp \
- xdoc-impl/cert.acl2
-
-
-xdoc-impl/extra-packages.cert : acl2x = 0
-xdoc-impl/extra-packages.cert : no_pcert = 0
-
-xdoc-impl/extra-packages.cert : \
- xdoc-impl/portcullis.cert \
- xdoc-impl/extra-packages.lisp \
- xdoc-impl/extra-packages.acl2 \
- xdoc-impl/cert.acl2 \
- cowles/packages.lsp \
- clause-processors/SULFA/books/sat/sat-package.acl2 \
- data-structures/define-u-package.lsp \
- data-structures/define-structures-package.lsp \
- data-structures/memories/package.lsp \
- hacking/hacker-pkg.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- tools/flag-package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-
-
-xdoc-impl/fmt-to-str.cert : acl2x = 0
-xdoc-impl/fmt-to-str.cert : no_pcert = 0
-
-xdoc-impl/fmt-to-str.cert : \
- tools/bstar.cert \
- xdoc-impl/portcullis.cert \
- xdoc-impl/fmt-to-str.lisp \
- xdoc-impl/cert.acl2
-
-
-xdoc-impl/import-acl2doc.cert : acl2x = 0
-xdoc-impl/import-acl2doc.cert : no_pcert = 0
-
-xdoc-impl/import-acl2doc.cert : \
- xdoc-impl/write-acl2-xdoc.cert \
- xdoc/base.cert \
- tools/bstar.cert \
- xdoc-impl/portcullis.cert \
- xdoc-impl/import-acl2doc.lisp \
- xdoc-impl/cert.acl2
-
-
-xdoc-impl/mkdir-raw.cert : acl2x = 0
-xdoc-impl/mkdir-raw.cert : no_pcert = 0
-
-xdoc-impl/mkdir-raw.cert : \
- xdoc-impl/mkdir.cert \
- tools/bstar.cert \
- xdoc-impl/portcullis.cert \
- xdoc-impl/mkdir-raw.lisp \
- xdoc-impl/mkdir-raw.acl2 \
- xdoc-impl/cert.acl2
-
-
-xdoc-impl/mkdir.cert : acl2x = 0
-xdoc-impl/mkdir.cert : no_pcert = 0
-
-xdoc-impl/mkdir.cert : \
- xdoc-impl/portcullis.cert \
- xdoc-impl/mkdir.lisp \
- xdoc-impl/cert.acl2
-
-
-xdoc-impl/parse-xml.cert : acl2x = 0
-xdoc-impl/parse-xml.cert : no_pcert = 0
-
-xdoc-impl/parse-xml.cert : \
- xdoc-impl/preprocess.cert \
- xdoc-impl/portcullis.cert \
- xdoc-impl/parse-xml.lisp \
- xdoc-impl/cert.acl2
-
-
-xdoc-impl/portcullis.cert : acl2x = 0
-xdoc-impl/portcullis.cert : no_pcert = 0
-
-xdoc-impl/portcullis.cert : \
- xdoc-impl/portcullis.lisp \
- xdoc-impl/portcullis.acl2 \
- xdoc/package.lsp \
- str/package.lsp \
- xdoc/package.lsp
-
-
-xdoc-impl/preprocess.cert : acl2x = 0
-xdoc-impl/preprocess.cert : no_pcert = 0
-
-xdoc-impl/preprocess.cert : \
- xdoc-impl/autolink.cert \
- str/top.cert \
- misc/assert.cert \
- xdoc-impl/portcullis.cert \
- xdoc-impl/preprocess.lisp \
- xdoc-impl/cert.acl2
-
-
-xdoc-impl/save.cert : acl2x = 0
-xdoc-impl/save.cert : no_pcert = 0
-
-xdoc-impl/save.cert : \
- xdoc-impl/mkdir.cert \
- xdoc/base.cert \
- xdoc-impl/preprocess.cert \
- xdoc-impl/parse-xml.cert \
- xdoc-impl/sort.cert \
- xdoc-impl/portcullis.cert \
- xdoc-impl/save.lisp \
- xdoc-impl/cert.acl2
-
-
-xdoc-impl/sort.cert : acl2x = 0
-xdoc-impl/sort.cert : no_pcert = 0
-
-xdoc-impl/sort.cert : \
- xdoc-impl/portcullis.cert \
- xdoc-impl/sort.lisp \
- xdoc-impl/cert.acl2
-
-
-xdoc-impl/topics.cert : acl2x = 0
-xdoc-impl/topics.cert : no_pcert = 0
-
-xdoc-impl/topics.cert : \
- xdoc-impl/import-acl2doc.cert \
- xdoc-impl/portcullis.cert \
- xdoc-impl/topics.lisp \
- xdoc-impl/cert.acl2
-
-
-xdoc-impl/write-acl2-xdoc.cert : acl2x = 0
-xdoc-impl/write-acl2-xdoc.cert : no_pcert = 0
-
-xdoc-impl/write-acl2-xdoc.cert : \
- xdoc-impl/portcullis.cert \
- xdoc-impl/write-acl2-xdoc.lisp \
- xdoc-impl/cert.acl2
-
-
-xdoc/base.cert : acl2x = 0
-xdoc/base.cert : no_pcert = 0
-
-xdoc/base.cert : \
- xdoc/portcullis.cert \
- xdoc/base.lisp \
- xdoc/cert.acl2
-
-
-xdoc/book-thms.cert : acl2x = 0
-xdoc/book-thms.cert : no_pcert = 0
-
-xdoc/book-thms.cert : \
- xdoc/portcullis.cert \
- xdoc/book-thms.lisp \
- xdoc/cert.acl2
-
-
-xdoc/defxdoc-raw.cert : acl2x = 0
-xdoc/defxdoc-raw.cert : no_pcert = 0
-
-xdoc/defxdoc-raw.cert : \
- xdoc/base.cert \
- xdoc/portcullis.cert \
- xdoc/defxdoc-raw.lisp \
- xdoc/defxdoc-raw.acl2
-
-
-xdoc/names.cert : acl2x = 0
-xdoc/names.cert : no_pcert = 0
-
-xdoc/names.cert : \
- xdoc/base.cert \
- xdoc/portcullis.cert \
- xdoc/names.lisp \
- xdoc/cert.acl2
-
-
-xdoc/portcullis.cert : acl2x = 0
-xdoc/portcullis.cert : no_pcert = 0
-
-xdoc/portcullis.cert : \
- xdoc/portcullis.lisp \
- xdoc/portcullis.acl2 \
- xdoc/package.lsp
-
-
-xdoc/top.cert : acl2x = 0
-xdoc/top.cert : no_pcert = 0
-
-xdoc/top.cert : \
- xdoc/base.cert \
- xdoc/book-thms.cert \
- xdoc/portcullis.cert \
- xdoc/top.lisp \
- xdoc/cert.acl2
-
-
-ifneq ($(ACL2_PCERT),)
-
-arithmetic-2/floor-mod/floor-mod-helper.pcert0 : no_pcert = 0
-arithmetic-2/floor-mod/floor-mod-helper.pcert0 : acl2x = 0
-arithmetic-2/floor-mod/floor-mod-helper.pcert0 : \
- arithmetic-2/meta/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- arithmetic-2/floor-mod/floor-mod-helper.lisp
-arithmetic-2/floor-mod/floor-mod-helper.pcert1 : acl2x = 0
-arithmetic-2/floor-mod/floor-mod-helper.pcert1 : no_pcert = 0
-arithmetic-2/floor-mod/floor-mod-helper.pcert1 : arithmetic-2/floor-mod/floor-mod-helper.pcert0
-arithmetic-2/floor-mod/floor-mod-helper.cert : | arithmetic-2/floor-mod/floor-mod-helper.pcert1
-
-arithmetic-2/floor-mod/floor-mod.pcert0 : no_pcert = 0
-arithmetic-2/floor-mod/floor-mod.pcert0 : acl2x = 0
-arithmetic-2/floor-mod/floor-mod.pcert0 : \
- arithmetic-2/floor-mod/floor-mod-helper.pcert0 \
- arithmetic-2/floor-mod/floor-mod.lisp
-arithmetic-2/floor-mod/floor-mod.pcert1 : acl2x = 0
-arithmetic-2/floor-mod/floor-mod.pcert1 : no_pcert = 0
-arithmetic-2/floor-mod/floor-mod.pcert1 : arithmetic-2/floor-mod/floor-mod.pcert0
-arithmetic-2/floor-mod/floor-mod.cert : | arithmetic-2/floor-mod/floor-mod.pcert1
-
-arithmetic-2/meta/cancel-terms-helper.pcert0 : no_pcert = 0
-arithmetic-2/meta/cancel-terms-helper.pcert0 : acl2x = 0
-arithmetic-2/meta/cancel-terms-helper.pcert0 : \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/cancel-terms-helper.lisp
-arithmetic-2/meta/cancel-terms-helper.pcert1 : acl2x = 0
-arithmetic-2/meta/cancel-terms-helper.pcert1 : no_pcert = 0
-arithmetic-2/meta/cancel-terms-helper.pcert1 : arithmetic-2/meta/cancel-terms-helper.pcert0
-arithmetic-2/meta/cancel-terms-helper.cert : | arithmetic-2/meta/cancel-terms-helper.pcert1
-
-arithmetic-2/meta/cancel-terms-meta.pcert0 : no_pcert = 0
-arithmetic-2/meta/cancel-terms-meta.pcert0 : acl2x = 0
-arithmetic-2/meta/cancel-terms-meta.pcert0 : \
- arithmetic-2/meta/common-meta.pcert0 \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/cancel-terms-helper.pcert0 \
- arithmetic-2/meta/cancel-terms-meta.lisp
-arithmetic-2/meta/cancel-terms-meta.pcert1 : acl2x = 0
-arithmetic-2/meta/cancel-terms-meta.pcert1 : no_pcert = 0
-arithmetic-2/meta/cancel-terms-meta.pcert1 : arithmetic-2/meta/cancel-terms-meta.pcert0
-arithmetic-2/meta/cancel-terms-meta.cert : | arithmetic-2/meta/cancel-terms-meta.pcert1
-
-arithmetic-2/meta/collect-terms-meta.pcert0 : no_pcert = 0
-arithmetic-2/meta/collect-terms-meta.pcert0 : acl2x = 0
-arithmetic-2/meta/collect-terms-meta.pcert0 : \
- arithmetic-2/meta/common-meta.pcert0 \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/collect-terms-meta.lisp
-arithmetic-2/meta/collect-terms-meta.pcert1 : acl2x = 0
-arithmetic-2/meta/collect-terms-meta.pcert1 : no_pcert = 0
-arithmetic-2/meta/collect-terms-meta.pcert1 : arithmetic-2/meta/collect-terms-meta.pcert0
-arithmetic-2/meta/collect-terms-meta.cert : | arithmetic-2/meta/collect-terms-meta.pcert1
-
-arithmetic-2/meta/common-meta.pcert0 : no_pcert = 0
-arithmetic-2/meta/common-meta.pcert0 : acl2x = 0
-arithmetic-2/meta/common-meta.pcert0 : \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/common-meta.lisp
-arithmetic-2/meta/common-meta.pcert1 : acl2x = 0
-arithmetic-2/meta/common-meta.pcert1 : no_pcert = 0
-arithmetic-2/meta/common-meta.pcert1 : arithmetic-2/meta/common-meta.pcert0
-arithmetic-2/meta/common-meta.cert : | arithmetic-2/meta/common-meta.pcert1
-
-arithmetic-2/meta/expt-helper.pcert0 : no_pcert = 0
-arithmetic-2/meta/expt-helper.pcert0 : acl2x = 0
-arithmetic-2/meta/expt-helper.pcert0 : \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/expt-helper.lisp
-arithmetic-2/meta/expt-helper.pcert1 : acl2x = 0
-arithmetic-2/meta/expt-helper.pcert1 : no_pcert = 0
-arithmetic-2/meta/expt-helper.pcert1 : arithmetic-2/meta/expt-helper.pcert0
-arithmetic-2/meta/expt-helper.cert : | arithmetic-2/meta/expt-helper.pcert1
-
-arithmetic-2/meta/expt.pcert0 : no_pcert = 0
-arithmetic-2/meta/expt.pcert0 : acl2x = 0
-arithmetic-2/meta/expt.pcert0 : \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/expt-helper.pcert0 \
- arithmetic-2/meta/expt.lisp
-arithmetic-2/meta/expt.pcert1 : acl2x = 0
-arithmetic-2/meta/expt.pcert1 : no_pcert = 0
-arithmetic-2/meta/expt.pcert1 : arithmetic-2/meta/expt.pcert0
-arithmetic-2/meta/expt.cert : | arithmetic-2/meta/expt.pcert1
-
-arithmetic-2/meta/integerp-meta.pcert0 : no_pcert = 0
-arithmetic-2/meta/integerp-meta.pcert0 : acl2x = 0
-arithmetic-2/meta/integerp-meta.pcert0 : \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/integerp-meta.lisp
-arithmetic-2/meta/integerp-meta.pcert1 : acl2x = 0
-arithmetic-2/meta/integerp-meta.pcert1 : no_pcert = 0
-arithmetic-2/meta/integerp-meta.pcert1 : arithmetic-2/meta/integerp-meta.pcert0
-arithmetic-2/meta/integerp-meta.cert : | arithmetic-2/meta/integerp-meta.pcert1
-
-arithmetic-2/meta/integerp.pcert0 : no_pcert = 0
-arithmetic-2/meta/integerp.pcert0 : acl2x = 0
-arithmetic-2/meta/integerp.pcert0 : \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/integerp.lisp
-arithmetic-2/meta/integerp.pcert1 : acl2x = 0
-arithmetic-2/meta/integerp.pcert1 : no_pcert = 0
-arithmetic-2/meta/integerp.pcert1 : arithmetic-2/meta/integerp.pcert0
-arithmetic-2/meta/integerp.cert : | arithmetic-2/meta/integerp.pcert1
-
-arithmetic-2/meta/mini-theories.pcert0 : no_pcert = 0
-arithmetic-2/meta/mini-theories.pcert0 : acl2x = 0
-arithmetic-2/meta/mini-theories.pcert0 : \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/mini-theories.lisp
-arithmetic-2/meta/mini-theories.pcert1 : acl2x = 0
-arithmetic-2/meta/mini-theories.pcert1 : no_pcert = 0
-arithmetic-2/meta/mini-theories.pcert1 : arithmetic-2/meta/mini-theories.pcert0
-arithmetic-2/meta/mini-theories.cert : | arithmetic-2/meta/mini-theories.pcert1
-
-arithmetic-2/meta/non-linear.pcert0 : no_pcert = 0
-arithmetic-2/meta/non-linear.pcert0 : acl2x = 0
-arithmetic-2/meta/non-linear.pcert0 : \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/cancel-terms-helper.pcert0 \
- arithmetic-2/meta/non-linear.lisp
-arithmetic-2/meta/non-linear.pcert1 : acl2x = 0
-arithmetic-2/meta/non-linear.pcert1 : no_pcert = 0
-arithmetic-2/meta/non-linear.pcert1 : arithmetic-2/meta/non-linear.pcert0
-arithmetic-2/meta/non-linear.cert : | arithmetic-2/meta/non-linear.pcert1
-
-arithmetic-2/meta/numerator-and-denominator.pcert0 : no_pcert = 0
-arithmetic-2/meta/numerator-and-denominator.pcert0 : acl2x = 0
-arithmetic-2/meta/numerator-and-denominator.pcert0 : \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/numerator-and-denominator.lisp
-arithmetic-2/meta/numerator-and-denominator.pcert1 : acl2x = 0
-arithmetic-2/meta/numerator-and-denominator.pcert1 : no_pcert = 0
-arithmetic-2/meta/numerator-and-denominator.pcert1 : arithmetic-2/meta/numerator-and-denominator.pcert0
-arithmetic-2/meta/numerator-and-denominator.cert : | arithmetic-2/meta/numerator-and-denominator.pcert1
-
-arithmetic-2/meta/post.pcert0 : no_pcert = 0
-arithmetic-2/meta/post.pcert0 : acl2x = 0
-arithmetic-2/meta/post.pcert0 : \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/post.lisp
-arithmetic-2/meta/post.pcert1 : acl2x = 0
-arithmetic-2/meta/post.pcert1 : no_pcert = 0
-arithmetic-2/meta/post.pcert1 : arithmetic-2/meta/post.pcert0
-arithmetic-2/meta/post.cert : | arithmetic-2/meta/post.pcert1
-
-arithmetic-2/meta/pre.pcert0 : no_pcert = 0
-arithmetic-2/meta/pre.pcert0 : acl2x = 0
-arithmetic-2/meta/pre.pcert0 : \
- arithmetic-2/pass1/top.pcert0 \
- arithmetic-2/meta/pre.lisp
-arithmetic-2/meta/pre.pcert1 : acl2x = 0
-arithmetic-2/meta/pre.pcert1 : no_pcert = 0
-arithmetic-2/meta/pre.pcert1 : arithmetic-2/meta/pre.pcert0
-arithmetic-2/meta/pre.cert : | arithmetic-2/meta/pre.pcert1
-
-arithmetic-2/meta/top.pcert0 : no_pcert = 0
-arithmetic-2/meta/top.pcert0 : acl2x = 0
-arithmetic-2/meta/top.pcert0 : \
- arithmetic-2/meta/pre.pcert0 \
- arithmetic-2/meta/integerp.pcert0 \
- arithmetic-2/meta/integerp-meta.pcert0 \
- arithmetic-2/meta/cancel-terms-meta.pcert0 \
- arithmetic-2/meta/collect-terms-meta.pcert0 \
- arithmetic-2/meta/numerator-and-denominator.pcert0 \
- arithmetic-2/meta/expt.pcert0 \
- arithmetic-2/meta/non-linear.pcert0 \
- arithmetic-2/meta/mini-theories.pcert0 \
- arithmetic-2/meta/post.pcert0 \
- arithmetic-2/meta/top.lisp
-arithmetic-2/meta/top.pcert1 : acl2x = 0
-arithmetic-2/meta/top.pcert1 : no_pcert = 0
-arithmetic-2/meta/top.pcert1 : arithmetic-2/meta/top.pcert0
-arithmetic-2/meta/top.cert : | arithmetic-2/meta/top.pcert1
-
-arithmetic-2/pass1/basic-arithmetic-helper.pcert0 : no_pcert = 0
-arithmetic-2/pass1/basic-arithmetic-helper.pcert0 : acl2x = 0
-arithmetic-2/pass1/basic-arithmetic-helper.pcert0 : \
- arithmetic-2/pass1/basic-arithmetic-helper.lisp
-arithmetic-2/pass1/basic-arithmetic-helper.pcert1 : acl2x = 0
-arithmetic-2/pass1/basic-arithmetic-helper.pcert1 : no_pcert = 0
-arithmetic-2/pass1/basic-arithmetic-helper.pcert1 : arithmetic-2/pass1/basic-arithmetic-helper.pcert0
-arithmetic-2/pass1/basic-arithmetic-helper.cert : | arithmetic-2/pass1/basic-arithmetic-helper.pcert1
-
-arithmetic-2/pass1/basic-arithmetic.pcert0 : no_pcert = 0
-arithmetic-2/pass1/basic-arithmetic.pcert0 : acl2x = 0
-arithmetic-2/pass1/basic-arithmetic.pcert0 : \
- arithmetic-2/pass1/basic-arithmetic-helper.pcert0 \
- arithmetic-2/pass1/basic-arithmetic.lisp
-arithmetic-2/pass1/basic-arithmetic.pcert1 : acl2x = 0
-arithmetic-2/pass1/basic-arithmetic.pcert1 : no_pcert = 0
-arithmetic-2/pass1/basic-arithmetic.pcert1 : arithmetic-2/pass1/basic-arithmetic.pcert0
-arithmetic-2/pass1/basic-arithmetic.cert : | arithmetic-2/pass1/basic-arithmetic.pcert1
-
-arithmetic-2/pass1/expt-helper.pcert0 : no_pcert = 0
-arithmetic-2/pass1/expt-helper.pcert0 : acl2x = 0
-arithmetic-2/pass1/expt-helper.pcert0 : \
- arithmetic-2/pass1/basic-arithmetic.pcert0 \
- arithmetic-2/pass1/inequalities.pcert0 \
- arithmetic-2/pass1/prefer-times.pcert0 \
- arithmetic-2/pass1/expt-helper.lisp
-arithmetic-2/pass1/expt-helper.pcert1 : acl2x = 0
-arithmetic-2/pass1/expt-helper.pcert1 : no_pcert = 0
-arithmetic-2/pass1/expt-helper.pcert1 : arithmetic-2/pass1/expt-helper.pcert0
-arithmetic-2/pass1/expt-helper.cert : | arithmetic-2/pass1/expt-helper.pcert1
-
-arithmetic-2/pass1/expt.pcert0 : no_pcert = 0
-arithmetic-2/pass1/expt.pcert0 : acl2x = 0
-arithmetic-2/pass1/expt.pcert0 : \
- arithmetic-2/pass1/basic-arithmetic.pcert0 \
- arithmetic-2/pass1/inequalities.pcert0 \
- arithmetic-2/pass1/prefer-times.pcert0 \
- arithmetic-2/pass1/expt-helper.pcert0 \
- arithmetic-2/pass1/expt.lisp
-arithmetic-2/pass1/expt.pcert1 : acl2x = 0
-arithmetic-2/pass1/expt.pcert1 : no_pcert = 0
-arithmetic-2/pass1/expt.pcert1 : arithmetic-2/pass1/expt.pcert0
-arithmetic-2/pass1/expt.cert : | arithmetic-2/pass1/expt.pcert1
-
-arithmetic-2/pass1/inequalities.pcert0 : no_pcert = 0
-arithmetic-2/pass1/inequalities.pcert0 : acl2x = 0
-arithmetic-2/pass1/inequalities.pcert0 : \
- arithmetic-2/pass1/basic-arithmetic.pcert0 \
- arithmetic-2/pass1/inequalities.lisp
-arithmetic-2/pass1/inequalities.pcert1 : acl2x = 0
-arithmetic-2/pass1/inequalities.pcert1 : no_pcert = 0
-arithmetic-2/pass1/inequalities.pcert1 : arithmetic-2/pass1/inequalities.pcert0
-arithmetic-2/pass1/inequalities.cert : | arithmetic-2/pass1/inequalities.pcert1
-
-arithmetic-2/pass1/mini-theories.pcert0 : no_pcert = 0
-arithmetic-2/pass1/mini-theories.pcert0 : acl2x = 0
-arithmetic-2/pass1/mini-theories.pcert0 : \
- arithmetic-2/pass1/basic-arithmetic.pcert0 \
- arithmetic-2/pass1/inequalities.pcert0 \
- arithmetic-2/pass1/prefer-times.pcert0 \
- arithmetic-2/pass1/expt.pcert0 \
- arithmetic-2/pass1/mini-theories.lisp
-arithmetic-2/pass1/mini-theories.pcert1 : acl2x = 0
-arithmetic-2/pass1/mini-theories.pcert1 : no_pcert = 0
-arithmetic-2/pass1/mini-theories.pcert1 : arithmetic-2/pass1/mini-theories.pcert0
-arithmetic-2/pass1/mini-theories.cert : | arithmetic-2/pass1/mini-theories.pcert1
-
-arithmetic-2/pass1/numerator-and-denominator-helper.pcert0 : no_pcert = 0
-arithmetic-2/pass1/numerator-and-denominator-helper.pcert0 : acl2x = 0
-arithmetic-2/pass1/numerator-and-denominator-helper.pcert0 : \
- arithmetic-2/pass1/basic-arithmetic.pcert0 \
- arithmetic-2/pass1/inequalities.pcert0 \
- arithmetic-2/pass1/prefer-times.pcert0 \
- arithmetic-2/pass1/numerator-and-denominator-helper.lisp
-arithmetic-2/pass1/numerator-and-denominator-helper.pcert1 : acl2x = 0
-arithmetic-2/pass1/numerator-and-denominator-helper.pcert1 : no_pcert = 0
-arithmetic-2/pass1/numerator-and-denominator-helper.pcert1 : arithmetic-2/pass1/numerator-and-denominator-helper.pcert0
-arithmetic-2/pass1/numerator-and-denominator-helper.cert : | arithmetic-2/pass1/numerator-and-denominator-helper.pcert1
-
-arithmetic-2/pass1/numerator-and-denominator.pcert0 : no_pcert = 0
-arithmetic-2/pass1/numerator-and-denominator.pcert0 : acl2x = 0
-arithmetic-2/pass1/numerator-and-denominator.pcert0 : \
- arithmetic-2/pass1/basic-arithmetic.pcert0 \
- arithmetic-2/pass1/inequalities.pcert0 \
- arithmetic-2/pass1/prefer-times.pcert0 \
- arithmetic-2/pass1/numerator-and-denominator-helper.pcert0 \
- arithmetic-2/pass1/numerator-and-denominator.lisp
-arithmetic-2/pass1/numerator-and-denominator.pcert1 : acl2x = 0
-arithmetic-2/pass1/numerator-and-denominator.pcert1 : no_pcert = 0
-arithmetic-2/pass1/numerator-and-denominator.pcert1 : arithmetic-2/pass1/numerator-and-denominator.pcert0
-arithmetic-2/pass1/numerator-and-denominator.cert : | arithmetic-2/pass1/numerator-and-denominator.pcert1
-
-arithmetic-2/pass1/prefer-times.pcert0 : no_pcert = 0
-arithmetic-2/pass1/prefer-times.pcert0 : acl2x = 0
-arithmetic-2/pass1/prefer-times.pcert0 : \
- arithmetic-2/pass1/basic-arithmetic.pcert0 \
- arithmetic-2/pass1/inequalities.pcert0 \
- arithmetic-2/pass1/prefer-times.lisp
-arithmetic-2/pass1/prefer-times.pcert1 : acl2x = 0
-arithmetic-2/pass1/prefer-times.pcert1 : no_pcert = 0
-arithmetic-2/pass1/prefer-times.pcert1 : arithmetic-2/pass1/prefer-times.pcert0
-arithmetic-2/pass1/prefer-times.cert : | arithmetic-2/pass1/prefer-times.pcert1
-
-arithmetic-2/pass1/top.pcert0 : no_pcert = 0
-arithmetic-2/pass1/top.pcert0 : acl2x = 0
-arithmetic-2/pass1/top.pcert0 : \
- arithmetic-2/pass1/basic-arithmetic.pcert0 \
- arithmetic-2/pass1/inequalities.pcert0 \
- arithmetic-2/pass1/expt.pcert0 \
- arithmetic-2/pass1/prefer-times.pcert0 \
- arithmetic-2/pass1/mini-theories.pcert0 \
- arithmetic-2/pass1/numerator-and-denominator.pcert0 \
- arithmetic-2/pass1/top.lisp
-arithmetic-2/pass1/top.pcert1 : acl2x = 0
-arithmetic-2/pass1/top.pcert1 : no_pcert = 0
-arithmetic-2/pass1/top.pcert1 : arithmetic-2/pass1/top.pcert0
-arithmetic-2/pass1/top.cert : | arithmetic-2/pass1/top.pcert1
-
-arithmetic-3/bind-free/arithmetic-theory.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/arithmetic-theory.pcert0 : acl2x = 0
-arithmetic-3/bind-free/arithmetic-theory.pcert0 : \
- arithmetic-3/bind-free/basic.pcert0 \
- arithmetic-3/bind-free/common.pcert0 \
- arithmetic-3/bind-free/building-blocks.pcert0 \
- arithmetic-3/bind-free/collect.pcert0 \
- arithmetic-3/bind-free/arithmetic-theory.lisp
-arithmetic-3/bind-free/arithmetic-theory.pcert1 : acl2x = 0
-arithmetic-3/bind-free/arithmetic-theory.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/arithmetic-theory.pcert1 : arithmetic-3/bind-free/arithmetic-theory.pcert0
-arithmetic-3/bind-free/arithmetic-theory.cert : | arithmetic-3/bind-free/arithmetic-theory.pcert1
-
-arithmetic-3/bind-free/banner.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/banner.pcert0 : acl2x = 0
-arithmetic-3/bind-free/banner.pcert0 : \
- arithmetic-3/bind-free/banner.lisp
-arithmetic-3/bind-free/banner.pcert1 : acl2x = 0
-arithmetic-3/bind-free/banner.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/banner.pcert1 : arithmetic-3/bind-free/banner.pcert0
-arithmetic-3/bind-free/banner.cert : | arithmetic-3/bind-free/banner.pcert1
-
-arithmetic-3/bind-free/basic-helper.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/basic-helper.pcert0 : acl2x = 0
-arithmetic-3/bind-free/basic-helper.pcert0 : \
- arithmetic-3/pass1/top.pcert0 \
- arithmetic-3/bind-free/default-hint.pcert0 \
- arithmetic-3/bind-free/basic-helper.lisp
-arithmetic-3/bind-free/basic-helper.pcert1 : acl2x = 0
-arithmetic-3/bind-free/basic-helper.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/basic-helper.pcert1 : arithmetic-3/bind-free/basic-helper.pcert0
-arithmetic-3/bind-free/basic-helper.cert : | arithmetic-3/bind-free/basic-helper.pcert1
-
-arithmetic-3/bind-free/basic.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/basic.pcert0 : acl2x = 0
-arithmetic-3/bind-free/basic.pcert0 : \
- arithmetic-3/pass1/top.pcert0 \
- arithmetic-3/bind-free/basic-helper.pcert0 \
- arithmetic-3/bind-free/building-blocks.pcert0 \
- arithmetic-3/bind-free/basic.lisp
-arithmetic-3/bind-free/basic.pcert1 : acl2x = 0
-arithmetic-3/bind-free/basic.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/basic.pcert1 : arithmetic-3/bind-free/basic.pcert0
-arithmetic-3/bind-free/basic.cert : | arithmetic-3/bind-free/basic.pcert1
-
-arithmetic-3/bind-free/building-blocks.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/building-blocks.pcert0 : acl2x = 0
-arithmetic-3/bind-free/building-blocks.pcert0 : \
- arithmetic-3/bind-free/building-blocks.lisp
-arithmetic-3/bind-free/building-blocks.pcert1 : acl2x = 0
-arithmetic-3/bind-free/building-blocks.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/building-blocks.pcert1 : arithmetic-3/bind-free/building-blocks.pcert0
-arithmetic-3/bind-free/building-blocks.cert : | arithmetic-3/bind-free/building-blocks.pcert1
-
-arithmetic-3/bind-free/collect.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/collect.pcert0 : acl2x = 0
-arithmetic-3/bind-free/collect.pcert0 : \
- arithmetic-3/pass1/top.pcert0 \
- arithmetic-3/bind-free/basic-helper.pcert0 \
- arithmetic-3/bind-free/collect.lisp
-arithmetic-3/bind-free/collect.pcert1 : acl2x = 0
-arithmetic-3/bind-free/collect.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/collect.pcert1 : arithmetic-3/bind-free/collect.pcert0
-arithmetic-3/bind-free/collect.cert : | arithmetic-3/bind-free/collect.pcert1
-
-arithmetic-3/bind-free/common.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/common.pcert0 : acl2x = 0
-arithmetic-3/bind-free/common.pcert0 : \
- arithmetic-3/pass1/top.pcert0 \
- arithmetic-3/bind-free/building-blocks.pcert0 \
- arithmetic-3/bind-free/common.lisp
-arithmetic-3/bind-free/common.pcert1 : acl2x = 0
-arithmetic-3/bind-free/common.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/common.pcert1 : arithmetic-3/bind-free/common.pcert0
-arithmetic-3/bind-free/common.cert : | arithmetic-3/bind-free/common.pcert1
-
-arithmetic-3/bind-free/default-hint.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/default-hint.pcert0 : acl2x = 0
-arithmetic-3/bind-free/default-hint.pcert0 : \
- arithmetic-3/bind-free/default-hint.lisp
-arithmetic-3/bind-free/default-hint.pcert1 : acl2x = 0
-arithmetic-3/bind-free/default-hint.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/default-hint.pcert1 : arithmetic-3/bind-free/default-hint.pcert0
-arithmetic-3/bind-free/default-hint.cert : | arithmetic-3/bind-free/default-hint.pcert1
-
-arithmetic-3/bind-free/integerp-meta.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/integerp-meta.pcert0 : acl2x = 0
-arithmetic-3/bind-free/integerp-meta.pcert0 : \
- arithmetic-3/pass1/top.pcert0 \
- arithmetic-3/bind-free/default-hint.pcert0 \
- arithmetic-3/bind-free/integerp-meta.lisp
-arithmetic-3/bind-free/integerp-meta.pcert1 : acl2x = 0
-arithmetic-3/bind-free/integerp-meta.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/integerp-meta.pcert1 : arithmetic-3/bind-free/integerp-meta.pcert0
-arithmetic-3/bind-free/integerp-meta.cert : | arithmetic-3/bind-free/integerp-meta.pcert1
-
-arithmetic-3/bind-free/integerp.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/integerp.pcert0 : acl2x = 0
-arithmetic-3/bind-free/integerp.pcert0 : \
- arithmetic-3/pass1/top.pcert0 \
- arithmetic-3/bind-free/building-blocks.pcert0 \
- arithmetic-3/bind-free/default-hint.pcert0 \
- arithmetic-3/bind-free/integerp.lisp
-arithmetic-3/bind-free/integerp.pcert1 : acl2x = 0
-arithmetic-3/bind-free/integerp.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/integerp.pcert1 : arithmetic-3/bind-free/integerp.pcert0
-arithmetic-3/bind-free/integerp.cert : | arithmetic-3/bind-free/integerp.pcert1
-
-arithmetic-3/bind-free/mini-theories-helper.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/mini-theories-helper.pcert0 : acl2x = 0
-arithmetic-3/bind-free/mini-theories-helper.pcert0 : \
- arithmetic-3/pass1/top.pcert0 \
- arithmetic-3/bind-free/default-hint.pcert0 \
- arithmetic-3/bind-free/mini-theories-helper.lisp
-arithmetic-3/bind-free/mini-theories-helper.pcert1 : acl2x = 0
-arithmetic-3/bind-free/mini-theories-helper.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/mini-theories-helper.pcert1 : arithmetic-3/bind-free/mini-theories-helper.pcert0
-arithmetic-3/bind-free/mini-theories-helper.cert : | arithmetic-3/bind-free/mini-theories-helper.pcert1
-
-arithmetic-3/bind-free/mini-theories.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/mini-theories.pcert0 : acl2x = 0
-arithmetic-3/bind-free/mini-theories.pcert0 : \
- arithmetic-3/bind-free/mini-theories-helper.pcert0 \
- arithmetic-3/bind-free/mini-theories.lisp
-arithmetic-3/bind-free/mini-theories.pcert1 : acl2x = 0
-arithmetic-3/bind-free/mini-theories.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/mini-theories.pcert1 : arithmetic-3/bind-free/mini-theories.pcert0
-arithmetic-3/bind-free/mini-theories.cert : | arithmetic-3/bind-free/mini-theories.pcert1
-
-arithmetic-3/bind-free/normalize.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/normalize.pcert0 : acl2x = 0
-arithmetic-3/bind-free/normalize.pcert0 : \
- arithmetic-3/bind-free/basic.pcert0 \
- arithmetic-3/bind-free/common.pcert0 \
- arithmetic-3/pass1/top.pcert0 \
- arithmetic-3/bind-free/normalize.lisp
-arithmetic-3/bind-free/normalize.pcert1 : acl2x = 0
-arithmetic-3/bind-free/normalize.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/normalize.pcert1 : arithmetic-3/bind-free/normalize.pcert0
-arithmetic-3/bind-free/normalize.cert : | arithmetic-3/bind-free/normalize.pcert1
-
-arithmetic-3/bind-free/numerator-and-denominator.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/numerator-and-denominator.pcert0 : acl2x = 0
-arithmetic-3/bind-free/numerator-and-denominator.pcert0 : \
- arithmetic-3/pass1/top.pcert0 \
- arithmetic-3/bind-free/numerator-and-denominator.lisp
-arithmetic-3/bind-free/numerator-and-denominator.pcert1 : acl2x = 0
-arithmetic-3/bind-free/numerator-and-denominator.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/numerator-and-denominator.pcert1 : arithmetic-3/bind-free/numerator-and-denominator.pcert0
-arithmetic-3/bind-free/numerator-and-denominator.cert : | arithmetic-3/bind-free/numerator-and-denominator.pcert1
-
-arithmetic-3/bind-free/remove-weak-inequalities.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/remove-weak-inequalities.pcert0 : acl2x = 0
-arithmetic-3/bind-free/remove-weak-inequalities.pcert0 : \
- arithmetic-3/bind-free/building-blocks.pcert0 \
- arithmetic-3/bind-free/remove-weak-inequalities.lisp
-arithmetic-3/bind-free/remove-weak-inequalities.pcert1 : acl2x = 0
-arithmetic-3/bind-free/remove-weak-inequalities.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/remove-weak-inequalities.pcert1 : arithmetic-3/bind-free/remove-weak-inequalities.pcert0
-arithmetic-3/bind-free/remove-weak-inequalities.cert : | arithmetic-3/bind-free/remove-weak-inequalities.pcert1
-
-arithmetic-3/bind-free/simplify-helper.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/simplify-helper.pcert0 : acl2x = 0
-arithmetic-3/bind-free/simplify-helper.pcert0 : \
- arithmetic-3/pass1/top.pcert0 \
- arithmetic-3/bind-free/default-hint.pcert0 \
- arithmetic-3/bind-free/simplify-helper.lisp
-arithmetic-3/bind-free/simplify-helper.pcert1 : acl2x = 0
-arithmetic-3/bind-free/simplify-helper.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/simplify-helper.pcert1 : arithmetic-3/bind-free/simplify-helper.pcert0
-arithmetic-3/bind-free/simplify-helper.cert : | arithmetic-3/bind-free/simplify-helper.pcert1
-
-arithmetic-3/bind-free/simplify.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/simplify.pcert0 : acl2x = 0
-arithmetic-3/bind-free/simplify.pcert0 : \
- arithmetic-3/bind-free/simplify-helper.pcert0 \
- arithmetic-3/bind-free/basic.pcert0 \
- arithmetic-3/bind-free/common.pcert0 \
- arithmetic-3/pass1/top.pcert0 \
- arithmetic-3/bind-free/simplify.lisp
-arithmetic-3/bind-free/simplify.pcert1 : acl2x = 0
-arithmetic-3/bind-free/simplify.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/simplify.pcert1 : arithmetic-3/bind-free/simplify.pcert0
-arithmetic-3/bind-free/simplify.cert : | arithmetic-3/bind-free/simplify.pcert1
-
-arithmetic-3/bind-free/top.pcert0 : no_pcert = 0
-arithmetic-3/bind-free/top.pcert0 : acl2x = 0
-arithmetic-3/bind-free/top.pcert0 : \
- arithmetic-3/bind-free/default-hint.pcert0 \
- arithmetic-3/bind-free/building-blocks.pcert0 \
- arithmetic-3/bind-free/mini-theories.pcert0 \
- arithmetic-3/bind-free/common.pcert0 \
- arithmetic-3/bind-free/normalize.pcert0 \
- arithmetic-3/bind-free/simplify.pcert0 \
- arithmetic-3/bind-free/numerator-and-denominator.pcert0 \
- arithmetic-3/bind-free/integerp.pcert0 \
- arithmetic-3/bind-free/integerp-meta.pcert0 \
- arithmetic-3/bind-free/basic.pcert0 \
- arithmetic-3/bind-free/collect.pcert0 \
- arithmetic-3/bind-free/remove-weak-inequalities.pcert0 \
- arithmetic-3/bind-free/arithmetic-theory.pcert0 \
- arithmetic-3/bind-free/banner.pcert0 \
- arithmetic-3/bind-free/top.lisp
-arithmetic-3/bind-free/top.pcert1 : acl2x = 0
-arithmetic-3/bind-free/top.pcert1 : no_pcert = 0
-arithmetic-3/bind-free/top.pcert1 : arithmetic-3/bind-free/top.pcert0
-arithmetic-3/bind-free/top.cert : | arithmetic-3/bind-free/top.pcert1
-
-arithmetic-3/extra/ext.pcert0 : no_pcert = 0
-arithmetic-3/extra/ext.pcert0 : acl2x = 0
-arithmetic-3/extra/ext.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/arithmetic/extra-rules.pcert0 \
- arithmetic-2/meta/expt.pcert0 \
- arithmetic-2/meta/integerp.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- arithmetic-3/extra/ext.lisp
-arithmetic-3/extra/ext.pcert1 : acl2x = 0
-arithmetic-3/extra/ext.pcert1 : no_pcert = 0
-arithmetic-3/extra/ext.pcert1 : arithmetic-3/extra/ext.pcert0
-arithmetic-3/extra/ext.cert : | arithmetic-3/extra/ext.pcert1
-
-arithmetic-3/extra/top-ext.pcert0 : no_pcert = 0
-arithmetic-3/extra/top-ext.pcert0 : acl2x = 0
-arithmetic-3/extra/top-ext.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- arithmetic-3/extra/ext.pcert0 \
- arithmetic-3/extra/top-ext.lisp
-arithmetic-3/extra/top-ext.pcert1 : acl2x = 0
-arithmetic-3/extra/top-ext.pcert1 : no_pcert = 0
-arithmetic-3/extra/top-ext.pcert1 : arithmetic-3/extra/top-ext.pcert0
-arithmetic-3/extra/top-ext.cert : | arithmetic-3/extra/top-ext.pcert1
-
-arithmetic-3/floor-mod/floor-mod.pcert0 : no_pcert = 0
-arithmetic-3/floor-mod/floor-mod.pcert0 : acl2x = 0
-arithmetic-3/floor-mod/floor-mod.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/bind-free/building-blocks.pcert0 \
- arithmetic-3/floor-mod/floor-mod.lisp
-arithmetic-3/floor-mod/floor-mod.pcert1 : acl2x = 0
-arithmetic-3/floor-mod/floor-mod.pcert1 : no_pcert = 0
-arithmetic-3/floor-mod/floor-mod.pcert1 : arithmetic-3/floor-mod/floor-mod.pcert0
-arithmetic-3/floor-mod/floor-mod.cert : | arithmetic-3/floor-mod/floor-mod.pcert1
-
-arithmetic-3/floor-mod/mod-expt-fast.pcert0 : no_pcert = 0
-arithmetic-3/floor-mod/mod-expt-fast.pcert0 : acl2x = 0
-arithmetic-3/floor-mod/mod-expt-fast.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- arithmetic-3/floor-mod/mod-expt-fast.lisp
-arithmetic-3/floor-mod/mod-expt-fast.pcert1 : acl2x = 0
-arithmetic-3/floor-mod/mod-expt-fast.pcert1 : no_pcert = 0
-arithmetic-3/floor-mod/mod-expt-fast.pcert1 : arithmetic-3/floor-mod/mod-expt-fast.pcert0
-arithmetic-3/floor-mod/mod-expt-fast.cert : | arithmetic-3/floor-mod/mod-expt-fast.pcert1
-
-arithmetic-3/pass1/basic-arithmetic-helper.pcert0 : no_pcert = 0
-arithmetic-3/pass1/basic-arithmetic-helper.pcert0 : acl2x = 0
-arithmetic-3/pass1/basic-arithmetic-helper.pcert0 : \
- arithmetic-3/pass1/basic-arithmetic-helper.lisp
-arithmetic-3/pass1/basic-arithmetic-helper.pcert1 : acl2x = 0
-arithmetic-3/pass1/basic-arithmetic-helper.pcert1 : no_pcert = 0
-arithmetic-3/pass1/basic-arithmetic-helper.pcert1 : arithmetic-3/pass1/basic-arithmetic-helper.pcert0
-arithmetic-3/pass1/basic-arithmetic-helper.cert : | arithmetic-3/pass1/basic-arithmetic-helper.pcert1
-
-arithmetic-3/pass1/basic-arithmetic.pcert0 : no_pcert = 0
-arithmetic-3/pass1/basic-arithmetic.pcert0 : acl2x = 0
-arithmetic-3/pass1/basic-arithmetic.pcert0 : \
- arithmetic-3/pass1/basic-arithmetic-helper.pcert0 \
- arithmetic-3/pass1/basic-arithmetic.lisp
-arithmetic-3/pass1/basic-arithmetic.pcert1 : acl2x = 0
-arithmetic-3/pass1/basic-arithmetic.pcert1 : no_pcert = 0
-arithmetic-3/pass1/basic-arithmetic.pcert1 : arithmetic-3/pass1/basic-arithmetic.pcert0
-arithmetic-3/pass1/basic-arithmetic.cert : | arithmetic-3/pass1/basic-arithmetic.pcert1
-
-arithmetic-3/pass1/expt-helper.pcert0 : no_pcert = 0
-arithmetic-3/pass1/expt-helper.pcert0 : acl2x = 0
-arithmetic-3/pass1/expt-helper.pcert0 : \
- arithmetic-3/pass1/basic-arithmetic.pcert0 \
- arithmetic-3/pass1/inequalities.pcert0 \
- arithmetic-3/pass1/prefer-times.pcert0 \
- arithmetic-3/pass1/expt-helper.lisp
-arithmetic-3/pass1/expt-helper.pcert1 : acl2x = 0
-arithmetic-3/pass1/expt-helper.pcert1 : no_pcert = 0
-arithmetic-3/pass1/expt-helper.pcert1 : arithmetic-3/pass1/expt-helper.pcert0
-arithmetic-3/pass1/expt-helper.cert : | arithmetic-3/pass1/expt-helper.pcert1
-
-arithmetic-3/pass1/expt.pcert0 : no_pcert = 0
-arithmetic-3/pass1/expt.pcert0 : acl2x = 0
-arithmetic-3/pass1/expt.pcert0 : \
- arithmetic-3/pass1/basic-arithmetic.pcert0 \
- arithmetic-3/pass1/inequalities.pcert0 \
- arithmetic-3/pass1/prefer-times.pcert0 \
- arithmetic-3/pass1/expt-helper.pcert0 \
- arithmetic-3/pass1/expt.lisp
-arithmetic-3/pass1/expt.pcert1 : acl2x = 0
-arithmetic-3/pass1/expt.pcert1 : no_pcert = 0
-arithmetic-3/pass1/expt.pcert1 : arithmetic-3/pass1/expt.pcert0
-arithmetic-3/pass1/expt.cert : | arithmetic-3/pass1/expt.pcert1
-
-arithmetic-3/pass1/inequalities.pcert0 : no_pcert = 0
-arithmetic-3/pass1/inequalities.pcert0 : acl2x = 0
-arithmetic-3/pass1/inequalities.pcert0 : \
- arithmetic-3/pass1/basic-arithmetic.pcert0 \
- arithmetic-3/pass1/inequalities.lisp
-arithmetic-3/pass1/inequalities.pcert1 : acl2x = 0
-arithmetic-3/pass1/inequalities.pcert1 : no_pcert = 0
-arithmetic-3/pass1/inequalities.pcert1 : arithmetic-3/pass1/inequalities.pcert0
-arithmetic-3/pass1/inequalities.cert : | arithmetic-3/pass1/inequalities.pcert1
-
-arithmetic-3/pass1/mini-theories.pcert0 : no_pcert = 0
-arithmetic-3/pass1/mini-theories.pcert0 : acl2x = 0
-arithmetic-3/pass1/mini-theories.pcert0 : \
- arithmetic-3/pass1/basic-arithmetic.pcert0 \
- arithmetic-3/pass1/inequalities.pcert0 \
- arithmetic-3/pass1/prefer-times.pcert0 \
- arithmetic-3/pass1/expt.pcert0 \
- arithmetic-3/pass1/mini-theories.lisp
-arithmetic-3/pass1/mini-theories.pcert1 : acl2x = 0
-arithmetic-3/pass1/mini-theories.pcert1 : no_pcert = 0
-arithmetic-3/pass1/mini-theories.pcert1 : arithmetic-3/pass1/mini-theories.pcert0
-arithmetic-3/pass1/mini-theories.cert : | arithmetic-3/pass1/mini-theories.pcert1
-
-arithmetic-3/pass1/non-linear.pcert0 : no_pcert = 0
-arithmetic-3/pass1/non-linear.pcert0 : acl2x = 0
-arithmetic-3/pass1/non-linear.pcert0 : \
- arithmetic-3/pass1/basic-arithmetic.pcert0 \
- arithmetic-3/pass1/expt.pcert0 \
- arithmetic-3/pass1/non-linear.lisp
-arithmetic-3/pass1/non-linear.pcert1 : acl2x = 0
-arithmetic-3/pass1/non-linear.pcert1 : no_pcert = 0
-arithmetic-3/pass1/non-linear.pcert1 : arithmetic-3/pass1/non-linear.pcert0
-arithmetic-3/pass1/non-linear.cert : | arithmetic-3/pass1/non-linear.pcert1
-
-arithmetic-3/pass1/num-and-denom-helper.pcert0 : no_pcert = 0
-arithmetic-3/pass1/num-and-denom-helper.pcert0 : acl2x = 0
-arithmetic-3/pass1/num-and-denom-helper.pcert0 : \
- arithmetic-3/pass1/basic-arithmetic.pcert0 \
- arithmetic-3/pass1/inequalities.pcert0 \
- arithmetic-3/pass1/prefer-times.pcert0 \
- arithmetic-3/pass1/non-linear.pcert0 \
- arithmetic-3/pass1/num-and-denom-helper.lisp
-arithmetic-3/pass1/num-and-denom-helper.pcert1 : acl2x = 0
-arithmetic-3/pass1/num-and-denom-helper.pcert1 : no_pcert = 0
-arithmetic-3/pass1/num-and-denom-helper.pcert1 : arithmetic-3/pass1/num-and-denom-helper.pcert0
-arithmetic-3/pass1/num-and-denom-helper.cert : | arithmetic-3/pass1/num-and-denom-helper.pcert1
-
-arithmetic-3/pass1/numerator-and-denominator.pcert0 : no_pcert = 0
-arithmetic-3/pass1/numerator-and-denominator.pcert0 : acl2x = 0
-arithmetic-3/pass1/numerator-and-denominator.pcert0 : \
- arithmetic-3/pass1/basic-arithmetic.pcert0 \
- arithmetic-3/pass1/inequalities.pcert0 \
- arithmetic-3/pass1/prefer-times.pcert0 \
- arithmetic-3/pass1/non-linear.pcert0 \
- arithmetic-3/pass1/num-and-denom-helper.pcert0 \
- arithmetic-3/pass1/numerator-and-denominator.lisp
-arithmetic-3/pass1/numerator-and-denominator.pcert1 : acl2x = 0
-arithmetic-3/pass1/numerator-and-denominator.pcert1 : no_pcert = 0
-arithmetic-3/pass1/numerator-and-denominator.pcert1 : arithmetic-3/pass1/numerator-and-denominator.pcert0
-arithmetic-3/pass1/numerator-and-denominator.cert : | arithmetic-3/pass1/numerator-and-denominator.pcert1
-
-arithmetic-3/pass1/prefer-times.pcert0 : no_pcert = 0
-arithmetic-3/pass1/prefer-times.pcert0 : acl2x = 0
-arithmetic-3/pass1/prefer-times.pcert0 : \
- arithmetic-3/pass1/basic-arithmetic.pcert0 \
- arithmetic-3/pass1/inequalities.pcert0 \
- arithmetic-3/pass1/prefer-times.lisp
-arithmetic-3/pass1/prefer-times.pcert1 : acl2x = 0
-arithmetic-3/pass1/prefer-times.pcert1 : no_pcert = 0
-arithmetic-3/pass1/prefer-times.pcert1 : arithmetic-3/pass1/prefer-times.pcert0
-arithmetic-3/pass1/prefer-times.cert : | arithmetic-3/pass1/prefer-times.pcert1
-
-arithmetic-3/pass1/top.pcert0 : no_pcert = 0
-arithmetic-3/pass1/top.pcert0 : acl2x = 0
-arithmetic-3/pass1/top.pcert0 : \
- arithmetic-3/pass1/basic-arithmetic.pcert0 \
- arithmetic-3/pass1/inequalities.pcert0 \
- arithmetic-3/pass1/expt.pcert0 \
- arithmetic-3/pass1/prefer-times.pcert0 \
- arithmetic-3/pass1/mini-theories.pcert0 \
- arithmetic-3/pass1/numerator-and-denominator.pcert0 \
- arithmetic-3/pass1/non-linear.pcert0 \
- arithmetic-3/pass1/top.lisp
-arithmetic-3/pass1/top.pcert1 : acl2x = 0
-arithmetic-3/pass1/top.pcert1 : no_pcert = 0
-arithmetic-3/pass1/top.pcert1 : arithmetic-3/pass1/top.pcert0
-arithmetic-3/pass1/top.cert : | arithmetic-3/pass1/top.pcert1
-
-arithmetic-3/top.pcert0 : no_pcert = 0
-arithmetic-3/top.pcert0 : acl2x = 0
-arithmetic-3/top.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- arithmetic-3/floor-mod/mod-expt-fast.pcert0 \
- arithmetic-3/top.lisp
-arithmetic-3/top.pcert1 : acl2x = 0
-arithmetic-3/top.pcert1 : no_pcert = 0
-arithmetic-3/top.pcert1 : arithmetic-3/top.pcert0
-arithmetic-3/top.cert : | arithmetic-3/top.pcert1
-
-arithmetic-5/lib/basic-ops/arithmetic-theory.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/arithmetic-theory.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/arithmetic-theory.pcert0 : \
- arithmetic-5/lib/basic-ops/common.pcert0 \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/basic-ops/basic.pcert0 \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.pcert0 \
- arithmetic-5/lib/basic-ops/expt.pcert0 \
- arithmetic-5/lib/basic-ops/collect.pcert0 \
- arithmetic-5/lib/basic-ops/arithmetic-theory.lisp
-arithmetic-5/lib/basic-ops/arithmetic-theory.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/arithmetic-theory.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/arithmetic-theory.pcert1 : arithmetic-5/lib/basic-ops/arithmetic-theory.pcert0
-arithmetic-5/lib/basic-ops/arithmetic-theory.cert : | arithmetic-5/lib/basic-ops/arithmetic-theory.pcert1
-
-arithmetic-5/lib/basic-ops/banner.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/banner.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/banner.pcert0 : \
- arithmetic-5/lib/basic-ops/banner.lisp
-arithmetic-5/lib/basic-ops/banner.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/banner.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/banner.pcert1 : arithmetic-5/lib/basic-ops/banner.pcert0
-arithmetic-5/lib/basic-ops/banner.cert : | arithmetic-5/lib/basic-ops/banner.pcert1
-
-arithmetic-5/lib/basic-ops/basic.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/basic.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/basic.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/basic.lisp
-arithmetic-5/lib/basic-ops/basic.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/basic.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/basic.pcert1 : arithmetic-5/lib/basic-ops/basic.pcert0
-arithmetic-5/lib/basic-ops/basic.cert : | arithmetic-5/lib/basic-ops/basic.pcert1
-
-arithmetic-5/lib/basic-ops/building-blocks-helper.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/building-blocks-helper.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/building-blocks-helper.pcert0 : \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/building-blocks-helper.lisp
-arithmetic-5/lib/basic-ops/building-blocks-helper.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/building-blocks-helper.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/building-blocks-helper.pcert1 : arithmetic-5/lib/basic-ops/building-blocks-helper.pcert0
-arithmetic-5/lib/basic-ops/building-blocks-helper.cert : | arithmetic-5/lib/basic-ops/building-blocks-helper.pcert1
-
-arithmetic-5/lib/basic-ops/building-blocks.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/building-blocks.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/building-blocks.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks-helper.pcert0 \
- arithmetic-5/lib/basic-ops/building-blocks.lisp
-arithmetic-5/lib/basic-ops/building-blocks.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/building-blocks.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/building-blocks.pcert1 : arithmetic-5/lib/basic-ops/building-blocks.pcert0
-arithmetic-5/lib/basic-ops/building-blocks.cert : | arithmetic-5/lib/basic-ops/building-blocks.pcert1
-
-arithmetic-5/lib/basic-ops/collect.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/collect.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/collect.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/expt-helper.pcert0 \
- arithmetic-5/lib/basic-ops/collect.lisp
-arithmetic-5/lib/basic-ops/collect.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/collect.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/collect.pcert1 : arithmetic-5/lib/basic-ops/collect.pcert0
-arithmetic-5/lib/basic-ops/collect.cert : | arithmetic-5/lib/basic-ops/collect.pcert1
-
-arithmetic-5/lib/basic-ops/common.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/common.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/common.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/common.lisp
-arithmetic-5/lib/basic-ops/common.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/common.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/common.pcert1 : arithmetic-5/lib/basic-ops/common.pcert0
-arithmetic-5/lib/basic-ops/common.cert : | arithmetic-5/lib/basic-ops/common.pcert1
-
-arithmetic-5/lib/basic-ops/default-hint.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/default-hint.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/default-hint.pcert0 : \
- arithmetic-5/lib/basic-ops/dynamic-e-d.pcert0 \
- arithmetic-5/lib/basic-ops/default-hint.lisp
-arithmetic-5/lib/basic-ops/default-hint.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/default-hint.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/default-hint.pcert1 : arithmetic-5/lib/basic-ops/default-hint.pcert0
-arithmetic-5/lib/basic-ops/default-hint.cert : | arithmetic-5/lib/basic-ops/default-hint.pcert1
-
-arithmetic-5/lib/basic-ops/distributivity.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/distributivity.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/distributivity.pcert0 : \
- arithmetic-5/lib/basic-ops/distributivity.lisp
-arithmetic-5/lib/basic-ops/distributivity.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/distributivity.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/distributivity.pcert1 : arithmetic-5/lib/basic-ops/distributivity.pcert0
-arithmetic-5/lib/basic-ops/distributivity.cert : | arithmetic-5/lib/basic-ops/distributivity.pcert1
-
-arithmetic-5/lib/basic-ops/dynamic-e-d.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/dynamic-e-d.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/dynamic-e-d.pcert0 : \
- arithmetic-5/lib/basic-ops/dynamic-e-d.lisp
-arithmetic-5/lib/basic-ops/dynamic-e-d.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/dynamic-e-d.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/dynamic-e-d.pcert1 : arithmetic-5/lib/basic-ops/dynamic-e-d.pcert0
-arithmetic-5/lib/basic-ops/dynamic-e-d.cert : | arithmetic-5/lib/basic-ops/dynamic-e-d.pcert1
-
-arithmetic-5/lib/basic-ops/elim-hint.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/elim-hint.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/elim-hint.pcert0 : \
- arithmetic-5/lib/basic-ops/default-hint.pcert0 \
- arithmetic-5/lib/basic-ops/elim-hint.lisp \
- arithmetic-5/lib/basic-ops/elim-hint.acl2
-arithmetic-5/lib/basic-ops/elim-hint.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/elim-hint.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/elim-hint.pcert1 : arithmetic-5/lib/basic-ops/elim-hint.pcert0
-arithmetic-5/lib/basic-ops/elim-hint.cert : | arithmetic-5/lib/basic-ops/elim-hint.pcert1
-
-arithmetic-5/lib/basic-ops/expt-helper.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/expt-helper.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/expt-helper.pcert0 : \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/default-hint.pcert0 \
- arithmetic-5/lib/basic-ops/expt-helper.lisp
-arithmetic-5/lib/basic-ops/expt-helper.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/expt-helper.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/expt-helper.pcert1 : arithmetic-5/lib/basic-ops/expt-helper.pcert0
-arithmetic-5/lib/basic-ops/expt-helper.cert : | arithmetic-5/lib/basic-ops/expt-helper.pcert1
-
-arithmetic-5/lib/basic-ops/expt.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/expt.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/expt.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/expt-helper.pcert0 \
- arithmetic-5/lib/basic-ops/types.pcert0 \
- arithmetic-5/lib/basic-ops/expt.lisp
-arithmetic-5/lib/basic-ops/expt.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/expt.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/expt.pcert1 : arithmetic-5/lib/basic-ops/expt.pcert0
-arithmetic-5/lib/basic-ops/expt.cert : | arithmetic-5/lib/basic-ops/expt.pcert1
-
-arithmetic-5/lib/basic-ops/forcing-types.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/forcing-types.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/forcing-types.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/basic-ops/forcing-types.lisp
-arithmetic-5/lib/basic-ops/forcing-types.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/forcing-types.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/forcing-types.pcert1 : arithmetic-5/lib/basic-ops/forcing-types.pcert0
-arithmetic-5/lib/basic-ops/forcing-types.cert : | arithmetic-5/lib/basic-ops/forcing-types.pcert1
-
-arithmetic-5/lib/basic-ops/if-normalization.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/if-normalization.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/if-normalization.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/basic-ops/if-normalization.lisp
-arithmetic-5/lib/basic-ops/if-normalization.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/if-normalization.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/if-normalization.pcert1 : arithmetic-5/lib/basic-ops/if-normalization.pcert0
-arithmetic-5/lib/basic-ops/if-normalization.cert : | arithmetic-5/lib/basic-ops/if-normalization.pcert1
-
-arithmetic-5/lib/basic-ops/integerp-helper.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/integerp-helper.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/integerp-helper.pcert0 : \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/basic-ops/default-hint.pcert0 \
- arithmetic-5/lib/basic-ops/integerp-helper.lisp
-arithmetic-5/lib/basic-ops/integerp-helper.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/integerp-helper.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/integerp-helper.pcert1 : arithmetic-5/lib/basic-ops/integerp-helper.pcert0
-arithmetic-5/lib/basic-ops/integerp-helper.cert : | arithmetic-5/lib/basic-ops/integerp-helper.pcert1
-
-arithmetic-5/lib/basic-ops/integerp-meta.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/integerp-meta.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/integerp-meta.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/default-hint.pcert0 \
- arithmetic-5/lib/basic-ops/integerp-meta.lisp
-arithmetic-5/lib/basic-ops/integerp-meta.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/integerp-meta.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/integerp-meta.pcert1 : arithmetic-5/lib/basic-ops/integerp-meta.pcert0
-arithmetic-5/lib/basic-ops/integerp-meta.cert : | arithmetic-5/lib/basic-ops/integerp-meta.pcert1
-
-arithmetic-5/lib/basic-ops/integerp.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/integerp.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/integerp.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/basic-ops/default-hint.pcert0 \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/integerp-helper.pcert0 \
- arithmetic-5/lib/basic-ops/common.pcert0 \
- arithmetic-5/lib/basic-ops/normalize.pcert0 \
- arithmetic-5/lib/basic-ops/simplify.pcert0 \
- arithmetic-5/lib/basic-ops/collect.pcert0 \
- arithmetic-5/lib/basic-ops/integerp.lisp
-arithmetic-5/lib/basic-ops/integerp.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/integerp.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/integerp.pcert1 : arithmetic-5/lib/basic-ops/integerp.pcert0
-arithmetic-5/lib/basic-ops/integerp.cert : | arithmetic-5/lib/basic-ops/integerp.pcert1
-
-arithmetic-5/lib/basic-ops/mini-theories.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/mini-theories.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/mini-theories.pcert0 : \
- arithmetic-5/lib/basic-ops/mini-theories.lisp
-arithmetic-5/lib/basic-ops/mini-theories.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/mini-theories.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/mini-theories.pcert1 : arithmetic-5/lib/basic-ops/mini-theories.pcert0
-arithmetic-5/lib/basic-ops/mini-theories.cert : | arithmetic-5/lib/basic-ops/mini-theories.pcert1
-
-arithmetic-5/lib/basic-ops/natp-posp.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/natp-posp.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/natp-posp.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/natp-posp.lisp
-arithmetic-5/lib/basic-ops/natp-posp.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/natp-posp.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/natp-posp.pcert1 : arithmetic-5/lib/basic-ops/natp-posp.pcert0
-arithmetic-5/lib/basic-ops/natp-posp.cert : | arithmetic-5/lib/basic-ops/natp-posp.pcert1
-
-arithmetic-5/lib/basic-ops/normalize.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/normalize.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/normalize.pcert0 : \
- arithmetic-5/lib/basic-ops/common.pcert0 \
- arithmetic-5/lib/basic-ops/basic.pcert0 \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/normalize.lisp
-arithmetic-5/lib/basic-ops/normalize.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/normalize.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/normalize.pcert1 : arithmetic-5/lib/basic-ops/normalize.pcert0
-arithmetic-5/lib/basic-ops/normalize.cert : | arithmetic-5/lib/basic-ops/normalize.pcert1
-
-arithmetic-5/lib/basic-ops/numerator-and-denominator.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/numerator-and-denominator.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/numerator-and-denominator.pcert0 : \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/numerator-and-denominator.lisp
-arithmetic-5/lib/basic-ops/numerator-and-denominator.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/numerator-and-denominator.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/numerator-and-denominator.pcert1 : arithmetic-5/lib/basic-ops/numerator-and-denominator.pcert0
-arithmetic-5/lib/basic-ops/numerator-and-denominator.cert : | arithmetic-5/lib/basic-ops/numerator-and-denominator.pcert1
-
-arithmetic-5/lib/basic-ops/remove-weak-inequalities.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/remove-weak-inequalities.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/remove-weak-inequalities.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/basic-ops/remove-weak-inequalities.lisp
-arithmetic-5/lib/basic-ops/remove-weak-inequalities.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/remove-weak-inequalities.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/remove-weak-inequalities.pcert1 : arithmetic-5/lib/basic-ops/remove-weak-inequalities.pcert0
-arithmetic-5/lib/basic-ops/remove-weak-inequalities.cert : | arithmetic-5/lib/basic-ops/remove-weak-inequalities.pcert1
-
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.pcert0 : \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.lisp
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.pcert1 : arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.pcert0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.cert : | arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.pcert1
-
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/simplify-helper.pcert0 \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.pcert0 \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.lisp
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.pcert1 : arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.pcert0
-arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.cert : | arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.pcert1
-
-arithmetic-5/lib/basic-ops/simplify-helper.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/simplify-helper.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/simplify-helper.pcert0 : \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/default-hint.pcert0 \
- arithmetic-5/lib/basic-ops/simplify-helper.lisp
-arithmetic-5/lib/basic-ops/simplify-helper.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/simplify-helper.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/simplify-helper.pcert1 : arithmetic-5/lib/basic-ops/simplify-helper.pcert0
-arithmetic-5/lib/basic-ops/simplify-helper.cert : | arithmetic-5/lib/basic-ops/simplify-helper.pcert1
-
-arithmetic-5/lib/basic-ops/simplify.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/simplify.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/simplify.pcert0 : \
- arithmetic-5/lib/basic-ops/common.pcert0 \
- arithmetic-5/lib/basic-ops/simplify-helper.pcert0 \
- arithmetic-5/lib/basic-ops/basic.pcert0 \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/simplify.lisp
-arithmetic-5/lib/basic-ops/simplify.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/simplify.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/simplify.pcert1 : arithmetic-5/lib/basic-ops/simplify.pcert0
-arithmetic-5/lib/basic-ops/simplify.cert : | arithmetic-5/lib/basic-ops/simplify.pcert1
-
-arithmetic-5/lib/basic-ops/top.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/top.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/top.pcert0 : \
- arithmetic-5/lib/basic-ops/we-are-here.pcert0 \
- arithmetic-5/lib/basic-ops/distributivity.pcert0 \
- arithmetic-5/lib/basic-ops/default-hint.pcert0 \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/basic-ops/common.pcert0 \
- arithmetic-5/lib/basic-ops/normalize.pcert0 \
- arithmetic-5/lib/basic-ops/simplify.pcert0 \
- arithmetic-5/lib/basic-ops/mini-theories.pcert0 \
- arithmetic-5/lib/basic-ops/numerator-and-denominator.pcert0 \
- arithmetic-5/lib/basic-ops/natp-posp.pcert0 \
- arithmetic-5/lib/basic-ops/integerp-meta.pcert0 \
- arithmetic-5/lib/basic-ops/integerp.pcert0 \
- arithmetic-5/lib/basic-ops/basic.pcert0 \
- arithmetic-5/lib/basic-ops/expt.pcert0 \
- arithmetic-5/lib/basic-ops/collect.pcert0 \
- arithmetic-5/lib/basic-ops/remove-weak-inequalities.pcert0 \
- arithmetic-5/lib/basic-ops/arithmetic-theory.pcert0 \
- arithmetic-5/lib/basic-ops/types.pcert0 \
- arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.pcert0 \
- arithmetic-5/lib/basic-ops/if-normalization.pcert0 \
- arithmetic-5/lib/basic-ops/forcing-types.pcert0 \
- arithmetic-5/lib/basic-ops/banner.pcert0 \
- arithmetic-5/lib/basic-ops/top.lisp
-arithmetic-5/lib/basic-ops/top.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/top.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/top.pcert1 : arithmetic-5/lib/basic-ops/top.pcert0
-arithmetic-5/lib/basic-ops/top.cert : | arithmetic-5/lib/basic-ops/top.pcert1
-
-arithmetic-5/lib/basic-ops/types-helper.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/types-helper.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/types-helper.pcert0 : \
- arithmetic-5/support/top.pcert0 \
- arithmetic-5/lib/basic-ops/types-helper.lisp
-arithmetic-5/lib/basic-ops/types-helper.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/types-helper.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/types-helper.pcert1 : arithmetic-5/lib/basic-ops/types-helper.pcert0
-arithmetic-5/lib/basic-ops/types-helper.cert : | arithmetic-5/lib/basic-ops/types-helper.pcert1
-
-arithmetic-5/lib/basic-ops/types.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/types.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/types.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/basic-ops/types-helper.pcert0 \
- arithmetic-5/lib/basic-ops/types.lisp
-arithmetic-5/lib/basic-ops/types.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/types.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/types.pcert1 : arithmetic-5/lib/basic-ops/types.pcert0
-arithmetic-5/lib/basic-ops/types.cert : | arithmetic-5/lib/basic-ops/types.pcert1
-
-arithmetic-5/lib/basic-ops/we-are-here.pcert0 : no_pcert = 0
-arithmetic-5/lib/basic-ops/we-are-here.pcert0 : acl2x = 0
-arithmetic-5/lib/basic-ops/we-are-here.pcert0 : \
- arithmetic-5/lib/basic-ops/we-are-here.lisp
-arithmetic-5/lib/basic-ops/we-are-here.pcert1 : acl2x = 0
-arithmetic-5/lib/basic-ops/we-are-here.pcert1 : no_pcert = 0
-arithmetic-5/lib/basic-ops/we-are-here.pcert1 : arithmetic-5/lib/basic-ops/we-are-here.pcert0
-arithmetic-5/lib/basic-ops/we-are-here.cert : | arithmetic-5/lib/basic-ops/we-are-here.pcert1
-
-arithmetic-5/lib/floor-mod/floor-mod-basic-helper.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/floor-mod-basic-helper.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod-basic-helper.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/floor-mod/forcing-types.pcert0 \
- arithmetic-5/lib/basic-ops/top.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-basic-helper.lisp
-arithmetic-5/lib/floor-mod/floor-mod-basic-helper.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod-basic-helper.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/floor-mod-basic-helper.pcert1 : arithmetic-5/lib/floor-mod/floor-mod-basic-helper.pcert0
-arithmetic-5/lib/floor-mod/floor-mod-basic-helper.cert : | arithmetic-5/lib/floor-mod/floor-mod-basic-helper.pcert1
-
-arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/floor-mod/forcing-types.pcert0 \
- arithmetic-5/lib/basic-ops/top.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-basic-helper.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-basic.lisp
-arithmetic-5/lib/floor-mod/floor-mod-basic.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod-basic.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/floor-mod-basic.pcert1 : arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0
-arithmetic-5/lib/floor-mod/floor-mod-basic.cert : | arithmetic-5/lib/floor-mod/floor-mod-basic.pcert1
-
-arithmetic-5/lib/floor-mod/floor-mod-helper.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/floor-mod-helper.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod-helper.pcert0 : \
- arithmetic-5/lib/basic-ops/top.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0 \
- arithmetic-5/lib/floor-mod/forcing-types.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-helper.lisp
-arithmetic-5/lib/floor-mod/floor-mod-helper.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod-helper.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/floor-mod-helper.pcert1 : arithmetic-5/lib/floor-mod/floor-mod-helper.pcert0
-arithmetic-5/lib/floor-mod/floor-mod-helper.cert : | arithmetic-5/lib/floor-mod/floor-mod-helper.pcert1
-
-arithmetic-5/lib/floor-mod/floor-mod.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/floor-mod.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/basic-ops/common.pcert0 \
- arithmetic-5/lib/basic-ops/top.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0 \
- arithmetic-5/lib/floor-mod/forcing-types.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-helper.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod.lisp
-arithmetic-5/lib/floor-mod/floor-mod.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/floor-mod.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/floor-mod.pcert1 : arithmetic-5/lib/floor-mod/floor-mod.pcert0
-arithmetic-5/lib/floor-mod/floor-mod.cert : | arithmetic-5/lib/floor-mod/floor-mod.pcert1
-
-arithmetic-5/lib/floor-mod/forcing-types.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/forcing-types.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/forcing-types.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/floor-mod/forcing-types.lisp
-arithmetic-5/lib/floor-mod/forcing-types.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/forcing-types.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/forcing-types.pcert1 : arithmetic-5/lib/floor-mod/forcing-types.pcert0
-arithmetic-5/lib/floor-mod/forcing-types.cert : | arithmetic-5/lib/floor-mod/forcing-types.pcert1
-
-arithmetic-5/lib/floor-mod/if-normalization.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/if-normalization.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/if-normalization.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/floor-mod/if-normalization.lisp
-arithmetic-5/lib/floor-mod/if-normalization.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/if-normalization.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/if-normalization.pcert1 : arithmetic-5/lib/floor-mod/if-normalization.pcert0
-arithmetic-5/lib/floor-mod/if-normalization.cert : | arithmetic-5/lib/floor-mod/if-normalization.pcert1
-
-arithmetic-5/lib/floor-mod/logand-helper.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/logand-helper.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/logand-helper.pcert0 : \
- arithmetic-5/lib/basic-ops/top.pcert0 \
- arithmetic-5/lib/floor-mod/more-floor-mod.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0 \
- arithmetic-5/lib/floor-mod/truncate-rem.pcert0 \
- arithmetic-5/lib/floor-mod/logand-helper.lisp
-arithmetic-5/lib/floor-mod/logand-helper.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/logand-helper.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/logand-helper.pcert1 : arithmetic-5/lib/floor-mod/logand-helper.pcert0
-arithmetic-5/lib/floor-mod/logand-helper.cert : | arithmetic-5/lib/floor-mod/logand-helper.pcert1
-
-arithmetic-5/lib/floor-mod/logand.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/logand.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/logand.pcert0 : \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/basic-ops/top.pcert0 \
- arithmetic-5/lib/floor-mod/more-floor-mod.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0 \
- arithmetic-5/lib/floor-mod/truncate-rem.pcert0 \
- arithmetic-5/lib/floor-mod/logand-helper.pcert0 \
- arithmetic-5/lib/floor-mod/logand.lisp
-arithmetic-5/lib/floor-mod/logand.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/logand.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/logand.pcert1 : arithmetic-5/lib/floor-mod/logand.pcert0
-arithmetic-5/lib/floor-mod/logand.cert : | arithmetic-5/lib/floor-mod/logand.pcert1
-
-arithmetic-5/lib/floor-mod/mod-expt-fast.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/mod-expt-fast.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/mod-expt-fast.pcert0 : \
- arithmetic-5/lib/basic-ops/top.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod.pcert0 \
- arithmetic-5/lib/floor-mod/more-floor-mod.pcert0 \
- arithmetic-5/lib/floor-mod/truncate-rem.pcert0 \
- arithmetic-5/lib/floor-mod/mod-expt-fast.lisp
-arithmetic-5/lib/floor-mod/mod-expt-fast.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/mod-expt-fast.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/mod-expt-fast.pcert1 : arithmetic-5/lib/floor-mod/mod-expt-fast.pcert0
-arithmetic-5/lib/floor-mod/mod-expt-fast.cert : | arithmetic-5/lib/floor-mod/mod-expt-fast.pcert1
-
-arithmetic-5/lib/floor-mod/more-floor-mod.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/more-floor-mod.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/more-floor-mod.pcert0 : \
- arithmetic-5/lib/basic-ops/top.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0 \
- arithmetic-5/lib/floor-mod/if-normalization.pcert0 \
- arithmetic-5/lib/floor-mod/forcing-types.pcert0 \
- arithmetic-5/lib/floor-mod/more-floor-mod.lisp
-arithmetic-5/lib/floor-mod/more-floor-mod.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/more-floor-mod.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/more-floor-mod.pcert1 : arithmetic-5/lib/floor-mod/more-floor-mod.pcert0
-arithmetic-5/lib/floor-mod/more-floor-mod.cert : | arithmetic-5/lib/floor-mod/more-floor-mod.pcert1
-
-arithmetic-5/lib/floor-mod/top.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/top.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/top.pcert0 : \
- arithmetic-5/lib/floor-mod/logand.pcert0 \
- arithmetic-5/lib/floor-mod/truncate-rem.pcert0 \
- arithmetic-5/lib/floor-mod/mod-expt-fast.pcert0 \
- arithmetic-5/lib/floor-mod/more-floor-mod.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0 \
- arithmetic-5/lib/floor-mod/if-normalization.pcert0 \
- arithmetic-5/lib/floor-mod/forcing-types.pcert0 \
- arithmetic-5/lib/floor-mod/top.lisp
-arithmetic-5/lib/floor-mod/top.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/top.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/top.pcert1 : arithmetic-5/lib/floor-mod/top.pcert0
-arithmetic-5/lib/floor-mod/top.cert : | arithmetic-5/lib/floor-mod/top.pcert1
-
-arithmetic-5/lib/floor-mod/truncate-rem.pcert0 : no_pcert = 0
-arithmetic-5/lib/floor-mod/truncate-rem.pcert0 : acl2x = 0
-arithmetic-5/lib/floor-mod/truncate-rem.pcert0 : \
- arithmetic-5/lib/basic-ops/top.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod.pcert0 \
- arithmetic-5/lib/floor-mod/floor-mod-basic.pcert0 \
- arithmetic-5/lib/basic-ops/building-blocks.pcert0 \
- arithmetic-5/lib/floor-mod/truncate-rem.lisp
-arithmetic-5/lib/floor-mod/truncate-rem.pcert1 : acl2x = 0
-arithmetic-5/lib/floor-mod/truncate-rem.pcert1 : no_pcert = 0
-arithmetic-5/lib/floor-mod/truncate-rem.pcert1 : arithmetic-5/lib/floor-mod/truncate-rem.pcert0
-arithmetic-5/lib/floor-mod/truncate-rem.cert : | arithmetic-5/lib/floor-mod/truncate-rem.pcert1
-
-arithmetic-5/support/basic-arithmetic-helper.pcert0 : no_pcert = 0
-arithmetic-5/support/basic-arithmetic-helper.pcert0 : acl2x = 0
-arithmetic-5/support/basic-arithmetic-helper.pcert0 : \
- arithmetic-5/support/basic-arithmetic-helper.lisp
-arithmetic-5/support/basic-arithmetic-helper.pcert1 : acl2x = 0
-arithmetic-5/support/basic-arithmetic-helper.pcert1 : no_pcert = 0
-arithmetic-5/support/basic-arithmetic-helper.pcert1 : arithmetic-5/support/basic-arithmetic-helper.pcert0
-arithmetic-5/support/basic-arithmetic-helper.cert : | arithmetic-5/support/basic-arithmetic-helper.pcert1
-
-arithmetic-5/support/basic-arithmetic.pcert0 : no_pcert = 0
-arithmetic-5/support/basic-arithmetic.pcert0 : acl2x = 0
-arithmetic-5/support/basic-arithmetic.pcert0 : \
- arithmetic-5/support/basic-arithmetic-helper.pcert0 \
- arithmetic-5/support/basic-arithmetic.lisp
-arithmetic-5/support/basic-arithmetic.pcert1 : acl2x = 0
-arithmetic-5/support/basic-arithmetic.pcert1 : no_pcert = 0
-arithmetic-5/support/basic-arithmetic.pcert1 : arithmetic-5/support/basic-arithmetic.pcert0
-arithmetic-5/support/basic-arithmetic.cert : | arithmetic-5/support/basic-arithmetic.pcert1
-
-arithmetic-5/support/expt-helper.pcert0 : no_pcert = 0
-arithmetic-5/support/expt-helper.pcert0 : acl2x = 0
-arithmetic-5/support/expt-helper.pcert0 : \
- arithmetic-5/support/basic-arithmetic.pcert0 \
- arithmetic-5/support/inequalities.pcert0 \
- arithmetic-5/support/prefer-times.pcert0 \
- arithmetic-5/support/expt-helper.lisp
-arithmetic-5/support/expt-helper.pcert1 : acl2x = 0
-arithmetic-5/support/expt-helper.pcert1 : no_pcert = 0
-arithmetic-5/support/expt-helper.pcert1 : arithmetic-5/support/expt-helper.pcert0
-arithmetic-5/support/expt-helper.cert : | arithmetic-5/support/expt-helper.pcert1
-
-arithmetic-5/support/expt.pcert0 : no_pcert = 0
-arithmetic-5/support/expt.pcert0 : acl2x = 0
-arithmetic-5/support/expt.pcert0 : \
- arithmetic-5/support/basic-arithmetic.pcert0 \
- arithmetic-5/support/inequalities.pcert0 \
- arithmetic-5/support/prefer-times.pcert0 \
- arithmetic-5/support/expt-helper.pcert0 \
- arithmetic-5/support/expt.lisp
-arithmetic-5/support/expt.pcert1 : acl2x = 0
-arithmetic-5/support/expt.pcert1 : no_pcert = 0
-arithmetic-5/support/expt.pcert1 : arithmetic-5/support/expt.pcert0
-arithmetic-5/support/expt.cert : | arithmetic-5/support/expt.pcert1
-
-arithmetic-5/support/inequalities.pcert0 : no_pcert = 0
-arithmetic-5/support/inequalities.pcert0 : acl2x = 0
-arithmetic-5/support/inequalities.pcert0 : \
- arithmetic-5/support/basic-arithmetic.pcert0 \
- arithmetic-5/support/inequalities.lisp
-arithmetic-5/support/inequalities.pcert1 : acl2x = 0
-arithmetic-5/support/inequalities.pcert1 : no_pcert = 0
-arithmetic-5/support/inequalities.pcert1 : arithmetic-5/support/inequalities.pcert0
-arithmetic-5/support/inequalities.cert : | arithmetic-5/support/inequalities.pcert1
-
-arithmetic-5/support/mini-theories.pcert0 : no_pcert = 0
-arithmetic-5/support/mini-theories.pcert0 : acl2x = 0
-arithmetic-5/support/mini-theories.pcert0 : \
- arithmetic-5/support/basic-arithmetic.pcert0 \
- arithmetic-5/support/inequalities.pcert0 \
- arithmetic-5/support/prefer-times.pcert0 \
- arithmetic-5/support/expt.pcert0 \
- arithmetic-5/support/mini-theories.lisp
-arithmetic-5/support/mini-theories.pcert1 : acl2x = 0
-arithmetic-5/support/mini-theories.pcert1 : no_pcert = 0
-arithmetic-5/support/mini-theories.pcert1 : arithmetic-5/support/mini-theories.pcert0
-arithmetic-5/support/mini-theories.cert : | arithmetic-5/support/mini-theories.pcert1
-
-arithmetic-5/support/non-linear.pcert0 : no_pcert = 0
-arithmetic-5/support/non-linear.pcert0 : acl2x = 0
-arithmetic-5/support/non-linear.pcert0 : \
- arithmetic-5/support/basic-arithmetic.pcert0 \
- arithmetic-5/support/expt.pcert0 \
- arithmetic-5/support/non-linear.lisp
-arithmetic-5/support/non-linear.pcert1 : acl2x = 0
-arithmetic-5/support/non-linear.pcert1 : no_pcert = 0
-arithmetic-5/support/non-linear.pcert1 : arithmetic-5/support/non-linear.pcert0
-arithmetic-5/support/non-linear.cert : | arithmetic-5/support/non-linear.pcert1
-
-arithmetic-5/support/num-and-denom-helper.pcert0 : no_pcert = 0
-arithmetic-5/support/num-and-denom-helper.pcert0 : acl2x = 0
-arithmetic-5/support/num-and-denom-helper.pcert0 : \
- arithmetic-5/support/basic-arithmetic.pcert0 \
- arithmetic-5/support/inequalities.pcert0 \
- arithmetic-5/support/prefer-times.pcert0 \
- arithmetic-5/support/non-linear.pcert0 \
- arithmetic-5/support/num-and-denom-helper.lisp
-arithmetic-5/support/num-and-denom-helper.pcert1 : acl2x = 0
-arithmetic-5/support/num-and-denom-helper.pcert1 : no_pcert = 0
-arithmetic-5/support/num-and-denom-helper.pcert1 : arithmetic-5/support/num-and-denom-helper.pcert0
-arithmetic-5/support/num-and-denom-helper.cert : | arithmetic-5/support/num-and-denom-helper.pcert1
-
-arithmetic-5/support/numerator-and-denominator.pcert0 : no_pcert = 0
-arithmetic-5/support/numerator-and-denominator.pcert0 : acl2x = 0
-arithmetic-5/support/numerator-and-denominator.pcert0 : \
- arithmetic-5/support/basic-arithmetic.pcert0 \
- arithmetic-5/support/inequalities.pcert0 \
- arithmetic-5/support/prefer-times.pcert0 \
- arithmetic-5/support/non-linear.pcert0 \
- arithmetic-5/support/num-and-denom-helper.pcert0 \
- arithmetic-5/support/numerator-and-denominator.lisp
-arithmetic-5/support/numerator-and-denominator.pcert1 : acl2x = 0
-arithmetic-5/support/numerator-and-denominator.pcert1 : no_pcert = 0
-arithmetic-5/support/numerator-and-denominator.pcert1 : arithmetic-5/support/numerator-and-denominator.pcert0
-arithmetic-5/support/numerator-and-denominator.cert : | arithmetic-5/support/numerator-and-denominator.pcert1
-
-arithmetic-5/support/prefer-times.pcert0 : no_pcert = 0
-arithmetic-5/support/prefer-times.pcert0 : acl2x = 0
-arithmetic-5/support/prefer-times.pcert0 : \
- arithmetic-5/support/basic-arithmetic.pcert0 \
- arithmetic-5/support/inequalities.pcert0 \
- arithmetic-5/support/prefer-times.lisp
-arithmetic-5/support/prefer-times.pcert1 : acl2x = 0
-arithmetic-5/support/prefer-times.pcert1 : no_pcert = 0
-arithmetic-5/support/prefer-times.pcert1 : arithmetic-5/support/prefer-times.pcert0
-arithmetic-5/support/prefer-times.cert : | arithmetic-5/support/prefer-times.pcert1
-
-arithmetic-5/support/top.pcert0 : no_pcert = 0
-arithmetic-5/support/top.pcert0 : acl2x = 0
-arithmetic-5/support/top.pcert0 : \
- arithmetic-5/support/basic-arithmetic.pcert0 \
- arithmetic-5/support/inequalities.pcert0 \
- arithmetic-5/support/expt.pcert0 \
- arithmetic-5/support/prefer-times.pcert0 \
- arithmetic-5/support/mini-theories.pcert0 \
- arithmetic-5/support/numerator-and-denominator.pcert0 \
- arithmetic-5/support/non-linear.pcert0 \
- arithmetic-5/support/top.lisp
-arithmetic-5/support/top.pcert1 : acl2x = 0
-arithmetic-5/support/top.pcert1 : no_pcert = 0
-arithmetic-5/support/top.pcert1 : arithmetic-5/support/top.pcert0
-arithmetic-5/support/top.cert : | arithmetic-5/support/top.pcert1
-
-arithmetic-5/top.pcert0 : no_pcert = 0
-arithmetic-5/top.pcert0 : acl2x = 0
-arithmetic-5/top.pcert0 : \
- arithmetic-5/lib/basic-ops/top.pcert0 \
- arithmetic-5/lib/floor-mod/top.pcert0 \
- arithmetic-5/top.lisp
-arithmetic-5/top.pcert1 : acl2x = 0
-arithmetic-5/top.pcert1 : no_pcert = 0
-arithmetic-5/top.pcert1 : arithmetic-5/top.pcert0
-arithmetic-5/top.cert : | arithmetic-5/top.pcert1
-
-arithmetic/abs.pcert0 : no_pcert = 0
-arithmetic/abs.pcert0 : acl2x = 0
-arithmetic/abs.pcert0 : \
- arithmetic/top.pcert0 \
- arithmetic/abs.lisp
-arithmetic/abs.pcert1 : acl2x = 0
-arithmetic/abs.pcert1 : no_pcert = 0
-arithmetic/abs.pcert1 : arithmetic/abs.pcert0
-arithmetic/abs.cert : | arithmetic/abs.pcert1
-
-arithmetic/binomial.pcert0 : no_pcert = 0
-arithmetic/binomial.pcert0 : acl2x = 0
-arithmetic/binomial.pcert0 : \
- arithmetic/top.pcert0 \
- arithmetic/factorial.pcert0 \
- arithmetic/sumlist.pcert0 \
- arithmetic/binomial.lisp
-arithmetic/binomial.pcert1 : acl2x = 0
-arithmetic/binomial.pcert1 : no_pcert = 0
-arithmetic/binomial.pcert1 : arithmetic/binomial.pcert0
-arithmetic/binomial.cert : | arithmetic/binomial.pcert1
-
-arithmetic/equalities.pcert0 : no_pcert = 0
-arithmetic/equalities.pcert0 : acl2x = 0
-arithmetic/equalities.pcert0 : \
- cowles/acl2-crg.pcert0 \
- arithmetic/equalities.lisp \
- arithmetic/equalities.acl2
-arithmetic/equalities.pcert1 : acl2x = 0
-arithmetic/equalities.pcert1 : no_pcert = 0
-arithmetic/equalities.pcert1 : arithmetic/equalities.pcert0
-arithmetic/equalities.cert : | arithmetic/equalities.pcert1
-
-arithmetic/factorial.pcert0 : no_pcert = 0
-arithmetic/factorial.pcert0 : acl2x = 0
-arithmetic/factorial.pcert0 : \
- arithmetic/factorial.lisp
-arithmetic/factorial.pcert1 : acl2x = 0
-arithmetic/factorial.pcert1 : no_pcert = 0
-arithmetic/factorial.pcert1 : arithmetic/factorial.pcert0
-arithmetic/factorial.cert : | arithmetic/factorial.pcert1
-
-arithmetic/idiv.pcert0 : no_pcert = 0
-arithmetic/idiv.pcert0 : acl2x = 0
-arithmetic/idiv.pcert0 : \
- arithmetic/top.pcert0 \
- arithmetic/idiv.lisp
-arithmetic/idiv.pcert1 : acl2x = 0
-arithmetic/idiv.pcert1 : no_pcert = 0
-arithmetic/idiv.pcert1 : arithmetic/idiv.pcert0
-arithmetic/idiv.cert : | arithmetic/idiv.pcert1
-
-arithmetic/inequalities.pcert0 : no_pcert = 0
-arithmetic/inequalities.pcert0 : acl2x = 0
-arithmetic/inequalities.pcert0 : \
- arithmetic/equalities.pcert0 \
- arithmetic/inequalities.lisp
-arithmetic/inequalities.pcert1 : acl2x = 0
-arithmetic/inequalities.pcert1 : no_pcert = 0
-arithmetic/inequalities.pcert1 : arithmetic/inequalities.pcert0
-arithmetic/inequalities.cert : | arithmetic/inequalities.pcert1
-
-arithmetic/mod-gcd.pcert0 : no_pcert = 0
-arithmetic/mod-gcd.pcert0 : acl2x = 0
-arithmetic/mod-gcd.pcert0 : \
- arithmetic/inequalities.pcert0 \
- arithmetic/mod-gcd.lisp
-arithmetic/mod-gcd.pcert1 : acl2x = 0
-arithmetic/mod-gcd.pcert1 : no_pcert = 0
-arithmetic/mod-gcd.pcert1 : arithmetic/mod-gcd.pcert0
-arithmetic/mod-gcd.cert : | arithmetic/mod-gcd.pcert1
-
-arithmetic/nat-listp.pcert0 : no_pcert = 0
-arithmetic/nat-listp.pcert0 : acl2x = 0
-arithmetic/nat-listp.pcert0 : \
- arithmetic/nat-listp.lisp
-arithmetic/nat-listp.pcert1 : acl2x = 0
-arithmetic/nat-listp.pcert1 : no_pcert = 0
-arithmetic/nat-listp.pcert1 : arithmetic/nat-listp.pcert0
-arithmetic/nat-listp.cert : | arithmetic/nat-listp.pcert1
-
-arithmetic/natp-posp.pcert0 : no_pcert = 0
-arithmetic/natp-posp.pcert0 : acl2x = 0
-arithmetic/natp-posp.pcert0 : \
- arithmetic/inequalities.pcert0 \
- arithmetic/natp-posp.lisp
-arithmetic/natp-posp.pcert1 : acl2x = 0
-arithmetic/natp-posp.pcert1 : no_pcert = 0
-arithmetic/natp-posp.pcert1 : arithmetic/natp-posp.pcert0
-arithmetic/natp-posp.cert : | arithmetic/natp-posp.pcert1
-
-arithmetic/rational-listp.pcert0 : no_pcert = 0
-arithmetic/rational-listp.pcert0 : acl2x = 0
-arithmetic/rational-listp.pcert0 : \
- arithmetic/rational-listp.lisp
-arithmetic/rational-listp.pcert1 : acl2x = 0
-arithmetic/rational-listp.pcert1 : no_pcert = 0
-arithmetic/rational-listp.pcert1 : arithmetic/rational-listp.pcert0
-arithmetic/rational-listp.cert : | arithmetic/rational-listp.pcert1
-
-arithmetic/rationals.pcert0 : no_pcert = 0
-arithmetic/rationals.pcert0 : acl2x = 0
-arithmetic/rationals.pcert0 : \
- arithmetic/inequalities.pcert0 \
- arithmetic/inequalities.pcert0 \
- arithmetic/mod-gcd.pcert0 \
- arithmetic/rationals.lisp
-arithmetic/rationals.pcert1 : acl2x = 0
-arithmetic/rationals.pcert1 : no_pcert = 0
-arithmetic/rationals.pcert1 : arithmetic/rationals.pcert0
-arithmetic/rationals.cert : | arithmetic/rationals.pcert1
-
-arithmetic/sumlist.pcert0 : no_pcert = 0
-arithmetic/sumlist.pcert0 : acl2x = 0
-arithmetic/sumlist.pcert0 : \
- arithmetic/sumlist.lisp
-arithmetic/sumlist.pcert1 : acl2x = 0
-arithmetic/sumlist.pcert1 : no_pcert = 0
-arithmetic/sumlist.pcert1 : arithmetic/sumlist.pcert0
-arithmetic/sumlist.cert : | arithmetic/sumlist.pcert1
-
-arithmetic/top-with-meta.pcert0 : no_pcert = 0
-arithmetic/top-with-meta.pcert0 : acl2x = 0
-arithmetic/top-with-meta.pcert0 : \
- arithmetic/top.pcert0 \
- meta/meta.pcert0 \
- arithmetic/top-with-meta.lisp
-arithmetic/top-with-meta.pcert1 : acl2x = 0
-arithmetic/top-with-meta.pcert1 : no_pcert = 0
-arithmetic/top-with-meta.pcert1 : arithmetic/top-with-meta.pcert0
-arithmetic/top-with-meta.cert : | arithmetic/top-with-meta.pcert1
-
-arithmetic/top.pcert0 : no_pcert = 0
-arithmetic/top.pcert0 : acl2x = 0
-arithmetic/top.pcert0 : \
- arithmetic/equalities.pcert0 \
- arithmetic/rational-listp.pcert0 \
- arithmetic/nat-listp.pcert0 \
- arithmetic/inequalities.pcert0 \
- arithmetic/natp-posp.pcert0 \
- arithmetic/rationals.pcert0 \
- arithmetic/top.lisp
-arithmetic/top.pcert1 : acl2x = 0
-arithmetic/top.pcert1 : no_pcert = 0
-arithmetic/top.pcert1 : arithmetic/top.pcert0
-arithmetic/top.cert : | arithmetic/top.pcert1
-
-bdd/alu-proofs.pcert0 : no_pcert = 0
-bdd/alu-proofs.pcert0 : acl2x = 0
-bdd/alu-proofs.pcert0 : \
- bdd/alu.pcert0 \
- bdd/alu-proofs.lisp
-bdd/alu-proofs.pcert1 : acl2x = 0
-bdd/alu-proofs.pcert1 : no_pcert = 0
-bdd/alu-proofs.pcert1 : bdd/alu-proofs.pcert0
-bdd/alu-proofs.cert : | bdd/alu-proofs.pcert1
-
-bdd/alu.pcert0 : no_pcert = 0
-bdd/alu.pcert0 : acl2x = 0
-bdd/alu.pcert0 : \
- bdd/bdd-primitives.pcert0 \
- bdd/alu.lisp
-bdd/alu.pcert1 : acl2x = 0
-bdd/alu.pcert1 : no_pcert = 0
-bdd/alu.pcert1 : bdd/alu.pcert0
-bdd/alu.cert : | bdd/alu.pcert1
-
-bdd/bdd-primitives.pcert0 : no_pcert = 0
-bdd/bdd-primitives.pcert0 : acl2x = 0
-bdd/bdd-primitives.pcert0 : \
- bdd/bdd-primitives.lisp
-bdd/bdd-primitives.pcert1 : acl2x = 0
-bdd/bdd-primitives.pcert1 : no_pcert = 0
-bdd/bdd-primitives.pcert1 : bdd/bdd-primitives.pcert0
-bdd/bdd-primitives.cert : | bdd/bdd-primitives.pcert1
-
-bdd/bool-ops.pcert0 : no_pcert = 0
-bdd/bool-ops.pcert0 : acl2x = 0
-bdd/bool-ops.pcert0 : \
- bdd/bool-ops.lisp
-bdd/bool-ops.pcert1 : acl2x = 0
-bdd/bool-ops.pcert1 : no_pcert = 0
-bdd/bool-ops.pcert1 : bdd/bool-ops.pcert0
-bdd/bool-ops.cert : | bdd/bool-ops.pcert1
-
-bdd/cbf.pcert0 : no_pcert = 0
-bdd/cbf.pcert0 : acl2x = 0
-bdd/cbf.pcert0 : \
- bdd/bool-ops.pcert0 \
- bdd/cbf.lisp
-bdd/cbf.pcert1 : acl2x = 0
-bdd/cbf.pcert1 : no_pcert = 0
-bdd/cbf.pcert1 : bdd/cbf.pcert0
-bdd/cbf.cert : | bdd/cbf.pcert1
-
-bdd/hamming.pcert0 : no_pcert = 0
-bdd/hamming.pcert0 : acl2x = 0
-bdd/hamming.pcert0 : \
- bdd/bdd-primitives.pcert0 \
- bdd/hamming.lisp
-bdd/hamming.pcert1 : acl2x = 0
-bdd/hamming.pcert1 : no_pcert = 0
-bdd/hamming.pcert1 : bdd/hamming.pcert0
-bdd/hamming.cert : | bdd/hamming.pcert1
-
-bdd/pg-theory.pcert0 : no_pcert = 0
-bdd/pg-theory.pcert0 : acl2x = 0
-bdd/pg-theory.pcert0 : \
- bdd/bdd-primitives.pcert0 \
- bdd/pg-theory.lisp
-bdd/pg-theory.pcert1 : acl2x = 0
-bdd/pg-theory.pcert1 : no_pcert = 0
-bdd/pg-theory.pcert1 : bdd/pg-theory.pcert0
-bdd/pg-theory.cert : | bdd/pg-theory.pcert1
-
-centaur/4v-sexpr/4v-logic.pcert0 : no_pcert = 0
-centaur/4v-sexpr/4v-logic.pcert0 : acl2x = 0
-centaur/4v-sexpr/4v-logic.pcert0 : \
- centaur/misc/witness-cp.pcert0 \
- tools/rulesets.pcert0 \
- xdoc/top.pcert0 \
- misc/definline.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/4v-logic.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/4v-logic.pcert1 : acl2x = 0
-centaur/4v-sexpr/4v-logic.pcert1 : no_pcert = 0
-centaur/4v-sexpr/4v-logic.pcert1 : centaur/4v-sexpr/4v-logic.pcert0
-centaur/4v-sexpr/4v-logic.cert : | centaur/4v-sexpr/4v-logic.pcert1
-
-centaur/4v-sexpr/bitspecs.pcert0 : no_pcert = 0
-centaur/4v-sexpr/bitspecs.pcert0 : acl2x = 0
-centaur/4v-sexpr/bitspecs.pcert0 : \
- centaur/4v-sexpr/4v-logic.pcert0 \
- centaur/4v-sexpr/sexpr-equivs.pcert0 \
- centaur/misc/vecs-ints.pcert0 \
- centaur/misc/hons-sets.pcert0 \
- centaur/misc/fast-alists.pcert0 \
- centaur/misc/patterns.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- ihs/logops-lemmas.pcert0 \
- data-structures/no-duplicates.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/bitspecs.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/bitspecs.pcert1 : acl2x = 0
-centaur/4v-sexpr/bitspecs.pcert1 : no_pcert = 0
-centaur/4v-sexpr/bitspecs.pcert1 : centaur/4v-sexpr/bitspecs.pcert0
-centaur/4v-sexpr/bitspecs.cert : | centaur/4v-sexpr/bitspecs.pcert1
-
-centaur/4v-sexpr/compose-sexpr.pcert0 : no_pcert = 0
-centaur/4v-sexpr/compose-sexpr.pcert0 : acl2x = 0
-centaur/4v-sexpr/compose-sexpr.pcert0 : \
- centaur/4v-sexpr/bitspecs.pcert0 \
- centaur/4v-sexpr/sexpr-to-faig.pcert0 \
- centaur/4v-sexpr/sexpr-advanced.pcert0 \
- centaur/misc/hons-extra.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/compose-sexpr.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/compose-sexpr.pcert1 : acl2x = 0
-centaur/4v-sexpr/compose-sexpr.pcert1 : no_pcert = 0
-centaur/4v-sexpr/compose-sexpr.pcert1 : centaur/4v-sexpr/compose-sexpr.pcert0
-centaur/4v-sexpr/compose-sexpr.cert : | centaur/4v-sexpr/compose-sexpr.pcert1
-
-centaur/4v-sexpr/g-sexpr-eval.pcert0 : no_pcert = 0
-centaur/4v-sexpr/g-sexpr-eval.pcert0 : acl2x = 0
-centaur/4v-sexpr/g-sexpr-eval.pcert0 : \
- centaur/4v-sexpr/svarmap.pcert0 \
- centaur/4v-sexpr/sexpr-to-faig.pcert0 \
- centaur/4v-sexpr/sexpr-equivs.pcert0 \
- centaur/gl/gl-util.pcert0 \
- centaur/misc/numlist.pcert0 \
- centaur/misc/hons-extra.pcert0 \
- centaur/misc/hons-sets.pcert0 \
- centaur/aig/eval-restrict.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- std/lists/take.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/4v-sexpr/g-sexpr-eval.lisp \
- centaur/4v-sexpr/g-sexpr-eval.acl2
-centaur/4v-sexpr/g-sexpr-eval.pcert1 : acl2x = 0
-centaur/4v-sexpr/g-sexpr-eval.pcert1 : no_pcert = 0
-centaur/4v-sexpr/g-sexpr-eval.pcert1 : centaur/4v-sexpr/g-sexpr-eval.pcert0
-centaur/4v-sexpr/g-sexpr-eval.cert : | centaur/4v-sexpr/g-sexpr-eval.pcert1
-
-centaur/4v-sexpr/nsexprs.pcert0 : no_pcert = 0
-centaur/4v-sexpr/nsexprs.pcert0 : acl2x = 0
-centaur/4v-sexpr/nsexprs.pcert0 : \
- centaur/4v-sexpr/sexpr-vars.pcert0 \
- centaur/bitops/bitsets.pcert0 \
- centaur/bitops/sbitsets.pcert0 \
- arithmetic/nat-listp.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/nsexprs.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/nsexprs.pcert1 : acl2x = 0
-centaur/4v-sexpr/nsexprs.pcert1 : no_pcert = 0
-centaur/4v-sexpr/nsexprs.pcert1 : centaur/4v-sexpr/nsexprs.pcert0
-centaur/4v-sexpr/nsexprs.cert : | centaur/4v-sexpr/nsexprs.pcert1
-
-centaur/4v-sexpr/onehot-rewrite.pcert0 : no_pcert = 0
-centaur/4v-sexpr/onehot-rewrite.pcert0 : acl2x = 0
-centaur/4v-sexpr/onehot-rewrite.pcert0 : \
- centaur/4v-sexpr/sexpr-rewrites.pcert0 \
- centaur/4v-sexpr/sexpr-building.pcert0 \
- cutil/defprojection.pcert0 \
- centaur/misc/filter-alist.pcert0 \
- data-structures/list-defthms.pcert0 \
- arithmetic/top.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/onehot-rewrite.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/onehot-rewrite.pcert1 : acl2x = 0
-centaur/4v-sexpr/onehot-rewrite.pcert1 : no_pcert = 0
-centaur/4v-sexpr/onehot-rewrite.pcert1 : centaur/4v-sexpr/onehot-rewrite.pcert0
-centaur/4v-sexpr/onehot-rewrite.cert : | centaur/4v-sexpr/onehot-rewrite.pcert1
-
-centaur/4v-sexpr/portcullis.pcert0 : no_pcert = 0
-centaur/4v-sexpr/portcullis.pcert0 : acl2x = 0
-centaur/4v-sexpr/portcullis.pcert0 : \
- centaur/4v-sexpr/portcullis.lisp \
- centaur/4v-sexpr/portcullis.acl2 \
- tools/flag-package.lsp \
- xdoc/package.lsp \
- centaur/vl/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-centaur/4v-sexpr/portcullis.pcert1 : acl2x = 0
-centaur/4v-sexpr/portcullis.pcert1 : no_pcert = 0
-centaur/4v-sexpr/portcullis.pcert1 : centaur/4v-sexpr/portcullis.pcert0
-centaur/4v-sexpr/portcullis.cert : | centaur/4v-sexpr/portcullis.pcert1
-
-centaur/4v-sexpr/sexpr-3v.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-3v.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-3v.pcert0 : \
- centaur/4v-sexpr/sexpr-eval.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-3v.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-3v.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-3v.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-3v.pcert1 : centaur/4v-sexpr/sexpr-3v.pcert0
-centaur/4v-sexpr/sexpr-3v.cert : | centaur/4v-sexpr/sexpr-3v.pcert1
-
-centaur/4v-sexpr/sexpr-advanced.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-advanced.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-advanced.pcert0 : \
- centaur/4v-sexpr/sexpr-vars.pcert0 \
- centaur/4v-sexpr/sexpr-equivs.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-advanced.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-advanced.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-advanced.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-advanced.pcert1 : centaur/4v-sexpr/sexpr-advanced.pcert0
-centaur/4v-sexpr/sexpr-advanced.cert : | centaur/4v-sexpr/sexpr-advanced.pcert1
-
-centaur/4v-sexpr/sexpr-building.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-building.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-building.pcert0 : \
- centaur/4v-sexpr/sexpr-eval.pcert0 \
- centaur/4v-sexpr/sexpr-vars.pcert0 \
- centaur/4v-sexpr/sexpr-3v.pcert0 \
- cutil/defprojection.pcert0 \
- misc/definline.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-building.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-building.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-building.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-building.pcert1 : centaur/4v-sexpr/sexpr-building.pcert0
-centaur/4v-sexpr/sexpr-building.cert : | centaur/4v-sexpr/sexpr-building.pcert1
-
-centaur/4v-sexpr/sexpr-equivs.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-equivs.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-equivs.pcert0 : \
- centaur/4v-sexpr/sexpr-eval.pcert0 \
- centaur/misc/universal-equiv.pcert0 \
- centaur/misc/fast-alists.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-equivs.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-equivs.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-equivs.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-equivs.pcert1 : centaur/4v-sexpr/sexpr-equivs.pcert0
-centaur/4v-sexpr/sexpr-equivs.cert : | centaur/4v-sexpr/sexpr-equivs.pcert1
-
-centaur/4v-sexpr/sexpr-eval.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-eval.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-eval.pcert0 : \
- centaur/4v-sexpr/4v-logic.pcert0 \
- centaur/misc/fast-alists.pcert0 \
- centaur/misc/hons-extra.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-eval.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-eval.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-eval.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-eval.pcert1 : centaur/4v-sexpr/sexpr-eval.pcert0
-centaur/4v-sexpr/sexpr-eval.cert : | centaur/4v-sexpr/sexpr-eval.pcert1
-
-centaur/4v-sexpr/sexpr-fixpoint-correct.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-fixpoint-correct.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-correct.pcert0 : \
- centaur/4v-sexpr/sexpr-fixpoint-spec.pcert0 \
- centaur/misc/hons-sets.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint-correct.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-fixpoint-correct.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-correct.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-fixpoint-correct.pcert1 : centaur/4v-sexpr/sexpr-fixpoint-correct.pcert0
-centaur/4v-sexpr/sexpr-fixpoint-correct.cert : | centaur/4v-sexpr/sexpr-fixpoint-correct.pcert1
-
-centaur/4v-sexpr/sexpr-fixpoint-rewriting.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-fixpoint-rewriting.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-rewriting.pcert0 : \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint-rewriting.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-fixpoint-rewriting.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-rewriting.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-fixpoint-rewriting.pcert1 : centaur/4v-sexpr/sexpr-fixpoint-rewriting.pcert0
-centaur/4v-sexpr/sexpr-fixpoint-rewriting.cert : | centaur/4v-sexpr/sexpr-fixpoint-rewriting.pcert1
-
-centaur/4v-sexpr/sexpr-fixpoint-spec.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-fixpoint-spec.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-spec.pcert0 : \
- centaur/4v-sexpr/sexpr-fixpoint.pcert0 \
- centaur/4v-sexpr/sexpr-advanced.pcert0 \
- misc/bash.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint-spec.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-fixpoint-spec.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-spec.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-fixpoint-spec.pcert1 : centaur/4v-sexpr/sexpr-fixpoint-spec.pcert0
-centaur/4v-sexpr/sexpr-fixpoint-spec.cert : | centaur/4v-sexpr/sexpr-fixpoint-spec.pcert1
-
-centaur/4v-sexpr/sexpr-fixpoint-top.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-fixpoint-top.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-top.pcert0 : \
- centaur/4v-sexpr/sexpr-fixpoint.pcert0 \
- centaur/4v-sexpr/sexpr-equivs.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint-correct.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint-top.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-fixpoint-top.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint-top.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-fixpoint-top.pcert1 : centaur/4v-sexpr/sexpr-fixpoint-top.pcert0
-centaur/4v-sexpr/sexpr-fixpoint-top.cert : | centaur/4v-sexpr/sexpr-fixpoint-top.pcert1
-
-centaur/4v-sexpr/sexpr-fixpoint.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-fixpoint.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint.pcert0 : \
- centaur/4v-sexpr/nsexprs.pcert0 \
- centaur/4v-sexpr/sexpr-rewrites.pcert0 \
- centaur/misc/hons-extra.pcert0 \
- centaur/misc/sneaky-load.pcert0 \
- centaur/misc/nat-list-duplicates.pcert0 \
- centaur/misc/tuplep.pcert0 \
- centaur/misc/dfs-measure.pcert0 \
- std/ks/two-nats-measure.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-fixpoint.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-fixpoint.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-fixpoint.pcert1 : centaur/4v-sexpr/sexpr-fixpoint.pcert0
-centaur/4v-sexpr/sexpr-fixpoint.cert : | centaur/4v-sexpr/sexpr-fixpoint.pcert1
-
-centaur/4v-sexpr/sexpr-loop-debug.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-loop-debug.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-loop-debug.pcert0 : \
- centaur/4v-sexpr/sexpr-fixpoint.pcert0 \
- centaur/vl/toe/toe-emodwire.pcert0 \
- centaur/vl/util/cw-unformatted.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- arithmetic-3/top.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-loop-debug.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-loop-debug.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-loop-debug.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-loop-debug.pcert1 : centaur/4v-sexpr/sexpr-loop-debug.pcert0
-centaur/4v-sexpr/sexpr-loop-debug.cert : | centaur/4v-sexpr/sexpr-loop-debug.pcert1
-
-centaur/4v-sexpr/sexpr-rewrites.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-rewrites.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-rewrites.pcert0 : \
- centaur/aig/base.pcert0 \
- centaur/4v-sexpr/sexpr-advanced.pcert0 \
- centaur/misc/hons-extra.pcert0 \
- centaur/4v-sexpr/sexpr-vars-1pass.pcert0 \
- std/ks/two-nats-measure.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-rewrites.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-rewrites.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-rewrites.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-rewrites.pcert1 : centaur/4v-sexpr/sexpr-rewrites.pcert0
-centaur/4v-sexpr/sexpr-rewrites.cert : | centaur/4v-sexpr/sexpr-rewrites.pcert1
-
-centaur/4v-sexpr/sexpr-to-faig.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-to-faig.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-to-faig.pcert0 : \
- centaur/4v-sexpr/sexpr-eval.pcert0 \
- centaur/4v-sexpr/sexpr-3v.pcert0 \
- centaur/aig/three-four.pcert0 \
- centaur/aig/aig-equivs.pcert0 \
- centaur/misc/tuplep.pcert0 \
- centaur/aig/eval-restrict.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-to-faig.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-to-faig.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-to-faig.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-to-faig.pcert1 : centaur/4v-sexpr/sexpr-to-faig.pcert0
-centaur/4v-sexpr/sexpr-to-faig.cert : | centaur/4v-sexpr/sexpr-to-faig.pcert1
-
-centaur/4v-sexpr/sexpr-vars-1pass.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-vars-1pass.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-vars-1pass.pcert0 : \
- centaur/4v-sexpr/sexpr-vars.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-vars-1pass.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-vars-1pass.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-vars-1pass.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-vars-1pass.pcert1 : centaur/4v-sexpr/sexpr-vars-1pass.pcert0
-centaur/4v-sexpr/sexpr-vars-1pass.cert : | centaur/4v-sexpr/sexpr-vars-1pass.pcert1
-
-centaur/4v-sexpr/sexpr-vars.pcert0 : no_pcert = 0
-centaur/4v-sexpr/sexpr-vars.pcert0 : acl2x = 0
-centaur/4v-sexpr/sexpr-vars.pcert0 : \
- centaur/4v-sexpr/sexpr-eval.pcert0 \
- centaur/misc/hons-alphorder-merge.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/sexpr-vars.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/sexpr-vars.pcert1 : acl2x = 0
-centaur/4v-sexpr/sexpr-vars.pcert1 : no_pcert = 0
-centaur/4v-sexpr/sexpr-vars.pcert1 : centaur/4v-sexpr/sexpr-vars.pcert0
-centaur/4v-sexpr/sexpr-vars.cert : | centaur/4v-sexpr/sexpr-vars.pcert1
-
-centaur/4v-sexpr/svarmap.pcert0 : no_pcert = 0
-centaur/4v-sexpr/svarmap.pcert0 : acl2x = 0
-centaur/4v-sexpr/svarmap.pcert0 : \
- centaur/aig/base.pcert0 \
- centaur/misc/fast-alists.pcert0 \
- centaur/misc/hons-sets.pcert0 \
- data-structures/no-duplicates.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/svarmap.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/svarmap.pcert1 : acl2x = 0
-centaur/4v-sexpr/svarmap.pcert1 : no_pcert = 0
-centaur/4v-sexpr/svarmap.pcert1 : centaur/4v-sexpr/svarmap.pcert0
-centaur/4v-sexpr/svarmap.cert : | centaur/4v-sexpr/svarmap.pcert1
-
-centaur/4v-sexpr/top.pcert0 : no_pcert = 0
-centaur/4v-sexpr/top.pcert0 : acl2x = 0
-centaur/4v-sexpr/top.pcert0 : \
- centaur/4v-sexpr/4v-logic.pcert0 \
- centaur/4v-sexpr/bitspecs.pcert0 \
- centaur/4v-sexpr/compose-sexpr.pcert0 \
- centaur/4v-sexpr/g-sexpr-eval.pcert0 \
- centaur/4v-sexpr/nsexprs.pcert0 \
- centaur/4v-sexpr/onehot-rewrite.pcert0 \
- centaur/4v-sexpr/sexpr-advanced.pcert0 \
- centaur/4v-sexpr/sexpr-building.pcert0 \
- centaur/4v-sexpr/sexpr-equivs.pcert0 \
- centaur/4v-sexpr/sexpr-eval.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint-correct.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint-rewriting.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint-spec.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint-top.pcert0 \
- centaur/4v-sexpr/sexpr-loop-debug.pcert0 \
- centaur/4v-sexpr/sexpr-rewrites.pcert0 \
- centaur/4v-sexpr/sexpr-to-faig.pcert0 \
- centaur/4v-sexpr/sexpr-vars.pcert0 \
- centaur/4v-sexpr/svarmap.pcert0 \
- centaur/4v-sexpr/portcullis.pcert0 \
- centaur/4v-sexpr/top.lisp \
- centaur/4v-sexpr/cert.acl2
-centaur/4v-sexpr/top.pcert1 : acl2x = 0
-centaur/4v-sexpr/top.pcert1 : no_pcert = 0
-centaur/4v-sexpr/top.pcert1 : centaur/4v-sexpr/top.pcert0
-centaur/4v-sexpr/top.cert : | centaur/4v-sexpr/top.pcert1
-
-centaur/aig/aig-equivs.pcert0 : no_pcert = 0
-centaur/aig/aig-equivs.pcert0 : acl2x = 0
-centaur/aig/aig-equivs.pcert0 : \
- centaur/aig/base.pcert0 \
- centaur/misc/witness-cp.pcert0 \
- centaur/misc/universal-equiv.pcert0 \
- centaur/misc/fast-alists.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/aig-equivs.lisp \
- centaur/aig/cert.acl2
-centaur/aig/aig-equivs.pcert1 : acl2x = 0
-centaur/aig/aig-equivs.pcert1 : no_pcert = 0
-centaur/aig/aig-equivs.pcert1 : centaur/aig/aig-equivs.pcert0
-centaur/aig/aig-equivs.cert : | centaur/aig/aig-equivs.pcert1
-
-centaur/aig/aig-vars-ext.pcert0 : no_pcert = 0
-centaur/aig/aig-vars-ext.pcert0 : acl2x = 0
-centaur/aig/aig-vars-ext.pcert0 : \
- defsort/defsort.pcert0 \
- centaur/aig/base.pcert0 \
- tools/bstar.pcert0 \
- centaur/bitops/sbitsets.pcert0 \
- centaur/misc/hons-extra.pcert0 \
- centaur/misc/alist-defs.pcert0 \
- centaur/misc/numlist.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/aig-vars-ext.lisp \
- centaur/aig/cert.acl2
-centaur/aig/aig-vars-ext.pcert1 : acl2x = 0
-centaur/aig/aig-vars-ext.pcert1 : no_pcert = 0
-centaur/aig/aig-vars-ext.pcert1 : centaur/aig/aig-vars-ext.pcert0
-centaur/aig/aig-vars-ext.cert : | centaur/aig/aig-vars-ext.pcert1
-
-centaur/aig/aig-vars.pcert0 : no_pcert = 0
-centaur/aig/aig-vars.pcert0 : acl2x = 0
-centaur/aig/aig-vars.pcert0 : \
- centaur/aig/base.pcert0 \
- centaur/misc/equal-sets.pcert0 \
- centaur/misc/alist-equiv.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/aig-vars.lisp \
- centaur/aig/cert.acl2
-centaur/aig/aig-vars.pcert1 : acl2x = 0
-centaur/aig/aig-vars.pcert1 : no_pcert = 0
-centaur/aig/aig-vars.pcert1 : centaur/aig/aig-vars.pcert0
-centaur/aig/aig-vars.cert : | centaur/aig/aig-vars.pcert1
-
-centaur/aig/aiger.pcert0 : no_pcert = 0
-centaur/aig/aiger.pcert0 : acl2x = 0
-centaur/aig/aiger.pcert0 : \
- tools/bstar.pcert0 \
- tools/mv-nth.pcert0 \
- data-structures/list-defthms.pcert0 \
- centaur/aig/aig-vars-ext.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/misc/sneaky-load.pcert0 \
- centaur/misc/numlist.pcert0 \
- tools/defmacfun.pcert0 \
- misc/definline.pcert0 \
- system/io.pcert0 \
- arithmetic/nat-listp.pcert0 \
- clause-processors/instantiate.pcert0 \
- centaur/bitops/ihsext-basics.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- cutil/defmvtypes.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/aiger.lisp \
- centaur/aig/cert.acl2
-centaur/aig/aiger.pcert1 : acl2x = 0
-centaur/aig/aiger.pcert1 : no_pcert = 0
-centaur/aig/aiger.pcert1 : centaur/aig/aiger.pcert0
-centaur/aig/aiger.cert : | centaur/aig/aiger.pcert1
-
-centaur/aig/base.pcert0 : no_pcert = 0
-centaur/aig/base.pcert0 : acl2x = 0
-centaur/aig/base.pcert0 : \
- cutil/defsection.pcert0 \
- centaur/misc/hons-alphorder-merge.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/base.lisp \
- centaur/aig/cert.acl2
-centaur/aig/base.pcert1 : acl2x = 0
-centaur/aig/base.pcert1 : no_pcert = 0
-centaur/aig/base.pcert1 : centaur/aig/base.pcert0
-centaur/aig/base.cert : | centaur/aig/base.pcert1
-
-centaur/aig/bddify-correct.pcert0 : no_pcert = 0
-centaur/aig/bddify-correct.pcert0 : acl2x = 0
-centaur/aig/bddify-correct.pcert0 : \
- centaur/aig/bddify.pcert0 \
- centaur/ubdds/param.pcert0 \
- centaur/ubdds/lite.pcert0 \
- centaur/misc/suffixp.pcert0 \
- tools/with-quoted-forms.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/bddify-correct.lisp \
- centaur/aig/cert.acl2
-centaur/aig/bddify-correct.pcert1 : acl2x = 0
-centaur/aig/bddify-correct.pcert1 : no_pcert = 0
-centaur/aig/bddify-correct.pcert1 : centaur/aig/bddify-correct.pcert0
-centaur/aig/bddify-correct.cert : | centaur/aig/bddify-correct.pcert1
-
-centaur/aig/bddify.pcert0 : no_pcert = 0
-centaur/aig/bddify.pcert0 : acl2x = 0
-centaur/aig/bddify.pcert0 : \
- centaur/aig/base.pcert0 \
- tools/bstar.pcert0 \
- tools/mv-nth.pcert0 \
- misc/hons-help2.pcert0 \
- centaur/ubdds/extra-operations.pcert0 \
- centaur/misc/memory-mgmt-logic.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/bddify.lisp \
- centaur/aig/cert.acl2
-centaur/aig/bddify.pcert1 : acl2x = 0
-centaur/aig/bddify.pcert1 : no_pcert = 0
-centaur/aig/bddify.pcert1 : centaur/aig/bddify.pcert0
-centaur/aig/bddify.cert : | centaur/aig/bddify.pcert1
-
-centaur/aig/eval-restrict.pcert0 : no_pcert = 0
-centaur/aig/eval-restrict.pcert0 : acl2x = 0
-centaur/aig/eval-restrict.pcert0 : \
- centaur/aig/base.pcert0 \
- centaur/aig/aig-equivs.pcert0 \
- centaur/aig/three-four.pcert0 \
- centaur/aig/aig-vars.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/eval-restrict.lisp \
- centaur/aig/cert.acl2
-centaur/aig/eval-restrict.pcert1 : acl2x = 0
-centaur/aig/eval-restrict.pcert1 : no_pcert = 0
-centaur/aig/eval-restrict.pcert1 : centaur/aig/eval-restrict.pcert0
-centaur/aig/eval-restrict.cert : | centaur/aig/eval-restrict.pcert1
-
-centaur/aig/g-aig-eval.pcert0 : no_pcert = 0
-centaur/aig/g-aig-eval.pcert0 : acl2x = 0
-centaur/aig/g-aig-eval.pcert0 : \
- centaur/aig/bddify-correct.pcert0 \
- centaur/gl/g-if.pcert0 \
- centaur/gl/gify.pcert0 \
- centaur/gl/gify-thms.pcert0 \
- centaur/gl/eval-f-i-cp.pcert0 \
- centaur/gl/bvecs.pcert0 \
- centaur/gl/gify-clause-proc.pcert0 \
- centaur/gl/general-object-thms.pcert0 \
- centaur/aig/eval-restrict.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/aig/g-aig-eval.lisp \
- centaur/aig/g-aig-eval.acl2
-centaur/aig/g-aig-eval.pcert1 : acl2x = 0
-centaur/aig/g-aig-eval.pcert1 : no_pcert = 0
-centaur/aig/g-aig-eval.pcert1 : centaur/aig/g-aig-eval.pcert0
-centaur/aig/g-aig-eval.cert : | centaur/aig/g-aig-eval.pcert1
-
-centaur/aig/induction.pcert0 : no_pcert = 0
-centaur/aig/induction.pcert0 : acl2x = 0
-centaur/aig/induction.pcert0 : \
- centaur/aig/eval-restrict.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/induction.lisp \
- centaur/aig/cert.acl2
-centaur/aig/induction.pcert1 : acl2x = 0
-centaur/aig/induction.pcert1 : no_pcert = 0
-centaur/aig/induction.pcert1 : centaur/aig/induction.pcert0
-centaur/aig/induction.cert : | centaur/aig/induction.pcert1
-
-centaur/aig/misc.pcert0 : no_pcert = 0
-centaur/aig/misc.pcert0 : acl2x = 0
-centaur/aig/misc.pcert0 : \
- centaur/aig/base.pcert0 \
- centaur/misc/equal-sets.pcert0 \
- tools/mv-nth.pcert0 \
- misc/gentle.pcert0 \
- misc/hons-help.pcert0 \
- centaur/aig/eval-restrict.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/misc.lisp \
- centaur/aig/cert.acl2
-centaur/aig/misc.pcert1 : acl2x = 0
-centaur/aig/misc.pcert1 : no_pcert = 0
-centaur/aig/misc.pcert1 : centaur/aig/misc.pcert0
-centaur/aig/misc.cert : | centaur/aig/misc.pcert1
-
-centaur/aig/portcullis.pcert0 : no_pcert = 0
-centaur/aig/portcullis.pcert0 : acl2x = 0
-centaur/aig/portcullis.pcert0 : \
- centaur/aig/portcullis.lisp \
- centaur/aig/portcullis.acl2 \
- centaur/vl/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- centaur/vl/other-packages.lsp \
- data-structures/define-u-package.lsp \
- tools/flag-package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- cowles/packages.lsp \
- centaur/aig/fsm-pkg.lsp
-centaur/aig/portcullis.pcert1 : acl2x = 0
-centaur/aig/portcullis.pcert1 : no_pcert = 0
-centaur/aig/portcullis.pcert1 : centaur/aig/portcullis.pcert0
-centaur/aig/portcullis.cert : | centaur/aig/portcullis.pcert1
-
-centaur/aig/three-four.pcert0 : no_pcert = 0
-centaur/aig/three-four.pcert0 : acl2x = 0
-centaur/aig/three-four.pcert0 : \
- centaur/aig/base.pcert0 \
- tools/bstar.pcert0 \
- tools/rulesets.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/three-four.lisp \
- centaur/aig/cert.acl2
-centaur/aig/three-four.pcert1 : acl2x = 0
-centaur/aig/three-four.pcert1 : no_pcert = 0
-centaur/aig/three-four.pcert1 : centaur/aig/three-four.pcert0
-centaur/aig/three-four.cert : | centaur/aig/three-four.pcert1
-
-centaur/aig/vuaig.pcert0 : no_pcert = 0
-centaur/aig/vuaig.pcert0 : acl2x = 0
-centaur/aig/vuaig.pcert0 : \
- centaur/aig/three-four.pcert0 \
- centaur/aig/portcullis.pcert0 \
- centaur/aig/vuaig.lisp \
- centaur/aig/cert.acl2
-centaur/aig/vuaig.pcert1 : acl2x = 0
-centaur/aig/vuaig.pcert1 : no_pcert = 0
-centaur/aig/vuaig.pcert1 : centaur/aig/vuaig.pcert0
-centaur/aig/vuaig.cert : | centaur/aig/vuaig.pcert1
-
-centaur/aig/witness.pcert0 : no_pcert = 0
-centaur/aig/witness.pcert0 : acl2x = 0
-centaur/aig/witness.pcert0 : \
- misc/hons-help2.pcert0 \
- centaur/aig/base.pcert0 \
- clause-processors/term-patterns.pcert0 \
- clause-processors/join-thms.pcert0 \
- tools/flag.pcert0 \
- centaur/aig/witness.lisp \
- centaur/aig/witness.acl2 \
- tools/flag-package.lsp
-centaur/aig/witness.pcert1 : acl2x = 0
-centaur/aig/witness.pcert1 : no_pcert = 0
-centaur/aig/witness.pcert1 : centaur/aig/witness.pcert0
-centaur/aig/witness.cert : | centaur/aig/witness.pcert1
-
-centaur/bitops/bits-between.pcert0 : no_pcert = 0
-centaur/bitops/bits-between.pcert0 : acl2x = 0
-centaur/bitops/bits-between.pcert0 : \
- cutil/defsection.pcert0 \
- tools/bstar.pcert0 \
- finite-set-theory/osets/sets.pcert0 \
- centaur/bitops/ihs-extensions.pcert0 \
- std/lists/rev.pcert0 \
- std/lists/append.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/bits-between.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/bits-between.pcert1 : acl2x = 0
-centaur/bitops/bits-between.pcert1 : no_pcert = 0
-centaur/bitops/bits-between.pcert1 : centaur/bitops/bits-between.pcert0
-centaur/bitops/bits-between.cert : | centaur/bitops/bits-between.pcert1
-
-centaur/bitops/bitsets-opt.pcert0 : no_pcert = 0
-centaur/bitops/bitsets-opt.pcert0 : acl2x = 0
-centaur/bitops/bitsets-opt.pcert0 : \
- centaur/bitops/bitsets.pcert0 \
- tools/include-raw.pcert0 \
- make-event/assert.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/bitsets-opt.lisp \
- centaur/bitops/cert.acl2 \
- centaur/bitops/bitsets-opt-raw.lsp
-centaur/bitops/bitsets-opt.pcert1 : acl2x = 0
-centaur/bitops/bitsets-opt.pcert1 : no_pcert = 0
-centaur/bitops/bitsets-opt.pcert1 : centaur/bitops/bitsets-opt.pcert0
-centaur/bitops/bitsets-opt.cert : | centaur/bitops/bitsets-opt.pcert1
-
-centaur/bitops/bitsets.pcert0 : no_pcert = 0
-centaur/bitops/bitsets.pcert0 : acl2x = 0
-centaur/bitops/bitsets.pcert0 : \
- centaur/bitops/bits-between.pcert0 \
- centaur/bitops/equal-by-logbitp.pcert0 \
- misc/definline.pcert0 \
- centaur/misc/witness-cp.pcert0 \
- centaur/bitops/ihs-extensions.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/bitsets.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/bitsets.pcert1 : acl2x = 0
-centaur/bitops/bitsets.pcert1 : no_pcert = 0
-centaur/bitops/bitsets.pcert1 : centaur/bitops/bitsets.pcert0
-centaur/bitops/bitsets.cert : | centaur/bitops/bitsets.pcert1
-
-centaur/bitops/congruences.pcert0 : no_pcert = 0
-centaur/bitops/congruences.pcert0 : acl2x = 0
-centaur/bitops/congruences.pcert0 : \
- tools/rulesets.pcert0 \
- centaur/misc/context-rw.pcert0 \
- ihs/basic-definitions.pcert0 \
- centaur/bitops/ihsext-basics.pcert0 \
- centaur/bitops/ihs-extensions.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/bitops/equal-by-logbitp.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/congruences.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/congruences.pcert1 : acl2x = 0
-centaur/bitops/congruences.pcert1 : no_pcert = 0
-centaur/bitops/congruences.pcert1 : centaur/bitops/congruences.pcert0
-centaur/bitops/congruences.cert : | centaur/bitops/congruences.pcert1
-
-centaur/bitops/equal-by-logbitp.pcert0 : no_pcert = 0
-centaur/bitops/equal-by-logbitp.pcert0 : acl2x = 0
-centaur/bitops/equal-by-logbitp.pcert0 : \
- cutil/wizard.pcert0 \
- centaur/bitops/integer-length.pcert0 \
- centaur/bitops/ihsext-basics.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/equal-by-logbitp.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/equal-by-logbitp.pcert1 : acl2x = 0
-centaur/bitops/equal-by-logbitp.pcert1 : no_pcert = 0
-centaur/bitops/equal-by-logbitp.pcert1 : centaur/bitops/equal-by-logbitp.pcert0
-centaur/bitops/equal-by-logbitp.cert : | centaur/bitops/equal-by-logbitp.pcert1
-
-centaur/bitops/extra-defs.pcert0 : no_pcert = 0
-centaur/bitops/extra-defs.pcert0 : acl2x = 0
-centaur/bitops/extra-defs.pcert0 : \
- centaur/bitops/ihsext-basics.pcert0 \
- arithmetic/top.pcert0 \
- centaur/misc/arith-equivs.pcert0 \
- ihs/logops-definitions.pcert0 \
- xdoc/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/extra-defs.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/extra-defs.pcert1 : acl2x = 0
-centaur/bitops/extra-defs.pcert1 : no_pcert = 0
-centaur/bitops/extra-defs.pcert1 : centaur/bitops/extra-defs.pcert0
-centaur/bitops/extra-defs.cert : | centaur/bitops/extra-defs.pcert1
-
-centaur/bitops/ihs-extensions.pcert0 : no_pcert = 0
-centaur/bitops/ihs-extensions.pcert0 : acl2x = 0
-centaur/bitops/ihs-extensions.pcert0 : \
- centaur/bitops/ihsext-basics.pcert0 \
- centaur/bitops/integer-length.pcert0 \
- centaur/bitops/equal-by-logbitp.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/ihs-extensions.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/ihs-extensions.pcert1 : acl2x = 0
-centaur/bitops/ihs-extensions.pcert1 : no_pcert = 0
-centaur/bitops/ihs-extensions.pcert1 : centaur/bitops/ihs-extensions.pcert0
-centaur/bitops/ihs-extensions.cert : | centaur/bitops/ihs-extensions.pcert1
-
-centaur/bitops/ihsext-basics.pcert0 : no_pcert = 0
-centaur/bitops/ihsext-basics.pcert0 : acl2x = 0
-centaur/bitops/ihsext-basics.pcert0 : \
- centaur/misc/arith-equivs.pcert0 \
- xdoc/top.pcert0 \
- tools/defredundant.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- ihs/logops-lemmas.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/ihsext-basics.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/ihsext-basics.pcert1 : acl2x = 0
-centaur/bitops/ihsext-basics.pcert1 : no_pcert = 0
-centaur/bitops/ihsext-basics.pcert1 : centaur/bitops/ihsext-basics.pcert0
-centaur/bitops/ihsext-basics.cert : | centaur/bitops/ihsext-basics.pcert1
-
-centaur/bitops/install-bit.pcert0 : no_pcert = 0
-centaur/bitops/install-bit.pcert0 : acl2x = 0
-centaur/bitops/install-bit.pcert0 : \
- cutil/defsection.pcert0 \
- centaur/misc/arith-equivs.pcert0 \
- centaur/misc/mfc-utils.pcert0 \
- centaur/misc/introduce-var.pcert0 \
- centaur/bitops/equal-by-logbitp.pcert0 \
- centaur/bitops/ihsext-basics.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/install-bit.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/install-bit.pcert1 : acl2x = 0
-centaur/bitops/install-bit.pcert1 : no_pcert = 0
-centaur/bitops/install-bit.pcert1 : centaur/bitops/install-bit.pcert0
-centaur/bitops/install-bit.cert : | centaur/bitops/install-bit.pcert1
-
-centaur/bitops/integer-length.pcert0 : no_pcert = 0
-centaur/bitops/integer-length.pcert0 : acl2x = 0
-centaur/bitops/integer-length.pcert0 : \
- cutil/defsection.pcert0 \
- ihs/logops-definitions.pcert0 \
- ihs/logops-lemmas.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/bitops/ihsext-basics.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/integer-length.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/integer-length.pcert1 : acl2x = 0
-centaur/bitops/integer-length.pcert1 : no_pcert = 0
-centaur/bitops/integer-length.pcert1 : centaur/bitops/integer-length.pcert0
-centaur/bitops/integer-length.cert : | centaur/bitops/integer-length.pcert1
-
-centaur/bitops/part-select.pcert0 : no_pcert = 0
-centaur/bitops/part-select.pcert0 : acl2x = 0
-centaur/bitops/part-select.pcert0 : \
- ihs/logops-definitions.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/bitops/ihsext-basics.pcert0 \
- misc/assert.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/part-select.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/part-select.pcert1 : acl2x = 0
-centaur/bitops/part-select.pcert1 : no_pcert = 0
-centaur/bitops/part-select.pcert1 : centaur/bitops/part-select.pcert0
-centaur/bitops/part-select.cert : | centaur/bitops/part-select.pcert1
-
-centaur/bitops/rotate.pcert0 : no_pcert = 0
-centaur/bitops/rotate.pcert0 : acl2x = 0
-centaur/bitops/rotate.pcert0 : \
- xdoc/top.pcert0 \
- tools/bstar.pcert0 \
- ihs/logops-definitions.pcert0 \
- centaur/misc/arith-equivs.pcert0 \
- centaur/bitops/ihsext-basics.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/bitops/equal-by-logbitp.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/rotate.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/rotate.pcert1 : acl2x = 0
-centaur/bitops/rotate.pcert1 : no_pcert = 0
-centaur/bitops/rotate.pcert1 : centaur/bitops/rotate.pcert0
-centaur/bitops/rotate.cert : | centaur/bitops/rotate.pcert1
-
-centaur/bitops/sbitsets.pcert0 : no_pcert = 0
-centaur/bitops/sbitsets.pcert0 : acl2x = 0
-centaur/bitops/sbitsets.pcert0 : \
- centaur/bitops/bits-between.pcert0 \
- misc/definline.pcert0 \
- centaur/bitops/equal-by-logbitp.pcert0 \
- centaur/bitops/ihs-extensions.pcert0 \
- centaur/misc/equal-sets.pcert0 \
- std/lists/revappend.pcert0 \
- std/lists/rev.pcert0 \
- std/lists/append.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/sbitsets.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/sbitsets.pcert1 : acl2x = 0
-centaur/bitops/sbitsets.pcert1 : no_pcert = 0
-centaur/bitops/sbitsets.pcert1 : centaur/bitops/sbitsets.pcert0
-centaur/bitops/sbitsets.cert : | centaur/bitops/sbitsets.pcert1
-
-centaur/bitops/sign-extend.pcert0 : no_pcert = 0
-centaur/bitops/sign-extend.pcert0 : acl2x = 0
-centaur/bitops/sign-extend.pcert0 : \
- xdoc/top.pcert0 \
- misc/definline.pcert0 \
- tools/bstar.pcert0 \
- ihs/logops-definitions.pcert0 \
- centaur/bitops/ihs-extensions.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/sign-extend.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/sign-extend.pcert1 : acl2x = 0
-centaur/bitops/sign-extend.pcert1 : no_pcert = 0
-centaur/bitops/sign-extend.pcert1 : centaur/bitops/sign-extend.pcert0
-centaur/bitops/sign-extend.cert : | centaur/bitops/sign-extend.pcert1
-
-centaur/bitops/top.pcert0 : no_pcert = 0
-centaur/bitops/top.pcert0 : acl2x = 0
-centaur/bitops/top.pcert0 : \
- centaur/bitops/bits-between.pcert0 \
- centaur/bitops/bitsets.pcert0 \
- centaur/bitops/bitsets-opt.pcert0 \
- centaur/bitops/equal-by-logbitp.pcert0 \
- centaur/bitops/ihs-extensions.pcert0 \
- centaur/bitops/integer-length.pcert0 \
- centaur/bitops/sbitsets.pcert0 \
- centaur/bitops/part-select.pcert0 \
- centaur/bitops/extra-defs.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- cutil/portcullis.pcert0 \
- centaur/bitops/top.lisp \
- centaur/bitops/cert.acl2
-centaur/bitops/top.pcert1 : acl2x = 0
-centaur/bitops/top.pcert1 : no_pcert = 0
-centaur/bitops/top.pcert1 : centaur/bitops/top.pcert0
-centaur/bitops/top.cert : | centaur/bitops/top.pcert1
-
-centaur/bridge/portcullis.pcert0 : no_pcert = 0
-centaur/bridge/portcullis.pcert0 : acl2x = 0
-centaur/bridge/portcullis.pcert0 : \
- str/portcullis.pcert0 \
- xdoc/portcullis.pcert0 \
- centaur/bridge/portcullis.lisp \
- centaur/bridge/portcullis.acl2 \
- centaur/bridge/package.lsp \
- tools/flag-package.lsp
-centaur/bridge/portcullis.pcert1 : acl2x = 0
-centaur/bridge/portcullis.pcert1 : no_pcert = 0
-centaur/bridge/portcullis.pcert1 : centaur/bridge/portcullis.pcert0
-centaur/bridge/portcullis.cert : | centaur/bridge/portcullis.pcert1
-
-centaur/bridge/to-json.pcert0 : no_pcert = 0
-centaur/bridge/to-json.pcert0 : acl2x = 0
-centaur/bridge/to-json.pcert0 : \
- misc/definline.pcert0 \
- str/cat.pcert0 \
- str/natstr.pcert0 \
- std/ks/two-nats-measure.pcert0 \
- std/ks/explode-atom.pcert0 \
- centaur/bitops/ihsext-basics.pcert0 \
- misc/assert.pcert0 \
- std/lists/nthcdr.pcert0 \
- arithmetic/top.pcert0 \
- str/strtok.pcert0 \
- tools/flag.pcert0 \
- centaur/bridge/portcullis.pcert0 \
- centaur/bridge/to-json.lisp \
- centaur/bridge/cert.acl2
-centaur/bridge/to-json.pcert1 : acl2x = 0
-centaur/bridge/to-json.pcert1 : no_pcert = 0
-centaur/bridge/to-json.pcert1 : centaur/bridge/to-json.pcert0
-centaur/bridge/to-json.cert : | centaur/bridge/to-json.pcert1
-
-centaur/bridge/top.pcert0 : no_pcert = 0
-centaur/bridge/top.pcert0 : acl2x = 0
-centaur/bridge/top.pcert0 : \
- xdoc/top.pcert0 \
- tools/include-raw.pcert0 \
- str/top.pcert0 \
- centaur/bridge/to-json.pcert0 \
- centaur/bridge/portcullis.pcert0 \
- centaur/bridge/top.lisp \
- centaur/bridge/cert.acl2 \
- centaur/bridge/bridge-raw.lsp
-centaur/bridge/top.pcert1 : acl2x = 0
-centaur/bridge/top.pcert1 : no_pcert = 0
-centaur/bridge/top.pcert1 : centaur/bridge/top.pcert0
-centaur/bridge/top.cert : | centaur/bridge/top.pcert1
-
-centaur/defrstobj/array-lemmas.pcert0 : no_pcert = 0
-centaur/defrstobj/array-lemmas.pcert0 : acl2x = 0
-centaur/defrstobj/array-lemmas.pcert0 : \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/array-lemmas.lisp \
- centaur/defrstobj/cert.acl2
-centaur/defrstobj/array-lemmas.pcert1 : acl2x = 0
-centaur/defrstobj/array-lemmas.pcert1 : no_pcert = 0
-centaur/defrstobj/array-lemmas.pcert1 : centaur/defrstobj/array-lemmas.pcert0
-centaur/defrstobj/array-lemmas.cert : | centaur/defrstobj/array-lemmas.pcert1
-
-centaur/defrstobj/basic-tests.pcert0 : no_pcert = 0
-centaur/defrstobj/basic-tests.pcert0 : acl2x = 0
-centaur/defrstobj/basic-tests.pcert0 : \
- centaur/defrstobj/defrstobj.pcert0 \
- centaur/defrstobj/typed-record-tests.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/basic-tests.lisp \
- centaur/defrstobj/cert.acl2
-centaur/defrstobj/basic-tests.pcert1 : acl2x = 0
-centaur/defrstobj/basic-tests.pcert1 : no_pcert = 0
-centaur/defrstobj/basic-tests.pcert1 : centaur/defrstobj/basic-tests.pcert0
-centaur/defrstobj/basic-tests.cert : | centaur/defrstobj/basic-tests.pcert1
-
-centaur/defrstobj/def-typed-record.pcert0 : no_pcert = 0
-centaur/defrstobj/def-typed-record.pcert0 : acl2x = 0
-centaur/defrstobj/def-typed-record.pcert0 : \
- centaur/defrstobj/typed-records.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/def-typed-record.lisp \
- centaur/defrstobj/cert.acl2
-centaur/defrstobj/def-typed-record.pcert1 : acl2x = 0
-centaur/defrstobj/def-typed-record.pcert1 : no_pcert = 0
-centaur/defrstobj/def-typed-record.pcert1 : centaur/defrstobj/def-typed-record.pcert0
-centaur/defrstobj/def-typed-record.cert : | centaur/defrstobj/def-typed-record.pcert1
-
-centaur/defrstobj/defrstobj.pcert0 : no_pcert = 0
-centaur/defrstobj/defrstobj.pcert0 : acl2x = 0
-centaur/defrstobj/defrstobj.pcert0 : \
- centaur/defrstobj/def-typed-record.pcert0 \
- centaur/defrstobj/g-delete-keys.pcert0 \
- centaur/defrstobj/fancy-worseguy.pcert0 \
- misc/definline.pcert0 \
- misc/records.pcert0 \
- tools/bstar.pcert0 \
- cutil/defsection.pcert0 \
- centaur/defrstobj/array-lemmas.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/defrstobj.lisp \
- centaur/defrstobj/cert.acl2
-centaur/defrstobj/defrstobj.pcert1 : acl2x = 0
-centaur/defrstobj/defrstobj.pcert1 : no_pcert = 0
-centaur/defrstobj/defrstobj.pcert1 : centaur/defrstobj/defrstobj.pcert0
-centaur/defrstobj/defrstobj.cert : | centaur/defrstobj/defrstobj.pcert1
-
-centaur/defrstobj/fancy-worseguy.pcert0 : no_pcert = 0
-centaur/defrstobj/fancy-worseguy.pcert0 : acl2x = 0
-centaur/defrstobj/fancy-worseguy.pcert0 : \
- centaur/defrstobj/g-delete-keys.pcert0 \
- misc/equal-by-g-help.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/fancy-worseguy.lisp \
- centaur/defrstobj/cert.acl2
-centaur/defrstobj/fancy-worseguy.pcert1 : acl2x = 0
-centaur/defrstobj/fancy-worseguy.pcert1 : no_pcert = 0
-centaur/defrstobj/fancy-worseguy.pcert1 : centaur/defrstobj/fancy-worseguy.pcert0
-centaur/defrstobj/fancy-worseguy.cert : | centaur/defrstobj/fancy-worseguy.pcert1
-
-centaur/defrstobj/g-delete-keys.pcert0 : no_pcert = 0
-centaur/defrstobj/g-delete-keys.pcert0 : acl2x = 0
-centaur/defrstobj/g-delete-keys.pcert0 : \
- misc/records.pcert0 \
- misc/equal-by-g.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/g-delete-keys.lisp \
- centaur/defrstobj/cert.acl2
-centaur/defrstobj/g-delete-keys.pcert1 : acl2x = 0
-centaur/defrstobj/g-delete-keys.pcert1 : no_pcert = 0
-centaur/defrstobj/g-delete-keys.pcert1 : centaur/defrstobj/g-delete-keys.pcert0
-centaur/defrstobj/g-delete-keys.cert : | centaur/defrstobj/g-delete-keys.pcert1
-
-centaur/defrstobj/groundwork/array-rec.pcert0 : no_pcert = 0
-centaur/defrstobj/groundwork/array-rec.pcert0 : acl2x = 0
-centaur/defrstobj/groundwork/array-rec.pcert0 : \
- cutil/defsection.pcert0 \
- misc/records.pcert0 \
- misc/equal-by-g.pcert0 \
- centaur/misc/equal-by-nths.pcert0 \
- centaur/defrstobj/groundwork/local.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/groundwork/array-rec.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-centaur/defrstobj/groundwork/array-rec.pcert1 : acl2x = 0
-centaur/defrstobj/groundwork/array-rec.pcert1 : no_pcert = 0
-centaur/defrstobj/groundwork/array-rec.pcert1 : centaur/defrstobj/groundwork/array-rec.pcert0
-centaur/defrstobj/groundwork/array-rec.cert : | centaur/defrstobj/groundwork/array-rec.pcert1
-
-centaur/defrstobj/groundwork/demo1.pcert0 : no_pcert = 0
-centaur/defrstobj/groundwork/demo1.pcert0 : acl2x = 0
-centaur/defrstobj/groundwork/demo1.pcert0 : \
- misc/records.pcert0 \
- misc/definline.pcert0 \
- centaur/defrstobj/groundwork/local.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/groundwork/demo1.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-centaur/defrstobj/groundwork/demo1.pcert1 : acl2x = 0
-centaur/defrstobj/groundwork/demo1.pcert1 : no_pcert = 0
-centaur/defrstobj/groundwork/demo1.pcert1 : centaur/defrstobj/groundwork/demo1.pcert0
-centaur/defrstobj/groundwork/demo1.cert : | centaur/defrstobj/groundwork/demo1.pcert1
-
-centaur/defrstobj/groundwork/demo2.pcert0 : no_pcert = 0
-centaur/defrstobj/groundwork/demo2.pcert0 : acl2x = 0
-centaur/defrstobj/groundwork/demo2.pcert0 : \
- misc/records.pcert0 \
- misc/definline.pcert0 \
- centaur/defrstobj/groundwork/local.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/groundwork/demo2.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-centaur/defrstobj/groundwork/demo2.pcert1 : acl2x = 0
-centaur/defrstobj/groundwork/demo2.pcert1 : no_pcert = 0
-centaur/defrstobj/groundwork/demo2.pcert1 : centaur/defrstobj/groundwork/demo2.pcert0
-centaur/defrstobj/groundwork/demo2.cert : | centaur/defrstobj/groundwork/demo2.pcert1
-
-centaur/defrstobj/groundwork/demo3.pcert0 : no_pcert = 0
-centaur/defrstobj/groundwork/demo3.pcert0 : acl2x = 0
-centaur/defrstobj/groundwork/demo3.pcert0 : \
- cutil/defsection.pcert0 \
- misc/definline.pcert0 \
- misc/records.pcert0 \
- centaur/defrstobj/groundwork/local.pcert0 \
- centaur/defrstobj/groundwork/array-rec.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/groundwork/demo3.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-centaur/defrstobj/groundwork/demo3.pcert1 : acl2x = 0
-centaur/defrstobj/groundwork/demo3.pcert1 : no_pcert = 0
-centaur/defrstobj/groundwork/demo3.pcert1 : centaur/defrstobj/groundwork/demo3.pcert0
-centaur/defrstobj/groundwork/demo3.cert : | centaur/defrstobj/groundwork/demo3.pcert1
-
-centaur/defrstobj/groundwork/demo4.pcert0 : no_pcert = 0
-centaur/defrstobj/groundwork/demo4.pcert0 : acl2x = 0
-centaur/defrstobj/groundwork/demo4.pcert0 : \
- cutil/defsection.pcert0 \
- misc/definline.pcert0 \
- misc/records.pcert0 \
- centaur/defrstobj/groundwork/array-rec.pcert0 \
- centaur/defrstobj/groundwork/local.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/groundwork/demo4.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-centaur/defrstobj/groundwork/demo4.pcert1 : acl2x = 0
-centaur/defrstobj/groundwork/demo4.pcert1 : no_pcert = 0
-centaur/defrstobj/groundwork/demo4.pcert1 : centaur/defrstobj/groundwork/demo4.pcert0
-centaur/defrstobj/groundwork/demo4.cert : | centaur/defrstobj/groundwork/demo4.pcert1
-
-centaur/defrstobj/groundwork/demo5.pcert0 : no_pcert = 0
-centaur/defrstobj/groundwork/demo5.pcert0 : acl2x = 0
-centaur/defrstobj/groundwork/demo5.pcert0 : \
- cutil/defsection.pcert0 \
- misc/definline.pcert0 \
- misc/records.pcert0 \
- centaur/defrstobj/def-typed-record.pcert0 \
- centaur/defrstobj/array-lemmas.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/groundwork/demo5.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-centaur/defrstobj/groundwork/demo5.pcert1 : acl2x = 0
-centaur/defrstobj/groundwork/demo5.pcert1 : no_pcert = 0
-centaur/defrstobj/groundwork/demo5.pcert1 : centaur/defrstobj/groundwork/demo5.pcert0
-centaur/defrstobj/groundwork/demo5.cert : | centaur/defrstobj/groundwork/demo5.pcert1
-
-centaur/defrstobj/groundwork/local.pcert0 : no_pcert = 0
-centaur/defrstobj/groundwork/local.pcert0 : acl2x = 0
-centaur/defrstobj/groundwork/local.pcert0 : \
- misc/records.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/groundwork/local.lisp \
- centaur/defrstobj/groundwork/cert.acl2
-centaur/defrstobj/groundwork/local.pcert1 : acl2x = 0
-centaur/defrstobj/groundwork/local.pcert1 : no_pcert = 0
-centaur/defrstobj/groundwork/local.pcert1 : centaur/defrstobj/groundwork/local.pcert0
-centaur/defrstobj/groundwork/local.cert : | centaur/defrstobj/groundwork/local.pcert1
-
-centaur/defrstobj/portcullis.pcert0 : no_pcert = 0
-centaur/defrstobj/portcullis.pcert0 : acl2x = 0
-centaur/defrstobj/portcullis.pcert0 : \
- centaur/defrstobj/portcullis.lisp \
- centaur/defrstobj/portcullis.acl2 \
- centaur/defrstobj/package.lsp
-centaur/defrstobj/portcullis.pcert1 : acl2x = 0
-centaur/defrstobj/portcullis.pcert1 : no_pcert = 0
-centaur/defrstobj/portcullis.pcert1 : centaur/defrstobj/portcullis.pcert0
-centaur/defrstobj/portcullis.cert : | centaur/defrstobj/portcullis.pcert1
-
-centaur/defrstobj/typed-record-tests.pcert0 : no_pcert = 0
-centaur/defrstobj/typed-record-tests.pcert0 : acl2x = 0
-centaur/defrstobj/typed-record-tests.pcert0 : \
- centaur/defrstobj/def-typed-record.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/typed-record-tests.lisp \
- centaur/defrstobj/cert.acl2
-centaur/defrstobj/typed-record-tests.pcert1 : acl2x = 0
-centaur/defrstobj/typed-record-tests.pcert1 : no_pcert = 0
-centaur/defrstobj/typed-record-tests.pcert1 : centaur/defrstobj/typed-record-tests.pcert0
-centaur/defrstobj/typed-record-tests.cert : | centaur/defrstobj/typed-record-tests.pcert1
-
-centaur/defrstobj/typed-records.pcert0 : no_pcert = 0
-centaur/defrstobj/typed-records.pcert0 : acl2x = 0
-centaur/defrstobj/typed-records.pcert0 : \
- misc/total-order.pcert0 \
- centaur/misc/mfc-utils.pcert0 \
- centaur/misc/introduce-var.pcert0 \
- centaur/misc/equal-by-nths.pcert0 \
- centaur/defrstobj/array-lemmas.pcert0 \
- centaur/defrstobj/portcullis.pcert0 \
- centaur/defrstobj/typed-records.lisp \
- centaur/defrstobj/cert.acl2
-centaur/defrstobj/typed-records.pcert1 : acl2x = 0
-centaur/defrstobj/typed-records.pcert1 : no_pcert = 0
-centaur/defrstobj/typed-records.pcert1 : centaur/defrstobj/typed-records.pcert0
-centaur/defrstobj/typed-records.cert : | centaur/defrstobj/typed-records.pcert1
-
-centaur/esim/esim-paths.pcert0 : no_pcert = 0
-centaur/esim/esim-paths.pcert0 : acl2x = 0
-centaur/esim/esim-paths.pcert0 : \
- centaur/esim/esim-sexpr-support.pcert0 \
- centaur/esim/esim-sexpr-support-thms.pcert0 \
- cutil/deflist.pcert0 \
- cutil/defmvtypes.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/esim-paths.lisp \
- centaur/esim/cert.acl2
-centaur/esim/esim-paths.pcert1 : acl2x = 0
-centaur/esim/esim-paths.pcert1 : no_pcert = 0
-centaur/esim/esim-paths.pcert1 : centaur/esim/esim-paths.pcert0
-centaur/esim/esim-paths.cert : | centaur/esim/esim-paths.pcert1
-
-centaur/esim/esim-primitives.pcert0 : no_pcert = 0
-centaur/esim/esim-primitives.pcert0 : acl2x = 0
-centaur/esim/esim-primitives.pcert0 : \
- tools/bstar.pcert0 \
- xdoc/top.pcert0 \
- centaur/esim/plist.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/esim-primitives.lisp \
- centaur/esim/cert.acl2
-centaur/esim/esim-primitives.pcert1 : acl2x = 0
-centaur/esim/esim-primitives.pcert1 : no_pcert = 0
-centaur/esim/esim-primitives.pcert1 : centaur/esim/esim-primitives.pcert0
-centaur/esim/esim-primitives.cert : | centaur/esim/esim-primitives.pcert1
-
-centaur/esim/esim-sexpr-correct.pcert0 : no_pcert = 0
-centaur/esim/esim-sexpr-correct.pcert0 : acl2x = 0
-centaur/esim/esim-sexpr-correct.pcert0 : \
- centaur/esim/esim-sexpr.pcert0 \
- centaur/esim/esim-spec.pcert0 \
- centaur/esim/esim-sexpr-support-thms.pcert0 \
- centaur/4v-sexpr/sexpr-advanced.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint-top.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/esim-sexpr-correct.lisp \
- centaur/esim/cert.acl2
-centaur/esim/esim-sexpr-correct.pcert1 : acl2x = 0
-centaur/esim/esim-sexpr-correct.pcert1 : no_pcert = 0
-centaur/esim/esim-sexpr-correct.pcert1 : centaur/esim/esim-sexpr-correct.pcert0
-centaur/esim/esim-sexpr-correct.cert : | centaur/esim/esim-sexpr-correct.pcert1
-
-centaur/esim/esim-sexpr-support-thms.pcert0 : no_pcert = 0
-centaur/esim/esim-sexpr-support-thms.pcert0 : acl2x = 0
-centaur/esim/esim-sexpr-support-thms.pcert0 : \
- centaur/esim/esim-sexpr-support.pcert0 \
- centaur/esim/local-theory.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/esim-sexpr-support-thms.lisp \
- centaur/esim/cert.acl2
-centaur/esim/esim-sexpr-support-thms.pcert1 : acl2x = 0
-centaur/esim/esim-sexpr-support-thms.pcert1 : no_pcert = 0
-centaur/esim/esim-sexpr-support-thms.pcert1 : centaur/esim/esim-sexpr-support-thms.pcert0
-centaur/esim/esim-sexpr-support-thms.cert : | centaur/esim/esim-sexpr-support-thms.pcert1
-
-centaur/esim/esim-sexpr-support.pcert0 : no_pcert = 0
-centaur/esim/esim-sexpr-support.pcert0 : acl2x = 0
-centaur/esim/esim-sexpr-support.pcert0 : \
- centaur/esim/plist.pcert0 \
- centaur/misc/patterns.pcert0 \
- centaur/4v-sexpr/sexpr-vars.pcert0 \
- std/ks/explode-nonnegative-integer.pcert0 \
- std/ks/two-nats-measure.pcert0 \
- arithmetic/nat-listp.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/esim-sexpr-support.lisp \
- centaur/esim/cert.acl2
-centaur/esim/esim-sexpr-support.pcert1 : acl2x = 0
-centaur/esim/esim-sexpr-support.pcert1 : no_pcert = 0
-centaur/esim/esim-sexpr-support.pcert1 : centaur/esim/esim-sexpr-support.pcert0
-centaur/esim/esim-sexpr-support.cert : | centaur/esim/esim-sexpr-support.pcert1
-
-centaur/esim/esim-sexpr.pcert0 : no_pcert = 0
-centaur/esim/esim-sexpr.pcert0 : acl2x = 0
-centaur/esim/esim-sexpr.pcert0 : \
- centaur/esim/esim-paths.pcert0 \
- centaur/esim/esim-sexpr-support.pcert0 \
- str/strsubst.pcert0 \
- str/substrp.pcert0 \
- centaur/misc/ap.pcert0 \
- centaur/4v-sexpr/sexpr-fixpoint.pcert0 \
- centaur/4v-sexpr/sexpr-to-faig.pcert0 \
- centaur/4v-sexpr/sexpr-equivs.pcert0 \
- centaur/esim/esim-sexpr-support-thms.pcert0 \
- centaur/4v-sexpr/sexpr-advanced.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/esim-sexpr.lisp \
- centaur/esim/cert.acl2
-centaur/esim/esim-sexpr.pcert1 : acl2x = 0
-centaur/esim/esim-sexpr.pcert1 : no_pcert = 0
-centaur/esim/esim-sexpr.pcert1 : centaur/esim/esim-sexpr.pcert0
-centaur/esim/esim-sexpr.cert : | centaur/esim/esim-sexpr.pcert1
-
-centaur/esim/esim-spec.pcert0 : no_pcert = 0
-centaur/esim/esim-spec.pcert0 : acl2x = 0
-centaur/esim/esim-spec.pcert0 : \
- centaur/esim/esim-sexpr-support.pcert0 \
- std/ks/two-nats-measure.pcert0 \
- std/lists/rev.pcert0 \
- centaur/4v-sexpr/4v-logic.pcert0 \
- centaur/4v-sexpr/sexpr-equivs.pcert0 \
- centaur/misc/patterns.pcert0 \
- centaur/esim/esim-sexpr-support-thms.pcert0 \
- centaur/4v-sexpr/sexpr-advanced.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/esim-spec.lisp \
- centaur/esim/cert.acl2
-centaur/esim/esim-spec.pcert1 : acl2x = 0
-centaur/esim/esim-spec.pcert1 : no_pcert = 0
-centaur/esim/esim-spec.pcert1 : centaur/esim/esim-spec.pcert0
-centaur/esim/esim-spec.cert : | centaur/esim/esim-spec.pcert1
-
-centaur/esim/esim-vcd.pcert0 : no_pcert = 0
-centaur/esim/esim-vcd.pcert0 : acl2x = 0
-centaur/esim/esim-vcd.pcert0 : \
- centaur/esim/esim-vl.pcert0 \
- centaur/esim/esim-paths.pcert0 \
- centaur/misc/load-stobj.pcert0 \
- centaur/vl/mlib/writer.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/util/string-alists.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/esim-vcd.lisp \
- centaur/esim/cert.acl2
-centaur/esim/esim-vcd.pcert1 : acl2x = 0
-centaur/esim/esim-vcd.pcert1 : no_pcert = 0
-centaur/esim/esim-vcd.pcert1 : centaur/esim/esim-vcd.pcert0
-centaur/esim/esim-vcd.cert : | centaur/esim/esim-vcd.pcert1
-
-centaur/esim/esim-vl.pcert0 : no_pcert = 0
-centaur/esim/esim-vl.pcert0 : acl2x = 0
-centaur/esim/esim-vl.pcert0 : \
- centaur/esim/esim-sexpr-support.pcert0 \
- centaur/vl/toe/toe-wirealist.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/esim-vl.lisp \
- centaur/esim/cert.acl2
-centaur/esim/esim-vl.pcert1 : acl2x = 0
-centaur/esim/esim-vl.pcert1 : no_pcert = 0
-centaur/esim/esim-vl.pcert1 : centaur/esim/esim-vl.pcert0
-centaur/esim/esim-vl.cert : | centaur/esim/esim-vl.pcert1
-
-centaur/esim/follow-backwards.pcert0 : no_pcert = 0
-centaur/esim/follow-backwards.pcert0 : acl2x = 0
-centaur/esim/follow-backwards.pcert0 : \
- centaur/esim/esim-paths.pcert0 \
- centaur/esim/esim-sexpr-support-thms.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/follow-backwards.lisp \
- centaur/esim/cert.acl2
-centaur/esim/follow-backwards.pcert1 : acl2x = 0
-centaur/esim/follow-backwards.pcert1 : no_pcert = 0
-centaur/esim/follow-backwards.pcert1 : centaur/esim/follow-backwards.pcert0
-centaur/esim/follow-backwards.cert : | centaur/esim/follow-backwards.pcert1
-
-centaur/esim/local-theory.pcert0 : no_pcert = 0
-centaur/esim/local-theory.pcert0 : acl2x = 0
-centaur/esim/local-theory.pcert0 : \
- std/lists/rev.pcert0 \
- data-structures/list-defthms.pcert0 \
- data-structures/no-duplicates.pcert0 \
- centaur/misc/fast-alists.pcert0 \
- centaur/misc/equal-sets.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/local-theory.lisp \
- centaur/esim/cert.acl2
-centaur/esim/local-theory.pcert1 : acl2x = 0
-centaur/esim/local-theory.pcert1 : no_pcert = 0
-centaur/esim/local-theory.pcert1 : centaur/esim/local-theory.pcert0
-centaur/esim/local-theory.cert : | centaur/esim/local-theory.pcert1
-
-centaur/esim/plist.pcert0 : no_pcert = 0
-centaur/esim/plist.pcert0 : acl2x = 0
-centaur/esim/plist.pcert0 : \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/plist.lisp \
- centaur/esim/cert.acl2
-centaur/esim/plist.pcert1 : acl2x = 0
-centaur/esim/plist.pcert1 : no_pcert = 0
-centaur/esim/plist.pcert1 : centaur/esim/plist.pcert0
-centaur/esim/plist.cert : | centaur/esim/plist.pcert1
-
-centaur/esim/portcullis.pcert0 : no_pcert = 0
-centaur/esim/portcullis.pcert0 : acl2x = 0
-centaur/esim/portcullis.pcert0 : \
- cutil/portcullis.pcert0 \
- str/portcullis.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/esim/portcullis.lisp \
- centaur/esim/portcullis.acl2 \
- centaur/esim/packages.lsp \
- tools/flag-package.lsp
-centaur/esim/portcullis.pcert1 : acl2x = 0
-centaur/esim/portcullis.pcert1 : no_pcert = 0
-centaur/esim/portcullis.pcert1 : centaur/esim/portcullis.pcert0
-centaur/esim/portcullis.cert : | centaur/esim/portcullis.pcert1
-
-centaur/esim/steps.pcert0 : no_pcert = 0
-centaur/esim/steps.pcert0 : acl2x = 0
-centaur/esim/steps.pcert0 : \
- centaur/esim/esim-sexpr.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/steps.lisp \
- centaur/esim/cert.acl2
-centaur/esim/steps.pcert1 : acl2x = 0
-centaur/esim/steps.pcert1 : no_pcert = 0
-centaur/esim/steps.pcert1 : centaur/esim/steps.pcert0
-centaur/esim/steps.cert : | centaur/esim/steps.pcert1
-
-centaur/esim/stv/stv-compile.pcert0 : no_pcert = 0
-centaur/esim/stv/stv-compile.pcert0 : acl2x = 0
-centaur/esim/stv/stv-compile.pcert0 : \
- centaur/esim/stv/stv-util.pcert0 \
- centaur/esim/esim-sexpr-support.pcert0 \
- centaur/esim/follow-backwards.pcert0 \
- centaur/misc/vecs-ints.pcert0 \
- centaur/misc/tuplep.pcert0 \
- cutil/defmvtypes.pcert0 \
- cutil/defprojection.pcert0 \
- str/natstr.pcert0 \
- std/lists/final-cdr.pcert0 \
- centaur/vl/util/defs.pcert0 \
- centaur/esim/esim-sexpr-support-thms.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/stv/stv-compile.lisp \
- centaur/esim/stv/cert.acl2
-centaur/esim/stv/stv-compile.pcert1 : acl2x = 0
-centaur/esim/stv/stv-compile.pcert1 : no_pcert = 0
-centaur/esim/stv/stv-compile.pcert1 : centaur/esim/stv/stv-compile.pcert0
-centaur/esim/stv/stv-compile.cert : | centaur/esim/stv/stv-compile.pcert1
-
-centaur/esim/stv/stv-debug.pcert0 : no_pcert = 0
-centaur/esim/stv/stv-debug.pcert0 : acl2x = 0
-centaur/esim/stv/stv-debug.pcert0 : \
- centaur/esim/stv/stv-run.pcert0 \
- centaur/esim/stv/stv-sim.pcert0 \
- oslib/date.pcert0 \
- centaur/misc/tshell.pcert0 \
- centaur/esim/esim-vcd.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/stv/stv-debug.lisp \
- centaur/esim/stv/cert.acl2
-centaur/esim/stv/stv-debug.pcert1 : acl2x = 0
-centaur/esim/stv/stv-debug.pcert1 : no_pcert = 0
-centaur/esim/stv/stv-debug.pcert1 : centaur/esim/stv/stv-debug.pcert0
-centaur/esim/stv/stv-debug.cert : | centaur/esim/stv/stv-debug.pcert1
-
-centaur/esim/stv/stv-doc.pcert0 : no_pcert = 0
-centaur/esim/stv/stv-doc.pcert0 : acl2x = 0
-centaur/esim/stv/stv-doc.pcert0 : \
- centaur/esim/stv/stv-util.pcert0 \
- centaur/esim/stv/stv-widen.pcert0 \
- str/stringify.pcert0 \
- centaur/vl/util/print-htmlencode.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/stv/stv-doc.lisp \
- centaur/esim/stv/cert.acl2
-centaur/esim/stv/stv-doc.pcert1 : acl2x = 0
-centaur/esim/stv/stv-doc.pcert1 : no_pcert = 0
-centaur/esim/stv/stv-doc.pcert1 : centaur/esim/stv/stv-doc.pcert0
-centaur/esim/stv/stv-doc.cert : | centaur/esim/stv/stv-doc.pcert1
-
-centaur/esim/stv/stv-expand.pcert0 : no_pcert = 0
-centaur/esim/stv/stv-expand.pcert0 : acl2x = 0
-centaur/esim/stv/stv-expand.pcert0 : \
- centaur/esim/stv/stv-util.pcert0 \
- centaur/esim/esim-vl.pcert0 \
- centaur/esim/esim-paths.pcert0 \
- centaur/vl/mlib/hid-tools.pcert0 \
- centaur/vl/mlib/expr-parse.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/stv/stv-expand.lisp \
- centaur/esim/stv/cert.acl2
-centaur/esim/stv/stv-expand.pcert1 : acl2x = 0
-centaur/esim/stv/stv-expand.pcert1 : no_pcert = 0
-centaur/esim/stv/stv-expand.pcert1 : centaur/esim/stv/stv-expand.pcert0
-centaur/esim/stv/stv-expand.cert : | centaur/esim/stv/stv-expand.pcert1
-
-centaur/esim/stv/stv-run.pcert0 : no_pcert = 0
-centaur/esim/stv/stv-run.pcert0 : acl2x = 0
-centaur/esim/stv/stv-run.pcert0 : \
- centaur/esim/stv/stv-util.pcert0 \
- str/hexify.pcert0 \
- centaur/misc/vecs-ints.pcert0 \
- centaur/vl/util/defs.pcert0 \
- centaur/4v-sexpr/bitspecs.pcert0 \
- centaur/4v-sexpr/sexpr-rewrites.pcert0 \
- centaur/gl/gl-util.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/stv/stv-run.lisp \
- centaur/esim/stv/cert.acl2
-centaur/esim/stv/stv-run.pcert1 : acl2x = 0
-centaur/esim/stv/stv-run.pcert1 : no_pcert = 0
-centaur/esim/stv/stv-run.pcert1 : centaur/esim/stv/stv-run.pcert0
-centaur/esim/stv/stv-run.cert : | centaur/esim/stv/stv-run.pcert1
-
-centaur/esim/stv/stv-sim.pcert0 : no_pcert = 0
-centaur/esim/stv/stv-sim.pcert0 : acl2x = 0
-centaur/esim/stv/stv-sim.pcert0 : \
- centaur/esim/stv/stv-util.pcert0 \
- centaur/vl/util/defs.pcert0 \
- centaur/esim/steps.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/stv/stv-sim.lisp \
- centaur/esim/stv/cert.acl2
-centaur/esim/stv/stv-sim.pcert1 : acl2x = 0
-centaur/esim/stv/stv-sim.pcert1 : no_pcert = 0
-centaur/esim/stv/stv-sim.pcert1 : centaur/esim/stv/stv-sim.pcert0
-centaur/esim/stv/stv-sim.cert : | centaur/esim/stv/stv-sim.pcert1
-
-centaur/esim/stv/stv-top.pcert0 : no_pcert = 0
-centaur/esim/stv/stv-top.pcert0 : acl2x = 0
-centaur/esim/stv/stv-top.pcert0 : \
- centaur/esim/stv/stv-sim.pcert0 \
- centaur/esim/stv/stv-compile.pcert0 \
- centaur/esim/stv/stv-expand.pcert0 \
- centaur/esim/stv/stv-widen.pcert0 \
- centaur/esim/stv/stv-doc.pcert0 \
- centaur/esim/stv/stv-run.pcert0 \
- centaur/gl/auto-bindings.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/stv/stv-top.lisp \
- centaur/esim/stv/cert.acl2
-centaur/esim/stv/stv-top.pcert1 : acl2x = 0
-centaur/esim/stv/stv-top.pcert1 : no_pcert = 0
-centaur/esim/stv/stv-top.pcert1 : centaur/esim/stv/stv-top.pcert0
-centaur/esim/stv/stv-top.cert : | centaur/esim/stv/stv-top.pcert1
-
-centaur/esim/stv/stv-util.pcert0 : no_pcert = 0
-centaur/esim/stv/stv-util.pcert0 : acl2x = 0
-centaur/esim/stv/stv-util.pcert0 : \
- centaur/esim/esim-sexpr-support.pcert0 \
- cutil/defaggregate.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/stv/stv-util.lisp \
- centaur/esim/stv/cert.acl2
-centaur/esim/stv/stv-util.pcert1 : acl2x = 0
-centaur/esim/stv/stv-util.pcert1 : no_pcert = 0
-centaur/esim/stv/stv-util.pcert1 : centaur/esim/stv/stv-util.pcert0
-centaur/esim/stv/stv-util.cert : | centaur/esim/stv/stv-util.pcert1
-
-centaur/esim/stv/stv-widen.pcert0 : no_pcert = 0
-centaur/esim/stv/stv-widen.pcert0 : acl2x = 0
-centaur/esim/stv/stv-widen.pcert0 : \
- centaur/esim/stv/stv-util.pcert0 \
- std/lists/repeat.pcert0 \
- std/lists/take.pcert0 \
- centaur/esim/portcullis.pcert0 \
- centaur/esim/stv/stv-widen.lisp \
- centaur/esim/stv/cert.acl2
-centaur/esim/stv/stv-widen.pcert1 : acl2x = 0
-centaur/esim/stv/stv-widen.pcert1 : no_pcert = 0
-centaur/esim/stv/stv-widen.pcert1 : centaur/esim/stv/stv-widen.pcert0
-centaur/esim/stv/stv-widen.cert : | centaur/esim/stv/stv-widen.pcert1
-
-centaur/gl/always-equal-prep.pcert0 : no_pcert = 0
-centaur/gl/always-equal-prep.pcert0 : acl2x = 0
-centaur/gl/always-equal-prep.pcert0 : \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- centaur/gl/g-if.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/always-equal-prep.lisp \
- centaur/gl/cert.acl2
-centaur/gl/always-equal-prep.pcert1 : acl2x = 0
-centaur/gl/always-equal-prep.pcert1 : no_pcert = 0
-centaur/gl/always-equal-prep.pcert1 : centaur/gl/always-equal-prep.pcert0
-centaur/gl/always-equal-prep.cert : | centaur/gl/always-equal-prep.pcert1
-
-centaur/gl/auto-bindings.pcert0 : no_pcert = 0
-centaur/gl/auto-bindings.pcert0 : acl2x = 0
-centaur/gl/auto-bindings.pcert0 : \
- centaur/gl/gl-doc-string.pcert0 \
- centaur/gl/gobject-types.pcert0 \
- centaur/misc/numlist.pcert0 \
- tools/bstar.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/auto-bindings.lisp \
- centaur/gl/cert.acl2
-centaur/gl/auto-bindings.pcert1 : acl2x = 0
-centaur/gl/auto-bindings.pcert1 : no_pcert = 0
-centaur/gl/auto-bindings.pcert1 : centaur/gl/auto-bindings.pcert0
-centaur/gl/auto-bindings.cert : | centaur/gl/auto-bindings.pcert1
-
-centaur/gl/bfr-aig-bddify.pcert0 : no_pcert = 0
-centaur/gl/bfr-aig-bddify.pcert0 : acl2x = 0
-centaur/gl/bfr-aig-bddify.pcert0 : \
- centaur/gl/bfr-sat.pcert0 \
- centaur/gl/gl-doc-string.pcert0 \
- centaur/aig/bddify-correct.pcert0 \
- centaur/aig/eval-restrict.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/bfr-aig-bddify.lisp \
- centaur/gl/cert.acl2
-centaur/gl/bfr-aig-bddify.pcert1 : acl2x = 0
-centaur/gl/bfr-aig-bddify.pcert1 : no_pcert = 0
-centaur/gl/bfr-aig-bddify.pcert1 : centaur/gl/bfr-aig-bddify.pcert0
-centaur/gl/bfr-aig-bddify.cert : | centaur/gl/bfr-aig-bddify.pcert1
-
-centaur/gl/bfr-sat.pcert0 : no_pcert = 0
-centaur/gl/bfr-sat.pcert0 : acl2x = 0
-centaur/gl/bfr-sat.pcert0 : \
- centaur/gl/bfr.pcert0 \
- centaur/gl/gl-doc-string.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/bfr-sat.lisp \
- centaur/gl/cert.acl2
-centaur/gl/bfr-sat.pcert1 : acl2x = 0
-centaur/gl/bfr-sat.pcert1 : no_pcert = 0
-centaur/gl/bfr-sat.pcert1 : centaur/gl/bfr-sat.pcert0
-centaur/gl/bfr-sat.cert : | centaur/gl/bfr-sat.pcert1
-
-centaur/gl/bfr.pcert0 : no_pcert = 0
-centaur/gl/bfr.pcert0 : acl2x = 0
-centaur/gl/bfr.pcert0 : \
- centaur/ubdds/lite.pcert0 \
- centaur/aig/witness.pcert0 \
- clause-processors/term-patterns.pcert0 \
- clause-processors/join-thms.pcert0 \
- tools/flag.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/bfr.lisp \
- centaur/gl/cert.acl2
-centaur/gl/bfr.pcert1 : acl2x = 0
-centaur/gl/bfr.pcert1 : no_pcert = 0
-centaur/gl/bfr.pcert1 : centaur/gl/bfr.pcert0
-centaur/gl/bfr.cert : | centaur/gl/bfr.pcert1
-
-centaur/gl/bvec-ite.pcert0 : no_pcert = 0
-centaur/gl/bvec-ite.pcert0 : acl2x = 0
-centaur/gl/bvec-ite.pcert0 : \
- centaur/gl/bvecs.pcert0 \
- tools/bstar.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/bvec-ite.lisp \
- centaur/gl/cert.acl2
-centaur/gl/bvec-ite.pcert1 : acl2x = 0
-centaur/gl/bvec-ite.pcert1 : no_pcert = 0
-centaur/gl/bvec-ite.pcert1 : centaur/gl/bvec-ite.pcert0
-centaur/gl/bvec-ite.cert : | centaur/gl/bvec-ite.pcert1
-
-centaur/gl/bvecs.pcert0 : no_pcert = 0
-centaur/gl/bvecs.pcert0 : acl2x = 0
-centaur/gl/bvecs.pcert0 : \
- centaur/gl/bfr.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- ihs/math-lemmas.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/bvecs.lisp \
- centaur/gl/cert.acl2
-centaur/gl/bvecs.pcert1 : acl2x = 0
-centaur/gl/bvecs.pcert1 : no_pcert = 0
-centaur/gl/bvecs.pcert1 : centaur/gl/bvecs.pcert0
-centaur/gl/bvecs.cert : | centaur/gl/bvecs.pcert1
-
-centaur/gl/def-gl-clause-proc.pcert0 : no_pcert = 0
-centaur/gl/def-gl-clause-proc.pcert0 : acl2x = 0
-centaur/gl/def-gl-clause-proc.pcert0 : \
- parallel/without-waterfall-parallelism.pcert0 \
- centaur/misc/defapply.pcert0 \
- centaur/gl/gify.pcert0 \
- centaur/gl/gify-thms.pcert0 \
- centaur/gl/run-gified-cp.pcert0 \
- centaur/gl/general-object-thms.pcert0 \
- centaur/gl/glcp-templates.pcert0 \
- centaur/gl/gl-doc-string.pcert0 \
- centaur/gl/generic-geval.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/def-gl-clause-proc.lisp \
- centaur/gl/cert.acl2
-centaur/gl/def-gl-clause-proc.pcert1 : acl2x = 0
-centaur/gl/def-gl-clause-proc.pcert1 : no_pcert = 0
-centaur/gl/def-gl-clause-proc.pcert1 : centaur/gl/def-gl-clause-proc.pcert0
-centaur/gl/def-gl-clause-proc.cert : | centaur/gl/def-gl-clause-proc.pcert1
-
-centaur/gl/defagg.pcert0 : no_pcert = 0
-centaur/gl/defagg.pcert0 : acl2x = 0
-centaur/gl/defagg.pcert0 : \
- cutil/defaggregate.pcert0 \
- tools/flag.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/defagg.lisp \
- centaur/gl/cert.acl2
-centaur/gl/defagg.pcert1 : acl2x = 0
-centaur/gl/defagg.pcert1 : no_pcert = 0
-centaur/gl/defagg.pcert1 : centaur/gl/defagg.pcert0
-centaur/gl/defagg.cert : | centaur/gl/defagg.pcert1
-
-centaur/gl/defapply.pcert0 : no_pcert = 0
-centaur/gl/defapply.pcert0 : acl2x = 0
-centaur/gl/defapply.pcert0 : \
- clause-processors/generalize.pcert0 \
- tools/mv-nth.pcert0 \
- tools/rulesets.pcert0 \
- centaur/gl/gl-util.pcert0 \
- misc/hons-help2.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/defapply.lisp \
- centaur/gl/cert.acl2
-centaur/gl/defapply.pcert1 : acl2x = 0
-centaur/gl/defapply.pcert1 : no_pcert = 0
-centaur/gl/defapply.pcert1 : centaur/gl/defapply.pcert0
-centaur/gl/defapply.cert : | centaur/gl/defapply.pcert1
-
-centaur/gl/eval-f-i-cp.pcert0 : no_pcert = 0
-centaur/gl/eval-f-i-cp.pcert0 : acl2x = 0
-centaur/gl/eval-f-i-cp.pcert0 : \
- centaur/gl/gl-util.pcert0 \
- tools/bstar.pcert0 \
- tools/mv-nth.pcert0 \
- misc/hons-help2.pcert0 \
- clause-processors/join-thms.pcert0 \
- centaur/misc/hons-sets.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/eval-f-i-cp.lisp \
- centaur/gl/cert.acl2
-centaur/gl/eval-f-i-cp.pcert1 : acl2x = 0
-centaur/gl/eval-f-i-cp.pcert1 : no_pcert = 0
-centaur/gl/eval-f-i-cp.pcert1 : centaur/gl/eval-f-i-cp.pcert0
-centaur/gl/eval-f-i-cp.cert : | centaur/gl/eval-f-i-cp.pcert1
-
-centaur/gl/eval-g-base-help.pcert0 : no_pcert = 0
-centaur/gl/eval-g-base-help.pcert0 : acl2x = 0
-centaur/gl/eval-g-base-help.pcert0 : \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/gify-clause-proc.pcert0 \
- centaur/gl/general-object-thms.pcert0 \
- tools/def-functional-instance.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/eval-g-base-help.lisp \
- centaur/gl/cert.acl2
-centaur/gl/eval-g-base-help.pcert1 : acl2x = 0
-centaur/gl/eval-g-base-help.pcert1 : no_pcert = 0
-centaur/gl/eval-g-base-help.pcert1 : centaur/gl/eval-g-base-help.pcert0
-centaur/gl/eval-g-base-help.cert : | centaur/gl/eval-g-base-help.pcert1
-
-centaur/gl/eval-g-base.pcert0 : no_pcert = 0
-centaur/gl/eval-g-base.pcert0 : acl2x = 0
-centaur/gl/eval-g-base.pcert0 : \
- centaur/gl/defapply.pcert0 \
- centaur/gl/generic-geval.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/eval-g-base.lisp \
- centaur/gl/cert.acl2
-centaur/gl/eval-g-base.pcert1 : acl2x = 0
-centaur/gl/eval-g-base.pcert1 : no_pcert = 0
-centaur/gl/eval-g-base.pcert1 : centaur/gl/eval-g-base.pcert0
-centaur/gl/eval-g-base.cert : | centaur/gl/eval-g-base.pcert1
-
-centaur/gl/factor-fns.pcert0 : no_pcert = 0
-centaur/gl/factor-fns.pcert0 : acl2x = 0
-centaur/gl/factor-fns.pcert0 : \
- tools/bstar.pcert0 \
- centaur/gl/rws.pcert0 \
- clause-processors/generalize.pcert0 \
- misc/hons-help.pcert0 \
- centaur/gl/gl-util.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/factor-fns.lisp \
- centaur/gl/cert.acl2
-centaur/gl/factor-fns.pcert1 : acl2x = 0
-centaur/gl/factor-fns.pcert1 : no_pcert = 0
-centaur/gl/factor-fns.pcert1 : centaur/gl/factor-fns.pcert0
-centaur/gl/factor-fns.cert : | centaur/gl/factor-fns.pcert1
-
-centaur/gl/g-always-equal.pcert0 : no_pcert = 0
-centaur/gl/g-always-equal.pcert0 : acl2x = 0
-centaur/gl/g-always-equal.pcert0 : \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/g-if.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- centaur/gl/always-equal-prep.pcert0 \
- centaur/gl/g-equal.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-always-equal.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-always-equal.pcert1 : acl2x = 0
-centaur/gl/g-always-equal.pcert1 : no_pcert = 0
-centaur/gl/g-always-equal.pcert1 : centaur/gl/g-always-equal.pcert0
-centaur/gl/g-always-equal.cert : | centaur/gl/g-always-equal.pcert1
-
-centaur/gl/g-ash.pcert0 : no_pcert = 0
-centaur/gl/g-ash.pcert0 : acl2x = 0
-centaur/gl/g-ash.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-ash.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-ash.pcert1 : acl2x = 0
-centaur/gl/g-ash.pcert1 : no_pcert = 0
-centaur/gl/g-ash.pcert1 : centaur/gl/g-ash.pcert0
-centaur/gl/g-ash.cert : | centaur/gl/g-ash.pcert1
-
-centaur/gl/g-binary-+.pcert0 : no_pcert = 0
-centaur/gl/g-binary-+.pcert0 : acl2x = 0
-centaur/gl/g-binary-+.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-binary-+.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-binary-+.pcert1 : acl2x = 0
-centaur/gl/g-binary-+.pcert1 : no_pcert = 0
-centaur/gl/g-binary-+.pcert1 : centaur/gl/g-binary-+.pcert0
-centaur/gl/g-binary-+.cert : | centaur/gl/g-binary-+.pcert1
-
-centaur/gl/g-binary-mult.pcert0 : no_pcert = 0
-centaur/gl/g-binary-mult.pcert0 : acl2x = 0
-centaur/gl/g-binary-mult.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-binary-mult.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-binary-mult.pcert1 : acl2x = 0
-centaur/gl/g-binary-mult.pcert1 : no_pcert = 0
-centaur/gl/g-binary-mult.pcert1 : centaur/gl/g-binary-mult.pcert0
-centaur/gl/g-binary-mult.cert : | centaur/gl/g-binary-mult.pcert1
-
-centaur/gl/g-code-char.pcert0 : no_pcert = 0
-centaur/gl/g-code-char.pcert0 : acl2x = 0
-centaur/gl/g-code-char.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- centaur/gl/g-lessthan.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-code-char.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-code-char.pcert1 : acl2x = 0
-centaur/gl/g-code-char.pcert1 : no_pcert = 0
-centaur/gl/g-code-char.pcert1 : centaur/gl/g-code-char.pcert0
-centaur/gl/g-code-char.cert : | centaur/gl/g-code-char.pcert1
-
-centaur/gl/g-coerce.pcert0 : no_pcert = 0
-centaur/gl/g-coerce.pcert0 : acl2x = 0
-centaur/gl/g-coerce.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-coerce.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-coerce.pcert1 : acl2x = 0
-centaur/gl/g-coerce.pcert1 : no_pcert = 0
-centaur/gl/g-coerce.pcert1 : centaur/gl/g-coerce.pcert0
-centaur/gl/g-coerce.cert : | centaur/gl/g-coerce.pcert1
-
-centaur/gl/g-cons.pcert0 : no_pcert = 0
-centaur/gl/g-cons.pcert0 : acl2x = 0
-centaur/gl/g-cons.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-cons.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-cons.pcert1 : acl2x = 0
-centaur/gl/g-cons.pcert1 : no_pcert = 0
-centaur/gl/g-cons.pcert1 : centaur/gl/g-cons.pcert0
-centaur/gl/g-cons.cert : | centaur/gl/g-cons.pcert1
-
-centaur/gl/g-equal.pcert0 : no_pcert = 0
-centaur/gl/g-equal.pcert0 : acl2x = 0
-centaur/gl/g-equal.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-equal.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-equal.pcert1 : acl2x = 0
-centaur/gl/g-equal.pcert1 : no_pcert = 0
-centaur/gl/g-equal.pcert1 : centaur/gl/g-equal.pcert0
-centaur/gl/g-equal.cert : | centaur/gl/g-equal.pcert1
-
-centaur/gl/g-floor.pcert0 : no_pcert = 0
-centaur/gl/g-floor.pcert0 : acl2x = 0
-centaur/gl/g-floor.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-floor.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-floor.pcert1 : acl2x = 0
-centaur/gl/g-floor.pcert1 : no_pcert = 0
-centaur/gl/g-floor.pcert1 : centaur/gl/g-floor.pcert0
-centaur/gl/g-floor.cert : | centaur/gl/g-floor.pcert1
-
-centaur/gl/g-gl-mbe.pcert0 : no_pcert = 0
-centaur/gl/g-gl-mbe.pcert0 : acl2x = 0
-centaur/gl/g-gl-mbe.pcert0 : \
- centaur/gl/bfr-sat.pcert0 \
- centaur/gl/g-always-equal.pcert0 \
- centaur/gl/gl-mbe.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-gl-mbe.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-gl-mbe.pcert1 : acl2x = 0
-centaur/gl/g-gl-mbe.pcert1 : no_pcert = 0
-centaur/gl/g-gl-mbe.pcert1 : centaur/gl/g-gl-mbe.pcert0
-centaur/gl/g-gl-mbe.cert : | centaur/gl/g-gl-mbe.pcert1
-
-centaur/gl/g-hide.pcert0 : no_pcert = 0
-centaur/gl/g-hide.pcert0 : acl2x = 0
-centaur/gl/g-hide.pcert0 : \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/gobjectp-thms.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-hide.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-hide.pcert1 : acl2x = 0
-centaur/gl/g-hide.pcert1 : no_pcert = 0
-centaur/gl/g-hide.pcert1 : centaur/gl/g-hide.pcert0
-centaur/gl/g-hide.cert : | centaur/gl/g-hide.pcert1
-
-centaur/gl/g-if.pcert0 : no_pcert = 0
-centaur/gl/g-if.pcert0 : acl2x = 0
-centaur/gl/g-if.pcert0 : \
- centaur/gl/ite-merge.pcert0 \
- centaur/gl/gtests.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-if.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-if.pcert1 : acl2x = 0
-centaur/gl/g-if.pcert1 : no_pcert = 0
-centaur/gl/g-if.pcert1 : centaur/gl/g-if.pcert0
-centaur/gl/g-if.cert : | centaur/gl/g-if.pcert1
-
-centaur/gl/g-integer-length.pcert0 : no_pcert = 0
-centaur/gl/g-integer-length.pcert0 : acl2x = 0
-centaur/gl/g-integer-length.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-integer-length.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-integer-length.pcert1 : acl2x = 0
-centaur/gl/g-integer-length.pcert1 : no_pcert = 0
-centaur/gl/g-integer-length.pcert1 : centaur/gl/g-integer-length.pcert0
-centaur/gl/g-integer-length.cert : | centaur/gl/g-integer-length.pcert1
-
-centaur/gl/g-intern.pcert0 : no_pcert = 0
-centaur/gl/g-intern.pcert0 : acl2x = 0
-centaur/gl/g-intern.pcert0 : \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/g-if.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-intern.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-intern.pcert1 : acl2x = 0
-centaur/gl/g-intern.pcert1 : no_pcert = 0
-centaur/gl/g-intern.pcert1 : centaur/gl/g-intern.pcert0
-centaur/gl/g-intern.cert : | centaur/gl/g-intern.pcert1
-
-centaur/gl/g-lessthan.pcert0 : no_pcert = 0
-centaur/gl/g-lessthan.pcert0 : acl2x = 0
-centaur/gl/g-lessthan.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-lessthan.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-lessthan.pcert1 : acl2x = 0
-centaur/gl/g-lessthan.pcert1 : no_pcert = 0
-centaur/gl/g-lessthan.pcert1 : centaur/gl/g-lessthan.pcert0
-centaur/gl/g-lessthan.cert : | centaur/gl/g-lessthan.pcert1
-
-centaur/gl/g-logand.pcert0 : no_pcert = 0
-centaur/gl/g-logand.pcert0 : acl2x = 0
-centaur/gl/g-logand.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-logand.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-logand.pcert1 : acl2x = 0
-centaur/gl/g-logand.pcert1 : no_pcert = 0
-centaur/gl/g-logand.pcert1 : centaur/gl/g-logand.pcert0
-centaur/gl/g-logand.cert : | centaur/gl/g-logand.pcert1
-
-centaur/gl/g-logbitp.pcert0 : no_pcert = 0
-centaur/gl/g-logbitp.pcert0 : acl2x = 0
-centaur/gl/g-logbitp.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-logbitp.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-logbitp.pcert1 : acl2x = 0
-centaur/gl/g-logbitp.pcert1 : no_pcert = 0
-centaur/gl/g-logbitp.pcert1 : centaur/gl/g-logbitp.pcert0
-centaur/gl/g-logbitp.cert : | centaur/gl/g-logbitp.pcert1
-
-centaur/gl/g-logior.pcert0 : no_pcert = 0
-centaur/gl/g-logior.pcert0 : acl2x = 0
-centaur/gl/g-logior.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-logior.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-logior.pcert1 : acl2x = 0
-centaur/gl/g-logior.pcert1 : no_pcert = 0
-centaur/gl/g-logior.pcert1 : centaur/gl/g-logior.pcert0
-centaur/gl/g-logior.cert : | centaur/gl/g-logior.pcert1
-
-centaur/gl/g-lognot.pcert0 : no_pcert = 0
-centaur/gl/g-lognot.pcert0 : acl2x = 0
-centaur/gl/g-lognot.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-lognot.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-lognot.pcert1 : acl2x = 0
-centaur/gl/g-lognot.pcert1 : no_pcert = 0
-centaur/gl/g-lognot.pcert1 : centaur/gl/g-lognot.pcert0
-centaur/gl/g-lognot.cert : | centaur/gl/g-lognot.pcert1
-
-centaur/gl/g-make-fast-alist.pcert0 : no_pcert = 0
-centaur/gl/g-make-fast-alist.pcert0 : acl2x = 0
-centaur/gl/g-make-fast-alist.pcert0 : \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/g-if.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-make-fast-alist.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-make-fast-alist.pcert1 : acl2x = 0
-centaur/gl/g-make-fast-alist.pcert1 : no_pcert = 0
-centaur/gl/g-make-fast-alist.pcert1 : centaur/gl/g-make-fast-alist.pcert0
-centaur/gl/g-make-fast-alist.cert : | centaur/gl/g-make-fast-alist.pcert1
-
-centaur/gl/g-mod.pcert0 : no_pcert = 0
-centaur/gl/g-mod.pcert0 : acl2x = 0
-centaur/gl/g-mod.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-mod.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-mod.pcert1 : acl2x = 0
-centaur/gl/g-mod.pcert1 : no_pcert = 0
-centaur/gl/g-mod.pcert1 : centaur/gl/g-mod.pcert0
-centaur/gl/g-mod.cert : | centaur/gl/g-mod.pcert1
-
-centaur/gl/g-predicates.pcert0 : no_pcert = 0
-centaur/gl/g-predicates.pcert0 : acl2x = 0
-centaur/gl/g-predicates.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-predicates.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-predicates.pcert1 : acl2x = 0
-centaur/gl/g-predicates.pcert1 : no_pcert = 0
-centaur/gl/g-predicates.pcert1 : centaur/gl/g-predicates.pcert0
-centaur/gl/g-predicates.cert : | centaur/gl/g-predicates.pcert1
-
-centaur/gl/g-primitives-help.pcert0 : no_pcert = 0
-centaur/gl/g-primitives-help.pcert0 : acl2x = 0
-centaur/gl/g-primitives-help.pcert0 : \
- tools/flag.pcert0 \
- centaur/gl/gl-util.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-primitives-help.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-primitives-help.pcert1 : acl2x = 0
-centaur/gl/g-primitives-help.pcert1 : no_pcert = 0
-centaur/gl/g-primitives-help.pcert1 : centaur/gl/g-primitives-help.pcert0
-centaur/gl/g-primitives-help.cert : | centaur/gl/g-primitives-help.pcert1
-
-centaur/gl/g-rem.pcert0 : no_pcert = 0
-centaur/gl/g-rem.pcert0 : acl2x = 0
-centaur/gl/g-rem.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-rem.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-rem.pcert1 : acl2x = 0
-centaur/gl/g-rem.pcert1 : no_pcert = 0
-centaur/gl/g-rem.pcert1 : centaur/gl/g-rem.pcert0
-centaur/gl/g-rem.cert : | centaur/gl/g-rem.pcert1
-
-centaur/gl/g-truncate.pcert0 : no_pcert = 0
-centaur/gl/g-truncate.pcert0 : acl2x = 0
-centaur/gl/g-truncate.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-truncate.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-truncate.pcert1 : acl2x = 0
-centaur/gl/g-truncate.pcert1 : no_pcert = 0
-centaur/gl/g-truncate.pcert1 : centaur/gl/g-truncate.pcert0
-centaur/gl/g-truncate.cert : | centaur/gl/g-truncate.pcert1
-
-centaur/gl/g-unary--.pcert0 : no_pcert = 0
-centaur/gl/g-unary--.pcert0 : acl2x = 0
-centaur/gl/g-unary--.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-unary--.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-unary--.pcert1 : acl2x = 0
-centaur/gl/g-unary--.pcert1 : no_pcert = 0
-centaur/gl/g-unary--.pcert1 : centaur/gl/g-unary--.pcert0
-centaur/gl/g-unary--.cert : | centaur/gl/g-unary--.pcert1
-
-centaur/gl/g-unary-concrete.pcert0 : no_pcert = 0
-centaur/gl/g-unary-concrete.pcert0 : acl2x = 0
-centaur/gl/g-unary-concrete.pcert0 : \
- centaur/gl/g-if.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- centaur/gl/eval-g-base.pcert0 \
- centaur/gl/symbolic-arithmetic.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/g-unary-concrete.lisp \
- centaur/gl/cert.acl2
-centaur/gl/g-unary-concrete.pcert1 : acl2x = 0
-centaur/gl/g-unary-concrete.pcert1 : no_pcert = 0
-centaur/gl/g-unary-concrete.pcert1 : centaur/gl/g-unary-concrete.pcert0
-centaur/gl/g-unary-concrete.cert : | centaur/gl/g-unary-concrete.pcert1
-
-centaur/gl/general-object-thms.pcert0 : no_pcert = 0
-centaur/gl/general-object-thms.pcert0 : acl2x = 0
-centaur/gl/general-object-thms.pcert0 : \
- centaur/gl/gtype-thms.pcert0 \
- centaur/gl/general-objects.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/general-object-thms.lisp \
- centaur/gl/cert.acl2
-centaur/gl/general-object-thms.pcert1 : acl2x = 0
-centaur/gl/general-object-thms.pcert1 : no_pcert = 0
-centaur/gl/general-object-thms.pcert1 : centaur/gl/general-object-thms.pcert0
-centaur/gl/general-object-thms.cert : | centaur/gl/general-object-thms.pcert1
-
-centaur/gl/general-objects.pcert0 : no_pcert = 0
-centaur/gl/general-objects.pcert0 : acl2x = 0
-centaur/gl/general-objects.pcert0 : \
- centaur/gl/gtypes.pcert0 \
- centaur/gl/gobjectp-thms.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/general-objects.lisp \
- centaur/gl/cert.acl2
-centaur/gl/general-objects.pcert1 : acl2x = 0
-centaur/gl/general-objects.pcert1 : no_pcert = 0
-centaur/gl/general-objects.pcert1 : centaur/gl/general-objects.pcert0
-centaur/gl/general-objects.cert : | centaur/gl/general-objects.pcert1
-
-centaur/gl/generic-geval.pcert0 : no_pcert = 0
-centaur/gl/generic-geval.pcert0 : acl2x = 0
-centaur/gl/generic-geval.pcert0 : \
- centaur/gl/gobjectp.pcert0 \
- centaur/gl/bvecs.pcert0 \
- tools/bstar.pcert0 \
- centaur/gl/gobjectp-thms.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/generic-geval.lisp \
- centaur/gl/cert.acl2
-centaur/gl/generic-geval.pcert1 : acl2x = 0
-centaur/gl/generic-geval.pcert1 : no_pcert = 0
-centaur/gl/generic-geval.pcert1 : centaur/gl/generic-geval.pcert0
-centaur/gl/generic-geval.cert : | centaur/gl/generic-geval.pcert1
-
-centaur/gl/gify-clause-proc.pcert0 : no_pcert = 0
-centaur/gl/gify-clause-proc.pcert0 : acl2x = 0
-centaur/gl/gify-clause-proc.pcert0 : \
- centaur/gl/g-if.pcert0 \
- clause-processors/unify-subst.pcert0 \
- tools/def-functional-instance.pcert0 \
- tools/defevaluator-fast.pcert0 \
- centaur/gl/gtype-thms.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gify-clause-proc.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gify-clause-proc.pcert1 : acl2x = 0
-centaur/gl/gify-clause-proc.pcert1 : no_pcert = 0
-centaur/gl/gify-clause-proc.pcert1 : centaur/gl/gify-clause-proc.pcert0
-centaur/gl/gify-clause-proc.cert : | centaur/gl/gify-clause-proc.pcert1
-
-centaur/gl/gify-thms.pcert0 : no_pcert = 0
-centaur/gl/gify-thms.pcert0 : acl2x = 0
-centaur/gl/gify-thms.pcert0 : \
- centaur/gl/gify-clause-proc.pcert0 \
- centaur/gl/gtype-thms.pcert0 \
- centaur/gl/gobjectp-thms.pcert0 \
- centaur/gl/general-object-thms.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- std/ks/two-nats-measure.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gify-thms.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gify-thms.pcert1 : acl2x = 0
-centaur/gl/gify-thms.pcert1 : no_pcert = 0
-centaur/gl/gify-thms.pcert1 : centaur/gl/gify-thms.pcert0
-centaur/gl/gify-thms.cert : | centaur/gl/gify-thms.pcert1
-
-centaur/gl/gify.pcert0 : no_pcert = 0
-centaur/gl/gify.pcert0 : acl2x = 0
-centaur/gl/gify.pcert0 : \
- tools/bstar.pcert0 \
- centaur/gl/defapply.pcert0 \
- misc/hons-help.pcert0 \
- centaur/gl/factor-fns.pcert0 \
- centaur/gl/g-primitives-help.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gify.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gify.pcert1 : acl2x = 0
-centaur/gl/gify.pcert1 : no_pcert = 0
-centaur/gl/gify.pcert1 : centaur/gl/gify.pcert0
-centaur/gl/gify.cert : | centaur/gl/gify.pcert1
-
-centaur/gl/gl-doc-string.pcert0 : no_pcert = 0
-centaur/gl/gl-doc-string.pcert0 : acl2x = 0
-centaur/gl/gl-doc-string.pcert0 : \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gl-doc-string.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gl-doc-string.pcert1 : acl2x = 0
-centaur/gl/gl-doc-string.pcert1 : no_pcert = 0
-centaur/gl/gl-doc-string.pcert1 : centaur/gl/gl-doc-string.pcert0
-centaur/gl/gl-doc-string.cert : | centaur/gl/gl-doc-string.pcert1
-
-centaur/gl/gl-generic-clause-proc.pcert0 : no_pcert = 0
-centaur/gl/gl-generic-clause-proc.pcert0 : acl2x = 0
-centaur/gl/gl-generic-clause-proc.pcert0 : \
- centaur/gl/param.pcert0 \
- centaur/gl/g-if.pcert0 \
- centaur/gl/gify.pcert0 \
- centaur/gl/bfr-sat.pcert0 \
- centaur/gl/glcp-templates.pcert0 \
- misc/untranslate-patterns.pcert0 \
- data-structures/no-duplicates.pcert0 \
- clause-processors/use-by-hint.pcert0 \
- clause-processors/decomp-hint.pcert0 \
- centaur/misc/interp-function-lookup.pcert0 \
- centaur/gl/general-object-thms.pcert0 \
- centaur/misc/hons-sets.pcert0 \
- tools/with-quoted-forms.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- system/f-put-global.pcert0 \
- tools/def-functional-instance.pcert0 \
- centaur/misc/vecs-ints.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gl-generic-clause-proc.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gl-generic-clause-proc.pcert1 : acl2x = 0
-centaur/gl/gl-generic-clause-proc.pcert1 : no_pcert = 0
-centaur/gl/gl-generic-clause-proc.pcert1 : centaur/gl/gl-generic-clause-proc.pcert0
-centaur/gl/gl-generic-clause-proc.cert : | centaur/gl/gl-generic-clause-proc.pcert1
-
-centaur/gl/gl-mbe.pcert0 : no_pcert = 0
-centaur/gl/gl-mbe.pcert0 : acl2x = 0
-centaur/gl/gl-mbe.pcert0 : \
- centaur/gl/gl-doc-string.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gl-mbe.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gl-mbe.pcert1 : acl2x = 0
-centaur/gl/gl-mbe.pcert1 : no_pcert = 0
-centaur/gl/gl-mbe.pcert1 : centaur/gl/gl-mbe.pcert0
-centaur/gl/gl-mbe.cert : | centaur/gl/gl-mbe.pcert1
-
-centaur/gl/gl-misc-defs.pcert0 : no_pcert = 0
-centaur/gl/gl-misc-defs.pcert0 : acl2x = 0
-centaur/gl/gl-misc-defs.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- std/ks/two-nats-measure.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gl-misc-defs.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gl-misc-defs.pcert1 : acl2x = 0
-centaur/gl/gl-misc-defs.pcert1 : no_pcert = 0
-centaur/gl/gl-misc-defs.pcert1 : centaur/gl/gl-misc-defs.pcert0
-centaur/gl/gl-misc-defs.cert : | centaur/gl/gl-misc-defs.pcert1
-
-centaur/gl/gl-misc-doc.pcert0 : no_pcert = 0
-centaur/gl/gl-misc-doc.pcert0 : acl2x = 0
-centaur/gl/gl-misc-doc.pcert0 : \
- centaur/gl/gl-doc-string.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gl-misc-doc.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gl-misc-doc.pcert1 : acl2x = 0
-centaur/gl/gl-misc-doc.pcert1 : no_pcert = 0
-centaur/gl/gl-misc-doc.pcert1 : centaur/gl/gl-misc-doc.pcert0
-centaur/gl/gl-misc-doc.cert : | centaur/gl/gl-misc-doc.pcert1
-
-centaur/gl/gl-util.pcert0 : no_pcert = 0
-centaur/gl/gl-util.pcert0 : acl2x = 0
-centaur/gl/gl-util.pcert0 : \
- tools/flag.pcert0 \
- tools/bstar.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gl-util.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gl-util.pcert1 : acl2x = 0
-centaur/gl/gl-util.pcert1 : no_pcert = 0
-centaur/gl/gl-util.pcert1 : centaur/gl/gl-util.pcert0
-centaur/gl/gl-util.cert : | centaur/gl/gl-util.pcert1
-
-centaur/gl/gl.pcert0 : no_pcert = 0
-centaur/gl/gl.pcert0 : acl2x = 0
-centaur/gl/gl.pcert0 : \
- centaur/gl/g-ash.pcert0 \
- centaur/gl/g-binary-+.pcert0 \
- centaur/gl/g-cons.pcert0 \
- centaur/gl/g-equal.pcert0 \
- centaur/gl/g-always-equal.pcert0 \
- centaur/gl/g-integer-length.pcert0 \
- centaur/gl/g-lessthan.pcert0 \
- centaur/gl/g-logand.pcert0 \
- centaur/gl/g-logior.pcert0 \
- centaur/gl/g-lognot.pcert0 \
- centaur/gl/g-logbitp.pcert0 \
- centaur/gl/g-unary--.pcert0 \
- centaur/gl/g-hide.pcert0 \
- centaur/gl/g-predicates.pcert0 \
- centaur/gl/g-binary-mult.pcert0 \
- centaur/gl/g-floor.pcert0 \
- centaur/gl/g-make-fast-alist.pcert0 \
- centaur/gl/g-mod.pcert0 \
- centaur/gl/g-truncate.pcert0 \
- centaur/gl/g-rem.pcert0 \
- centaur/gl/g-unary-concrete.pcert0 \
- centaur/gl/g-coerce.pcert0 \
- centaur/gl/g-code-char.pcert0 \
- centaur/gl/g-intern.pcert0 \
- centaur/gl/gl-misc-defs.pcert0 \
- centaur/gl/eval-f-i-cp.pcert0 \
- centaur/gl/gl-generic-clause-proc.pcert0 \
- centaur/gl/def-gl-clause-proc.pcert0 \
- centaur/gl/gify-thms.pcert0 \
- centaur/gl/gl-misc-doc.pcert0 \
- centaur/gl/auto-bindings.pcert0 \
- centaur/gl/g-gl-mbe.pcert0 \
- centaur/gl/general-object-thms.pcert0 \
- centaur/gl/eval-g-base-help.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gl.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gl.pcert1 : acl2x = 0
-centaur/gl/gl.pcert1 : no_pcert = 0
-centaur/gl/gl.pcert1 : centaur/gl/gl.pcert0
-centaur/gl/gl.cert : | centaur/gl/gl.pcert1
-
-centaur/gl/glcp-templates.pcert0 : no_pcert = 0
-centaur/gl/glcp-templates.pcert0 : acl2x = 0
-centaur/gl/glcp-templates.pcert0 : \
- tools/flag.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/glcp-templates.lisp \
- centaur/gl/cert.acl2
-centaur/gl/glcp-templates.pcert1 : acl2x = 0
-centaur/gl/glcp-templates.pcert1 : no_pcert = 0
-centaur/gl/glcp-templates.pcert1 : centaur/gl/glcp-templates.pcert0
-centaur/gl/glcp-templates.cert : | centaur/gl/glcp-templates.pcert1
-
-centaur/gl/gobject-type-thms.pcert0 : no_pcert = 0
-centaur/gl/gobject-type-thms.pcert0 : acl2x = 0
-centaur/gl/gobject-type-thms.pcert0 : \
- centaur/gl/defagg.pcert0 \
- tools/pattern-match.pcert0 \
- misc/untranslate-patterns.pcert0 \
- tools/rulesets.pcert0 \
- centaur/gl/gobject-types.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gobject-type-thms.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gobject-type-thms.pcert1 : acl2x = 0
-centaur/gl/gobject-type-thms.pcert1 : no_pcert = 0
-centaur/gl/gobject-type-thms.pcert1 : centaur/gl/gobject-type-thms.pcert0
-centaur/gl/gobject-type-thms.cert : | centaur/gl/gobject-type-thms.pcert1
-
-centaur/gl/gobject-types.pcert0 : no_pcert = 0
-centaur/gl/gobject-types.pcert0 : acl2x = 0
-centaur/gl/gobject-types.pcert0 : \
- centaur/gl/defagg.pcert0 \
- tools/pattern-match.pcert0 \
- misc/untranslate-patterns.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gobject-types.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gobject-types.pcert1 : acl2x = 0
-centaur/gl/gobject-types.pcert1 : no_pcert = 0
-centaur/gl/gobject-types.pcert1 : centaur/gl/gobject-types.pcert0
-centaur/gl/gobject-types.cert : | centaur/gl/gobject-types.pcert1
-
-centaur/gl/gobjectp-thms.pcert0 : no_pcert = 0
-centaur/gl/gobjectp-thms.pcert0 : acl2x = 0
-centaur/gl/gobjectp-thms.pcert0 : \
- centaur/gl/gobjectp.pcert0 \
- centaur/gl/gobject-type-thms.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gobjectp-thms.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gobjectp-thms.pcert1 : acl2x = 0
-centaur/gl/gobjectp-thms.pcert1 : no_pcert = 0
-centaur/gl/gobjectp-thms.pcert1 : centaur/gl/gobjectp-thms.pcert0
-centaur/gl/gobjectp-thms.cert : | centaur/gl/gobjectp-thms.pcert1
-
-centaur/gl/gobjectp.pcert0 : no_pcert = 0
-centaur/gl/gobjectp.pcert0 : acl2x = 0
-centaur/gl/gobjectp.pcert0 : \
- centaur/gl/bfr.pcert0 \
- centaur/gl/defagg.pcert0 \
- tools/pattern-match.pcert0 \
- centaur/gl/bvecs.pcert0 \
- centaur/gl/gobject-types.pcert0 \
- centaur/gl/gobject-type-thms.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gobjectp.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gobjectp.pcert1 : acl2x = 0
-centaur/gl/gobjectp.pcert1 : no_pcert = 0
-centaur/gl/gobjectp.pcert1 : centaur/gl/gobjectp.pcert0
-centaur/gl/gobjectp.cert : | centaur/gl/gobjectp.pcert1
-
-centaur/gl/gtests.pcert0 : no_pcert = 0
-centaur/gl/gtests.pcert0 : acl2x = 0
-centaur/gl/gtests.pcert0 : \
- centaur/gl/hyp-fix.pcert0 \
- centaur/gl/gtypes.pcert0 \
- centaur/gl/gtype-thms.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- tools/mv-nth.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gtests.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gtests.pcert1 : acl2x = 0
-centaur/gl/gtests.pcert1 : no_pcert = 0
-centaur/gl/gtests.pcert1 : centaur/gl/gtests.pcert0
-centaur/gl/gtests.cert : | centaur/gl/gtests.pcert1
-
-centaur/gl/gtype-thms.pcert0 : no_pcert = 0
-centaur/gl/gtype-thms.pcert0 : acl2x = 0
-centaur/gl/gtype-thms.pcert0 : \
- centaur/gl/gtypes.pcert0 \
- centaur/gl/gobjectp-thms.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gtype-thms.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gtype-thms.pcert1 : acl2x = 0
-centaur/gl/gtype-thms.pcert1 : no_pcert = 0
-centaur/gl/gtype-thms.pcert1 : centaur/gl/gtype-thms.pcert0
-centaur/gl/gtype-thms.cert : | centaur/gl/gtype-thms.pcert1
-
-centaur/gl/gtypes.pcert0 : no_pcert = 0
-centaur/gl/gtypes.pcert0 : acl2x = 0
-centaur/gl/gtypes.pcert0 : \
- centaur/gl/gobjectp.pcert0 \
- centaur/gl/generic-geval.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/gtypes.lisp \
- centaur/gl/cert.acl2
-centaur/gl/gtypes.pcert1 : acl2x = 0
-centaur/gl/gtypes.pcert1 : no_pcert = 0
-centaur/gl/gtypes.pcert1 : centaur/gl/gtypes.pcert0
-centaur/gl/gtypes.cert : | centaur/gl/gtypes.pcert1
-
-centaur/gl/hyp-fix-logic.pcert0 : no_pcert = 0
-centaur/gl/hyp-fix-logic.pcert0 : acl2x = 0
-centaur/gl/hyp-fix-logic.pcert0 : \
- centaur/gl/hyp-fix.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/hyp-fix-logic.lisp \
- centaur/gl/cert.acl2
-centaur/gl/hyp-fix-logic.pcert1 : acl2x = 0
-centaur/gl/hyp-fix-logic.pcert1 : no_pcert = 0
-centaur/gl/hyp-fix-logic.pcert1 : centaur/gl/hyp-fix-logic.pcert0
-centaur/gl/hyp-fix-logic.cert : | centaur/gl/hyp-fix-logic.pcert1
-
-centaur/gl/hyp-fix.pcert0 : no_pcert = 0
-centaur/gl/hyp-fix.pcert0 : acl2x = 0
-centaur/gl/hyp-fix.pcert0 : \
- centaur/gl/bfr.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/hyp-fix.lisp \
- centaur/gl/cert.acl2
-centaur/gl/hyp-fix.pcert1 : acl2x = 0
-centaur/gl/hyp-fix.pcert1 : no_pcert = 0
-centaur/gl/hyp-fix.pcert1 : centaur/gl/hyp-fix.pcert0
-centaur/gl/hyp-fix.cert : | centaur/gl/hyp-fix.pcert1
-
-centaur/gl/ite-merge.pcert0 : no_pcert = 0
-centaur/gl/ite-merge.pcert0 : acl2x = 0
-centaur/gl/ite-merge.pcert0 : \
- centaur/gl/general-objects.pcert0 \
- centaur/gl/general-object-thms.pcert0 \
- centaur/gl/hyp-fix-logic.pcert0 \
- centaur/gl/bvec-ite.pcert0 \
- centaur/gl/hyp-fix.pcert0 \
- std/ks/two-nats-measure.pcert0 \
- tools/mv-nth.pcert0 \
- misc/invariants.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/ite-merge.lisp \
- centaur/gl/cert.acl2
-centaur/gl/ite-merge.pcert1 : acl2x = 0
-centaur/gl/ite-merge.pcert1 : no_pcert = 0
-centaur/gl/ite-merge.pcert1 : centaur/gl/ite-merge.pcert0
-centaur/gl/ite-merge.cert : | centaur/gl/ite-merge.pcert1
-
-centaur/gl/param.pcert0 : no_pcert = 0
-centaur/gl/param.pcert0 : acl2x = 0
-centaur/gl/param.pcert0 : \
- centaur/gl/shape-spec.pcert0 \
- centaur/gl/gtype-thms.pcert0 \
- data-structures/no-duplicates.pcert0 \
- tools/mv-nth.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- centaur/ubdds/param.pcert0 \
- centaur/ubdds/lite.pcert0 \
- centaur/aig/misc.pcert0 \
- centaur/aig/eval-restrict.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/param.lisp \
- centaur/gl/cert.acl2
-centaur/gl/param.pcert1 : acl2x = 0
-centaur/gl/param.pcert1 : no_pcert = 0
-centaur/gl/param.pcert1 : centaur/gl/param.pcert0
-centaur/gl/param.cert : | centaur/gl/param.pcert1
-
-centaur/gl/portcullis.pcert0 : no_pcert = 0
-centaur/gl/portcullis.pcert0 : acl2x = 0
-centaur/gl/portcullis.pcert0 : \
- cutil/portcullis.pcert0 \
- centaur/gl/portcullis.lisp \
- centaur/gl/portcullis.acl2 \
- centaur/gl/package.lsp \
- centaur/vl/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- centaur/aignet/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- tools/flag-package.lsp \
- centaur/satlink/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- tools/flag-package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- tools/flag-package.lsp
-centaur/gl/portcullis.pcert1 : acl2x = 0
-centaur/gl/portcullis.pcert1 : no_pcert = 0
-centaur/gl/portcullis.pcert1 : centaur/gl/portcullis.pcert0
-centaur/gl/portcullis.cert : | centaur/gl/portcullis.pcert1
-
-centaur/gl/run-gified-cp.pcert0 : no_pcert = 0
-centaur/gl/run-gified-cp.pcert0 : acl2x = 0
-centaur/gl/run-gified-cp.pcert0 : \
- centaur/gl/bfr.pcert0 \
- centaur/gl/gobjectp.pcert0 \
- tools/mv-nth.pcert0 \
- tools/bstar.pcert0 \
- tools/defevaluator-fast.pcert0 \
- clause-processors/unify-subst.pcert0 \
- centaur/misc/evaluator-metatheorems.pcert0 \
- centaur/misc/interp-function-lookup.pcert0 \
- centaur/ubdds/witness.pcert0 \
- std/lists/take.pcert0 \
- centaur/gl/gobjectp-thms.pcert0 \
- tools/def-functional-instance.pcert0 \
- centaur/gl/gl-util.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/run-gified-cp.lisp \
- centaur/gl/cert.acl2
-centaur/gl/run-gified-cp.pcert1 : acl2x = 0
-centaur/gl/run-gified-cp.pcert1 : no_pcert = 0
-centaur/gl/run-gified-cp.pcert1 : centaur/gl/run-gified-cp.pcert0
-centaur/gl/run-gified-cp.cert : | centaur/gl/run-gified-cp.pcert1
-
-centaur/gl/rws.pcert0 : no_pcert = 0
-centaur/gl/rws.pcert0 : acl2x = 0
-centaur/gl/rws.pcert0 : \
- clause-processors/use-by-hint.pcert0 \
- clause-processors/multi-env-trick.pcert0 \
- tools/bstar.pcert0 \
- tools/mv-nth.pcert0 \
- tools/flag.pcert0 \
- tools/rulesets.pcert0 \
- centaur/misc/equal-sets.pcert0 \
- centaur/misc/alist-equiv.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/rws.lisp \
- centaur/gl/cert.acl2
-centaur/gl/rws.pcert1 : acl2x = 0
-centaur/gl/rws.pcert1 : no_pcert = 0
-centaur/gl/rws.pcert1 : centaur/gl/rws.pcert0
-centaur/gl/rws.cert : | centaur/gl/rws.pcert1
-
-centaur/gl/shape-spec.pcert0 : no_pcert = 0
-centaur/gl/shape-spec.pcert0 : acl2x = 0
-centaur/gl/shape-spec.pcert0 : \
- centaur/gl/gtypes.pcert0 \
- centaur/gl/gl-doc-string.pcert0 \
- centaur/gl/gtype-thms.pcert0 \
- data-structures/no-duplicates.pcert0 \
- tools/mv-nth.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- centaur/misc/fast-alists.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/shape-spec.lisp \
- centaur/gl/cert.acl2
-centaur/gl/shape-spec.pcert1 : acl2x = 0
-centaur/gl/shape-spec.pcert1 : no_pcert = 0
-centaur/gl/shape-spec.pcert1 : centaur/gl/shape-spec.pcert0
-centaur/gl/shape-spec.cert : | centaur/gl/shape-spec.pcert1
-
-centaur/gl/symbolic-arithmetic-fns.pcert0 : no_pcert = 0
-centaur/gl/symbolic-arithmetic-fns.pcert0 : acl2x = 0
-centaur/gl/symbolic-arithmetic-fns.pcert0 : \
- centaur/gl/bvec-ite.pcert0 \
- tools/mv-nth.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/symbolic-arithmetic-fns.lisp \
- centaur/gl/cert.acl2
-centaur/gl/symbolic-arithmetic-fns.pcert1 : acl2x = 0
-centaur/gl/symbolic-arithmetic-fns.pcert1 : no_pcert = 0
-centaur/gl/symbolic-arithmetic-fns.pcert1 : centaur/gl/symbolic-arithmetic-fns.pcert0
-centaur/gl/symbolic-arithmetic-fns.cert : | centaur/gl/symbolic-arithmetic-fns.pcert1
-
-centaur/gl/symbolic-arithmetic.pcert0 : no_pcert = 0
-centaur/gl/symbolic-arithmetic.pcert0 : acl2x = 0
-centaur/gl/symbolic-arithmetic.pcert0 : \
- centaur/gl/symbolic-arithmetic-fns.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- ihs/logops-lemmas.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- centaur/gl/portcullis.pcert0 \
- centaur/gl/symbolic-arithmetic.lisp \
- centaur/gl/cert.acl2
-centaur/gl/symbolic-arithmetic.pcert1 : acl2x = 0
-centaur/gl/symbolic-arithmetic.pcert1 : no_pcert = 0
-centaur/gl/symbolic-arithmetic.pcert1 : centaur/gl/symbolic-arithmetic.pcert0
-centaur/gl/symbolic-arithmetic.cert : | centaur/gl/symbolic-arithmetic.pcert1
-
-centaur/misc/absstobjs.pcert0 : no_pcert = 0
-centaur/misc/absstobjs.pcert0 : acl2x = 0
-centaur/misc/absstobjs.pcert0 : \
- tools/bstar.pcert0 \
- centaur/misc/absstobjs.lisp
-centaur/misc/absstobjs.pcert1 : acl2x = 0
-centaur/misc/absstobjs.pcert1 : no_pcert = 0
-centaur/misc/absstobjs.pcert1 : centaur/misc/absstobjs.pcert0
-centaur/misc/absstobjs.cert : | centaur/misc/absstobjs.pcert1
-
-centaur/misc/alist-defs.pcert0 : no_pcert = 0
-centaur/misc/alist-defs.pcert0 : acl2x = 0
-centaur/misc/alist-defs.pcert0 : \
- misc/hons-help.pcert0 \
- centaur/misc/hons-extra.pcert0 \
- centaur/misc/alist-defs.lisp
-centaur/misc/alist-defs.pcert1 : acl2x = 0
-centaur/misc/alist-defs.pcert1 : no_pcert = 0
-centaur/misc/alist-defs.pcert1 : centaur/misc/alist-defs.pcert0
-centaur/misc/alist-defs.cert : | centaur/misc/alist-defs.pcert1
-
-centaur/misc/alist-equiv.pcert0 : no_pcert = 0
-centaur/misc/alist-equiv.pcert0 : acl2x = 0
-centaur/misc/alist-equiv.pcert0 : \
- misc/hons-help2.pcert0 \
- cutil/defsection.pcert0 \
- centaur/misc/alist-defs.pcert0 \
- std/lists/sets.pcert0 \
- centaur/misc/alist-equiv.lisp
-centaur/misc/alist-equiv.pcert1 : acl2x = 0
-centaur/misc/alist-equiv.pcert1 : no_pcert = 0
-centaur/misc/alist-equiv.pcert1 : centaur/misc/alist-equiv.pcert0
-centaur/misc/alist-equiv.cert : | centaur/misc/alist-equiv.pcert1
-
-centaur/misc/alist-witness.pcert0 : no_pcert = 0
-centaur/misc/alist-witness.pcert0 : acl2x = 0
-centaur/misc/alist-witness.pcert0 : \
- centaur/misc/alist-equiv.pcert0 \
- centaur/misc/witness-cp.pcert0 \
- centaur/misc/alist-witness.lisp
-centaur/misc/alist-witness.pcert1 : acl2x = 0
-centaur/misc/alist-witness.pcert1 : no_pcert = 0
-centaur/misc/alist-witness.pcert1 : centaur/misc/alist-witness.pcert0
-centaur/misc/alist-witness.cert : | centaur/misc/alist-witness.pcert1
-
-centaur/misc/ap.pcert0 : no_pcert = 0
-centaur/misc/ap.pcert0 : acl2x = 0
-centaur/misc/ap.pcert0 : \
- centaur/misc/ap.lisp
-centaur/misc/ap.pcert1 : acl2x = 0
-centaur/misc/ap.pcert1 : no_pcert = 0
-centaur/misc/ap.pcert1 : centaur/misc/ap.pcert0
-centaur/misc/ap.cert : | centaur/misc/ap.pcert1
-
-centaur/misc/arith-equivs.pcert0 : no_pcert = 0
-centaur/misc/arith-equivs.pcert0 : acl2x = 0
-centaur/misc/arith-equivs.pcert0 : \
- ihs/basic-definitions.pcert0 \
- tools/rulesets.pcert0 \
- std/lists/mfc-utils.pcert0 \
- centaur/misc/arith-equivs.lisp
-centaur/misc/arith-equivs.pcert1 : acl2x = 0
-centaur/misc/arith-equivs.pcert1 : no_pcert = 0
-centaur/misc/arith-equivs.pcert1 : centaur/misc/arith-equivs.pcert0
-centaur/misc/arith-equivs.cert : | centaur/misc/arith-equivs.pcert1
-
-centaur/misc/context-rw.pcert0 : no_pcert = 0
-centaur/misc/context-rw.pcert0 : acl2x = 0
-centaur/misc/context-rw.pcert0 : \
- clause-processors/unify-subst.pcert0 \
- centaur/misc/alist-witness.pcert0 \
- clause-processors/meta-extract-user.pcert0 \
- centaur/misc/equal-sets.pcert0 \
- clause-processors/sublis-var-meaning.pcert0 \
- xdoc/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- centaur/misc/context-rw.lisp \
- centaur/misc/context-rw.acl2
-centaur/misc/context-rw.pcert1 : acl2x = 0
-centaur/misc/context-rw.pcert1 : no_pcert = 0
-centaur/misc/context-rw.pcert1 : centaur/misc/context-rw.pcert0
-centaur/misc/context-rw.cert : | centaur/misc/context-rw.pcert1
-
-centaur/misc/defapply.pcert0 : no_pcert = 0
-centaur/misc/defapply.pcert0 : acl2x = 0
-centaur/misc/defapply.pcert0 : \
- tools/bstar.pcert0 \
- clause-processors/generalize.pcert0 \
- tools/rulesets.pcert0 \
- clause-processors/use-by-hint.pcert0 \
- misc/untranslate-patterns.pcert0 \
- tools/defevaluator-fast.pcert0 \
- tools/mv-nth.pcert0 \
- centaur/misc/evaluator-metatheorems.pcert0 \
- centaur/misc/interp-function-lookup.pcert0 \
- tools/def-functional-instance.pcert0 \
- tools/with-quoted-forms.pcert0 \
- centaur/misc/defapply.lisp
-centaur/misc/defapply.pcert1 : acl2x = 0
-centaur/misc/defapply.pcert1 : no_pcert = 0
-centaur/misc/defapply.pcert1 : centaur/misc/defapply.pcert0
-centaur/misc/defapply.cert : | centaur/misc/defapply.pcert1
-
-centaur/misc/dfs-measure.pcert0 : no_pcert = 0
-centaur/misc/dfs-measure.pcert0 : acl2x = 0
-centaur/misc/dfs-measure.pcert0 : \
- centaur/misc/suffixp.pcert0 \
- tools/rulesets.pcert0 \
- std/ks/two-nats-measure.pcert0 \
- misc/hons-help.pcert0 \
- tools/bstar.pcert0 \
- centaur/misc/dfs-measure.lisp
-centaur/misc/dfs-measure.pcert1 : acl2x = 0
-centaur/misc/dfs-measure.pcert1 : no_pcert = 0
-centaur/misc/dfs-measure.pcert1 : centaur/misc/dfs-measure.pcert0
-centaur/misc/dfs-measure.cert : | centaur/misc/dfs-measure.pcert1
-
-centaur/misc/equal-by-nths.pcert0 : no_pcert = 0
-centaur/misc/equal-by-nths.pcert0 : acl2x = 0
-centaur/misc/equal-by-nths.pcert0 : \
- centaur/misc/equal-by-nths.lisp
-centaur/misc/equal-by-nths.pcert1 : acl2x = 0
-centaur/misc/equal-by-nths.pcert1 : no_pcert = 0
-centaur/misc/equal-by-nths.pcert1 : centaur/misc/equal-by-nths.pcert0
-centaur/misc/equal-by-nths.cert : | centaur/misc/equal-by-nths.pcert1
-
-centaur/misc/equal-sets.pcert0 : no_pcert = 0
-centaur/misc/equal-sets.pcert0 : acl2x = 0
-centaur/misc/equal-sets.pcert0 : \
- finite-set-theory/osets/sets.pcert0 \
- std/lists/sets.pcert0 \
- centaur/misc/witness-cp.pcert0 \
- centaur/misc/equal-sets.lisp \
- centaur/misc/equal-sets.acl2 \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-centaur/misc/equal-sets.pcert1 : acl2x = 0
-centaur/misc/equal-sets.pcert1 : no_pcert = 0
-centaur/misc/equal-sets.pcert1 : centaur/misc/equal-sets.pcert0
-centaur/misc/equal-sets.cert : | centaur/misc/equal-sets.pcert1
-
-centaur/misc/evaluator-metatheorems.pcert0 : no_pcert = 0
-centaur/misc/evaluator-metatheorems.pcert0 : acl2x = 0
-centaur/misc/evaluator-metatheorems.pcert0 : \
- tools/bstar.pcert0 \
- tools/mv-nth.pcert0 \
- clause-processors/use-by-hint.pcert0 \
- tools/rulesets.pcert0 \
- clause-processors/ev-theoremp.pcert0 \
- centaur/misc/evaluator-metatheorems.lisp
-centaur/misc/evaluator-metatheorems.pcert1 : acl2x = 0
-centaur/misc/evaluator-metatheorems.pcert1 : no_pcert = 0
-centaur/misc/evaluator-metatheorems.pcert1 : centaur/misc/evaluator-metatheorems.pcert0
-centaur/misc/evaluator-metatheorems.cert : | centaur/misc/evaluator-metatheorems.pcert1
-
-centaur/misc/fal-graphs.pcert0 : no_pcert = 0
-centaur/misc/fal-graphs.pcert0 : acl2x = 0
-centaur/misc/fal-graphs.pcert0 : \
- tools/bstar.pcert0 \
- centaur/misc/fal-graphs.lisp
-centaur/misc/fal-graphs.pcert1 : acl2x = 0
-centaur/misc/fal-graphs.pcert1 : no_pcert = 0
-centaur/misc/fal-graphs.pcert1 : centaur/misc/fal-graphs.pcert0
-centaur/misc/fal-graphs.cert : | centaur/misc/fal-graphs.pcert1
-
-centaur/misc/fast-alists.pcert0 : no_pcert = 0
-centaur/misc/fast-alists.pcert0 : acl2x = 0
-centaur/misc/fast-alists.pcert0 : \
- centaur/misc/alist-witness.pcert0 \
- centaur/misc/equal-sets.pcert0 \
- centaur/misc/universal-equiv.pcert0 \
- centaur/misc/fast-alists.lisp
-centaur/misc/fast-alists.pcert1 : acl2x = 0
-centaur/misc/fast-alists.pcert1 : no_pcert = 0
-centaur/misc/fast-alists.pcert1 : centaur/misc/fast-alists.pcert0
-centaur/misc/fast-alists.cert : | centaur/misc/fast-alists.pcert1
-
-centaur/misc/filter-alist.pcert0 : no_pcert = 0
-centaur/misc/filter-alist.pcert0 : acl2x = 0
-centaur/misc/filter-alist.pcert0 : \
- centaur/misc/fast-alists.pcert0 \
- std/lists/rev.pcert0 \
- centaur/misc/filter-alist.lisp
-centaur/misc/filter-alist.pcert1 : acl2x = 0
-centaur/misc/filter-alist.pcert1 : no_pcert = 0
-centaur/misc/filter-alist.pcert1 : centaur/misc/filter-alist.pcert0
-centaur/misc/filter-alist.cert : | centaur/misc/filter-alist.pcert1
-
-centaur/misc/hons-alphorder-merge.pcert0 : no_pcert = 0
-centaur/misc/hons-alphorder-merge.pcert0 : acl2x = 0
-centaur/misc/hons-alphorder-merge.pcert0 : \
- misc/total-order.pcert0 \
- centaur/misc/equal-sets.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- centaur/misc/hons-alphorder-merge.lisp \
- centaur/misc/hons-alphorder-merge.acl2
-centaur/misc/hons-alphorder-merge.pcert1 : acl2x = 0
-centaur/misc/hons-alphorder-merge.pcert1 : no_pcert = 0
-centaur/misc/hons-alphorder-merge.pcert1 : centaur/misc/hons-alphorder-merge.pcert0
-centaur/misc/hons-alphorder-merge.cert : | centaur/misc/hons-alphorder-merge.pcert1
-
-centaur/misc/hons-extra.pcert0 : no_pcert = 0
-centaur/misc/hons-extra.pcert0 : acl2x = 0
-centaur/misc/hons-extra.pcert0 : \
- tools/bstar.pcert0 \
- centaur/misc/hons-extra.lisp
-centaur/misc/hons-extra.pcert1 : acl2x = 0
-centaur/misc/hons-extra.pcert1 : no_pcert = 0
-centaur/misc/hons-extra.pcert1 : centaur/misc/hons-extra.pcert0
-centaur/misc/hons-extra.cert : | centaur/misc/hons-extra.pcert1
-
-centaur/misc/hons-remove-dups.pcert0 : no_pcert = 0
-centaur/misc/hons-remove-dups.pcert0 : acl2x = 0
-centaur/misc/hons-remove-dups.pcert0 : \
- std/lists/rev.pcert0 \
- centaur/misc/alist-equiv.pcert0 \
- centaur/misc/hons-remove-dups.lisp
-centaur/misc/hons-remove-dups.pcert1 : acl2x = 0
-centaur/misc/hons-remove-dups.pcert1 : no_pcert = 0
-centaur/misc/hons-remove-dups.pcert1 : centaur/misc/hons-remove-dups.pcert0
-centaur/misc/hons-remove-dups.cert : | centaur/misc/hons-remove-dups.pcert1
-
-centaur/misc/hons-sets.pcert0 : no_pcert = 0
-centaur/misc/hons-sets.pcert0 : acl2x = 0
-centaur/misc/hons-sets.pcert0 : \
- misc/hons-help2.pcert0 \
- centaur/misc/equal-sets.pcert0 \
- centaur/misc/alist-defs.pcert0 \
- centaur/misc/hons-sets.lisp
-centaur/misc/hons-sets.pcert1 : acl2x = 0
-centaur/misc/hons-sets.pcert1 : no_pcert = 0
-centaur/misc/hons-sets.pcert1 : centaur/misc/hons-sets.pcert0
-centaur/misc/hons-sets.cert : | centaur/misc/hons-sets.pcert1
-
-centaur/misc/interp-function-lookup.pcert0 : no_pcert = 0
-centaur/misc/interp-function-lookup.pcert0 : acl2x = 0
-centaur/misc/interp-function-lookup.pcert0 : \
- centaur/misc/hons-sets.pcert0 \
- tools/bstar.pcert0 \
- tools/mv-nth.pcert0 \
- clause-processors/use-by-hint.pcert0 \
- tools/rulesets.pcert0 \
- misc/untranslate-patterns.pcert0 \
- clause-processors/ev-theoremp.pcert0 \
- tools/def-functional-instance.pcert0 \
- centaur/misc/interp-function-lookup.lisp
-centaur/misc/interp-function-lookup.pcert1 : acl2x = 0
-centaur/misc/interp-function-lookup.pcert1 : no_pcert = 0
-centaur/misc/interp-function-lookup.pcert1 : centaur/misc/interp-function-lookup.pcert0
-centaur/misc/interp-function-lookup.cert : | centaur/misc/interp-function-lookup.pcert1
-
-centaur/misc/introduce-var.pcert0 : no_pcert = 0
-centaur/misc/introduce-var.pcert0 : acl2x = 0
-centaur/misc/introduce-var.pcert0 : \
- clause-processors/generalize.pcert0 \
- centaur/vl/util/namedb.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/misc/introduce-var.lisp \
- centaur/misc/introduce-var.acl2
-centaur/misc/introduce-var.pcert1 : acl2x = 0
-centaur/misc/introduce-var.pcert1 : no_pcert = 0
-centaur/misc/introduce-var.pcert1 : centaur/misc/introduce-var.pcert0
-centaur/misc/introduce-var.cert : | centaur/misc/introduce-var.pcert1
-
-centaur/misc/lists.pcert0 : no_pcert = 0
-centaur/misc/lists.pcert0 : acl2x = 0
-centaur/misc/lists.pcert0 : \
- centaur/misc/arith-equivs.pcert0 \
- std/lists/equiv.pcert0 \
- data-structures/list-defthms.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/misc/lists.lisp
-centaur/misc/lists.pcert1 : acl2x = 0
-centaur/misc/lists.pcert1 : no_pcert = 0
-centaur/misc/lists.pcert1 : centaur/misc/lists.pcert0
-centaur/misc/lists.cert : | centaur/misc/lists.pcert1
-
-centaur/misc/load-stobj-tests.pcert0 : no_pcert = 0
-centaur/misc/load-stobj-tests.pcert0 : acl2x = 0
-centaur/misc/load-stobj-tests.pcert0 : \
- centaur/misc/load-stobj.pcert0 \
- tools/defconsts.pcert0 \
- misc/assert.pcert0 \
- centaur/misc/load-stobj-tests.lisp
-centaur/misc/load-stobj-tests.pcert1 : acl2x = 0
-centaur/misc/load-stobj-tests.pcert1 : no_pcert = 0
-centaur/misc/load-stobj-tests.pcert1 : centaur/misc/load-stobj-tests.pcert0
-centaur/misc/load-stobj-tests.cert : | centaur/misc/load-stobj-tests.pcert1
-
-centaur/misc/load-stobj.pcert0 : no_pcert = 0
-centaur/misc/load-stobj.pcert0 : acl2x = 0
-centaur/misc/load-stobj.pcert0 : \
- std/lists/list-fix.pcert0 \
- arithmetic/top.pcert0 \
- data-structures/list-defthms.pcert0 \
- centaur/misc/equal-by-nths.pcert0 \
- tools/do-not.pcert0 \
- centaur/misc/load-stobj.lisp
-centaur/misc/load-stobj.pcert1 : acl2x = 0
-centaur/misc/load-stobj.pcert1 : no_pcert = 0
-centaur/misc/load-stobj.pcert1 : centaur/misc/load-stobj.pcert0
-centaur/misc/load-stobj.cert : | centaur/misc/load-stobj.pcert1
-
-centaur/misc/memory-mgmt-logic.pcert0 : no_pcert = 0
-centaur/misc/memory-mgmt-logic.pcert0 : acl2x = 0
-centaur/misc/memory-mgmt-logic.pcert0 : \
- centaur/misc/memory-mgmt-logic.lisp
-centaur/misc/memory-mgmt-logic.pcert1 : acl2x = 0
-centaur/misc/memory-mgmt-logic.pcert1 : no_pcert = 0
-centaur/misc/memory-mgmt-logic.pcert1 : centaur/misc/memory-mgmt-logic.pcert0
-centaur/misc/memory-mgmt-logic.cert : | centaur/misc/memory-mgmt-logic.pcert1
-
-centaur/misc/memory-mgmt-raw.pcert0 : no_pcert = 0
-centaur/misc/memory-mgmt-raw.pcert0 : acl2x = 0
-centaur/misc/memory-mgmt-raw.pcert0 : \
- centaur/misc/memory-mgmt-logic.pcert0 \
- tools/include-raw.pcert0 \
- centaur/misc/memory-mgmt-raw.lisp \
- centaur/misc/hons-analyze-memory-raw.lsp
-centaur/misc/memory-mgmt-raw.pcert1 : acl2x = 0
-centaur/misc/memory-mgmt-raw.pcert1 : no_pcert = 0
-centaur/misc/memory-mgmt-raw.pcert1 : centaur/misc/memory-mgmt-raw.pcert0
-centaur/misc/memory-mgmt-raw.cert : | centaur/misc/memory-mgmt-raw.pcert1
-
-centaur/misc/mfc-utils.pcert0 : no_pcert = 0
-centaur/misc/mfc-utils.pcert0 : acl2x = 0
-centaur/misc/mfc-utils.pcert0 : \
- std/lists/mfc-utils.pcert0 \
- centaur/misc/mfc-utils.lisp
-centaur/misc/mfc-utils.pcert1 : acl2x = 0
-centaur/misc/mfc-utils.pcert1 : no_pcert = 0
-centaur/misc/mfc-utils.pcert1 : centaur/misc/mfc-utils.pcert0
-centaur/misc/mfc-utils.cert : | centaur/misc/mfc-utils.pcert1
-
-centaur/misc/nat-list-duplicates.pcert0 : no_pcert = 0
-centaur/misc/nat-list-duplicates.pcert0 : acl2x = 0
-centaur/misc/nat-list-duplicates.pcert0 : \
- xdoc/top.pcert0 \
- misc/hons-help.pcert0 \
- tools/bstar.pcert0 \
- arithmetic/nat-listp.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- tools/mv-nth.pcert0 \
- centaur/misc/alist-equiv.pcert0 \
- centaur/misc/nat-list-duplicates.lisp
-centaur/misc/nat-list-duplicates.pcert1 : acl2x = 0
-centaur/misc/nat-list-duplicates.pcert1 : no_pcert = 0
-centaur/misc/nat-list-duplicates.pcert1 : centaur/misc/nat-list-duplicates.pcert0
-centaur/misc/nat-list-duplicates.cert : | centaur/misc/nat-list-duplicates.pcert1
-
-centaur/misc/numlist.pcert0 : no_pcert = 0
-centaur/misc/numlist.pcert0 : acl2x = 0
-centaur/misc/numlist.pcert0 : \
- centaur/misc/numlist.lisp
-centaur/misc/numlist.pcert1 : acl2x = 0
-centaur/misc/numlist.pcert1 : no_pcert = 0
-centaur/misc/numlist.pcert1 : centaur/misc/numlist.pcert0
-centaur/misc/numlist.cert : | centaur/misc/numlist.pcert1
-
-centaur/misc/osets-witnessing.pcert0 : no_pcert = 0
-centaur/misc/osets-witnessing.pcert0 : acl2x = 0
-centaur/misc/osets-witnessing.pcert0 : \
- finite-set-theory/osets/sets.pcert0 \
- centaur/misc/witness-cp.pcert0 \
- tools/rulesets.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- centaur/misc/osets-witnessing.lisp \
- centaur/misc/osets-witnessing.acl2
-centaur/misc/osets-witnessing.pcert1 : acl2x = 0
-centaur/misc/osets-witnessing.pcert1 : no_pcert = 0
-centaur/misc/osets-witnessing.pcert1 : centaur/misc/osets-witnessing.pcert0
-centaur/misc/osets-witnessing.cert : | centaur/misc/osets-witnessing.pcert1
-
-centaur/misc/patterns.pcert0 : no_pcert = 0
-centaur/misc/patterns.pcert0 : acl2x = 0
-centaur/misc/patterns.pcert0 : \
- centaur/misc/alist-equiv.pcert0 \
- centaur/misc/fast-alists.pcert0 \
- centaur/misc/patterns.lisp
-centaur/misc/patterns.pcert1 : acl2x = 0
-centaur/misc/patterns.pcert1 : no_pcert = 0
-centaur/misc/patterns.pcert1 : centaur/misc/patterns.pcert0
-centaur/misc/patterns.cert : | centaur/misc/patterns.pcert1
-
-centaur/misc/seed-random.pcert0 : no_pcert = 0
-centaur/misc/seed-random.pcert0 : acl2x = 0
-centaur/misc/seed-random.pcert0 : \
- tools/defconsts.pcert0 \
- tools/bstar.pcert0 \
- misc/assert.pcert0 \
- centaur/misc/seed-random.lisp
-centaur/misc/seed-random.pcert1 : acl2x = 0
-centaur/misc/seed-random.pcert1 : no_pcert = 0
-centaur/misc/seed-random.pcert1 : centaur/misc/seed-random.pcert0
-centaur/misc/seed-random.cert : | centaur/misc/seed-random.pcert1
-
-centaur/misc/smm-impl.pcert0 : no_pcert = 0
-centaur/misc/smm-impl.pcert0 : acl2x = 0
-centaur/misc/smm-impl.pcert0 : \
- tools/bstar.pcert0 \
- centaur/misc/u32-listp.pcert0 \
- xdoc/base.pcert0 \
- arithmetic/nat-listp.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- centaur/misc/arith-equivs.pcert0 \
- centaur/misc/absstobjs.pcert0 \
- tools/mv-nth.pcert0 \
- centaur/misc/lists.pcert0 \
- misc/definline.pcert0 \
- centaur/misc/smm-impl.lisp
-centaur/misc/smm-impl.pcert1 : acl2x = 0
-centaur/misc/smm-impl.pcert1 : no_pcert = 0
-centaur/misc/smm-impl.pcert1 : centaur/misc/smm-impl.pcert0
-centaur/misc/smm-impl.cert : | centaur/misc/smm-impl.pcert1
-
-centaur/misc/smm.pcert0 : no_pcert = 0
-centaur/misc/smm.pcert0 : acl2x = 0
-centaur/misc/smm.pcert0 : \
- centaur/misc/smm-impl.pcert0 \
- tools/bstar.pcert0 \
- xdoc/base.pcert0 \
- misc/definline.pcert0 \
- centaur/misc/arith-equivs.pcert0 \
- centaur/misc/u32-listp.pcert0 \
- centaur/misc/smm.lisp
-centaur/misc/smm.pcert1 : acl2x = 0
-centaur/misc/smm.pcert1 : no_pcert = 0
-centaur/misc/smm.pcert1 : centaur/misc/smm.pcert0
-centaur/misc/smm.cert : | centaur/misc/smm.pcert1
-
-centaur/misc/sneaky-load.pcert0 : no_pcert = 0
-centaur/misc/sneaky-load.pcert0 : acl2x = 0
-centaur/misc/sneaky-load.pcert0 : \
- tools/bstar.pcert0 \
- centaur/misc/sneaky-load.lisp
-centaur/misc/sneaky-load.pcert1 : acl2x = 0
-centaur/misc/sneaky-load.pcert1 : no_pcert = 0
-centaur/misc/sneaky-load.pcert1 : centaur/misc/sneaky-load.pcert0
-centaur/misc/sneaky-load.cert : | centaur/misc/sneaky-load.pcert1
-
-centaur/misc/suffixp.pcert0 : no_pcert = 0
-centaur/misc/suffixp.pcert0 : acl2x = 0
-centaur/misc/suffixp.pcert0 : \
- centaur/misc/suffixp.lisp
-centaur/misc/suffixp.pcert1 : acl2x = 0
-centaur/misc/suffixp.pcert1 : no_pcert = 0
-centaur/misc/suffixp.pcert1 : centaur/misc/suffixp.pcert0
-centaur/misc/suffixp.cert : | centaur/misc/suffixp.pcert1
-
-centaur/misc/tailrec.pcert0 : no_pcert = 0
-centaur/misc/tailrec.pcert0 : acl2x = 0
-centaur/misc/tailrec.pcert0 : \
- tools/bstar.pcert0 \
- tools/mv-nth.pcert0 \
- clause-processors/use-by-hint.pcert0 \
- clause-processors/generalize.pcert0 \
- std/lists/take.pcert0 \
- arithmetic/top.pcert0 \
- centaur/misc/tailrec.lisp \
- centaur/misc/tailrec.acl2 \
- tools/flag-package.lsp
-centaur/misc/tailrec.pcert1 : acl2x = 0
-centaur/misc/tailrec.pcert1 : no_pcert = 0
-centaur/misc/tailrec.pcert1 : centaur/misc/tailrec.pcert0
-centaur/misc/tailrec.cert : | centaur/misc/tailrec.pcert1
-
-centaur/misc/top.pcert0 : no_pcert = 0
-centaur/misc/top.pcert0 : acl2x = 0
-centaur/misc/top.pcert0 : \
- centaur/misc/alist-defs.pcert0 \
- centaur/misc/alist-equiv.pcert0 \
- centaur/misc/ap.pcert0 \
- centaur/misc/defapply.pcert0 \
- centaur/misc/dfs-measure.pcert0 \
- centaur/misc/equal-by-nths.pcert0 \
- centaur/misc/equal-sets.pcert0 \
- centaur/misc/evaluator-metatheorems.pcert0 \
- centaur/misc/fal-graphs.pcert0 \
- centaur/misc/fast-alists.pcert0 \
- centaur/misc/filter-alist.pcert0 \
- centaur/misc/hons-alphorder-merge.pcert0 \
- centaur/misc/hons-extra.pcert0 \
- centaur/misc/hons-remove-dups.pcert0 \
- centaur/misc/hons-sets.pcert0 \
- centaur/misc/interp-function-lookup.pcert0 \
- centaur/misc/memory-mgmt-logic.pcert0 \
- centaur/misc/memory-mgmt-raw.pcert0 \
- centaur/misc/nat-list-duplicates.pcert0 \
- centaur/misc/numlist.pcert0 \
- centaur/misc/patterns.pcert0 \
- centaur/misc/seed-random.pcert0 \
- centaur/misc/sneaky-load.pcert0 \
- centaur/misc/suffixp.pcert0 \
- centaur/misc/tuplep.pcert0 \
- centaur/misc/universal-equiv.pcert0 \
- centaur/misc/vecs-ints.pcert0 \
- centaur/misc/witness-cp.pcert0 \
- centaur/misc/top.lisp
-centaur/misc/top.pcert1 : acl2x = 0
-centaur/misc/top.pcert1 : no_pcert = 0
-centaur/misc/top.pcert1 : centaur/misc/top.pcert0
-centaur/misc/top.cert : | centaur/misc/top.pcert1
-
-centaur/misc/tshell.pcert0 : no_pcert = 0
-centaur/misc/tshell.pcert0 : acl2x = 0
-centaur/misc/tshell.pcert0 : \
- tools/include-raw.pcert0 \
- str/strprefixp.pcert0 \
- centaur/misc/tshell.lisp \
- centaur/misc/tshell-raw.lsp
-centaur/misc/tshell.pcert1 : acl2x = 0
-centaur/misc/tshell.pcert1 : no_pcert = 0
-centaur/misc/tshell.pcert1 : centaur/misc/tshell.pcert0
-centaur/misc/tshell.cert : | centaur/misc/tshell.pcert1
-
-centaur/misc/tuplep.pcert0 : no_pcert = 0
-centaur/misc/tuplep.pcert0 : acl2x = 0
-centaur/misc/tuplep.pcert0 : \
- centaur/misc/tuplep.lisp
-centaur/misc/tuplep.pcert1 : acl2x = 0
-centaur/misc/tuplep.pcert1 : no_pcert = 0
-centaur/misc/tuplep.pcert1 : centaur/misc/tuplep.pcert0
-centaur/misc/tuplep.cert : | centaur/misc/tuplep.pcert1
-
-centaur/misc/u32-listp.pcert0 : no_pcert = 0
-centaur/misc/u32-listp.pcert0 : acl2x = 0
-centaur/misc/u32-listp.pcert0 : \
- centaur/misc/u32-listp.lisp
-centaur/misc/u32-listp.pcert1 : acl2x = 0
-centaur/misc/u32-listp.pcert1 : no_pcert = 0
-centaur/misc/u32-listp.pcert1 : centaur/misc/u32-listp.pcert0
-centaur/misc/u32-listp.cert : | centaur/misc/u32-listp.pcert1
-
-centaur/misc/universal-equiv.pcert0 : no_pcert = 0
-centaur/misc/universal-equiv.pcert0 : acl2x = 0
-centaur/misc/universal-equiv.pcert0 : \
- clause-processors/equality.pcert0 \
- centaur/misc/universal-equiv.lisp
-centaur/misc/universal-equiv.pcert1 : acl2x = 0
-centaur/misc/universal-equiv.pcert1 : no_pcert = 0
-centaur/misc/universal-equiv.pcert1 : centaur/misc/universal-equiv.pcert0
-centaur/misc/universal-equiv.cert : | centaur/misc/universal-equiv.pcert1
-
-centaur/misc/vecs-ints.pcert0 : no_pcert = 0
-centaur/misc/vecs-ints.pcert0 : acl2x = 0
-centaur/misc/vecs-ints.pcert0 : \
- ihs/quotient-remainder-lemmas.pcert0 \
- ihs/math-lemmas.pcert0 \
- centaur/misc/vecs-ints.lisp
-centaur/misc/vecs-ints.pcert1 : acl2x = 0
-centaur/misc/vecs-ints.pcert1 : no_pcert = 0
-centaur/misc/vecs-ints.pcert1 : centaur/misc/vecs-ints.pcert0
-centaur/misc/vecs-ints.cert : | centaur/misc/vecs-ints.pcert1
-
-centaur/misc/witness-cp.pcert0 : no_pcert = 0
-centaur/misc/witness-cp.pcert0 : acl2x = 0
-centaur/misc/witness-cp.pcert0 : \
- clause-processors/witness-cp.pcert0 \
- centaur/misc/witness-cp.lisp
-centaur/misc/witness-cp.pcert1 : acl2x = 0
-centaur/misc/witness-cp.pcert1 : no_pcert = 0
-centaur/misc/witness-cp.pcert1 : centaur/misc/witness-cp.pcert0
-centaur/misc/witness-cp.cert : | centaur/misc/witness-cp.pcert1
-
-centaur/ubdds/core.pcert0 : no_pcert = 0
-centaur/ubdds/core.pcert0 : acl2x = 0
-centaur/ubdds/core.pcert0 : \
- misc/definline.pcert0 \
- centaur/misc/memory-mgmt-logic.pcert0 \
- misc/computed-hint-rewrite.pcert0 \
- tools/rulesets.pcert0 \
- xdoc/top.pcert0 \
- xdoc/portcullis.pcert0 \
- centaur/ubdds/core.lisp \
- centaur/ubdds/cert.acl2
-centaur/ubdds/core.pcert1 : acl2x = 0
-centaur/ubdds/core.pcert1 : no_pcert = 0
-centaur/ubdds/core.pcert1 : centaur/ubdds/core.pcert0
-centaur/ubdds/core.cert : | centaur/ubdds/core.pcert1
-
-centaur/ubdds/extra-operations.pcert0 : no_pcert = 0
-centaur/ubdds/extra-operations.pcert0 : acl2x = 0
-centaur/ubdds/extra-operations.pcert0 : \
- centaur/ubdds/core.pcert0 \
- xdoc/portcullis.pcert0 \
- centaur/ubdds/extra-operations.lisp \
- centaur/ubdds/cert.acl2
-centaur/ubdds/extra-operations.pcert1 : acl2x = 0
-centaur/ubdds/extra-operations.pcert1 : no_pcert = 0
-centaur/ubdds/extra-operations.pcert1 : centaur/ubdds/extra-operations.pcert0
-centaur/ubdds/extra-operations.cert : | centaur/ubdds/extra-operations.pcert1
-
-centaur/ubdds/lite.pcert0 : no_pcert = 0
-centaur/ubdds/lite.pcert0 : acl2x = 0
-centaur/ubdds/lite.pcert0 : \
- centaur/ubdds/witness.pcert0 \
- centaur/ubdds/subset.pcert0 \
- misc/untranslate-patterns.pcert0 \
- xdoc/portcullis.pcert0 \
- centaur/ubdds/lite.lisp \
- centaur/ubdds/cert.acl2
-centaur/ubdds/lite.pcert1 : acl2x = 0
-centaur/ubdds/lite.pcert1 : no_pcert = 0
-centaur/ubdds/lite.pcert1 : centaur/ubdds/lite.pcert0
-centaur/ubdds/lite.cert : | centaur/ubdds/lite.pcert1
-
-centaur/ubdds/param.pcert0 : no_pcert = 0
-centaur/ubdds/param.pcert0 : acl2x = 0
-centaur/ubdds/param.pcert0 : \
- centaur/ubdds/extra-operations.pcert0 \
- misc/hons-help2.pcert0 \
- tools/rulesets.pcert0 \
- std/lists/take.pcert0 \
- arithmetic/top.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- xdoc/portcullis.pcert0 \
- centaur/ubdds/param.lisp \
- centaur/ubdds/cert.acl2
-centaur/ubdds/param.pcert1 : acl2x = 0
-centaur/ubdds/param.pcert1 : no_pcert = 0
-centaur/ubdds/param.pcert1 : centaur/ubdds/param.pcert0
-centaur/ubdds/param.cert : | centaur/ubdds/param.pcert1
-
-centaur/ubdds/sanity-check-macros.pcert0 : no_pcert = 0
-centaur/ubdds/sanity-check-macros.pcert0 : acl2x = 0
-centaur/ubdds/sanity-check-macros.pcert0 : \
- centaur/ubdds/lite.pcert0 \
- xdoc/portcullis.pcert0 \
- centaur/ubdds/sanity-check-macros.lisp \
- centaur/ubdds/cert.acl2
-centaur/ubdds/sanity-check-macros.pcert1 : acl2x = 0
-centaur/ubdds/sanity-check-macros.pcert1 : no_pcert = 0
-centaur/ubdds/sanity-check-macros.pcert1 : centaur/ubdds/sanity-check-macros.pcert0
-centaur/ubdds/sanity-check-macros.cert : | centaur/ubdds/sanity-check-macros.pcert1
-
-centaur/ubdds/subset.pcert0 : no_pcert = 0
-centaur/ubdds/subset.pcert0 : acl2x = 0
-centaur/ubdds/subset.pcert0 : \
- centaur/ubdds/extra-operations.pcert0 \
- xdoc/portcullis.pcert0 \
- centaur/ubdds/subset.lisp \
- centaur/ubdds/cert.acl2
-centaur/ubdds/subset.pcert1 : acl2x = 0
-centaur/ubdds/subset.pcert1 : no_pcert = 0
-centaur/ubdds/subset.pcert1 : centaur/ubdds/subset.pcert0
-centaur/ubdds/subset.cert : | centaur/ubdds/subset.pcert1
-
-centaur/ubdds/witness.pcert0 : no_pcert = 0
-centaur/ubdds/witness.pcert0 : acl2x = 0
-centaur/ubdds/witness.pcert0 : \
- centaur/ubdds/extra-operations.pcert0 \
- misc/hons-help2.pcert0 \
- clause-processors/term-patterns.pcert0 \
- clause-processors/use-by-hint.pcert0 \
- tools/mv-nth.pcert0 \
- clause-processors/generalize.pcert0 \
- tools/flag.pcert0 \
- centaur/ubdds/witness.lisp \
- centaur/ubdds/witness.acl2 \
- tools/flag-package.lsp
-centaur/ubdds/witness.pcert1 : acl2x = 0
-centaur/ubdds/witness.pcert1 : no_pcert = 0
-centaur/ubdds/witness.pcert1 : centaur/ubdds/witness.pcert0
-centaur/ubdds/witness.cert : | centaur/ubdds/witness.pcert1
-
-centaur/vl/checkers/checkers.pcert0 : no_pcert = 0
-centaur/vl/checkers/checkers.pcert0 : acl2x = 0
-centaur/vl/checkers/checkers.pcert0 : \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/checkers.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/checkers.pcert1 : acl2x = 0
-centaur/vl/checkers/checkers.pcert1 : no_pcert = 0
-centaur/vl/checkers/checkers.pcert1 : centaur/vl/checkers/checkers.pcert0
-centaur/vl/checkers/checkers.cert : | centaur/vl/checkers/checkers.pcert1
-
-centaur/vl/checkers/condcheck.pcert0 : no_pcert = 0
-centaur/vl/checkers/condcheck.pcert0 : acl2x = 0
-centaur/vl/checkers/condcheck.pcert0 : \
- centaur/vl/mlib/ctxexprs.pcert0 \
- centaur/vl/checkers/duplicate-detect.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/condcheck.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/condcheck.pcert1 : acl2x = 0
-centaur/vl/checkers/condcheck.pcert1 : no_pcert = 0
-centaur/vl/checkers/condcheck.pcert1 : centaur/vl/checkers/condcheck.pcert0
-centaur/vl/checkers/condcheck.cert : | centaur/vl/checkers/condcheck.pcert1
-
-centaur/vl/checkers/dupeinst-check.pcert0 : no_pcert = 0
-centaur/vl/checkers/dupeinst-check.pcert0 : acl2x = 0
-centaur/vl/checkers/dupeinst-check.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/checkers/duplicate-detect.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/dupeinst-check.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/dupeinst-check.pcert1 : acl2x = 0
-centaur/vl/checkers/dupeinst-check.pcert1 : no_pcert = 0
-centaur/vl/checkers/dupeinst-check.pcert1 : centaur/vl/checkers/dupeinst-check.pcert0
-centaur/vl/checkers/dupeinst-check.cert : | centaur/vl/checkers/dupeinst-check.pcert1
-
-centaur/vl/checkers/duperhs.pcert0 : no_pcert = 0
-centaur/vl/checkers/duperhs.pcert0 : acl2x = 0
-centaur/vl/checkers/duperhs.pcert0 : \
- centaur/vl/checkers/duplicate-detect.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/writer.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/duperhs.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/duperhs.pcert1 : acl2x = 0
-centaur/vl/checkers/duperhs.pcert1 : no_pcert = 0
-centaur/vl/checkers/duperhs.pcert1 : centaur/vl/checkers/duperhs.pcert0
-centaur/vl/checkers/duperhs.cert : | centaur/vl/checkers/duperhs.pcert1
-
-centaur/vl/checkers/duplicate-detect.pcert0 : no_pcert = 0
-centaur/vl/checkers/duplicate-detect.pcert0 : acl2x = 0
-centaur/vl/checkers/duplicate-detect.pcert0 : \
- centaur/vl/mlib/writer.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/duplicate-detect.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/duplicate-detect.pcert1 : acl2x = 0
-centaur/vl/checkers/duplicate-detect.pcert1 : no_pcert = 0
-centaur/vl/checkers/duplicate-detect.pcert1 : centaur/vl/checkers/duplicate-detect.pcert0
-centaur/vl/checkers/duplicate-detect.cert : | centaur/vl/checkers/duplicate-detect.pcert1
-
-centaur/vl/checkers/leftright.pcert0 : no_pcert = 0
-centaur/vl/checkers/leftright.pcert0 : acl2x = 0
-centaur/vl/checkers/leftright.pcert0 : \
- centaur/vl/mlib/ctxexprs.pcert0 \
- centaur/vl/checkers/duplicate-detect.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/leftright.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/leftright.pcert1 : acl2x = 0
-centaur/vl/checkers/leftright.pcert1 : no_pcert = 0
-centaur/vl/checkers/leftright.pcert1 : centaur/vl/checkers/leftright.pcert0
-centaur/vl/checkers/leftright.cert : | centaur/vl/checkers/leftright.pcert1
-
-centaur/vl/checkers/multidrive-detect.pcert0 : no_pcert = 0
-centaur/vl/checkers/multidrive-detect.pcert0 : acl2x = 0
-centaur/vl/checkers/multidrive-detect.pcert0 : \
- centaur/vl/checkers/duplicate-detect.pcert0 \
- centaur/vl/mlib/lvalues.pcert0 \
- centaur/vl/toe/toe-wirealist.pcert0 \
- centaur/vl/toe/toe-verilogify.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/misc/fal-graphs.pcert0 \
- centaur/misc/hons-extra.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/multidrive-detect.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/multidrive-detect.pcert1 : acl2x = 0
-centaur/vl/checkers/multidrive-detect.pcert1 : no_pcert = 0
-centaur/vl/checkers/multidrive-detect.pcert1 : centaur/vl/checkers/multidrive-detect.pcert0
-centaur/vl/checkers/multidrive-detect.cert : | centaur/vl/checkers/multidrive-detect.pcert1
-
-centaur/vl/checkers/oddexpr.pcert0 : no_pcert = 0
-centaur/vl/checkers/oddexpr.pcert0 : acl2x = 0
-centaur/vl/checkers/oddexpr.pcert0 : \
- centaur/vl/mlib/ctxexprs.pcert0 \
- centaur/vl/transforms/xf-sizing.pcert0 \
- centaur/vl/mlib/fmt.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/oddexpr.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/oddexpr.pcert1 : acl2x = 0
-centaur/vl/checkers/oddexpr.pcert1 : no_pcert = 0
-centaur/vl/checkers/oddexpr.pcert1 : centaur/vl/checkers/oddexpr.pcert0
-centaur/vl/checkers/oddexpr.cert : | centaur/vl/checkers/oddexpr.pcert1
-
-centaur/vl/checkers/portcheck.pcert0 : no_pcert = 0
-centaur/vl/checkers/portcheck.pcert0 : acl2x = 0
-centaur/vl/checkers/portcheck.pcert0 : \
- centaur/vl/mlib/modnamespace.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/portcheck.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/portcheck.pcert1 : acl2x = 0
-centaur/vl/checkers/portcheck.pcert1 : no_pcert = 0
-centaur/vl/checkers/portcheck.pcert1 : centaur/vl/checkers/portcheck.pcert0
-centaur/vl/checkers/portcheck.cert : | centaur/vl/checkers/portcheck.pcert1
-
-centaur/vl/checkers/qmarksize-check.pcert0 : no_pcert = 0
-centaur/vl/checkers/qmarksize-check.pcert0 : acl2x = 0
-centaur/vl/checkers/qmarksize-check.pcert0 : \
- centaur/vl/mlib/ctxexprs.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/qmarksize-check.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/qmarksize-check.pcert1 : acl2x = 0
-centaur/vl/checkers/qmarksize-check.pcert1 : no_pcert = 0
-centaur/vl/checkers/qmarksize-check.pcert1 : centaur/vl/checkers/qmarksize-check.pcert0
-centaur/vl/checkers/qmarksize-check.cert : | centaur/vl/checkers/qmarksize-check.pcert1
-
-centaur/vl/checkers/selfassigns.pcert0 : no_pcert = 0
-centaur/vl/checkers/selfassigns.pcert0 : acl2x = 0
-centaur/vl/checkers/selfassigns.pcert0 : \
- centaur/vl/mlib/ctxexprs.pcert0 \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/selfassigns.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/selfassigns.pcert1 : acl2x = 0
-centaur/vl/checkers/selfassigns.pcert1 : no_pcert = 0
-centaur/vl/checkers/selfassigns.pcert1 : centaur/vl/checkers/selfassigns.pcert0
-centaur/vl/checkers/selfassigns.cert : | centaur/vl/checkers/selfassigns.pcert1
-
-centaur/vl/checkers/skip-detect.pcert0 : no_pcert = 0
-centaur/vl/checkers/skip-detect.pcert0 : acl2x = 0
-centaur/vl/checkers/skip-detect.pcert0 : \
- centaur/vl/mlib/ctxexprs.pcert0 \
- centaur/vl/mlib/print-context.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/skip-detect.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/skip-detect.pcert1 : acl2x = 0
-centaur/vl/checkers/skip-detect.pcert1 : no_pcert = 0
-centaur/vl/checkers/skip-detect.pcert1 : centaur/vl/checkers/skip-detect.pcert0
-centaur/vl/checkers/skip-detect.cert : | centaur/vl/checkers/skip-detect.pcert1
-
-centaur/vl/checkers/typo-detect.pcert0 : no_pcert = 0
-centaur/vl/checkers/typo-detect.pcert0 : acl2x = 0
-centaur/vl/checkers/typo-detect.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/string-alists.pcert0 \
- centaur/vl/util/character-list-listp.pcert0 \
- centaur/vl/loader/lexer-utils.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/typo-detect.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/typo-detect.pcert1 : acl2x = 0
-centaur/vl/checkers/typo-detect.pcert1 : no_pcert = 0
-centaur/vl/checkers/typo-detect.pcert1 : centaur/vl/checkers/typo-detect.pcert0
-centaur/vl/checkers/typo-detect.cert : | centaur/vl/checkers/typo-detect.pcert1
-
-centaur/vl/checkers/use-set-report.pcert0 : no_pcert = 0
-centaur/vl/checkers/use-set-report.pcert0 : acl2x = 0
-centaur/vl/checkers/use-set-report.pcert0 : \
- centaur/vl/mlib/writer.pcert0 \
- centaur/vl/mlib/print-warnings.pcert0 \
- centaur/vl/util/string-alists.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/use-set-report.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/use-set-report.pcert1 : acl2x = 0
-centaur/vl/checkers/use-set-report.pcert1 : no_pcert = 0
-centaur/vl/checkers/use-set-report.pcert1 : centaur/vl/checkers/use-set-report.pcert0
-centaur/vl/checkers/use-set-report.cert : | centaur/vl/checkers/use-set-report.pcert1
-
-centaur/vl/checkers/use-set-tool.pcert0 : no_pcert = 0
-centaur/vl/checkers/use-set-tool.pcert0 : acl2x = 0
-centaur/vl/checkers/use-set-tool.pcert0 : \
- centaur/vl/checkers/use-set.pcert0 \
- centaur/vl/loader/loader.pcert0 \
- centaur/vl/transforms/xf-argresolve.pcert0 \
- centaur/vl/transforms/xf-portdecl-sign.pcert0 \
- centaur/vl/transforms/cn-hooks.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/mlib/modname-sets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/use-set-tool.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/use-set-tool.pcert1 : acl2x = 0
-centaur/vl/checkers/use-set-tool.pcert1 : no_pcert = 0
-centaur/vl/checkers/use-set-tool.pcert1 : centaur/vl/checkers/use-set-tool.pcert0
-centaur/vl/checkers/use-set-tool.cert : | centaur/vl/checkers/use-set-tool.pcert1
-
-centaur/vl/checkers/use-set.pcert0 : no_pcert = 0
-centaur/vl/checkers/use-set.pcert0 : acl2x = 0
-centaur/vl/checkers/use-set.pcert0 : \
- centaur/vl/checkers/typo-detect.pcert0 \
- centaur/vl/checkers/use-set-report.pcert0 \
- centaur/vl/mlib/warnings.pcert0 \
- centaur/vl/mlib/allexprs.pcert0 \
- centaur/vl/mlib/find-item.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/checkers/use-set.lisp \
- centaur/vl/checkers/cert.acl2
-centaur/vl/checkers/use-set.pcert1 : acl2x = 0
-centaur/vl/checkers/use-set.pcert1 : no_pcert = 0
-centaur/vl/checkers/use-set.pcert1 : centaur/vl/checkers/use-set.pcert0
-centaur/vl/checkers/use-set.cert : | centaur/vl/checkers/use-set.pcert1
-
-centaur/vl/lint/bit-use-set.pcert0 : no_pcert = 0
-centaur/vl/lint/bit-use-set.pcert0 : acl2x = 0
-centaur/vl/lint/bit-use-set.pcert0 : \
- centaur/vl/toe/toe-preliminary.pcert0 \
- centaur/vl/wf-reasonable-p.pcert0 \
- centaur/vl/lint/disconnected.pcert0 \
- centaur/vl/mlib/hierarchy.pcert0 \
- centaur/vl/mlib/allexprs.pcert0 \
- centaur/vl/mlib/lvalues.pcert0 \
- centaur/vl/mlib/warnings.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/lint/use-set-ignore.pcert0 \
- centaur/bitops/bitsets.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/bit-use-set.lisp \
- centaur/vl/lint/cert.acl2
-centaur/vl/lint/bit-use-set.pcert1 : acl2x = 0
-centaur/vl/lint/bit-use-set.pcert1 : no_pcert = 0
-centaur/vl/lint/bit-use-set.pcert1 : centaur/vl/lint/bit-use-set.pcert0
-centaur/vl/lint/bit-use-set.cert : | centaur/vl/lint/bit-use-set.pcert1
-
-centaur/vl/lint/check-case.pcert0 : no_pcert = 0
-centaur/vl/lint/check-case.pcert0 : acl2x = 0
-centaur/vl/lint/check-case.pcert0 : \
- centaur/vl/mlib/modnamespace.pcert0 \
- centaur/vl/mlib/writer.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/check-case.lisp \
- centaur/vl/lint/cert.acl2
-centaur/vl/lint/check-case.pcert1 : acl2x = 0
-centaur/vl/lint/check-case.pcert1 : no_pcert = 0
-centaur/vl/lint/check-case.pcert1 : centaur/vl/lint/check-case.pcert0
-centaur/vl/lint/check-case.cert : | centaur/vl/lint/check-case.pcert1
-
-centaur/vl/lint/check-namespace.pcert0 : no_pcert = 0
-centaur/vl/lint/check-namespace.pcert0 : acl2x = 0
-centaur/vl/lint/check-namespace.pcert0 : \
- centaur/vl/wf-reasonable-p.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/check-namespace.lisp \
- centaur/vl/lint/cert.acl2
-centaur/vl/lint/check-namespace.pcert1 : acl2x = 0
-centaur/vl/lint/check-namespace.pcert1 : no_pcert = 0
-centaur/vl/lint/check-namespace.pcert1 : centaur/vl/lint/check-namespace.pcert0
-centaur/vl/lint/check-namespace.cert : | centaur/vl/lint/check-namespace.pcert1
-
-centaur/vl/lint/disconnected.pcert0 : no_pcert = 0
-centaur/vl/lint/disconnected.pcert0 : acl2x = 0
-centaur/vl/lint/disconnected.pcert0 : \
- centaur/vl/toe/toe-wirealist.pcert0 \
- centaur/vl/toe/toe-verilogify.pcert0 \
- centaur/vl/mlib/allexprs.pcert0 \
- centaur/vl/mlib/fmt.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/disconnected.lisp \
- centaur/vl/lint/cert.acl2
-centaur/vl/lint/disconnected.pcert1 : acl2x = 0
-centaur/vl/lint/disconnected.pcert1 : no_pcert = 0
-centaur/vl/lint/disconnected.pcert1 : centaur/vl/lint/disconnected.pcert0
-centaur/vl/lint/disconnected.cert : | centaur/vl/lint/disconnected.pcert1
-
-centaur/vl/lint/lint.pcert0 : no_pcert = 0
-centaur/vl/lint/lint.pcert0 : acl2x = 0
-centaur/vl/lint/lint.pcert0 : \
- centaur/vl/lint/bit-use-set.pcert0 \
- centaur/vl/lint/check-case.pcert0 \
- centaur/vl/lint/check-namespace.pcert0 \
- centaur/vl/lint/disconnected.pcert0 \
- centaur/vl/lint/xf-drop-missing-submodules.pcert0 \
- centaur/vl/lint/xf-lint-stmt-rewrite.pcert0 \
- centaur/vl/lint/xf-remove-toohard.pcert0 \
- centaur/vl/lint/xf-undefined-names.pcert0 \
- centaur/vl/lint/xf-suppress-warnings.pcert0 \
- centaur/vl/checkers/condcheck.pcert0 \
- centaur/vl/checkers/duplicate-detect.pcert0 \
- centaur/vl/checkers/dupeinst-check.pcert0 \
- centaur/vl/checkers/duperhs.pcert0 \
- centaur/vl/checkers/leftright.pcert0 \
- centaur/vl/checkers/multidrive-detect.pcert0 \
- centaur/vl/checkers/oddexpr.pcert0 \
- centaur/vl/checkers/portcheck.pcert0 \
- centaur/vl/checkers/qmarksize-check.pcert0 \
- centaur/vl/checkers/selfassigns.pcert0 \
- centaur/vl/checkers/skip-detect.pcert0 \
- centaur/vl/loader/loader.pcert0 \
- centaur/vl/transforms/cn-hooks.pcert0 \
- centaur/vl/transforms/xf-argresolve.pcert0 \
- centaur/vl/transforms/xf-array-indexing.pcert0 \
- centaur/vl/transforms/xf-assign-trunc.pcert0 \
- centaur/vl/transforms/xf-blankargs.pcert0 \
- centaur/vl/transforms/xf-clean-params.pcert0 \
- centaur/vl/transforms/xf-drop-blankports.pcert0 \
- centaur/vl/transforms/xf-expr-split.pcert0 \
- centaur/vl/transforms/xf-expand-functions.pcert0 \
- centaur/vl/transforms/xf-follow-hids.pcert0 \
- centaur/vl/transforms/xf-hid-elim.pcert0 \
- centaur/vl/transforms/xf-orig.pcert0 \
- centaur/vl/transforms/xf-oprewrite.pcert0 \
- centaur/vl/transforms/xf-portdecl-sign.pcert0 \
- centaur/vl/transforms/xf-resolve-ranges.pcert0 \
- centaur/vl/transforms/xf-replicate-insts.pcert0 \
- centaur/vl/transforms/xf-sizing.pcert0 \
- centaur/vl/transforms/xf-unparameterize.pcert0 \
- centaur/vl/transforms/xf-unused-reg.pcert0 \
- centaur/vl/mlib/modname-sets.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/lint.lisp \
- centaur/vl/lint/lint.acl2
-centaur/vl/lint/lint.pcert1 : acl2x = 0
-centaur/vl/lint/lint.pcert1 : no_pcert = 0
-centaur/vl/lint/lint.pcert1 : centaur/vl/lint/lint.pcert0
-centaur/vl/lint/lint.cert : | centaur/vl/lint/lint.pcert1
-
-centaur/vl/lint/use-set-ignore.pcert0 : no_pcert = 0
-centaur/vl/lint/use-set-ignore.pcert0 : acl2x = 0
-centaur/vl/lint/use-set-ignore.pcert0 : \
- centaur/vl/loader/parse-lvalues.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/mlib/fmt.pcert0 \
- centaur/vl/checkers/oddexpr.pcert0 \
- centaur/vl/toe/toe-wirealist.pcert0 \
- centaur/vl/transforms/xf-sizing.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/use-set-ignore.lisp \
- centaur/vl/lint/cert.acl2
-centaur/vl/lint/use-set-ignore.pcert1 : acl2x = 0
-centaur/vl/lint/use-set-ignore.pcert1 : no_pcert = 0
-centaur/vl/lint/use-set-ignore.pcert1 : centaur/vl/lint/use-set-ignore.pcert0
-centaur/vl/lint/use-set-ignore.cert : | centaur/vl/lint/use-set-ignore.pcert1
-
-centaur/vl/lint/xf-drop-missing-submodules.pcert0 : no_pcert = 0
-centaur/vl/lint/xf-drop-missing-submodules.pcert0 : acl2x = 0
-centaur/vl/lint/xf-drop-missing-submodules.pcert0 : \
- centaur/vl/mlib/filter.pcert0 \
- centaur/vl/mlib/hierarchy.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/xf-drop-missing-submodules.lisp \
- centaur/vl/lint/cert.acl2
-centaur/vl/lint/xf-drop-missing-submodules.pcert1 : acl2x = 0
-centaur/vl/lint/xf-drop-missing-submodules.pcert1 : no_pcert = 0
-centaur/vl/lint/xf-drop-missing-submodules.pcert1 : centaur/vl/lint/xf-drop-missing-submodules.pcert0
-centaur/vl/lint/xf-drop-missing-submodules.cert : | centaur/vl/lint/xf-drop-missing-submodules.pcert1
-
-centaur/vl/lint/xf-drop-unresolved-submodules.pcert0 : no_pcert = 0
-centaur/vl/lint/xf-drop-unresolved-submodules.pcert0 : acl2x = 0
-centaur/vl/lint/xf-drop-unresolved-submodules.pcert0 : \
- centaur/vl/mlib/filter.pcert0 \
- centaur/vl/mlib/hierarchy.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/xf-drop-unresolved-submodules.lisp \
- centaur/vl/lint/cert.acl2
-centaur/vl/lint/xf-drop-unresolved-submodules.pcert1 : acl2x = 0
-centaur/vl/lint/xf-drop-unresolved-submodules.pcert1 : no_pcert = 0
-centaur/vl/lint/xf-drop-unresolved-submodules.pcert1 : centaur/vl/lint/xf-drop-unresolved-submodules.pcert0
-centaur/vl/lint/xf-drop-unresolved-submodules.cert : | centaur/vl/lint/xf-drop-unresolved-submodules.pcert1
-
-centaur/vl/lint/xf-lint-stmt-rewrite.pcert0 : no_pcert = 0
-centaur/vl/lint/xf-lint-stmt-rewrite.pcert0 : acl2x = 0
-centaur/vl/lint/xf-lint-stmt-rewrite.pcert0 : \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/xf-lint-stmt-rewrite.lisp \
- centaur/vl/lint/cert.acl2
-centaur/vl/lint/xf-lint-stmt-rewrite.pcert1 : acl2x = 0
-centaur/vl/lint/xf-lint-stmt-rewrite.pcert1 : no_pcert = 0
-centaur/vl/lint/xf-lint-stmt-rewrite.pcert1 : centaur/vl/lint/xf-lint-stmt-rewrite.pcert0
-centaur/vl/lint/xf-lint-stmt-rewrite.cert : | centaur/vl/lint/xf-lint-stmt-rewrite.pcert1
-
-centaur/vl/lint/xf-remove-toohard.pcert0 : no_pcert = 0
-centaur/vl/lint/xf-remove-toohard.pcert0 : acl2x = 0
-centaur/vl/lint/xf-remove-toohard.pcert0 : \
- centaur/vl/mlib/writer.pcert0 \
- centaur/vl/mlib/allexprs.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/xf-remove-toohard.lisp \
- centaur/vl/lint/cert.acl2
-centaur/vl/lint/xf-remove-toohard.pcert1 : acl2x = 0
-centaur/vl/lint/xf-remove-toohard.pcert1 : no_pcert = 0
-centaur/vl/lint/xf-remove-toohard.pcert1 : centaur/vl/lint/xf-remove-toohard.pcert0
-centaur/vl/lint/xf-remove-toohard.cert : | centaur/vl/lint/xf-remove-toohard.pcert1
-
-centaur/vl/lint/xf-suppress-warnings.pcert0 : no_pcert = 0
-centaur/vl/lint/xf-suppress-warnings.pcert0 : acl2x = 0
-centaur/vl/lint/xf-suppress-warnings.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/xf-suppress-warnings.lisp \
- centaur/vl/lint/cert.acl2
-centaur/vl/lint/xf-suppress-warnings.pcert1 : acl2x = 0
-centaur/vl/lint/xf-suppress-warnings.pcert1 : no_pcert = 0
-centaur/vl/lint/xf-suppress-warnings.pcert1 : centaur/vl/lint/xf-suppress-warnings.pcert0
-centaur/vl/lint/xf-suppress-warnings.cert : | centaur/vl/lint/xf-suppress-warnings.pcert1
-
-centaur/vl/lint/xf-undefined-names.pcert0 : no_pcert = 0
-centaur/vl/lint/xf-undefined-names.pcert0 : acl2x = 0
-centaur/vl/lint/xf-undefined-names.pcert0 : \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/lint/xf-undefined-names.lisp \
- centaur/vl/lint/cert.acl2
-centaur/vl/lint/xf-undefined-names.pcert1 : acl2x = 0
-centaur/vl/lint/xf-undefined-names.pcert1 : no_pcert = 0
-centaur/vl/lint/xf-undefined-names.pcert1 : centaur/vl/lint/xf-undefined-names.pcert0
-centaur/vl/lint/xf-undefined-names.cert : | centaur/vl/lint/xf-undefined-names.pcert1
-
-centaur/vl/loader/defines.pcert0 : no_pcert = 0
-centaur/vl/loader/defines.pcert0 : acl2x = 0
-centaur/vl/loader/defines.pcert0 : \
- centaur/vl/util/echars.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/defines.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/defines.pcert1 : acl2x = 0
-centaur/vl/loader/defines.pcert1 : no_pcert = 0
-centaur/vl/loader/defines.pcert1 : centaur/vl/loader/defines.pcert0
-centaur/vl/loader/defines.cert : | centaur/vl/loader/defines.pcert1
-
-centaur/vl/loader/filemap.pcert0 : no_pcert = 0
-centaur/vl/loader/filemap.pcert0 : acl2x = 0
-centaur/vl/loader/filemap.pcert0 : \
- centaur/vl/util/echars.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/filemap.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/filemap.pcert1 : acl2x = 0
-centaur/vl/loader/filemap.pcert1 : no_pcert = 0
-centaur/vl/loader/filemap.pcert1 : centaur/vl/loader/filemap.pcert0
-centaur/vl/loader/filemap.cert : | centaur/vl/loader/filemap.pcert1
-
-centaur/vl/loader/find-file.pcert0 : no_pcert = 0
-centaur/vl/loader/find-file.pcert0 : acl2x = 0
-centaur/vl/loader/find-file.pcert0 : \
- centaur/vl/util/warnings.pcert0 \
- std/io/open-input-channel.pcert0 \
- std/io/close-input-channel.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/find-file.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/find-file.pcert1 : acl2x = 0
-centaur/vl/loader/find-file.pcert1 : no_pcert = 0
-centaur/vl/loader/find-file.pcert1 : centaur/vl/loader/find-file.pcert0
-centaur/vl/loader/find-file.cert : | centaur/vl/loader/find-file.pcert1
-
-centaur/vl/loader/inject-comments.pcert0 : no_pcert = 0
-centaur/vl/loader/inject-comments.pcert0 : acl2x = 0
-centaur/vl/loader/inject-comments.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/inject-comments.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/inject-comments.pcert1 : acl2x = 0
-centaur/vl/loader/inject-comments.pcert1 : no_pcert = 0
-centaur/vl/loader/inject-comments.pcert1 : centaur/vl/loader/inject-comments.pcert0
-centaur/vl/loader/inject-comments.cert : | centaur/vl/loader/inject-comments.pcert1
-
-centaur/vl/loader/lexer-tests.pcert0 : no_pcert = 0
-centaur/vl/loader/lexer-tests.pcert0 : acl2x = 0
-centaur/vl/loader/lexer-tests.pcert0 : \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/lexer-tests.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/lexer-tests.pcert1 : acl2x = 0
-centaur/vl/loader/lexer-tests.pcert1 : no_pcert = 0
-centaur/vl/loader/lexer-tests.pcert1 : centaur/vl/loader/lexer-tests.pcert0
-centaur/vl/loader/lexer-tests.cert : | centaur/vl/loader/lexer-tests.pcert1
-
-centaur/vl/loader/lexer-tokens.pcert0 : no_pcert = 0
-centaur/vl/loader/lexer-tokens.pcert0 : acl2x = 0
-centaur/vl/loader/lexer-tokens.pcert0 : \
- centaur/vl/util/bits.pcert0 \
- centaur/vl/util/echars.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/lexer-tokens.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/lexer-tokens.pcert1 : acl2x = 0
-centaur/vl/loader/lexer-tokens.pcert1 : no_pcert = 0
-centaur/vl/loader/lexer-tokens.pcert1 : centaur/vl/loader/lexer-tokens.pcert0
-centaur/vl/loader/lexer-tokens.cert : | centaur/vl/loader/lexer-tokens.pcert1
-
-centaur/vl/loader/lexer-utils.pcert0 : no_pcert = 0
-centaur/vl/loader/lexer-utils.pcert0 : acl2x = 0
-centaur/vl/loader/lexer-utils.pcert0 : \
- std/lists/prefixp.pcert0 \
- centaur/vl/util/echars.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/lexer-utils.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/lexer-utils.pcert1 : acl2x = 0
-centaur/vl/loader/lexer-utils.pcert1 : no_pcert = 0
-centaur/vl/loader/lexer-utils.pcert1 : centaur/vl/loader/lexer-utils.pcert0
-centaur/vl/loader/lexer-utils.cert : | centaur/vl/loader/lexer-utils.pcert1
-
-centaur/vl/loader/lexer.pcert0 : no_pcert = 0
-centaur/vl/loader/lexer.pcert0 : acl2x = 0
-centaur/vl/loader/lexer.pcert0 : \
- centaur/vl/loader/lexer-tokens.pcert0 \
- centaur/vl/loader/lexer-utils.pcert0 \
- centaur/vl/util/warnings.pcert0 \
- centaur/vl/util/commentmap.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/lexer.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/lexer.pcert1 : acl2x = 0
-centaur/vl/loader/lexer.pcert1 : no_pcert = 0
-centaur/vl/loader/lexer.pcert1 : centaur/vl/loader/lexer.pcert0
-centaur/vl/loader/lexer.cert : | centaur/vl/loader/lexer.pcert1
-
-centaur/vl/loader/loader.pcert0 : no_pcert = 0
-centaur/vl/loader/loader.pcert0 : acl2x = 0
-centaur/vl/loader/loader.pcert0 : \
- centaur/vl/loader/read-file.pcert0 \
- centaur/vl/loader/find-file.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/loader/preprocessor.pcert0 \
- centaur/vl/loader/parser.pcert0 \
- centaur/vl/loader/filemap.pcert0 \
- centaur/vl/loader/inject-comments.pcert0 \
- centaur/vl/loader/overrides.pcert0 \
- centaur/vl/mlib/hierarchy.pcert0 \
- centaur/vl/mlib/print-warnings.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/util/gc.pcert0 \
- centaur/misc/hons-extra.pcert0 \
- defsort/duplicated-members.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/loader.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/loader.pcert1 : acl2x = 0
-centaur/vl/loader/loader.pcert1 : no_pcert = 0
-centaur/vl/loader/loader.pcert1 : centaur/vl/loader/loader.pcert0
-centaur/vl/loader/loader.cert : | centaur/vl/loader/loader.pcert1
-
-centaur/vl/loader/make-implicit-wires.pcert0 : no_pcert = 0
-centaur/vl/loader/make-implicit-wires.pcert0 : acl2x = 0
-centaur/vl/loader/make-implicit-wires.pcert0 : \
- centaur/vl/mlib/allexprs.pcert0 \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/mlib/modnamespace.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/make-implicit-wires.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/make-implicit-wires.pcert1 : acl2x = 0
-centaur/vl/loader/make-implicit-wires.pcert1 : no_pcert = 0
-centaur/vl/loader/make-implicit-wires.pcert1 : centaur/vl/loader/make-implicit-wires.pcert0
-centaur/vl/loader/make-implicit-wires.cert : | centaur/vl/loader/make-implicit-wires.pcert1
-
-centaur/vl/loader/overrides.pcert0 : no_pcert = 0
-centaur/vl/loader/overrides.pcert0 : acl2x = 0
-centaur/vl/loader/overrides.pcert0 : \
- centaur/vl/loader/read-file.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/loader/preprocessor.pcert0 \
- centaur/vl/loader/parse-utils.pcert0 \
- centaur/vl/loader/parse-error.pcert0 \
- centaur/vl/loader/filemap.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/mlib/warnings.pcert0 \
- oslib/ls.pcert0 \
- str/top.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/overrides.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/overrides.pcert1 : acl2x = 0
-centaur/vl/loader/overrides.pcert1 : no_pcert = 0
-centaur/vl/loader/overrides.pcert1 : centaur/vl/loader/overrides.pcert0
-centaur/vl/loader/overrides.cert : | centaur/vl/loader/overrides.pcert1
-
-centaur/vl/loader/parse-blockitems.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-blockitems.pcert0 : acl2x = 0
-centaur/vl/loader/parse-blockitems.pcert0 : \
- centaur/vl/loader/parse-ranges.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-blockitems.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-blockitems.pcert1 : acl2x = 0
-centaur/vl/loader/parse-blockitems.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-blockitems.pcert1 : centaur/vl/loader/parse-blockitems.pcert0
-centaur/vl/loader/parse-blockitems.cert : | centaur/vl/loader/parse-blockitems.pcert1
-
-centaur/vl/loader/parse-delays.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-delays.pcert0 : acl2x = 0
-centaur/vl/loader/parse-delays.pcert0 : \
- centaur/vl/loader/parse-expressions.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-delays.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-delays.pcert1 : acl2x = 0
-centaur/vl/loader/parse-delays.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-delays.pcert1 : centaur/vl/loader/parse-delays.pcert0
-centaur/vl/loader/parse-delays.cert : | centaur/vl/loader/parse-delays.pcert1
-
-centaur/vl/loader/parse-error.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-error.pcert0 : acl2x = 0
-centaur/vl/loader/parse-error.pcert0 : \
- centaur/vl/loader/lexer-tokens.pcert0 \
- centaur/vl/mlib/fmt.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-error.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-error.pcert1 : acl2x = 0
-centaur/vl/loader/parse-error.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-error.pcert1 : centaur/vl/loader/parse-error.pcert0
-centaur/vl/loader/parse-error.cert : | centaur/vl/loader/parse-error.pcert1
-
-centaur/vl/loader/parse-eventctrl.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-eventctrl.pcert0 : acl2x = 0
-centaur/vl/loader/parse-eventctrl.pcert0 : \
- centaur/vl/loader/parse-delays.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-eventctrl.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-eventctrl.pcert1 : acl2x = 0
-centaur/vl/loader/parse-eventctrl.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-eventctrl.pcert1 : centaur/vl/loader/parse-eventctrl.pcert0
-centaur/vl/loader/parse-eventctrl.cert : | centaur/vl/loader/parse-eventctrl.pcert1
-
-centaur/vl/loader/parse-expressions-def.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-expressions-def.pcert0 : acl2x = 0
-centaur/vl/loader/parse-expressions-def.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/loader/parse-utils.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-expressions-def.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-expressions-def.pcert1 : acl2x = 0
-centaur/vl/loader/parse-expressions-def.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-expressions-def.pcert1 : centaur/vl/loader/parse-expressions-def.pcert0
-centaur/vl/loader/parse-expressions-def.cert : | centaur/vl/loader/parse-expressions-def.pcert1
-
-centaur/vl/loader/parse-expressions-eof.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-expressions-eof.pcert0 : acl2x = 0
-centaur/vl/loader/parse-expressions-eof.pcert0 : \
- centaur/vl/loader/parse-expressions-def.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-expressions-eof.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-expressions-eof.pcert1 : acl2x = 0
-centaur/vl/loader/parse-expressions-eof.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-expressions-eof.pcert1 : centaur/vl/loader/parse-expressions-eof.pcert0
-centaur/vl/loader/parse-expressions-eof.cert : | centaur/vl/loader/parse-expressions-eof.pcert1
-
-centaur/vl/loader/parse-expressions-error.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-expressions-error.pcert0 : acl2x = 0
-centaur/vl/loader/parse-expressions-error.pcert0 : \
- centaur/vl/loader/parse-expressions-def.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-expressions-error.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-expressions-error.pcert1 : acl2x = 0
-centaur/vl/loader/parse-expressions-error.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-expressions-error.pcert1 : centaur/vl/loader/parse-expressions-error.pcert0
-centaur/vl/loader/parse-expressions-error.cert : | centaur/vl/loader/parse-expressions-error.pcert1
-
-centaur/vl/loader/parse-expressions-progress.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-expressions-progress.pcert0 : acl2x = 0
-centaur/vl/loader/parse-expressions-progress.pcert0 : \
- centaur/vl/loader/parse-expressions-def.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-expressions-progress.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-expressions-progress.pcert1 : acl2x = 0
-centaur/vl/loader/parse-expressions-progress.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-expressions-progress.pcert1 : centaur/vl/loader/parse-expressions-progress.pcert0
-centaur/vl/loader/parse-expressions-progress.cert : | centaur/vl/loader/parse-expressions-progress.pcert1
-
-centaur/vl/loader/parse-expressions-result.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-expressions-result.pcert0 : acl2x = 0
-centaur/vl/loader/parse-expressions-result.pcert0 : \
- centaur/vl/loader/parse-expressions-def.pcert0 \
- centaur/vl/loader/parse-expressions-tokenlist.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-expressions-result.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-expressions-result.pcert1 : acl2x = 0
-centaur/vl/loader/parse-expressions-result.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-expressions-result.pcert1 : centaur/vl/loader/parse-expressions-result.pcert0
-centaur/vl/loader/parse-expressions-result.cert : | centaur/vl/loader/parse-expressions-result.pcert1
-
-centaur/vl/loader/parse-expressions-tokenlist.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-expressions-tokenlist.pcert0 : acl2x = 0
-centaur/vl/loader/parse-expressions-tokenlist.pcert0 : \
- centaur/vl/loader/parse-expressions-def.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-expressions-tokenlist.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-expressions-tokenlist.pcert1 : acl2x = 0
-centaur/vl/loader/parse-expressions-tokenlist.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-expressions-tokenlist.pcert1 : centaur/vl/loader/parse-expressions-tokenlist.pcert0
-centaur/vl/loader/parse-expressions-tokenlist.cert : | centaur/vl/loader/parse-expressions-tokenlist.pcert1
-
-centaur/vl/loader/parse-expressions-warnings.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-expressions-warnings.pcert0 : acl2x = 0
-centaur/vl/loader/parse-expressions-warnings.pcert0 : \
- centaur/vl/loader/parse-expressions-def.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-expressions-warnings.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-expressions-warnings.pcert1 : acl2x = 0
-centaur/vl/loader/parse-expressions-warnings.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-expressions-warnings.pcert1 : centaur/vl/loader/parse-expressions-warnings.pcert0
-centaur/vl/loader/parse-expressions-warnings.cert : | centaur/vl/loader/parse-expressions-warnings.pcert1
-
-centaur/vl/loader/parse-expressions.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-expressions.pcert0 : acl2x = 0
-centaur/vl/loader/parse-expressions.pcert0 : \
- centaur/vl/loader/parse-expressions-def.pcert0 \
- centaur/vl/loader/parse-expressions-error.pcert0 \
- centaur/vl/loader/parse-expressions-tokenlist.pcert0 \
- centaur/vl/loader/parse-expressions-warnings.pcert0 \
- centaur/vl/loader/parse-expressions-progress.pcert0 \
- centaur/vl/loader/parse-expressions-eof.pcert0 \
- centaur/vl/loader/parse-expressions-result.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-expressions.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-expressions.pcert1 : acl2x = 0
-centaur/vl/loader/parse-expressions.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-expressions.pcert1 : centaur/vl/loader/parse-expressions.pcert0
-centaur/vl/loader/parse-expressions.cert : | centaur/vl/loader/parse-expressions.pcert1
-
-centaur/vl/loader/parse-functions.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-functions.pcert0 : acl2x = 0
-centaur/vl/loader/parse-functions.pcert0 : \
- centaur/vl/loader/parse-blockitems.pcert0 \
- centaur/vl/loader/parse-ports.pcert0 \
- centaur/vl/loader/parse-statements.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-functions.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-functions.pcert1 : acl2x = 0
-centaur/vl/loader/parse-functions.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-functions.pcert1 : centaur/vl/loader/parse-functions.pcert0
-centaur/vl/loader/parse-functions.cert : | centaur/vl/loader/parse-functions.pcert1
-
-centaur/vl/loader/parse-gates.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-gates.pcert0 : acl2x = 0
-centaur/vl/loader/parse-gates.pcert0 : \
- centaur/vl/loader/parse-strengths.pcert0 \
- centaur/vl/loader/parse-delays.pcert0 \
- centaur/vl/loader/parse-ranges.pcert0 \
- centaur/vl/loader/parse-lvalues.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-gates.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-gates.pcert1 : acl2x = 0
-centaur/vl/loader/parse-gates.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-gates.pcert1 : centaur/vl/loader/parse-gates.pcert0
-centaur/vl/loader/parse-gates.cert : | centaur/vl/loader/parse-gates.pcert1
-
-centaur/vl/loader/parse-insts.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-insts.pcert0 : acl2x = 0
-centaur/vl/loader/parse-insts.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/loader/parse-ranges.pcert0 \
- centaur/vl/loader/parse-lvalues.pcert0 \
- centaur/vl/loader/parse-delays.pcert0 \
- centaur/vl/loader/parse-strengths.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-insts.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-insts.pcert1 : acl2x = 0
-centaur/vl/loader/parse-insts.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-insts.pcert1 : centaur/vl/loader/parse-insts.pcert0
-centaur/vl/loader/parse-insts.cert : | centaur/vl/loader/parse-insts.pcert1
-
-centaur/vl/loader/parse-lvalues.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-lvalues.pcert0 : acl2x = 0
-centaur/vl/loader/parse-lvalues.pcert0 : \
- centaur/vl/loader/parse-expressions.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-lvalues.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-lvalues.pcert1 : acl2x = 0
-centaur/vl/loader/parse-lvalues.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-lvalues.pcert1 : centaur/vl/loader/parse-lvalues.pcert0
-centaur/vl/loader/parse-lvalues.cert : | centaur/vl/loader/parse-lvalues.pcert1
-
-centaur/vl/loader/parse-modules.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-modules.pcert0 : acl2x = 0
-centaur/vl/loader/parse-modules.pcert0 : \
- centaur/vl/loader/parse-statements.pcert0 \
- centaur/vl/loader/parse-ports.pcert0 \
- centaur/vl/loader/parse-nets.pcert0 \
- centaur/vl/loader/parse-blockitems.pcert0 \
- centaur/vl/loader/parse-insts.pcert0 \
- centaur/vl/loader/parse-gates.pcert0 \
- centaur/vl/loader/parse-functions.pcert0 \
- centaur/vl/loader/make-implicit-wires.pcert0 \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/mlib/port-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-modules.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-modules.pcert1 : acl2x = 0
-centaur/vl/loader/parse-modules.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-modules.pcert1 : centaur/vl/loader/parse-modules.pcert0
-centaur/vl/loader/parse-modules.cert : | centaur/vl/loader/parse-modules.pcert1
-
-centaur/vl/loader/parse-nets.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-nets.pcert0 : acl2x = 0
-centaur/vl/loader/parse-nets.pcert0 : \
- centaur/vl/loader/parse-ranges.pcert0 \
- centaur/vl/loader/parse-lvalues.pcert0 \
- centaur/vl/loader/parse-delays.pcert0 \
- centaur/vl/loader/parse-strengths.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-nets.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-nets.pcert1 : acl2x = 0
-centaur/vl/loader/parse-nets.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-nets.pcert1 : centaur/vl/loader/parse-nets.pcert0
-centaur/vl/loader/parse-nets.cert : | centaur/vl/loader/parse-nets.pcert1
-
-centaur/vl/loader/parse-ports.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-ports.pcert0 : acl2x = 0
-centaur/vl/loader/parse-ports.pcert0 : \
- centaur/vl/loader/parse-nets.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-ports.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-ports.pcert1 : acl2x = 0
-centaur/vl/loader/parse-ports.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-ports.pcert1 : centaur/vl/loader/parse-ports.pcert0
-centaur/vl/loader/parse-ports.cert : | centaur/vl/loader/parse-ports.pcert1
-
-centaur/vl/loader/parse-ranges.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-ranges.pcert0 : acl2x = 0
-centaur/vl/loader/parse-ranges.pcert0 : \
- centaur/vl/loader/parse-expressions.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-ranges.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-ranges.pcert1 : acl2x = 0
-centaur/vl/loader/parse-ranges.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-ranges.pcert1 : centaur/vl/loader/parse-ranges.pcert0
-centaur/vl/loader/parse-ranges.cert : | centaur/vl/loader/parse-ranges.pcert1
-
-centaur/vl/loader/parse-statements-def.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-statements-def.pcert0 : acl2x = 0
-centaur/vl/loader/parse-statements-def.pcert0 : \
- centaur/vl/loader/parse-eventctrl.pcert0 \
- centaur/vl/loader/parse-blockitems.pcert0 \
- centaur/vl/loader/parse-lvalues.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-statements-def.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-statements-def.pcert1 : acl2x = 0
-centaur/vl/loader/parse-statements-def.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-statements-def.pcert1 : centaur/vl/loader/parse-statements-def.pcert0
-centaur/vl/loader/parse-statements-def.cert : | centaur/vl/loader/parse-statements-def.pcert1
-
-centaur/vl/loader/parse-statements-error.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-statements-error.pcert0 : acl2x = 0
-centaur/vl/loader/parse-statements-error.pcert0 : \
- centaur/vl/loader/parse-statements-def.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-statements-error.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-statements-error.pcert1 : acl2x = 0
-centaur/vl/loader/parse-statements-error.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-statements-error.pcert1 : centaur/vl/loader/parse-statements-error.pcert0
-centaur/vl/loader/parse-statements-error.cert : | centaur/vl/loader/parse-statements-error.pcert1
-
-centaur/vl/loader/parse-statements-progress.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-statements-progress.pcert0 : acl2x = 0
-centaur/vl/loader/parse-statements-progress.pcert0 : \
- centaur/vl/loader/parse-statements-def.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-statements-progress.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-statements-progress.pcert1 : acl2x = 0
-centaur/vl/loader/parse-statements-progress.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-statements-progress.pcert1 : centaur/vl/loader/parse-statements-progress.pcert0
-centaur/vl/loader/parse-statements-progress.cert : | centaur/vl/loader/parse-statements-progress.pcert1
-
-centaur/vl/loader/parse-statements-result.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-statements-result.pcert0 : acl2x = 0
-centaur/vl/loader/parse-statements-result.pcert0 : \
- centaur/vl/loader/parse-statements-def.pcert0 \
- centaur/vl/loader/parse-statements-tokenlist.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-statements-result.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-statements-result.pcert1 : acl2x = 0
-centaur/vl/loader/parse-statements-result.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-statements-result.pcert1 : centaur/vl/loader/parse-statements-result.pcert0
-centaur/vl/loader/parse-statements-result.cert : | centaur/vl/loader/parse-statements-result.pcert1
-
-centaur/vl/loader/parse-statements-tokenlist.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-statements-tokenlist.pcert0 : acl2x = 0
-centaur/vl/loader/parse-statements-tokenlist.pcert0 : \
- centaur/vl/loader/parse-statements-def.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-statements-tokenlist.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-statements-tokenlist.pcert1 : acl2x = 0
-centaur/vl/loader/parse-statements-tokenlist.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-statements-tokenlist.pcert1 : centaur/vl/loader/parse-statements-tokenlist.pcert0
-centaur/vl/loader/parse-statements-tokenlist.cert : | centaur/vl/loader/parse-statements-tokenlist.pcert1
-
-centaur/vl/loader/parse-statements-warninglist.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-statements-warninglist.pcert0 : acl2x = 0
-centaur/vl/loader/parse-statements-warninglist.pcert0 : \
- centaur/vl/loader/parse-statements-def.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-statements-warninglist.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-statements-warninglist.pcert1 : acl2x = 0
-centaur/vl/loader/parse-statements-warninglist.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-statements-warninglist.pcert1 : centaur/vl/loader/parse-statements-warninglist.pcert0
-centaur/vl/loader/parse-statements-warninglist.cert : | centaur/vl/loader/parse-statements-warninglist.pcert1
-
-centaur/vl/loader/parse-statements.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-statements.pcert0 : acl2x = 0
-centaur/vl/loader/parse-statements.pcert0 : \
- centaur/vl/loader/parse-statements-def.pcert0 \
- centaur/vl/loader/parse-statements-error.pcert0 \
- centaur/vl/loader/parse-statements-progress.pcert0 \
- centaur/vl/loader/parse-statements-tokenlist.pcert0 \
- centaur/vl/loader/parse-statements-warninglist.pcert0 \
- centaur/vl/loader/parse-statements-result.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-statements.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-statements.pcert1 : acl2x = 0
-centaur/vl/loader/parse-statements.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-statements.pcert1 : centaur/vl/loader/parse-statements.pcert0
-centaur/vl/loader/parse-statements.cert : | centaur/vl/loader/parse-statements.pcert1
-
-centaur/vl/loader/parse-strengths.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-strengths.pcert0 : acl2x = 0
-centaur/vl/loader/parse-strengths.pcert0 : \
- centaur/vl/loader/parse-utils.pcert0 \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-strengths.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-strengths.pcert1 : acl2x = 0
-centaur/vl/loader/parse-strengths.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-strengths.pcert1 : centaur/vl/loader/parse-strengths.pcert0
-centaur/vl/loader/parse-strengths.cert : | centaur/vl/loader/parse-strengths.pcert1
-
-centaur/vl/loader/parse-utils.pcert0 : no_pcert = 0
-centaur/vl/loader/parse-utils.pcert0 : acl2x = 0
-centaur/vl/loader/parse-utils.pcert0 : \
- centaur/vl/loader/lexer-tokens.pcert0 \
- misc/seqw.pcert0 \
- misc/untranslate-patterns.pcert0 \
- tools/flag.pcert0 \
- centaur/vl/util/warnings.pcert0 \
- tools/rulesets.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parse-utils.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parse-utils.pcert1 : acl2x = 0
-centaur/vl/loader/parse-utils.pcert1 : no_pcert = 0
-centaur/vl/loader/parse-utils.pcert1 : centaur/vl/loader/parse-utils.pcert0
-centaur/vl/loader/parse-utils.cert : | centaur/vl/loader/parse-utils.pcert1
-
-centaur/vl/loader/parser.pcert0 : no_pcert = 0
-centaur/vl/loader/parser.pcert0 : acl2x = 0
-centaur/vl/loader/parser.pcert0 : \
- centaur/vl/loader/parse-modules.pcert0 \
- centaur/vl/loader/parse-error.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/parser.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/parser.pcert1 : acl2x = 0
-centaur/vl/loader/parser.pcert1 : no_pcert = 0
-centaur/vl/loader/parser.pcert1 : centaur/vl/loader/parser.pcert0
-centaur/vl/loader/parser.cert : | centaur/vl/loader/parser.pcert1
-
-centaur/vl/loader/preprocessor-tests.pcert0 : no_pcert = 0
-centaur/vl/loader/preprocessor-tests.pcert0 : acl2x = 0
-centaur/vl/loader/preprocessor-tests.pcert0 : \
- centaur/vl/loader/preprocessor.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/preprocessor-tests.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/preprocessor-tests.pcert1 : acl2x = 0
-centaur/vl/loader/preprocessor-tests.pcert1 : no_pcert = 0
-centaur/vl/loader/preprocessor-tests.pcert1 : centaur/vl/loader/preprocessor-tests.pcert0
-centaur/vl/loader/preprocessor-tests.cert : | centaur/vl/loader/preprocessor-tests.pcert1
-
-centaur/vl/loader/preprocessor.pcert0 : no_pcert = 0
-centaur/vl/loader/preprocessor.pcert0 : acl2x = 0
-centaur/vl/loader/preprocessor.pcert0 : \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/loader/read-file.pcert0 \
- centaur/vl/loader/find-file.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/loader/defines.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/preprocessor.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/preprocessor.pcert1 : acl2x = 0
-centaur/vl/loader/preprocessor.pcert1 : no_pcert = 0
-centaur/vl/loader/preprocessor.pcert1 : centaur/vl/loader/preprocessor.pcert0
-centaur/vl/loader/preprocessor.cert : | centaur/vl/loader/preprocessor.pcert1
-
-centaur/vl/loader/read-file.pcert0 : no_pcert = 0
-centaur/vl/loader/read-file.pcert0 : acl2x = 0
-centaur/vl/loader/read-file.pcert0 : \
- centaur/vl/util/echars.pcert0 \
- std/io/file-measure.pcert0 \
- std/io/open-input-channel.pcert0 \
- std/io/read-byte.pcert0 \
- std/io/close-input-channel.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/loader/read-file.lisp \
- centaur/vl/loader/cert.acl2
-centaur/vl/loader/read-file.pcert1 : acl2x = 0
-centaur/vl/loader/read-file.pcert1 : no_pcert = 0
-centaur/vl/loader/read-file.pcert1 : centaur/vl/loader/read-file.pcert0
-centaur/vl/loader/read-file.cert : | centaur/vl/loader/read-file.pcert1
-
-centaur/vl/mlib/allexprs.pcert0 : no_pcert = 0
-centaur/vl/mlib/allexprs.pcert0 : acl2x = 0
-centaur/vl/mlib/allexprs.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/allexprs.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/allexprs.pcert1 : acl2x = 0
-centaur/vl/mlib/allexprs.pcert1 : no_pcert = 0
-centaur/vl/mlib/allexprs.pcert1 : centaur/vl/mlib/allexprs.pcert0
-centaur/vl/mlib/allexprs.cert : | centaur/vl/mlib/allexprs.pcert1
-
-centaur/vl/mlib/atts.pcert0 : no_pcert = 0
-centaur/vl/mlib/atts.pcert0 : acl2x = 0
-centaur/vl/mlib/atts.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/atts.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/atts.pcert1 : acl2x = 0
-centaur/vl/mlib/atts.pcert1 : no_pcert = 0
-centaur/vl/mlib/atts.pcert1 : centaur/vl/mlib/atts.pcert0
-centaur/vl/mlib/atts.cert : | centaur/vl/mlib/atts.pcert1
-
-centaur/vl/mlib/clean-concats.pcert0 : no_pcert = 0
-centaur/vl/mlib/clean-concats.pcert0 : acl2x = 0
-centaur/vl/mlib/clean-concats.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/clean-concats.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/clean-concats.pcert1 : acl2x = 0
-centaur/vl/mlib/clean-concats.pcert1 : no_pcert = 0
-centaur/vl/mlib/clean-concats.pcert1 : centaur/vl/mlib/clean-concats.pcert0
-centaur/vl/mlib/clean-concats.cert : | centaur/vl/mlib/clean-concats.pcert1
-
-centaur/vl/mlib/comment-writer.pcert0 : no_pcert = 0
-centaur/vl/mlib/comment-writer.pcert0 : acl2x = 0
-centaur/vl/mlib/comment-writer.pcert0 : \
- centaur/vl/mlib/writer.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/loader/inject-comments.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/comment-writer.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/comment-writer.pcert1 : acl2x = 0
-centaur/vl/mlib/comment-writer.pcert1 : no_pcert = 0
-centaur/vl/mlib/comment-writer.pcert1 : centaur/vl/mlib/comment-writer.pcert0
-centaur/vl/mlib/comment-writer.cert : | centaur/vl/mlib/comment-writer.pcert1
-
-centaur/vl/mlib/context.pcert0 : no_pcert = 0
-centaur/vl/mlib/context.pcert0 : acl2x = 0
-centaur/vl/mlib/context.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/context.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/context.pcert1 : acl2x = 0
-centaur/vl/mlib/context.pcert1 : no_pcert = 0
-centaur/vl/mlib/context.pcert1 : centaur/vl/mlib/context.pcert0
-centaur/vl/mlib/context.cert : | centaur/vl/mlib/context.pcert1
-
-centaur/vl/mlib/ctxexprs.pcert0 : no_pcert = 0
-centaur/vl/mlib/ctxexprs.pcert0 : acl2x = 0
-centaur/vl/mlib/ctxexprs.pcert0 : \
- centaur/vl/mlib/allexprs.pcert0 \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/ctxexprs.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/ctxexprs.pcert1 : acl2x = 0
-centaur/vl/mlib/ctxexprs.pcert1 : no_pcert = 0
-centaur/vl/mlib/ctxexprs.pcert1 : centaur/vl/mlib/ctxexprs.pcert0
-centaur/vl/mlib/ctxexprs.cert : | centaur/vl/mlib/ctxexprs.pcert1
-
-centaur/vl/mlib/delta.pcert0 : no_pcert = 0
-centaur/vl/mlib/delta.pcert0 : acl2x = 0
-centaur/vl/mlib/delta.pcert0 : \
- centaur/vl/mlib/namefactory.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/delta.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/delta.pcert1 : acl2x = 0
-centaur/vl/mlib/delta.pcert1 : no_pcert = 0
-centaur/vl/mlib/delta.pcert1 : centaur/vl/mlib/delta.pcert0
-centaur/vl/mlib/delta.cert : | centaur/vl/mlib/delta.pcert1
-
-centaur/vl/mlib/expr-building.pcert0 : no_pcert = 0
-centaur/vl/mlib/expr-building.pcert0 : acl2x = 0
-centaur/vl/mlib/expr-building.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/expr-building.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/expr-building.pcert1 : acl2x = 0
-centaur/vl/mlib/expr-building.pcert1 : no_pcert = 0
-centaur/vl/mlib/expr-building.pcert1 : centaur/vl/mlib/expr-building.pcert0
-centaur/vl/mlib/expr-building.cert : | centaur/vl/mlib/expr-building.pcert1
-
-centaur/vl/mlib/expr-parse.pcert0 : no_pcert = 0
-centaur/vl/mlib/expr-parse.pcert0 : acl2x = 0
-centaur/vl/mlib/expr-parse.pcert0 : \
- centaur/vl/mlib/print-warnings.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/loader/parse-expressions.pcert0 \
- centaur/vl/loader/parse-error.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/expr-parse.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/expr-parse.pcert1 : acl2x = 0
-centaur/vl/mlib/expr-parse.pcert1 : no_pcert = 0
-centaur/vl/mlib/expr-parse.pcert1 : centaur/vl/mlib/expr-parse.pcert0
-centaur/vl/mlib/expr-parse.cert : | centaur/vl/mlib/expr-parse.pcert1
-
-centaur/vl/mlib/expr-slice.pcert0 : no_pcert = 0
-centaur/vl/mlib/expr-slice.pcert0 : acl2x = 0
-centaur/vl/mlib/expr-slice.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/mlib/find-item.pcert0 \
- centaur/vl/mlib/welltyped.pcert0 \
- centaur/vl/mlib/expr-building.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/expr-slice.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/expr-slice.pcert1 : acl2x = 0
-centaur/vl/mlib/expr-slice.pcert1 : no_pcert = 0
-centaur/vl/mlib/expr-slice.pcert1 : centaur/vl/mlib/expr-slice.pcert0
-centaur/vl/mlib/expr-slice.cert : | centaur/vl/mlib/expr-slice.pcert1
-
-centaur/vl/mlib/expr-tools.pcert0 : no_pcert = 0
-centaur/vl/mlib/expr-tools.pcert0 : acl2x = 0
-centaur/vl/mlib/expr-tools.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/expr-tools.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/expr-tools.pcert1 : acl2x = 0
-centaur/vl/mlib/expr-tools.pcert1 : no_pcert = 0
-centaur/vl/mlib/expr-tools.pcert1 : centaur/vl/mlib/expr-tools.pcert0
-centaur/vl/mlib/expr-tools.cert : | centaur/vl/mlib/expr-tools.pcert1
-
-centaur/vl/mlib/filter.pcert0 : no_pcert = 0
-centaur/vl/mlib/filter.pcert0 : acl2x = 0
-centaur/vl/mlib/filter.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/filter.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/filter.pcert1 : acl2x = 0
-centaur/vl/mlib/filter.pcert1 : no_pcert = 0
-centaur/vl/mlib/filter.pcert1 : centaur/vl/mlib/filter.pcert0
-centaur/vl/mlib/filter.cert : | centaur/vl/mlib/filter.pcert1
-
-centaur/vl/mlib/find-item.pcert0 : no_pcert = 0
-centaur/vl/mlib/find-item.pcert0 : acl2x = 0
-centaur/vl/mlib/find-item.pcert0 : \
- centaur/vl/mlib/modnamespace.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/find-item.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/find-item.pcert1 : acl2x = 0
-centaur/vl/mlib/find-item.pcert1 : no_pcert = 0
-centaur/vl/mlib/find-item.pcert1 : centaur/vl/mlib/find-item.pcert0
-centaur/vl/mlib/find-item.cert : | centaur/vl/mlib/find-item.pcert1
-
-centaur/vl/mlib/find-module.pcert0 : no_pcert = 0
-centaur/vl/mlib/find-module.pcert0 : acl2x = 0
-centaur/vl/mlib/find-module.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/find-module.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/find-module.pcert1 : acl2x = 0
-centaur/vl/mlib/find-module.pcert1 : no_pcert = 0
-centaur/vl/mlib/find-module.pcert1 : centaur/vl/mlib/find-module.pcert0
-centaur/vl/mlib/find-module.cert : | centaur/vl/mlib/find-module.pcert1
-
-centaur/vl/mlib/fmt.pcert0 : no_pcert = 0
-centaur/vl/mlib/fmt.pcert0 : acl2x = 0
-centaur/vl/mlib/fmt.pcert0 : \
- centaur/vl/mlib/writer.pcert0 \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/mlib/print-context.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/fmt.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/fmt.pcert1 : acl2x = 0
-centaur/vl/mlib/fmt.pcert1 : no_pcert = 0
-centaur/vl/mlib/fmt.pcert1 : centaur/vl/mlib/fmt.pcert0
-centaur/vl/mlib/fmt.cert : | centaur/vl/mlib/fmt.pcert1
-
-centaur/vl/mlib/hid-tools.pcert0 : no_pcert = 0
-centaur/vl/mlib/hid-tools.pcert0 : acl2x = 0
-centaur/vl/mlib/hid-tools.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/hid-tools.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/hid-tools.pcert1 : acl2x = 0
-centaur/vl/mlib/hid-tools.pcert1 : no_pcert = 0
-centaur/vl/mlib/hid-tools.pcert1 : centaur/vl/mlib/hid-tools.pcert0
-centaur/vl/mlib/hid-tools.cert : | centaur/vl/mlib/hid-tools.pcert1
-
-centaur/vl/mlib/hierarchy.pcert0 : no_pcert = 0
-centaur/vl/mlib/hierarchy.pcert0 : acl2x = 0
-centaur/vl/mlib/hierarchy.pcert0 : \
- centaur/vl/mlib/find-module.pcert0 \
- centaur/vl/mlib/modnamespace.pcert0 \
- centaur/vl/mlib/filter.pcert0 \
- centaur/vl/util/string-alists.pcert0 \
- centaur/vl/util/defwellformed.pcert0 \
- centaur/vl/mlib/modname-sets.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/misc/osets-witnessing.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/hierarchy.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/hierarchy.pcert1 : acl2x = 0
-centaur/vl/mlib/hierarchy.pcert1 : no_pcert = 0
-centaur/vl/mlib/hierarchy.pcert1 : centaur/vl/mlib/hierarchy.pcert0
-centaur/vl/mlib/hierarchy.cert : | centaur/vl/mlib/hierarchy.pcert1
-
-centaur/vl/mlib/lvalues-mentioning.pcert0 : no_pcert = 0
-centaur/vl/mlib/lvalues-mentioning.pcert0 : acl2x = 0
-centaur/vl/mlib/lvalues-mentioning.pcert0 : \
- centaur/vl/mlib/lvalues.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/lvalues-mentioning.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/lvalues-mentioning.pcert1 : acl2x = 0
-centaur/vl/mlib/lvalues-mentioning.pcert1 : no_pcert = 0
-centaur/vl/mlib/lvalues-mentioning.pcert1 : centaur/vl/mlib/lvalues-mentioning.pcert0
-centaur/vl/mlib/lvalues-mentioning.cert : | centaur/vl/mlib/lvalues-mentioning.pcert1
-
-centaur/vl/mlib/lvalues.pcert0 : no_pcert = 0
-centaur/vl/mlib/lvalues.pcert0 : acl2x = 0
-centaur/vl/mlib/lvalues.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/hid-tools.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/lvalues.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/lvalues.pcert1 : acl2x = 0
-centaur/vl/mlib/lvalues.pcert1 : no_pcert = 0
-centaur/vl/mlib/lvalues.pcert1 : centaur/vl/mlib/lvalues.pcert0
-centaur/vl/mlib/lvalues.cert : | centaur/vl/mlib/lvalues.pcert1
-
-centaur/vl/mlib/modname-sets.pcert0 : no_pcert = 0
-centaur/vl/mlib/modname-sets.pcert0 : acl2x = 0
-centaur/vl/mlib/modname-sets.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/modname-sets.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/modname-sets.pcert1 : acl2x = 0
-centaur/vl/mlib/modname-sets.pcert1 : no_pcert = 0
-centaur/vl/mlib/modname-sets.pcert1 : centaur/vl/mlib/modname-sets.pcert0
-centaur/vl/mlib/modname-sets.cert : | centaur/vl/mlib/modname-sets.pcert1
-
-centaur/vl/mlib/modnamespace.pcert0 : no_pcert = 0
-centaur/vl/mlib/modnamespace.pcert0 : acl2x = 0
-centaur/vl/mlib/modnamespace.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/modnamespace.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/modnamespace.pcert1 : acl2x = 0
-centaur/vl/mlib/modnamespace.pcert1 : no_pcert = 0
-centaur/vl/mlib/modnamespace.pcert1 : centaur/vl/mlib/modnamespace.pcert0
-centaur/vl/mlib/modnamespace.cert : | centaur/vl/mlib/modnamespace.pcert1
-
-centaur/vl/mlib/namefactory.pcert0 : no_pcert = 0
-centaur/vl/mlib/namefactory.pcert0 : acl2x = 0
-centaur/vl/mlib/namefactory.pcert0 : \
- centaur/vl/util/namedb.pcert0 \
- centaur/vl/mlib/modnamespace.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/namefactory.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/namefactory.pcert1 : acl2x = 0
-centaur/vl/mlib/namefactory.pcert1 : no_pcert = 0
-centaur/vl/mlib/namefactory.pcert1 : centaur/vl/mlib/namefactory.pcert0
-centaur/vl/mlib/namefactory.cert : | centaur/vl/mlib/namefactory.pcert1
-
-centaur/vl/mlib/namemangle.pcert0 : no_pcert = 0
-centaur/vl/mlib/namemangle.pcert0 : acl2x = 0
-centaur/vl/mlib/namemangle.pcert0 : \
- centaur/vl/mlib/namefactory.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/namemangle.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/namemangle.pcert1 : acl2x = 0
-centaur/vl/mlib/namemangle.pcert1 : no_pcert = 0
-centaur/vl/mlib/namemangle.pcert1 : centaur/vl/mlib/namemangle.pcert0
-centaur/vl/mlib/namemangle.cert : | centaur/vl/mlib/namemangle.pcert1
-
-centaur/vl/mlib/port-tools.pcert0 : no_pcert = 0
-centaur/vl/mlib/port-tools.pcert0 : acl2x = 0
-centaur/vl/mlib/port-tools.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/mlib/find-item.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/port-tools.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/port-tools.pcert1 : acl2x = 0
-centaur/vl/mlib/port-tools.pcert1 : no_pcert = 0
-centaur/vl/mlib/port-tools.pcert1 : centaur/vl/mlib/port-tools.pcert0
-centaur/vl/mlib/port-tools.cert : | centaur/vl/mlib/port-tools.pcert1
-
-centaur/vl/mlib/print-context.pcert0 : no_pcert = 0
-centaur/vl/mlib/print-context.pcert0 : acl2x = 0
-centaur/vl/mlib/print-context.pcert0 : \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/mlib/writer.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/print-context.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/print-context.pcert1 : acl2x = 0
-centaur/vl/mlib/print-context.pcert1 : no_pcert = 0
-centaur/vl/mlib/print-context.pcert1 : centaur/vl/mlib/print-context.pcert0
-centaur/vl/mlib/print-context.cert : | centaur/vl/mlib/print-context.pcert1
-
-centaur/vl/mlib/print-warnings.pcert0 : no_pcert = 0
-centaur/vl/mlib/print-warnings.pcert0 : acl2x = 0
-centaur/vl/mlib/print-warnings.pcert0 : \
- centaur/vl/mlib/warnings.pcert0 \
- centaur/vl/mlib/fmt.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/print-warnings.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/print-warnings.pcert1 : acl2x = 0
-centaur/vl/mlib/print-warnings.pcert1 : no_pcert = 0
-centaur/vl/mlib/print-warnings.pcert1 : centaur/vl/mlib/print-warnings.pcert0
-centaur/vl/mlib/print-warnings.cert : | centaur/vl/mlib/print-warnings.pcert1
-
-centaur/vl/mlib/range-tools.pcert0 : no_pcert = 0
-centaur/vl/mlib/range-tools.pcert0 : acl2x = 0
-centaur/vl/mlib/range-tools.pcert0 : \
- centaur/vl/mlib/find-item.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/range-tools.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/range-tools.pcert1 : acl2x = 0
-centaur/vl/mlib/range-tools.pcert1 : no_pcert = 0
-centaur/vl/mlib/range-tools.pcert1 : centaur/vl/mlib/range-tools.pcert0
-centaur/vl/mlib/range-tools.cert : | centaur/vl/mlib/range-tools.pcert1
-
-centaur/vl/mlib/relocate.pcert0 : no_pcert = 0
-centaur/vl/mlib/relocate.pcert0 : acl2x = 0
-centaur/vl/mlib/relocate.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/relocate.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/relocate.pcert1 : acl2x = 0
-centaur/vl/mlib/relocate.pcert1 : no_pcert = 0
-centaur/vl/mlib/relocate.pcert1 : centaur/vl/mlib/relocate.pcert0
-centaur/vl/mlib/relocate.cert : | centaur/vl/mlib/relocate.pcert1
-
-centaur/vl/mlib/remove-bad.pcert0 : no_pcert = 0
-centaur/vl/mlib/remove-bad.pcert0 : acl2x = 0
-centaur/vl/mlib/remove-bad.pcert0 : \
- centaur/vl/mlib/hierarchy.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/mlib/modname-sets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/remove-bad.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/remove-bad.pcert1 : acl2x = 0
-centaur/vl/mlib/remove-bad.pcert1 : no_pcert = 0
-centaur/vl/mlib/remove-bad.pcert1 : centaur/vl/mlib/remove-bad.pcert0
-centaur/vl/mlib/remove-bad.cert : | centaur/vl/mlib/remove-bad.pcert1
-
-centaur/vl/mlib/rvalues.pcert0 : no_pcert = 0
-centaur/vl/mlib/rvalues.pcert0 : acl2x = 0
-centaur/vl/mlib/rvalues.pcert0 : \
- centaur/vl/mlib/hid-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/rvalues.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/rvalues.pcert1 : acl2x = 0
-centaur/vl/mlib/rvalues.pcert1 : no_pcert = 0
-centaur/vl/mlib/rvalues.pcert1 : centaur/vl/mlib/rvalues.pcert0
-centaur/vl/mlib/rvalues.cert : | centaur/vl/mlib/rvalues.pcert1
-
-centaur/vl/mlib/stmt-tools.pcert0 : no_pcert = 0
-centaur/vl/mlib/stmt-tools.pcert0 : acl2x = 0
-centaur/vl/mlib/stmt-tools.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/stmt-tools.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/stmt-tools.pcert1 : acl2x = 0
-centaur/vl/mlib/stmt-tools.pcert1 : no_pcert = 0
-centaur/vl/mlib/stmt-tools.pcert1 : centaur/vl/mlib/stmt-tools.pcert0
-centaur/vl/mlib/stmt-tools.cert : | centaur/vl/mlib/stmt-tools.pcert1
-
-centaur/vl/mlib/sub-counts.pcert0 : no_pcert = 0
-centaur/vl/mlib/sub-counts.pcert0 : acl2x = 0
-centaur/vl/mlib/sub-counts.pcert0 : \
- centaur/vl/mlib/find-module.pcert0 \
- centaur/vl/transforms/xf-resolve-ranges.pcert0 \
- centaur/vl/transforms/xf-subst.pcert0 \
- centaur/vl/transforms/xf-unparameterize.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/sub-counts.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/sub-counts.pcert1 : acl2x = 0
-centaur/vl/mlib/sub-counts.pcert1 : no_pcert = 0
-centaur/vl/mlib/sub-counts.pcert1 : centaur/vl/mlib/sub-counts.pcert0
-centaur/vl/mlib/sub-counts.cert : | centaur/vl/mlib/sub-counts.pcert1
-
-centaur/vl/mlib/warnings.pcert0 : no_pcert = 0
-centaur/vl/mlib/warnings.pcert0 : acl2x = 0
-centaur/vl/mlib/warnings.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/warnings.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/warnings.pcert1 : acl2x = 0
-centaur/vl/mlib/warnings.pcert1 : no_pcert = 0
-centaur/vl/mlib/warnings.pcert1 : centaur/vl/mlib/warnings.pcert0
-centaur/vl/mlib/warnings.cert : | centaur/vl/mlib/warnings.pcert1
-
-centaur/vl/mlib/welltyped.pcert0 : no_pcert = 0
-centaur/vl/mlib/welltyped.pcert0 : acl2x = 0
-centaur/vl/mlib/welltyped.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/util/sum-nats.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/welltyped.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/welltyped.pcert1 : acl2x = 0
-centaur/vl/mlib/welltyped.pcert1 : no_pcert = 0
-centaur/vl/mlib/welltyped.pcert1 : centaur/vl/mlib/welltyped.pcert0
-centaur/vl/mlib/welltyped.cert : | centaur/vl/mlib/welltyped.pcert1
-
-centaur/vl/mlib/writer.pcert0 : no_pcert = 0
-centaur/vl/mlib/writer.pcert0 : acl2x = 0
-centaur/vl/mlib/writer.pcert0 : \
- centaur/vl/mlib/find-module.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/mlib/modnamespace.pcert0 \
- centaur/vl/loader/lexer.pcert0 \
- centaur/vl/util/print.pcert0 \
- str/strrpos.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/mlib/writer.lisp \
- centaur/vl/mlib/cert.acl2
-centaur/vl/mlib/writer.pcert1 : acl2x = 0
-centaur/vl/mlib/writer.pcert1 : no_pcert = 0
-centaur/vl/mlib/writer.pcert1 : centaur/vl/mlib/writer.pcert0
-centaur/vl/mlib/writer.cert : | centaur/vl/mlib/writer.pcert1
-
-centaur/vl/onehot.pcert0 : no_pcert = 0
-centaur/vl/onehot.pcert0 : acl2x = 0
-centaur/vl/onehot.pcert0 : \
- centaur/vl/transforms/occform/simple.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- arithmetic-5/top.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/onehot.lisp \
- centaur/vl/cert.acl2
-centaur/vl/onehot.pcert1 : acl2x = 0
-centaur/vl/onehot.pcert1 : no_pcert = 0
-centaur/vl/onehot.pcert1 : centaur/vl/onehot.pcert0
-centaur/vl/onehot.cert : | centaur/vl/onehot.pcert1
-
-centaur/vl/parsetree.pcert0 : no_pcert = 0
-centaur/vl/parsetree.pcert0 : acl2x = 0
-centaur/vl/parsetree.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/bits.pcert0 \
- centaur/vl/util/commentmap.pcert0 \
- centaur/vl/util/warnings.pcert0 \
- centaur/vl/util/echars.pcert0 \
- tools/flag.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/parsetree.lisp \
- centaur/vl/cert.acl2
-centaur/vl/parsetree.pcert1 : acl2x = 0
-centaur/vl/parsetree.pcert1 : no_pcert = 0
-centaur/vl/parsetree.pcert1 : centaur/vl/parsetree.pcert0
-centaur/vl/parsetree.cert : | centaur/vl/parsetree.pcert1
-
-centaur/vl/portcullis.pcert0 : no_pcert = 0
-centaur/vl/portcullis.pcert0 : acl2x = 0
-centaur/vl/portcullis.pcert0 : \
- tools/safe-case.pcert0 \
- xdoc/top.pcert0 \
- clause-processors/autohide.pcert0 \
- tools/rulesets.pcert0 \
- centaur/vl/portcullis.lisp \
- centaur/vl/portcullis.acl2 \
- centaur/vl/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- centaur/vl/other-packages.lsp \
- data-structures/define-u-package.lsp \
- tools/flag-package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- cowles/packages.lsp
-centaur/vl/portcullis.pcert1 : acl2x = 0
-centaur/vl/portcullis.pcert1 : no_pcert = 0
-centaur/vl/portcullis.pcert1 : centaur/vl/portcullis.pcert0
-centaur/vl/portcullis.cert : | centaur/vl/portcullis.pcert1
-
-centaur/vl/primitives.pcert0 : no_pcert = 0
-centaur/vl/primitives.pcert0 : acl2x = 0
-centaur/vl/primitives.pcert0 : \
- centaur/vl/mlib/expr-building.pcert0 \
- centaur/esim/esim-primitives.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/primitives.lisp \
- centaur/vl/cert.acl2
-centaur/vl/primitives.pcert1 : acl2x = 0
-centaur/vl/primitives.pcert1 : no_pcert = 0
-centaur/vl/primitives.pcert1 : centaur/vl/primitives.pcert0
-centaur/vl/primitives.cert : | centaur/vl/primitives.pcert1
-
-centaur/vl/toe/toe-add-res-modules.pcert0 : no_pcert = 0
-centaur/vl/toe/toe-add-res-modules.pcert0 : acl2x = 0
-centaur/vl/toe/toe-add-res-modules.pcert0 : \
- centaur/vl/toe/toe-wirealist.pcert0 \
- centaur/esim/esim-sexpr-support.pcert0 \
- centaur/esim/esim-primitives.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/esim-lemmas.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/toe/toe-add-res-modules.lisp \
- centaur/vl/toe/cert.acl2
-centaur/vl/toe/toe-add-res-modules.pcert1 : acl2x = 0
-centaur/vl/toe/toe-add-res-modules.pcert1 : no_pcert = 0
-centaur/vl/toe/toe-add-res-modules.pcert1 : centaur/vl/toe/toe-add-res-modules.pcert0
-centaur/vl/toe/toe-add-res-modules.cert : | centaur/vl/toe/toe-add-res-modules.pcert1
-
-centaur/vl/toe/toe-add-zdrivers.pcert0 : no_pcert = 0
-centaur/vl/toe/toe-add-zdrivers.pcert0 : acl2x = 0
-centaur/vl/toe/toe-add-zdrivers.pcert0 : \
- centaur/vl/toe/toe-wirealist.pcert0 \
- centaur/esim/esim-sexpr-support.pcert0 \
- centaur/esim/esim-primitives.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/esim-lemmas.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/toe/toe-add-zdrivers.lisp \
- centaur/vl/toe/cert.acl2
-centaur/vl/toe/toe-add-zdrivers.pcert1 : acl2x = 0
-centaur/vl/toe/toe-add-zdrivers.pcert1 : no_pcert = 0
-centaur/vl/toe/toe-add-zdrivers.pcert1 : centaur/vl/toe/toe-add-zdrivers.pcert0
-centaur/vl/toe/toe-add-zdrivers.cert : | centaur/vl/toe/toe-add-zdrivers.pcert1
-
-centaur/vl/toe/toe-emodwire.pcert0 : no_pcert = 0
-centaur/vl/toe/toe-emodwire.pcert0 : acl2x = 0
-centaur/vl/toe/toe-emodwire.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- misc/assert.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/position.pcert0 \
- std/ks/intern-in-package-of-symbol.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/toe/toe-emodwire.lisp \
- centaur/vl/toe/cert.acl2
-centaur/vl/toe/toe-emodwire.pcert1 : acl2x = 0
-centaur/vl/toe/toe-emodwire.pcert1 : no_pcert = 0
-centaur/vl/toe/toe-emodwire.pcert1 : centaur/vl/toe/toe-emodwire.pcert0
-centaur/vl/toe/toe-emodwire.cert : | centaur/vl/toe/toe-emodwire.pcert1
-
-centaur/vl/toe/toe-eocc-allnames.pcert0 : no_pcert = 0
-centaur/vl/toe/toe-eocc-allnames.pcert0 : acl2x = 0
-centaur/vl/toe/toe-eocc-allnames.pcert0 : \
- centaur/esim/esim-sexpr-support.pcert0 \
- centaur/vl/toe/toe-emodwire.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/esim-lemmas.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/toe/toe-eocc-allnames.lisp \
- centaur/vl/toe/cert.acl2
-centaur/vl/toe/toe-eocc-allnames.pcert1 : acl2x = 0
-centaur/vl/toe/toe-eocc-allnames.pcert1 : no_pcert = 0
-centaur/vl/toe/toe-eocc-allnames.pcert1 : centaur/vl/toe/toe-eocc-allnames.pcert0
-centaur/vl/toe/toe-eocc-allnames.cert : | centaur/vl/toe/toe-eocc-allnames.pcert1
-
-centaur/vl/toe/toe-preliminary.pcert0 : no_pcert = 0
-centaur/vl/toe/toe-preliminary.pcert0 : acl2x = 0
-centaur/vl/toe/toe-preliminary.pcert0 : \
- centaur/vl/toe/toe-wirealist.pcert0 \
- centaur/vl/toe/toe-verilogify.pcert0 \
- centaur/vl/mlib/find-module.pcert0 \
- centaur/esim/esim-sexpr-support.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/util/esim-lemmas.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/toe/toe-preliminary.lisp \
- centaur/vl/toe/cert.acl2
-centaur/vl/toe/toe-preliminary.pcert1 : acl2x = 0
-centaur/vl/toe/toe-preliminary.pcert1 : no_pcert = 0
-centaur/vl/toe/toe-preliminary.pcert1 : centaur/vl/toe/toe-preliminary.pcert0
-centaur/vl/toe/toe-preliminary.cert : | centaur/vl/toe/toe-preliminary.pcert1
-
-centaur/vl/toe/toe-top.pcert0 : no_pcert = 0
-centaur/vl/toe/toe-top.pcert0 : acl2x = 0
-centaur/vl/toe/toe-top.pcert0 : \
- centaur/vl/toe/toe-eocc-allnames.pcert0 \
- centaur/vl/toe/toe-preliminary.pcert0 \
- centaur/vl/toe/toe-add-res-modules.pcert0 \
- centaur/vl/toe/toe-add-zdrivers.pcert0 \
- centaur/vl/mlib/remove-bad.pcert0 \
- centaur/vl/mlib/atts.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/esim-lemmas.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/toe/toe-top.lisp \
- centaur/vl/toe/cert.acl2
-centaur/vl/toe/toe-top.pcert1 : acl2x = 0
-centaur/vl/toe/toe-top.pcert1 : no_pcert = 0
-centaur/vl/toe/toe-top.pcert1 : centaur/vl/toe/toe-top.pcert0
-centaur/vl/toe/toe-top.cert : | centaur/vl/toe/toe-top.pcert1
-
-centaur/vl/toe/toe-verilogify.pcert0 : no_pcert = 0
-centaur/vl/toe/toe-verilogify.pcert0 : acl2x = 0
-centaur/vl/toe/toe-verilogify.pcert0 : \
- centaur/vl/toe/toe-emodwire.pcert0 \
- misc/assert.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/toe/toe-verilogify.lisp \
- centaur/vl/toe/cert.acl2
-centaur/vl/toe/toe-verilogify.pcert1 : acl2x = 0
-centaur/vl/toe/toe-verilogify.pcert1 : no_pcert = 0
-centaur/vl/toe/toe-verilogify.pcert1 : centaur/vl/toe/toe-verilogify.pcert0
-centaur/vl/toe/toe-verilogify.cert : | centaur/vl/toe/toe-verilogify.pcert1
-
-centaur/vl/toe/toe-wirealist.pcert0 : no_pcert = 0
-centaur/vl/toe/toe-wirealist.pcert0 : acl2x = 0
-centaur/vl/toe/toe-wirealist.pcert0 : \
- centaur/vl/toe/toe-emodwire.pcert0 \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/intersectp-equal.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/toe/toe-wirealist.lisp \
- centaur/vl/toe/cert.acl2
-centaur/vl/toe/toe-wirealist.pcert1 : acl2x = 0
-centaur/vl/toe/toe-wirealist.pcert1 : no_pcert = 0
-centaur/vl/toe/toe-wirealist.pcert1 : centaur/vl/toe/toe-wirealist.pcert0
-centaur/vl/toe/toe-wirealist.cert : | centaur/vl/toe/toe-wirealist.pcert1
-
-centaur/vl/top.pcert0 : no_pcert = 0
-centaur/vl/top.pcert0 : acl2x = 0
-centaur/vl/top.pcert0 : \
- centaur/vl/checkers/checkers.pcert0 \
- centaur/vl/checkers/duplicate-detect.pcert0 \
- centaur/vl/checkers/multidrive-detect.pcert0 \
- centaur/vl/checkers/portcheck.pcert0 \
- centaur/vl/checkers/use-set.pcert0 \
- centaur/vl/loader/loader.pcert0 \
- centaur/vl/mlib/comment-writer.pcert0 \
- centaur/vl/toe/toe-top.pcert0 \
- centaur/vl/transforms/cn-hooks.pcert0 \
- centaur/vl/transforms/always/top.pcert0 \
- centaur/vl/transforms/occform/top.pcert0 \
- centaur/vl/transforms/xf-addinstnames.pcert0 \
- centaur/vl/transforms/xf-argresolve.pcert0 \
- centaur/vl/transforms/xf-assign-trunc.pcert0 \
- centaur/vl/transforms/xf-blankargs.pcert0 \
- centaur/vl/transforms/xf-clean-params.pcert0 \
- centaur/vl/transforms/xf-designregs.pcert0 \
- centaur/vl/transforms/xf-designwires.pcert0 \
- centaur/vl/transforms/xf-delayredux.pcert0 \
- centaur/vl/transforms/xf-drop-blankports.pcert0 \
- centaur/vl/transforms/xf-elim-supply.pcert0 \
- centaur/vl/transforms/xf-expand-functions.pcert0 \
- centaur/vl/transforms/xf-expr-split.pcert0 \
- centaur/vl/transforms/xf-follow-hids.pcert0 \
- centaur/vl/transforms/xf-gateredux.pcert0 \
- centaur/vl/transforms/xf-gatesplit.pcert0 \
- centaur/vl/transforms/xf-gate-elim.pcert0 \
- centaur/vl/transforms/xf-hid-elim.pcert0 \
- centaur/vl/transforms/xf-oprewrite.pcert0 \
- centaur/vl/transforms/xf-optimize-rw.pcert0 \
- centaur/vl/transforms/xf-orig.pcert0 \
- centaur/vl/transforms/xf-portdecl-sign.pcert0 \
- centaur/vl/transforms/xf-replicate-insts.pcert0 \
- centaur/vl/transforms/xf-resolve-ranges.pcert0 \
- centaur/vl/transforms/xf-sizing.pcert0 \
- centaur/vl/transforms/xf-unparameterize.pcert0 \
- centaur/vl/transforms/xf-unused-reg.pcert0 \
- centaur/vl/transforms/xf-weirdint-elim.pcert0 \
- centaur/vl/transforms/xf-annotate-mods.pcert0 \
- centaur/vl/util/clean-alist.pcert0 \
- centaur/vl/translation.pcert0 \
- centaur/misc/sneaky-load.pcert0 \
- centaur/vl/mlib/modname-sets.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- system/f-put-global.pcert0 \
- centaur/vl/loader/lexer-tests.pcert0 \
- centaur/vl/loader/preprocessor-tests.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/top.lisp \
- centaur/vl/top.acl2
-centaur/vl/top.pcert1 : acl2x = 0
-centaur/vl/top.pcert1 : no_pcert = 0
-centaur/vl/top.pcert1 : centaur/vl/top.pcert0
-centaur/vl/top.cert : | centaur/vl/top.pcert1
-
-centaur/vl/transforms/always/conditions.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/conditions.pcert0 : acl2x = 0
-centaur/vl/transforms/always/conditions.pcert0 : \
- centaur/vl/mlib/welltyped.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/conditions.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/conditions.pcert1 : acl2x = 0
-centaur/vl/transforms/always/conditions.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/conditions.pcert1 : centaur/vl/transforms/always/conditions.pcert0
-centaur/vl/transforms/always/conditions.cert : | centaur/vl/transforms/always/conditions.pcert1
-
-centaur/vl/transforms/always/elimalways.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/elimalways.pcert0 : acl2x = 0
-centaur/vl/transforms/always/elimalways.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/elimalways.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/elimalways.pcert1 : acl2x = 0
-centaur/vl/transforms/always/elimalways.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/elimalways.pcert1 : centaur/vl/transforms/always/elimalways.pcert0
-centaur/vl/transforms/always/elimalways.cert : | centaur/vl/transforms/always/elimalways.pcert1
-
-centaur/vl/transforms/always/eliminitial.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/eliminitial.pcert0 : acl2x = 0
-centaur/vl/transforms/always/eliminitial.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/eliminitial.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/eliminitial.pcert1 : acl2x = 0
-centaur/vl/transforms/always/eliminitial.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/eliminitial.pcert1 : centaur/vl/transforms/always/eliminitial.pcert0
-centaur/vl/transforms/always/eliminitial.cert : | centaur/vl/transforms/always/eliminitial.pcert1
-
-centaur/vl/transforms/always/elimnegedge.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/elimnegedge.pcert0 : acl2x = 0
-centaur/vl/transforms/always/elimnegedge.pcert0 : \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/mlib/delta.pcert0 \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/transforms/occform/util.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/elimnegedge.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/elimnegedge.pcert1 : acl2x = 0
-centaur/vl/transforms/always/elimnegedge.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/elimnegedge.pcert1 : centaur/vl/transforms/always/elimnegedge.pcert0
-centaur/vl/transforms/always/elimnegedge.cert : | centaur/vl/transforms/always/elimnegedge.pcert1
-
-centaur/vl/transforms/always/flopcode-debug.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/flopcode-debug.pcert0 : acl2x = 0
-centaur/vl/transforms/always/flopcode-debug.pcert0 : \
- centaur/vl/transforms/always/flopcode-prog.pcert0 \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/flopcode-debug.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/flopcode-debug.pcert1 : acl2x = 0
-centaur/vl/transforms/always/flopcode-debug.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/flopcode-debug.pcert1 : centaur/vl/transforms/always/flopcode-debug.pcert0
-centaur/vl/transforms/always/flopcode-debug.cert : | centaur/vl/transforms/always/flopcode-debug.pcert1
-
-centaur/vl/transforms/always/flopcode-prog.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/flopcode-prog.pcert0 : acl2x = 0
-centaur/vl/transforms/always/flopcode-prog.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/welltyped.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/flopcode-prog.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/flopcode-prog.pcert1 : acl2x = 0
-centaur/vl/transforms/always/flopcode-prog.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/flopcode-prog.pcert1 : centaur/vl/transforms/always/flopcode-prog.pcert0
-centaur/vl/transforms/always/flopcode-prog.cert : | centaur/vl/transforms/always/flopcode-prog.pcert1
-
-centaur/vl/transforms/always/flopcode-synth.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/flopcode-synth.pcert0 : acl2x = 0
-centaur/vl/transforms/always/flopcode-synth.pcert0 : \
- centaur/vl/transforms/always/flopcode-prog.pcert0 \
- centaur/vl/transforms/always/flopcode-debug.pcert0 \
- centaur/vl/transforms/always/util.pcert0 \
- centaur/vl/transforms/always/make-flop.pcert0 \
- centaur/vl/mlib/delta.pcert0 \
- centaur/vl/mlib/filter.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/flopcode-synth.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/flopcode-synth.pcert1 : acl2x = 0
-centaur/vl/transforms/always/flopcode-synth.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/flopcode-synth.pcert1 : centaur/vl/transforms/always/flopcode-synth.pcert0
-centaur/vl/transforms/always/flopcode-synth.cert : | centaur/vl/transforms/always/flopcode-synth.pcert1
-
-centaur/vl/transforms/always/ifmerge.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/ifmerge.pcert0 : acl2x = 0
-centaur/vl/transforms/always/ifmerge.pcert0 : \
- centaur/vl/transforms/always/conditions.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/ifmerge.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/ifmerge.pcert1 : acl2x = 0
-centaur/vl/transforms/always/ifmerge.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/ifmerge.pcert1 : centaur/vl/transforms/always/ifmerge.pcert0
-centaur/vl/transforms/always/ifmerge.cert : | centaur/vl/transforms/always/ifmerge.pcert1
-
-centaur/vl/transforms/always/latchcode.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/latchcode.pcert0 : acl2x = 0
-centaur/vl/transforms/always/latchcode.pcert0 : \
- centaur/vl/transforms/always/util.pcert0 \
- centaur/vl/transforms/always/make-latch.pcert0 \
- centaur/vl/mlib/delta.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/latchcode.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/latchcode.pcert1 : acl2x = 0
-centaur/vl/transforms/always/latchcode.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/latchcode.pcert1 : centaur/vl/transforms/always/latchcode.pcert0
-centaur/vl/transforms/always/latchcode.cert : | centaur/vl/transforms/always/latchcode.pcert1
-
-centaur/vl/transforms/always/make-flop.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/make-flop.pcert0 : acl2x = 0
-centaur/vl/transforms/always/make-flop.pcert0 : \
- centaur/vl/primitives.pcert0 \
- centaur/vl/transforms/occform/util.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/make-flop.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/make-flop.pcert1 : acl2x = 0
-centaur/vl/transforms/always/make-flop.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/make-flop.pcert1 : centaur/vl/transforms/always/make-flop.pcert0
-centaur/vl/transforms/always/make-flop.cert : | centaur/vl/transforms/always/make-flop.pcert1
-
-centaur/vl/transforms/always/make-latch.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/make-latch.pcert0 : acl2x = 0
-centaur/vl/transforms/always/make-latch.pcert0 : \
- centaur/vl/primitives.pcert0 \
- centaur/vl/transforms/occform/util.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/make-latch.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/make-latch.pcert1 : acl2x = 0
-centaur/vl/transforms/always/make-latch.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/make-latch.pcert1 : centaur/vl/transforms/always/make-latch.pcert0
-centaur/vl/transforms/always/make-latch.cert : | centaur/vl/transforms/always/make-latch.pcert1
-
-centaur/vl/transforms/always/stmtrewrite.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/stmtrewrite.pcert0 : acl2x = 0
-centaur/vl/transforms/always/stmtrewrite.pcert0 : \
- centaur/vl/transforms/xf-resolve-ranges.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/stmtrewrite.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/stmtrewrite.pcert1 : acl2x = 0
-centaur/vl/transforms/always/stmtrewrite.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/stmtrewrite.pcert1 : centaur/vl/transforms/always/stmtrewrite.pcert0
-centaur/vl/transforms/always/stmtrewrite.cert : | centaur/vl/transforms/always/stmtrewrite.pcert1
-
-centaur/vl/transforms/always/stmttemps.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/stmttemps.pcert0 : acl2x = 0
-centaur/vl/transforms/always/stmttemps.pcert0 : \
- centaur/vl/transforms/always/util.pcert0 \
- centaur/vl/transforms/always/conditions.pcert0 \
- centaur/vl/transforms/occform/util.pcert0 \
- centaur/vl/mlib/expr-slice.pcert0 \
- centaur/vl/mlib/delta.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/stmttemps.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/stmttemps.pcert1 : acl2x = 0
-centaur/vl/transforms/always/stmttemps.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/stmttemps.pcert1 : centaur/vl/transforms/always/stmttemps.pcert0
-centaur/vl/transforms/always/stmttemps.cert : | centaur/vl/transforms/always/stmttemps.pcert1
-
-centaur/vl/transforms/always/synthalways.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/synthalways.pcert0 : acl2x = 0
-centaur/vl/transforms/always/synthalways.pcert0 : \
- centaur/vl/transforms/always/flopcode-synth.pcert0 \
- centaur/vl/transforms/always/latchcode.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/synthalways.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/synthalways.pcert1 : acl2x = 0
-centaur/vl/transforms/always/synthalways.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/synthalways.pcert1 : centaur/vl/transforms/always/synthalways.pcert0
-centaur/vl/transforms/always/synthalways.cert : | centaur/vl/transforms/always/synthalways.pcert1
-
-centaur/vl/transforms/always/top.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/top.pcert0 : acl2x = 0
-centaur/vl/transforms/always/top.pcert0 : \
- centaur/vl/transforms/always/elimalways.pcert0 \
- centaur/vl/transforms/always/eliminitial.pcert0 \
- centaur/vl/transforms/always/elimnegedge.pcert0 \
- centaur/vl/transforms/always/synthalways.pcert0 \
- centaur/vl/transforms/always/stmtrewrite.pcert0 \
- centaur/vl/transforms/always/stmttemps.pcert0 \
- centaur/vl/transforms/always/unelse.pcert0 \
- centaur/vl/transforms/always/ifmerge.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/top.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/top.pcert1 : acl2x = 0
-centaur/vl/transforms/always/top.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/top.pcert1 : centaur/vl/transforms/always/top.pcert0
-centaur/vl/transforms/always/top.cert : | centaur/vl/transforms/always/top.pcert1
-
-centaur/vl/transforms/always/unelse.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/unelse.pcert0 : acl2x = 0
-centaur/vl/transforms/always/unelse.pcert0 : \
- centaur/vl/transforms/always/conditions.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/unelse.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/unelse.pcert1 : acl2x = 0
-centaur/vl/transforms/always/unelse.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/unelse.pcert1 : centaur/vl/transforms/always/unelse.pcert0
-centaur/vl/transforms/always/unelse.cert : | centaur/vl/transforms/always/unelse.pcert1
-
-centaur/vl/transforms/always/util.pcert0 : no_pcert = 0
-centaur/vl/transforms/always/util.pcert0 : acl2x = 0
-centaur/vl/transforms/always/util.pcert0 : \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/mlib/lvalues.pcert0 \
- centaur/vl/mlib/find-item.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/always/util.lisp \
- centaur/vl/transforms/always/cert.acl2
-centaur/vl/transforms/always/util.pcert1 : acl2x = 0
-centaur/vl/transforms/always/util.pcert1 : no_pcert = 0
-centaur/vl/transforms/always/util.pcert1 : centaur/vl/transforms/always/util.pcert0
-centaur/vl/transforms/always/util.cert : | centaur/vl/transforms/always/util.pcert1
-
-centaur/vl/transforms/cn-hooks.pcert0 : no_pcert = 0
-centaur/vl/transforms/cn-hooks.pcert0 : acl2x = 0
-centaur/vl/transforms/cn-hooks.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/cn-hooks.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/cn-hooks.pcert1 : acl2x = 0
-centaur/vl/transforms/cn-hooks.pcert1 : no_pcert = 0
-centaur/vl/transforms/cn-hooks.pcert1 : centaur/vl/transforms/cn-hooks.pcert0
-centaur/vl/transforms/cn-hooks.cert : | centaur/vl/transforms/cn-hooks.pcert1
-
-centaur/vl/transforms/occform/add.pcert0 : no_pcert = 0
-centaur/vl/transforms/occform/add.pcert0 : acl2x = 0
-centaur/vl/transforms/occform/add.pcert0 : \
- centaur/vl/transforms/occform/simple.pcert0 \
- centaur/vl/transforms/occform/xdet.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/occform/add.lisp \
- centaur/vl/transforms/occform/cert.acl2
-centaur/vl/transforms/occform/add.pcert1 : acl2x = 0
-centaur/vl/transforms/occform/add.pcert1 : no_pcert = 0
-centaur/vl/transforms/occform/add.pcert1 : centaur/vl/transforms/occform/add.pcert0
-centaur/vl/transforms/occform/add.cert : | centaur/vl/transforms/occform/add.pcert1
-
-centaur/vl/transforms/occform/compare.pcert0 : no_pcert = 0
-centaur/vl/transforms/occform/compare.pcert0 : acl2x = 0
-centaur/vl/transforms/occform/compare.pcert0 : \
- centaur/vl/transforms/occform/add.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/occform/compare.lisp \
- centaur/vl/transforms/occform/cert.acl2
-centaur/vl/transforms/occform/compare.pcert1 : acl2x = 0
-centaur/vl/transforms/occform/compare.pcert1 : no_pcert = 0
-centaur/vl/transforms/occform/compare.pcert1 : centaur/vl/transforms/occform/compare.pcert0
-centaur/vl/transforms/occform/compare.cert : | centaur/vl/transforms/occform/compare.pcert1
-
-centaur/vl/transforms/occform/div.pcert0 : no_pcert = 0
-centaur/vl/transforms/occform/div.pcert0 : acl2x = 0
-centaur/vl/transforms/occform/div.pcert0 : \
- centaur/vl/transforms/occform/add.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/occform/div.lisp \
- centaur/vl/transforms/occform/cert.acl2
-centaur/vl/transforms/occform/div.pcert1 : acl2x = 0
-centaur/vl/transforms/occform/div.pcert1 : no_pcert = 0
-centaur/vl/transforms/occform/div.pcert1 : centaur/vl/transforms/occform/div.pcert0
-centaur/vl/transforms/occform/div.cert : | centaur/vl/transforms/occform/div.pcert1
-
-centaur/vl/transforms/occform/mul.pcert0 : no_pcert = 0
-centaur/vl/transforms/occform/mul.pcert0 : acl2x = 0
-centaur/vl/transforms/occform/mul.pcert0 : \
- centaur/vl/transforms/occform/add.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/occform/mul.lisp \
- centaur/vl/transforms/occform/cert.acl2
-centaur/vl/transforms/occform/mul.pcert1 : acl2x = 0
-centaur/vl/transforms/occform/mul.pcert1 : no_pcert = 0
-centaur/vl/transforms/occform/mul.pcert1 : centaur/vl/transforms/occform/mul.pcert0
-centaur/vl/transforms/occform/mul.cert : | centaur/vl/transforms/occform/mul.pcert1
-
-centaur/vl/transforms/occform/select.pcert0 : no_pcert = 0
-centaur/vl/transforms/occform/select.pcert0 : acl2x = 0
-centaur/vl/transforms/occform/select.pcert0 : \
- centaur/vl/transforms/occform/simple.pcert0 \
- centaur/vl/util/next-power-of-2.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/occform/select.lisp \
- centaur/vl/transforms/occform/cert.acl2
-centaur/vl/transforms/occform/select.pcert1 : acl2x = 0
-centaur/vl/transforms/occform/select.pcert1 : no_pcert = 0
-centaur/vl/transforms/occform/select.pcert1 : centaur/vl/transforms/occform/select.pcert0
-centaur/vl/transforms/occform/select.cert : | centaur/vl/transforms/occform/select.pcert1
-
-centaur/vl/transforms/occform/shl.pcert0 : no_pcert = 0
-centaur/vl/transforms/occform/shl.pcert0 : acl2x = 0
-centaur/vl/transforms/occform/shl.pcert0 : \
- centaur/vl/transforms/occform/simple.pcert0 \
- centaur/vl/transforms/occform/xdet.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/occform/shl.lisp \
- centaur/vl/transforms/occform/cert.acl2
-centaur/vl/transforms/occform/shl.pcert1 : acl2x = 0
-centaur/vl/transforms/occform/shl.pcert1 : no_pcert = 0
-centaur/vl/transforms/occform/shl.pcert1 : centaur/vl/transforms/occform/shl.pcert0
-centaur/vl/transforms/occform/shl.cert : | centaur/vl/transforms/occform/shl.pcert1
-
-centaur/vl/transforms/occform/shr.pcert0 : no_pcert = 0
-centaur/vl/transforms/occform/shr.pcert0 : acl2x = 0
-centaur/vl/transforms/occform/shr.pcert0 : \
- centaur/vl/transforms/occform/shl.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/occform/shr.lisp \
- centaur/vl/transforms/occform/cert.acl2
-centaur/vl/transforms/occform/shr.pcert1 : acl2x = 0
-centaur/vl/transforms/occform/shr.pcert1 : no_pcert = 0
-centaur/vl/transforms/occform/shr.pcert1 : centaur/vl/transforms/occform/shr.pcert0
-centaur/vl/transforms/occform/shr.cert : | centaur/vl/transforms/occform/shr.pcert1
-
-centaur/vl/transforms/occform/simple.pcert0 : no_pcert = 0
-centaur/vl/transforms/occform/simple.pcert0 : acl2x = 0
-centaur/vl/transforms/occform/simple.pcert0 : \
- centaur/vl/transforms/occform/util.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/occform/simple.lisp \
- centaur/vl/transforms/occform/cert.acl2
-centaur/vl/transforms/occform/simple.pcert1 : acl2x = 0
-centaur/vl/transforms/occform/simple.pcert1 : no_pcert = 0
-centaur/vl/transforms/occform/simple.pcert1 : centaur/vl/transforms/occform/simple.pcert0
-centaur/vl/transforms/occform/simple.cert : | centaur/vl/transforms/occform/simple.pcert1
-
-centaur/vl/transforms/occform/top.pcert0 : no_pcert = 0
-centaur/vl/transforms/occform/top.pcert0 : acl2x = 0
-centaur/vl/transforms/occform/top.pcert0 : \
- centaur/vl/transforms/occform/add.pcert0 \
- centaur/vl/transforms/occform/compare.pcert0 \
- centaur/vl/transforms/occform/div.pcert0 \
- centaur/vl/transforms/occform/mul.pcert0 \
- centaur/vl/transforms/occform/select.pcert0 \
- centaur/vl/transforms/occform/shl.pcert0 \
- centaur/vl/transforms/occform/shr.pcert0 \
- centaur/vl/transforms/occform/simple.pcert0 \
- centaur/vl/transforms/occform/xdet.pcert0 \
- centaur/vl/mlib/expr-slice.pcert0 \
- centaur/vl/mlib/namefactory.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/occform/top.lisp \
- centaur/vl/transforms/occform/cert.acl2
-centaur/vl/transforms/occform/top.pcert1 : acl2x = 0
-centaur/vl/transforms/occform/top.pcert1 : no_pcert = 0
-centaur/vl/transforms/occform/top.pcert1 : centaur/vl/transforms/occform/top.pcert0
-centaur/vl/transforms/occform/top.cert : | centaur/vl/transforms/occform/top.pcert1
-
-centaur/vl/transforms/occform/util.pcert0 : no_pcert = 0
-centaur/vl/transforms/occform/util.pcert0 : acl2x = 0
-centaur/vl/transforms/occform/util.pcert0 : \
- centaur/vl/primitives.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/expr-building.pcert0 \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/mlib/namefactory.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/occform/util.lisp \
- centaur/vl/transforms/occform/cert.acl2
-centaur/vl/transforms/occform/util.pcert1 : acl2x = 0
-centaur/vl/transforms/occform/util.pcert1 : no_pcert = 0
-centaur/vl/transforms/occform/util.pcert1 : centaur/vl/transforms/occform/util.pcert0
-centaur/vl/transforms/occform/util.cert : | centaur/vl/transforms/occform/util.pcert1
-
-centaur/vl/transforms/occform/xdet.pcert0 : no_pcert = 0
-centaur/vl/transforms/occform/xdet.pcert0 : acl2x = 0
-centaur/vl/transforms/occform/xdet.pcert0 : \
- centaur/vl/transforms/occform/simple.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/occform/xdet.lisp \
- centaur/vl/transforms/occform/cert.acl2
-centaur/vl/transforms/occform/xdet.pcert1 : acl2x = 0
-centaur/vl/transforms/occform/xdet.pcert1 : no_pcert = 0
-centaur/vl/transforms/occform/xdet.pcert1 : centaur/vl/transforms/occform/xdet.pcert0
-centaur/vl/transforms/occform/xdet.cert : | centaur/vl/transforms/occform/xdet.pcert1
-
-centaur/vl/transforms/xf-addinstnames.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-addinstnames.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-addinstnames.pcert0 : \
- centaur/vl/mlib/namefactory.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-addinstnames.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-addinstnames.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-addinstnames.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-addinstnames.pcert1 : centaur/vl/transforms/xf-addinstnames.pcert0
-centaur/vl/transforms/xf-addinstnames.cert : | centaur/vl/transforms/xf-addinstnames.pcert1
-
-centaur/vl/transforms/xf-annotate-mods.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-annotate-mods.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-annotate-mods.pcert0 : \
- centaur/vl/checkers/duplicate-detect.pcert0 \
- centaur/vl/checkers/portcheck.pcert0 \
- centaur/vl/mlib/warnings.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/transforms/xf-designwires.pcert0 \
- centaur/vl/transforms/xf-portdecl-sign.pcert0 \
- centaur/vl/transforms/xf-argresolve.pcert0 \
- centaur/vl/transforms/xf-orig.pcert0 \
- centaur/vl/transforms/cn-hooks.pcert0 \
- centaur/vl/transforms/xf-follow-hids.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-annotate-mods.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-annotate-mods.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-annotate-mods.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-annotate-mods.pcert1 : centaur/vl/transforms/xf-annotate-mods.pcert0
-centaur/vl/transforms/xf-annotate-mods.cert : | centaur/vl/transforms/xf-annotate-mods.pcert1
-
-centaur/vl/transforms/xf-argresolve.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-argresolve.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-argresolve.pcert0 : \
- centaur/vl/mlib/find-item.pcert0 \
- centaur/vl/mlib/port-tools.pcert0 \
- centaur/vl/mlib/find-module.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-argresolve.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-argresolve.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-argresolve.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-argresolve.pcert1 : centaur/vl/transforms/xf-argresolve.pcert0
-centaur/vl/transforms/xf-argresolve.cert : | centaur/vl/transforms/xf-argresolve.pcert1
-
-centaur/vl/transforms/xf-array-indexing.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-array-indexing.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-array-indexing.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-array-indexing.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-array-indexing.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-array-indexing.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-array-indexing.pcert1 : centaur/vl/transforms/xf-array-indexing.pcert0
-centaur/vl/transforms/xf-array-indexing.cert : | centaur/vl/transforms/xf-array-indexing.pcert1
-
-centaur/vl/transforms/xf-assign-trunc.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-assign-trunc.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-assign-trunc.pcert0 : \
- centaur/vl/wf-ranges-resolved-p.pcert0 \
- centaur/vl/wf-widthsfixed-p.pcert0 \
- centaur/vl/mlib/namefactory.pcert0 \
- centaur/vl/mlib/welltyped.pcert0 \
- centaur/vl/mlib/delta.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-assign-trunc.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-assign-trunc.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-assign-trunc.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-assign-trunc.pcert1 : centaur/vl/transforms/xf-assign-trunc.pcert0
-centaur/vl/transforms/xf-assign-trunc.cert : | centaur/vl/transforms/xf-assign-trunc.pcert1
-
-centaur/vl/transforms/xf-blankargs.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-blankargs.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-blankargs.pcert0 : \
- centaur/vl/mlib/find-module.pcert0 \
- centaur/vl/mlib/namefactory.pcert0 \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/mlib/port-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-blankargs.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-blankargs.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-blankargs.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-blankargs.pcert1 : centaur/vl/transforms/xf-blankargs.pcert0
-centaur/vl/transforms/xf-blankargs.cert : | centaur/vl/transforms/xf-blankargs.pcert1
-
-centaur/vl/transforms/xf-clean-params.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-clean-params.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-clean-params.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/allexprs.pcert0 \
- centaur/vl/mlib/modnamespace.pcert0 \
- centaur/vl/mlib/filter.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-clean-params.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-clean-params.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-clean-params.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-clean-params.pcert1 : centaur/vl/transforms/xf-clean-params.pcert0
-centaur/vl/transforms/xf-clean-params.cert : | centaur/vl/transforms/xf-clean-params.pcert1
-
-centaur/vl/transforms/xf-clean-selects.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-clean-selects.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-clean-selects.pcert0 : \
- centaur/vl/mlib/clean-concats.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-clean-selects.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-clean-selects.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-clean-selects.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-clean-selects.pcert1 : centaur/vl/transforms/xf-clean-selects.pcert0
-centaur/vl/transforms/xf-clean-selects.cert : | centaur/vl/transforms/xf-clean-selects.pcert1
-
-centaur/vl/transforms/xf-delayredux.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-delayredux.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-delayredux.pcert0 : \
- centaur/vl/transforms/occform/util.pcert0 \
- centaur/vl/mlib/delta.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-delayredux.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-delayredux.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-delayredux.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-delayredux.pcert1 : centaur/vl/transforms/xf-delayredux.pcert0
-centaur/vl/transforms/xf-delayredux.cert : | centaur/vl/transforms/xf-delayredux.pcert1
-
-centaur/vl/transforms/xf-designregs.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-designregs.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-designregs.pcert0 : \
- centaur/vl/mlib/writer.pcert0 \
- centaur/vl/mlib/hid-tools.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/mlib/find-item.pcert0 \
- centaur/vl/util/sum-nats.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- defsort/defsort.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/primitives.pcert0 \
- centaur/esim/esim-sexpr-support.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-designregs.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-designregs.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-designregs.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-designregs.pcert1 : centaur/vl/transforms/xf-designregs.pcert0
-centaur/vl/transforms/xf-designregs.cert : | centaur/vl/transforms/xf-designregs.pcert1
-
-centaur/vl/transforms/xf-designwires.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-designwires.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-designwires.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-designwires.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-designwires.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-designwires.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-designwires.pcert1 : centaur/vl/transforms/xf-designwires.pcert0
-centaur/vl/transforms/xf-designwires.cert : | centaur/vl/transforms/xf-designwires.pcert1
-
-centaur/vl/transforms/xf-drop-blankports.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-drop-blankports.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-drop-blankports.pcert0 : \
- centaur/vl/mlib/find-module.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-drop-blankports.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-drop-blankports.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-drop-blankports.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-drop-blankports.pcert1 : centaur/vl/transforms/xf-drop-blankports.pcert0
-centaur/vl/transforms/xf-drop-blankports.cert : | centaur/vl/transforms/xf-drop-blankports.pcert1
-
-centaur/vl/transforms/xf-elim-supply.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-elim-supply.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-elim-supply.pcert0 : \
- centaur/vl/transforms/xf-subst.pcert0 \
- centaur/vl/mlib/find-item.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-elim-supply.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-elim-supply.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-elim-supply.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-elim-supply.pcert1 : centaur/vl/transforms/xf-elim-supply.pcert0
-centaur/vl/transforms/xf-elim-supply.cert : | centaur/vl/transforms/xf-elim-supply.pcert1
-
-centaur/vl/transforms/xf-expand-functions.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-expand-functions.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-expand-functions.pcert0 : \
- centaur/vl/transforms/always/stmtrewrite.pcert0 \
- centaur/vl/transforms/xf-subst.pcert0 \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/mlib/allexprs.pcert0 \
- centaur/vl/mlib/namefactory.pcert0 \
- centaur/vl/util/toposort.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-expand-functions.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-expand-functions.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-expand-functions.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-expand-functions.pcert1 : centaur/vl/transforms/xf-expand-functions.pcert0
-centaur/vl/transforms/xf-expand-functions.cert : | centaur/vl/transforms/xf-expand-functions.pcert1
-
-centaur/vl/transforms/xf-expr-simp.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-expr-simp.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-expr-simp.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/fmt.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-expr-simp.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-expr-simp.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-expr-simp.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-expr-simp.pcert1 : centaur/vl/transforms/xf-expr-simp.pcert0
-centaur/vl/transforms/xf-expr-simp.cert : | centaur/vl/transforms/xf-expr-simp.pcert1
-
-centaur/vl/transforms/xf-expr-split.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-expr-split.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-expr-split.pcert0 : \
- centaur/vl/mlib/expr-slice.pcert0 \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/mlib/delta.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-expr-split.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-expr-split.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-expr-split.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-expr-split.pcert1 : centaur/vl/transforms/xf-expr-split.pcert0
-centaur/vl/transforms/xf-expr-split.cert : | centaur/vl/transforms/xf-expr-split.pcert1
-
-centaur/vl/transforms/xf-follow-hids.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-follow-hids.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-follow-hids.pcert0 : \
- centaur/vl/transforms/xf-resolve-ranges.pcert0 \
- centaur/vl/mlib/hierarchy.pcert0 \
- centaur/vl/mlib/find-item.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/hid-tools.pcert0 \
- centaur/vl/wf-ranges-resolved-p.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-follow-hids.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-follow-hids.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-follow-hids.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-follow-hids.pcert1 : centaur/vl/transforms/xf-follow-hids.pcert0
-centaur/vl/transforms/xf-follow-hids.cert : | centaur/vl/transforms/xf-follow-hids.pcert1
-
-centaur/vl/transforms/xf-gate-elim.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-gate-elim.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-gate-elim.pcert0 : \
- centaur/vl/primitives.pcert0 \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-gate-elim.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-gate-elim.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-gate-elim.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-gate-elim.pcert1 : centaur/vl/transforms/xf-gate-elim.pcert0
-centaur/vl/transforms/xf-gate-elim.cert : | centaur/vl/transforms/xf-gate-elim.pcert1
-
-centaur/vl/transforms/xf-gateredux.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-gateredux.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-gateredux.pcert0 : \
- centaur/vl/transforms/occform/simple.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-gateredux.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-gateredux.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-gateredux.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-gateredux.pcert1 : centaur/vl/transforms/xf-gateredux.pcert0
-centaur/vl/transforms/xf-gateredux.cert : | centaur/vl/transforms/xf-gateredux.pcert1
-
-centaur/vl/transforms/xf-gatesplit.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-gatesplit.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-gatesplit.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/mlib/namefactory.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-gatesplit.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-gatesplit.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-gatesplit.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-gatesplit.pcert1 : centaur/vl/transforms/xf-gatesplit.pcert0
-centaur/vl/transforms/xf-gatesplit.cert : | centaur/vl/transforms/xf-gatesplit.pcert1
-
-centaur/vl/transforms/xf-hid-elim.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-hid-elim.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-hid-elim.pcert0 : \
- centaur/vl/transforms/xf-resolve-ranges.pcert0 \
- centaur/vl/mlib/find-module.pcert0 \
- centaur/vl/mlib/find-item.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/hid-tools.pcert0 \
- centaur/vl/wf-ranges-resolved-p.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-hid-elim.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-hid-elim.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-hid-elim.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-hid-elim.pcert1 : centaur/vl/transforms/xf-hid-elim.pcert0
-centaur/vl/transforms/xf-hid-elim.cert : | centaur/vl/transforms/xf-hid-elim.pcert1
-
-centaur/vl/transforms/xf-inline.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-inline.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-inline.pcert0 : \
- centaur/vl/transforms/xf-subst.pcert0 \
- centaur/vl/mlib/namemangle.pcert0 \
- centaur/vl/mlib/relocate.pcert0 \
- centaur/vl/mlib/namefactory.pcert0 \
- centaur/vl/mlib/port-tools.pcert0 \
- centaur/vl/mlib/writer.pcert0 \
- centaur/vl/mlib/print-warnings.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-inline.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-inline.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-inline.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-inline.pcert1 : centaur/vl/transforms/xf-inline.pcert0
-centaur/vl/transforms/xf-inline.cert : | centaur/vl/transforms/xf-inline.pcert1
-
-centaur/vl/transforms/xf-oprewrite.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-oprewrite.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-oprewrite.pcert0 : \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/checkers/duplicate-detect.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-oprewrite.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-oprewrite.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-oprewrite.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-oprewrite.pcert1 : centaur/vl/transforms/xf-oprewrite.pcert0
-centaur/vl/transforms/xf-oprewrite.cert : | centaur/vl/transforms/xf-oprewrite.pcert1
-
-centaur/vl/transforms/xf-optimize-rw.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-optimize-rw.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-optimize-rw.pcert0 : \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-optimize-rw.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-optimize-rw.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-optimize-rw.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-optimize-rw.pcert1 : centaur/vl/transforms/xf-optimize-rw.pcert0
-centaur/vl/transforms/xf-optimize-rw.cert : | centaur/vl/transforms/xf-optimize-rw.pcert1
-
-centaur/vl/transforms/xf-orig.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-orig.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-orig.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-orig.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-orig.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-orig.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-orig.pcert1 : centaur/vl/transforms/xf-orig.pcert0
-centaur/vl/transforms/xf-orig.cert : | centaur/vl/transforms/xf-orig.pcert1
-
-centaur/vl/transforms/xf-portdecl-sign.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-portdecl-sign.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-portdecl-sign.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-portdecl-sign.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-portdecl-sign.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-portdecl-sign.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-portdecl-sign.pcert1 : centaur/vl/transforms/xf-portdecl-sign.pcert0
-centaur/vl/transforms/xf-portdecl-sign.cert : | centaur/vl/transforms/xf-portdecl-sign.pcert1
-
-centaur/vl/transforms/xf-propagate.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-propagate.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-propagate.pcert0 : \
- centaur/vl/transforms/xf-subst.pcert0 \
- centaur/vl/mlib/allexprs.pcert0 \
- centaur/vl/mlib/modnamespace.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-propagate.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-propagate.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-propagate.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-propagate.pcert1 : centaur/vl/transforms/xf-propagate.pcert0
-centaur/vl/transforms/xf-propagate.cert : | centaur/vl/transforms/xf-propagate.pcert1
-
-centaur/vl/transforms/xf-replicate-insts.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-replicate-insts.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-replicate-insts.pcert0 : \
- centaur/vl/mlib/expr-slice.pcert0 \
- centaur/vl/mlib/namefactory.pcert0 \
- centaur/vl/mlib/find-module.pcert0 \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-replicate-insts.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-replicate-insts.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-replicate-insts.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-replicate-insts.pcert1 : centaur/vl/transforms/xf-replicate-insts.pcert0
-centaur/vl/transforms/xf-replicate-insts.cert : | centaur/vl/transforms/xf-replicate-insts.pcert1
-
-centaur/vl/transforms/xf-resolve-ranges.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-resolve-ranges.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-resolve-ranges.pcert0 : \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-resolve-ranges.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-resolve-ranges.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-resolve-ranges.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-resolve-ranges.pcert1 : centaur/vl/transforms/xf-resolve-ranges.pcert0
-centaur/vl/transforms/xf-resolve-ranges.cert : | centaur/vl/transforms/xf-resolve-ranges.pcert1
-
-centaur/vl/transforms/xf-sizing.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-sizing.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-sizing.pcert0 : \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/util/sum-nats.pcert0 \
- centaur/vl/mlib/context.pcert0 \
- centaur/vl/mlib/welltyped.pcert0 \
- centaur/vl/mlib/lvalues.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/bitops/ihs-extensions.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-sizing.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-sizing.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-sizing.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-sizing.pcert1 : centaur/vl/transforms/xf-sizing.pcert0
-centaur/vl/transforms/xf-sizing.cert : | centaur/vl/transforms/xf-sizing.pcert1
-
-centaur/vl/transforms/xf-subst.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-subst.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-subst.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-subst.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-subst.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-subst.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-subst.pcert1 : centaur/vl/transforms/xf-subst.pcert0
-centaur/vl/transforms/xf-subst.cert : | centaur/vl/transforms/xf-subst.pcert1
-
-centaur/vl/transforms/xf-unparameterize.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-unparameterize.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-unparameterize.pcert0 : \
- centaur/vl/transforms/xf-subst.pcert0 \
- centaur/vl/mlib/remove-bad.pcert0 \
- centaur/vl/mlib/print-warnings.pcert0 \
- centaur/vl/wf-ranges-resolved-p.pcert0 \
- centaur/vl/onehot.pcert0 \
- centaur/vl/util/cwtime.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/mlib/modname-sets.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-unparameterize.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-unparameterize.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-unparameterize.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-unparameterize.pcert1 : centaur/vl/transforms/xf-unparameterize.pcert0
-centaur/vl/transforms/xf-unparameterize.cert : | centaur/vl/transforms/xf-unparameterize.pcert1
-
-centaur/vl/transforms/xf-unused-reg.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-unused-reg.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-unused-reg.pcert0 : \
- centaur/vl/mlib/allexprs.pcert0 \
- centaur/vl/mlib/modnamespace.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-unused-reg.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-unused-reg.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-unused-reg.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-unused-reg.pcert1 : centaur/vl/transforms/xf-unused-reg.pcert0
-centaur/vl/transforms/xf-unused-reg.cert : | centaur/vl/transforms/xf-unused-reg.pcert1
-
-centaur/vl/transforms/xf-weirdint-elim.pcert0 : no_pcert = 0
-centaur/vl/transforms/xf-weirdint-elim.pcert0 : acl2x = 0
-centaur/vl/transforms/xf-weirdint-elim.pcert0 : \
- centaur/vl/transforms/occform/util.pcert0 \
- centaur/vl/mlib/allexprs.pcert0 \
- centaur/vl/mlib/stmt-tools.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/transforms/xf-weirdint-elim.lisp \
- centaur/vl/transforms/cert.acl2
-centaur/vl/transforms/xf-weirdint-elim.pcert1 : acl2x = 0
-centaur/vl/transforms/xf-weirdint-elim.pcert1 : no_pcert = 0
-centaur/vl/transforms/xf-weirdint-elim.pcert1 : centaur/vl/transforms/xf-weirdint-elim.pcert0
-centaur/vl/transforms/xf-weirdint-elim.cert : | centaur/vl/transforms/xf-weirdint-elim.pcert1
-
-centaur/vl/translation.pcert0 : no_pcert = 0
-centaur/vl/translation.pcert0 : acl2x = 0
-centaur/vl/translation.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/loader/filemap.pcert0 \
- centaur/vl/loader/defines.pcert0 \
- centaur/vl/checkers/use-set-report.pcert0 \
- centaur/vl/transforms/xf-designregs.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/translation.lisp \
- centaur/vl/cert.acl2
-centaur/vl/translation.pcert1 : acl2x = 0
-centaur/vl/translation.pcert1 : no_pcert = 0
-centaur/vl/translation.pcert1 : centaur/vl/translation.pcert0
-centaur/vl/translation.cert : | centaur/vl/translation.pcert1
-
-centaur/vl/util/arithmetic.pcert0 : no_pcert = 0
-centaur/vl/util/arithmetic.pcert0 : acl2x = 0
-centaur/vl/util/arithmetic.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- centaur/bitops/integer-length.pcert0 \
- cutil/deflist.pcert0 \
- centaur/vl/util/subsetp-equal.pcert0 \
- data-structures/list-defthms.pcert0 \
- misc/hons-help.pcert0 \
- std/lists/list-defuns.pcert0 \
- std/lists/nthcdr.pcert0 \
- std/lists/take.pcert0 \
- std/lists/coerce.pcert0 \
- std/lists/list-fix.pcert0 \
- std/ks/explode-atom.pcert0 \
- std/lists/repeat.pcert0 \
- std/lists/rev.pcert0 \
- defsort/duplicity.pcert0 \
- tools/mv-nth.pcert0 \
- tools/bstar.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/arithmetic.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/arithmetic.pcert1 : acl2x = 0
-centaur/vl/util/arithmetic.pcert1 : no_pcert = 0
-centaur/vl/util/arithmetic.pcert1 : centaur/vl/util/arithmetic.pcert0
-centaur/vl/util/arithmetic.cert : | centaur/vl/util/arithmetic.pcert1
-
-centaur/vl/util/bits.pcert0 : no_pcert = 0
-centaur/vl/util/bits.pcert0 : acl2x = 0
-centaur/vl/util/bits.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/bits.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/bits.pcert1 : acl2x = 0
-centaur/vl/util/bits.pcert1 : no_pcert = 0
-centaur/vl/util/bits.pcert1 : centaur/vl/util/bits.pcert0
-centaur/vl/util/bits.cert : | centaur/vl/util/bits.pcert1
-
-centaur/vl/util/character-list-listp.pcert0 : no_pcert = 0
-centaur/vl/util/character-list-listp.pcert0 : acl2x = 0
-centaur/vl/util/character-list-listp.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/character-list-listp.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/character-list-listp.pcert1 : acl2x = 0
-centaur/vl/util/character-list-listp.pcert1 : no_pcert = 0
-centaur/vl/util/character-list-listp.pcert1 : centaur/vl/util/character-list-listp.pcert0
-centaur/vl/util/character-list-listp.cert : | centaur/vl/util/character-list-listp.pcert1
-
-centaur/vl/util/clean-alist.pcert0 : no_pcert = 0
-centaur/vl/util/clean-alist.pcert0 : acl2x = 0
-centaur/vl/util/clean-alist.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- misc/hons-help.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/clean-alist.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/clean-alist.pcert1 : acl2x = 0
-centaur/vl/util/clean-alist.pcert1 : no_pcert = 0
-centaur/vl/util/clean-alist.pcert1 : centaur/vl/util/clean-alist.pcert0
-centaur/vl/util/clean-alist.cert : | centaur/vl/util/clean-alist.pcert1
-
-centaur/vl/util/commentmap.pcert0 : no_pcert = 0
-centaur/vl/util/commentmap.pcert0 : acl2x = 0
-centaur/vl/util/commentmap.pcert0 : \
- centaur/vl/util/echars.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/commentmap.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/commentmap.pcert1 : acl2x = 0
-centaur/vl/util/commentmap.pcert1 : no_pcert = 0
-centaur/vl/util/commentmap.pcert1 : centaur/vl/util/commentmap.pcert0
-centaur/vl/util/commentmap.cert : | centaur/vl/util/commentmap.pcert1
-
-centaur/vl/util/cw-unformatted.pcert0 : no_pcert = 0
-centaur/vl/util/cw-unformatted.pcert0 : acl2x = 0
-centaur/vl/util/cw-unformatted.pcert0 : \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/cw-unformatted.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/cw-unformatted.pcert1 : acl2x = 0
-centaur/vl/util/cw-unformatted.pcert1 : no_pcert = 0
-centaur/vl/util/cw-unformatted.pcert1 : centaur/vl/util/cw-unformatted.pcert0
-centaur/vl/util/cw-unformatted.cert : | centaur/vl/util/cw-unformatted.pcert1
-
-centaur/vl/util/cwtime.pcert0 : no_pcert = 0
-centaur/vl/util/cwtime.pcert0 : acl2x = 0
-centaur/vl/util/cwtime.pcert0 : \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/cwtime.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/cwtime.pcert1 : acl2x = 0
-centaur/vl/util/cwtime.pcert1 : no_pcert = 0
-centaur/vl/util/cwtime.pcert1 : centaur/vl/util/cwtime.pcert0
-centaur/vl/util/cwtime.cert : | centaur/vl/util/cwtime.pcert1
-
-centaur/vl/util/defs.pcert0 : no_pcert = 0
-centaur/vl/util/defs.pcert0 : acl2x = 0
-centaur/vl/util/defs.pcert0 : \
- cutil/top.pcert0 \
- tools/defconsts.pcert0 \
- std/ks/two-nats-measure.pcert0 \
- std/lists/list-defuns.pcert0 \
- centaur/bitops/integer-length.pcert0 \
- centaur/misc/alist-equiv.pcert0 \
- centaur/misc/hons-extra.pcert0 \
- str/top.pcert0 \
- str/fast-cat.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- data-structures/list-defthms.pcert0 \
- centaur/misc/equal-sets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/defs.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/defs.pcert1 : acl2x = 0
-centaur/vl/util/defs.pcert1 : no_pcert = 0
-centaur/vl/util/defs.pcert1 : centaur/vl/util/defs.pcert0
-centaur/vl/util/defs.cert : | centaur/vl/util/defs.pcert1
-
-centaur/vl/util/defwellformed.pcert0 : no_pcert = 0
-centaur/vl/util/defwellformed.pcert0 : acl2x = 0
-centaur/vl/util/defwellformed.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/warnings.pcert0 \
- tools/flag.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/defwellformed.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/defwellformed.pcert1 : acl2x = 0
-centaur/vl/util/defwellformed.pcert1 : no_pcert = 0
-centaur/vl/util/defwellformed.pcert1 : centaur/vl/util/defwellformed.pcert0
-centaur/vl/util/defwellformed.cert : | centaur/vl/util/defwellformed.pcert1
-
-centaur/vl/util/echars.pcert0 : no_pcert = 0
-centaur/vl/util/echars.pcert0 : acl2x = 0
-centaur/vl/util/echars.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- misc/assert.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/echars.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/echars.pcert1 : acl2x = 0
-centaur/vl/util/echars.pcert1 : no_pcert = 0
-centaur/vl/util/echars.pcert1 : centaur/vl/util/echars.pcert0
-centaur/vl/util/echars.cert : | centaur/vl/util/echars.pcert1
-
-centaur/vl/util/esim-lemmas.pcert0 : no_pcert = 0
-centaur/vl/util/esim-lemmas.pcert0 : acl2x = 0
-centaur/vl/util/esim-lemmas.pcert0 : \
- centaur/esim/esim-sexpr-support.pcert0 \
- centaur/esim/esim-sexpr-support-thms.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/esim-lemmas.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/esim-lemmas.pcert1 : acl2x = 0
-centaur/vl/util/esim-lemmas.pcert1 : no_pcert = 0
-centaur/vl/util/esim-lemmas.pcert1 : centaur/vl/util/esim-lemmas.pcert0
-centaur/vl/util/esim-lemmas.cert : | centaur/vl/util/esim-lemmas.pcert1
-
-centaur/vl/util/gc.pcert0 : no_pcert = 0
-centaur/vl/util/gc.pcert0 : acl2x = 0
-centaur/vl/util/gc.pcert0 : \
- centaur/misc/memory-mgmt-raw.pcert0 \
- tools/include-raw.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/gc.lisp \
- centaur/vl/util/cert.acl2 \
- centaur/vl/util/gc-raw.lsp
-centaur/vl/util/gc.pcert1 : acl2x = 0
-centaur/vl/util/gc.pcert1 : no_pcert = 0
-centaur/vl/util/gc.pcert1 : centaur/vl/util/gc.pcert0
-centaur/vl/util/gc.cert : | centaur/vl/util/gc.pcert1
-
-centaur/vl/util/intersectp-equal.pcert0 : no_pcert = 0
-centaur/vl/util/intersectp-equal.pcert0 : acl2x = 0
-centaur/vl/util/intersectp-equal.pcert0 : \
- std/lists/list-defuns.pcert0 \
- cutil/define.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/intersectp-equal.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/intersectp-equal.pcert1 : acl2x = 0
-centaur/vl/util/intersectp-equal.pcert1 : no_pcert = 0
-centaur/vl/util/intersectp-equal.pcert1 : centaur/vl/util/intersectp-equal.pcert0
-centaur/vl/util/intersectp-equal.cert : | centaur/vl/util/intersectp-equal.pcert1
-
-centaur/vl/util/namedb.pcert0 : no_pcert = 0
-centaur/vl/util/namedb.pcert0 : acl2x = 0
-centaur/vl/util/namedb.pcert0 : \
- str/top.pcert0 \
- centaur/vl/util/string-alists.pcert0 \
- centaur/vl/util/nat-alists.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/namedb.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/namedb.pcert1 : acl2x = 0
-centaur/vl/util/namedb.pcert1 : no_pcert = 0
-centaur/vl/util/namedb.pcert1 : centaur/vl/util/namedb.pcert0
-centaur/vl/util/namedb.cert : | centaur/vl/util/namedb.pcert1
-
-centaur/vl/util/nat-alists.pcert0 : no_pcert = 0
-centaur/vl/util/nat-alists.pcert0 : acl2x = 0
-centaur/vl/util/nat-alists.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/nat-alists.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/nat-alists.pcert1 : acl2x = 0
-centaur/vl/util/nat-alists.pcert1 : no_pcert = 0
-centaur/vl/util/nat-alists.pcert1 : centaur/vl/util/nat-alists.pcert0
-centaur/vl/util/nat-alists.cert : | centaur/vl/util/nat-alists.pcert1
-
-centaur/vl/util/next-power-of-2.pcert0 : no_pcert = 0
-centaur/vl/util/next-power-of-2.pcert0 : acl2x = 0
-centaur/vl/util/next-power-of-2.pcert0 : \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/next-power-of-2.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/next-power-of-2.pcert1 : acl2x = 0
-centaur/vl/util/next-power-of-2.pcert1 : no_pcert = 0
-centaur/vl/util/next-power-of-2.pcert1 : centaur/vl/util/next-power-of-2.pcert0
-centaur/vl/util/next-power-of-2.cert : | centaur/vl/util/next-power-of-2.pcert1
-
-centaur/vl/util/osets.pcert0 : no_pcert = 0
-centaur/vl/util/osets.pcert0 : acl2x = 0
-centaur/vl/util/osets.pcert0 : \
- centaur/vl/util/subsetp-equal.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/osets.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/osets.pcert1 : acl2x = 0
-centaur/vl/util/osets.pcert1 : no_pcert = 0
-centaur/vl/util/osets.pcert1 : centaur/vl/util/osets.pcert0
-centaur/vl/util/osets.cert : | centaur/vl/util/osets.pcert1
-
-centaur/vl/util/position.pcert0 : no_pcert = 0
-centaur/vl/util/position.pcert0 : acl2x = 0
-centaur/vl/util/position.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/position.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/position.pcert1 : acl2x = 0
-centaur/vl/util/position.pcert1 : no_pcert = 0
-centaur/vl/util/position.pcert1 : centaur/vl/util/position.pcert0
-centaur/vl/util/position.cert : | centaur/vl/util/position.pcert1
-
-centaur/vl/util/prefix-hash.pcert0 : no_pcert = 0
-centaur/vl/util/prefix-hash.pcert0 : acl2x = 0
-centaur/vl/util/prefix-hash.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/prefix-hash.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/prefix-hash.pcert1 : acl2x = 0
-centaur/vl/util/prefix-hash.pcert1 : no_pcert = 0
-centaur/vl/util/prefix-hash.pcert1 : centaur/vl/util/prefix-hash.pcert0
-centaur/vl/util/prefix-hash.cert : | centaur/vl/util/prefix-hash.pcert1
-
-centaur/vl/util/prefixp.pcert0 : no_pcert = 0
-centaur/vl/util/prefixp.pcert0 : acl2x = 0
-centaur/vl/util/prefixp.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/prefixp.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/prefixp.pcert1 : acl2x = 0
-centaur/vl/util/prefixp.pcert1 : no_pcert = 0
-centaur/vl/util/prefixp.pcert1 : centaur/vl/util/prefixp.pcert0
-centaur/vl/util/prefixp.cert : | centaur/vl/util/prefixp.pcert1
-
-centaur/vl/util/print-htmlencode.pcert0 : no_pcert = 0
-centaur/vl/util/print-htmlencode.pcert0 : acl2x = 0
-centaur/vl/util/print-htmlencode.pcert0 : \
- tools/bstar.pcert0 \
- make-event/assert.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/print-htmlencode.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/print-htmlencode.pcert1 : acl2x = 0
-centaur/vl/util/print-htmlencode.pcert1 : no_pcert = 0
-centaur/vl/util/print-htmlencode.pcert1 : centaur/vl/util/print-htmlencode.pcert0
-centaur/vl/util/print-htmlencode.cert : | centaur/vl/util/print-htmlencode.pcert1
-
-centaur/vl/util/print-urlencode.pcert0 : no_pcert = 0
-centaur/vl/util/print-urlencode.pcert0 : acl2x = 0
-centaur/vl/util/print-urlencode.pcert0 : \
- xdoc/top.pcert0 \
- misc/definline.pcert0 \
- make-event/assert.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/print-urlencode.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/print-urlencode.pcert1 : acl2x = 0
-centaur/vl/util/print-urlencode.pcert1 : no_pcert = 0
-centaur/vl/util/print-urlencode.pcert1 : centaur/vl/util/print-urlencode.pcert0
-centaur/vl/util/print-urlencode.cert : | centaur/vl/util/print-urlencode.pcert1
-
-centaur/vl/util/print.pcert0 : no_pcert = 0
-centaur/vl/util/print.pcert0 : acl2x = 0
-centaur/vl/util/print.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/print-urlencode.pcert0 \
- centaur/vl/util/print-htmlencode.pcert0 \
- centaur/vl/util/cw-unformatted.pcert0 \
- str/natstr.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- make-event/assert.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/print.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/print.pcert1 : acl2x = 0
-centaur/vl/util/print.pcert1 : no_pcert = 0
-centaur/vl/util/print.pcert1 : centaur/vl/util/print.pcert0
-centaur/vl/util/print.cert : | centaur/vl/util/print.pcert1
-
-centaur/vl/util/string-alists.pcert0 : no_pcert = 0
-centaur/vl/util/string-alists.pcert0 : acl2x = 0
-centaur/vl/util/string-alists.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/string-alists.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/string-alists.pcert1 : acl2x = 0
-centaur/vl/util/string-alists.pcert1 : no_pcert = 0
-centaur/vl/util/string-alists.pcert1 : centaur/vl/util/string-alists.pcert0
-centaur/vl/util/string-alists.cert : | centaur/vl/util/string-alists.pcert1
-
-centaur/vl/util/subsetp-equal.pcert0 : no_pcert = 0
-centaur/vl/util/subsetp-equal.pcert0 : acl2x = 0
-centaur/vl/util/subsetp-equal.pcert0 : \
- centaur/misc/equal-sets.pcert0 \
- finite-set-theory/osets/sets.pcert0 \
- std/lists/list-fix.pcert0 \
- std/lists/take.pcert0 \
- defsort/duplicated-members.pcert0 \
- arithmetic/top.pcert0 \
- data-structures/list-defthms.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/subsetp-equal.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/subsetp-equal.pcert1 : acl2x = 0
-centaur/vl/util/subsetp-equal.pcert1 : no_pcert = 0
-centaur/vl/util/subsetp-equal.pcert1 : centaur/vl/util/subsetp-equal.pcert0
-centaur/vl/util/subsetp-equal.cert : | centaur/vl/util/subsetp-equal.pcert1
-
-centaur/vl/util/sum-nats.pcert0 : no_pcert = 0
-centaur/vl/util/sum-nats.pcert0 : acl2x = 0
-centaur/vl/util/sum-nats.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/sum-nats.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/sum-nats.pcert1 : acl2x = 0
-centaur/vl/util/sum-nats.pcert1 : no_pcert = 0
-centaur/vl/util/sum-nats.pcert1 : centaur/vl/util/sum-nats.pcert0
-centaur/vl/util/sum-nats.cert : | centaur/vl/util/sum-nats.pcert1
-
-centaur/vl/util/toposort.pcert0 : no_pcert = 0
-centaur/vl/util/toposort.pcert0 : acl2x = 0
-centaur/vl/util/toposort.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- make-event/assert.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/toposort.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/toposort.pcert1 : acl2x = 0
-centaur/vl/util/toposort.pcert1 : no_pcert = 0
-centaur/vl/util/toposort.pcert1 : centaur/vl/util/toposort.pcert0
-centaur/vl/util/toposort.cert : | centaur/vl/util/toposort.pcert1
-
-centaur/vl/util/warnings.pcert0 : no_pcert = 0
-centaur/vl/util/warnings.pcert0 : acl2x = 0
-centaur/vl/util/warnings.pcert0 : \
- centaur/vl/util/defs.pcert0 \
- defsort/remove-dups.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/util/warnings.lisp \
- centaur/vl/util/cert.acl2
-centaur/vl/util/warnings.pcert1 : acl2x = 0
-centaur/vl/util/warnings.pcert1 : no_pcert = 0
-centaur/vl/util/warnings.pcert1 : centaur/vl/util/warnings.pcert0
-centaur/vl/util/warnings.cert : | centaur/vl/util/warnings.pcert1
-
-centaur/vl/wf-ranges-resolved-p.pcert0 : no_pcert = 0
-centaur/vl/wf-ranges-resolved-p.pcert0 : acl2x = 0
-centaur/vl/wf-ranges-resolved-p.pcert0 : \
- centaur/vl/mlib/range-tools.pcert0 \
- centaur/vl/util/defwellformed.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/wf-ranges-resolved-p.lisp \
- centaur/vl/cert.acl2
-centaur/vl/wf-ranges-resolved-p.pcert1 : acl2x = 0
-centaur/vl/wf-ranges-resolved-p.pcert1 : no_pcert = 0
-centaur/vl/wf-ranges-resolved-p.pcert1 : centaur/vl/wf-ranges-resolved-p.pcert0
-centaur/vl/wf-ranges-resolved-p.cert : | centaur/vl/wf-ranges-resolved-p.pcert1
-
-centaur/vl/wf-reasonable-p.pcert0 : no_pcert = 0
-centaur/vl/wf-reasonable-p.pcert0 : acl2x = 0
-centaur/vl/wf-reasonable-p.pcert0 : \
- centaur/vl/mlib/modnamespace.pcert0 \
- centaur/vl/mlib/find-item.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/util/defwellformed.pcert0 \
- centaur/vl/util/warnings.pcert0 \
- defsort/duplicated-members.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/util/osets.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/wf-reasonable-p.lisp \
- centaur/vl/cert.acl2
-centaur/vl/wf-reasonable-p.pcert1 : acl2x = 0
-centaur/vl/wf-reasonable-p.pcert1 : no_pcert = 0
-centaur/vl/wf-reasonable-p.pcert1 : centaur/vl/wf-reasonable-p.pcert0
-centaur/vl/wf-reasonable-p.cert : | centaur/vl/wf-reasonable-p.pcert1
-
-centaur/vl/wf-widthsfixed-p.pcert0 : no_pcert = 0
-centaur/vl/wf-widthsfixed-p.pcert0 : acl2x = 0
-centaur/vl/wf-widthsfixed-p.pcert0 : \
- centaur/vl/parsetree.pcert0 \
- centaur/vl/mlib/expr-tools.pcert0 \
- centaur/vl/wf-reasonable-p.pcert0 \
- centaur/vl/util/arithmetic.pcert0 \
- centaur/vl/portcullis.pcert0 \
- centaur/vl/wf-widthsfixed-p.lisp \
- centaur/vl/cert.acl2
-centaur/vl/wf-widthsfixed-p.pcert1 : acl2x = 0
-centaur/vl/wf-widthsfixed-p.pcert1 : no_pcert = 0
-centaur/vl/wf-widthsfixed-p.pcert1 : centaur/vl/wf-widthsfixed-p.pcert0
-centaur/vl/wf-widthsfixed-p.cert : | centaur/vl/wf-widthsfixed-p.pcert1
-
-clause-processors/autohide.pcert0 : no_pcert = 0
-clause-processors/autohide.pcert0 : acl2x = 0
-clause-processors/autohide.pcert0 : \
- clause-processors/join-thms.pcert0 \
- tools/flag.pcert0 \
- tools/do-not.pcert0 \
- clause-processors/equality.pcert0 \
- clause-processors/autohide.lisp \
- clause-processors/autohide.acl2 \
- tools/flag-package.lsp
-clause-processors/autohide.pcert1 : acl2x = 0
-clause-processors/autohide.pcert1 : no_pcert = 0
-clause-processors/autohide.pcert1 : clause-processors/autohide.pcert0
-clause-processors/autohide.cert : | clause-processors/autohide.pcert1
-
-clause-processors/basic-examples.pcert0 : no_pcert = 0
-clause-processors/basic-examples.pcert0 : acl2x = 0
-clause-processors/basic-examples.pcert0 : \
- misc/eval.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- clause-processors/basic-examples.lisp \
- clause-processors/basic-examples.acl2
-clause-processors/basic-examples.pcert1 : acl2x = 0
-clause-processors/basic-examples.pcert1 : no_pcert = 0
-clause-processors/basic-examples.pcert1 : clause-processors/basic-examples.pcert0
-clause-processors/basic-examples.cert : | clause-processors/basic-examples.pcert1
-
-clause-processors/bv-add-common.pcert0 : no_pcert = 0
-clause-processors/bv-add-common.pcert0 : acl2x = 0
-clause-processors/bv-add-common.pcert0 : \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- clause-processors/bv-add-common.lisp
-clause-processors/bv-add-common.pcert1 : acl2x = 0
-clause-processors/bv-add-common.pcert1 : no_pcert = 0
-clause-processors/bv-add-common.pcert1 : clause-processors/bv-add-common.pcert0
-clause-processors/bv-add-common.cert : | clause-processors/bv-add-common.pcert1
-
-clause-processors/bv-add-tests.pcert0 : no_pcert = 0
-clause-processors/bv-add-tests.pcert0 : acl2x = 0
-clause-processors/bv-add-tests.pcert0 : \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- clause-processors/bv-add-common.pcert0 \
- clause-processors/bv-add.pcert0 \
- clause-processors/bv-add-tests.lisp
-clause-processors/bv-add-tests.pcert1 : acl2x = 0
-clause-processors/bv-add-tests.pcert1 : no_pcert = 0
-clause-processors/bv-add-tests.pcert1 : clause-processors/bv-add-tests.pcert0
-clause-processors/bv-add-tests.cert : | clause-processors/bv-add-tests.pcert1
-
-clause-processors/bv-add.pcert0 : no_pcert = 0
-clause-processors/bv-add.pcert0 : acl2x = 0
-clause-processors/bv-add.pcert0 : \
- textbook/chap11/perm-append.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- clause-processors/bv-add.lisp
-clause-processors/bv-add.pcert1 : acl2x = 0
-clause-processors/bv-add.pcert1 : no_pcert = 0
-clause-processors/bv-add.pcert1 : clause-processors/bv-add.pcert0
-clause-processors/bv-add.cert : | clause-processors/bv-add.pcert1
-
-clause-processors/decomp-hint.pcert0 : no_pcert = 0
-clause-processors/decomp-hint.pcert0 : acl2x = 0
-clause-processors/decomp-hint.pcert0 : \
- clause-processors/join-thms.pcert0 \
- tools/bstar.pcert0 \
- clause-processors/decomp-hint.lisp
-clause-processors/decomp-hint.pcert1 : acl2x = 0
-clause-processors/decomp-hint.pcert1 : no_pcert = 0
-clause-processors/decomp-hint.pcert1 : clause-processors/decomp-hint.pcert0
-clause-processors/decomp-hint.cert : | clause-processors/decomp-hint.pcert1
-
-clause-processors/equality.pcert0 : no_pcert = 0
-clause-processors/equality.pcert0 : acl2x = 0
-clause-processors/equality.pcert0 : \
- tools/flag.pcert0 \
- misc/eval.pcert0 \
- clause-processors/equality.lisp \
- clause-processors/equality.acl2 \
- tools/flag-package.lsp
-clause-processors/equality.pcert1 : acl2x = 0
-clause-processors/equality.pcert1 : no_pcert = 0
-clause-processors/equality.pcert1 : clause-processors/equality.pcert0
-clause-processors/equality.cert : | clause-processors/equality.pcert1
-
-clause-processors/ev-find-rules.pcert0 : no_pcert = 0
-clause-processors/ev-find-rules.pcert0 : acl2x = 0
-clause-processors/ev-find-rules.pcert0 : \
- clause-processors/ev-find-rules.lisp
-clause-processors/ev-find-rules.pcert1 : acl2x = 0
-clause-processors/ev-find-rules.pcert1 : no_pcert = 0
-clause-processors/ev-find-rules.pcert1 : clause-processors/ev-find-rules.pcert0
-clause-processors/ev-find-rules.cert : | clause-processors/ev-find-rules.pcert1
-
-clause-processors/ev-theoremp.pcert0 : no_pcert = 0
-clause-processors/ev-theoremp.pcert0 : acl2x = 0
-clause-processors/ev-theoremp.pcert0 : \
- clause-processors/join-thms.pcert0 \
- clause-processors/ev-theoremp.lisp
-clause-processors/ev-theoremp.pcert1 : acl2x = 0
-clause-processors/ev-theoremp.pcert1 : no_pcert = 0
-clause-processors/ev-theoremp.pcert1 : clause-processors/ev-theoremp.pcert0
-clause-processors/ev-theoremp.cert : | clause-processors/ev-theoremp.pcert1
-
-clause-processors/find-subterms.pcert0 : no_pcert = 0
-clause-processors/find-subterms.pcert0 : acl2x = 0
-clause-processors/find-subterms.pcert0 : \
- clause-processors/find-subterms.lisp
-clause-processors/find-subterms.pcert1 : acl2x = 0
-clause-processors/find-subterms.pcert1 : no_pcert = 0
-clause-processors/find-subterms.pcert1 : clause-processors/find-subterms.pcert0
-clause-processors/find-subterms.cert : | clause-processors/find-subterms.pcert1
-
-clause-processors/generalize.pcert0 : no_pcert = 0
-clause-processors/generalize.pcert0 : acl2x = 0
-clause-processors/generalize.pcert0 : \
- tools/flag.pcert0 \
- data-structures/list-theory.pcert0 \
- clause-processors/join-thms.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- clause-processors/generalize.lisp \
- clause-processors/generalize.acl2 \
- tools/flag-package.lsp
-clause-processors/generalize.pcert1 : acl2x = 0
-clause-processors/generalize.pcert1 : no_pcert = 0
-clause-processors/generalize.pcert1 : clause-processors/generalize.pcert0
-clause-processors/generalize.cert : | clause-processors/generalize.pcert1
-
-clause-processors/instantiate.pcert0 : no_pcert = 0
-clause-processors/instantiate.pcert0 : acl2x = 0
-clause-processors/instantiate.pcert0 : \
- clause-processors/unify-subst.pcert0 \
- tools/flag.pcert0 \
- tools/bstar.pcert0 \
- clause-processors/instantiate.lisp
-clause-processors/instantiate.pcert1 : acl2x = 0
-clause-processors/instantiate.pcert1 : no_pcert = 0
-clause-processors/instantiate.pcert1 : clause-processors/instantiate.pcert0
-clause-processors/instantiate.cert : | clause-processors/instantiate.pcert1
-
-clause-processors/join-thms.pcert0 : no_pcert = 0
-clause-processors/join-thms.pcert0 : acl2x = 0
-clause-processors/join-thms.pcert0 : \
- clause-processors/ev-find-rules.pcert0 \
- clause-processors/join-thms.lisp
-clause-processors/join-thms.pcert1 : acl2x = 0
-clause-processors/join-thms.pcert1 : no_pcert = 0
-clause-processors/join-thms.pcert1 : clause-processors/join-thms.pcert0
-clause-processors/join-thms.cert : | clause-processors/join-thms.pcert1
-
-clause-processors/just-expand.pcert0 : no_pcert = 0
-clause-processors/just-expand.pcert0 : acl2x = 0
-clause-processors/just-expand.pcert0 : \
- clause-processors/unify-subst.pcert0 \
- tools/bstar.pcert0 \
- clause-processors/ev-theoremp.pcert0 \
- clause-processors/use-by-hint.pcert0 \
- clause-processors/just-expand.lisp
-clause-processors/just-expand.pcert1 : acl2x = 0
-clause-processors/just-expand.pcert1 : no_pcert = 0
-clause-processors/just-expand.pcert1 : clause-processors/just-expand.pcert0
-clause-processors/just-expand.cert : | clause-processors/just-expand.pcert1
-
-clause-processors/meta-extract-simple-test.pcert0 : no_pcert = 0
-clause-processors/meta-extract-simple-test.pcert0 : acl2x = 0
-clause-processors/meta-extract-simple-test.pcert0 : \
- system/meta-extract.pcert0 \
- arithmetic-5/top.pcert0 \
- arithmetic-5/top.pcert0 \
- arithmetic-5/top.pcert0 \
- clause-processors/meta-extract-simple-test.lisp
-clause-processors/meta-extract-simple-test.pcert1 : acl2x = 0
-clause-processors/meta-extract-simple-test.pcert1 : no_pcert = 0
-clause-processors/meta-extract-simple-test.pcert1 : clause-processors/meta-extract-simple-test.pcert0
-clause-processors/meta-extract-simple-test.cert : | clause-processors/meta-extract-simple-test.pcert1
-
-clause-processors/meta-extract-user.pcert0 : no_pcert = 0
-clause-processors/meta-extract-user.pcert0 : acl2x = 0
-clause-processors/meta-extract-user.pcert0 : \
- tools/defevaluator-fast.pcert0 \
- clause-processors/ev-theoremp.pcert0 \
- tools/def-functional-instance.pcert0 \
- system/sublis-var.pcert0 \
- system/meta-extract.pcert0 \
- clause-processors/meta-extract-user.lisp
-clause-processors/meta-extract-user.pcert1 : acl2x = 0
-clause-processors/meta-extract-user.pcert1 : no_pcert = 0
-clause-processors/meta-extract-user.pcert1 : clause-processors/meta-extract-user.pcert0
-clause-processors/meta-extract-user.cert : | clause-processors/meta-extract-user.pcert1
-
-clause-processors/multi-env-trick.pcert0 : no_pcert = 0
-clause-processors/multi-env-trick.pcert0 : acl2x = 0
-clause-processors/multi-env-trick.pcert0 : \
- clause-processors/join-thms.pcert0 \
- misc/untranslate-patterns.pcert0 \
- clause-processors/multi-env-trick.lisp
-clause-processors/multi-env-trick.pcert1 : acl2x = 0
-clause-processors/multi-env-trick.pcert1 : no_pcert = 0
-clause-processors/multi-env-trick.pcert1 : clause-processors/multi-env-trick.pcert0
-clause-processors/multi-env-trick.cert : | clause-processors/multi-env-trick.pcert1
-
-clause-processors/null-fail-hints.pcert0 : no_pcert = 0
-clause-processors/null-fail-hints.pcert0 : acl2x = 0
-clause-processors/null-fail-hints.pcert0 : \
- clause-processors/join-thms.pcert0 \
- clause-processors/null-fail-hints.lisp
-clause-processors/null-fail-hints.pcert1 : acl2x = 0
-clause-processors/null-fail-hints.pcert1 : no_pcert = 0
-clause-processors/null-fail-hints.pcert1 : clause-processors/null-fail-hints.pcert0
-clause-processors/null-fail-hints.cert : | clause-processors/null-fail-hints.pcert1
-
-clause-processors/nvalues-thms.pcert0 : no_pcert = 0
-clause-processors/nvalues-thms.pcert0 : acl2x = 0
-clause-processors/nvalues-thms.pcert0 : \
- tools/bstar.pcert0 \
- tools/mv-nth.pcert0 \
- clause-processors/multi-env-trick.pcert0 \
- clause-processors/join-thms.pcert0 \
- tools/flag.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- clause-processors/nvalues-thms.lisp
-clause-processors/nvalues-thms.pcert1 : acl2x = 0
-clause-processors/nvalues-thms.pcert1 : no_pcert = 0
-clause-processors/nvalues-thms.pcert1 : clause-processors/nvalues-thms.pcert0
-clause-processors/nvalues-thms.cert : | clause-processors/nvalues-thms.pcert1
-
-clause-processors/replace-defined-consts.pcert0 : no_pcert = 0
-clause-processors/replace-defined-consts.pcert0 : acl2x = 0
-clause-processors/replace-defined-consts.pcert0 : \
- clause-processors/use-by-hint.pcert0 \
- clause-processors/multi-env-trick.pcert0 \
- tools/bstar.pcert0 \
- tools/flag.pcert0 \
- tools/mv-nth.pcert0 \
- clause-processors/replace-defined-consts.lisp \
- clause-processors/replace-defined-consts.acl2 \
- tools/flag-package.lsp
-clause-processors/replace-defined-consts.pcert1 : acl2x = 0
-clause-processors/replace-defined-consts.pcert1 : no_pcert = 0
-clause-processors/replace-defined-consts.pcert1 : clause-processors/replace-defined-consts.pcert0
-clause-processors/replace-defined-consts.cert : | clause-processors/replace-defined-consts.pcert1
-
-clause-processors/replace-impl.pcert0 : no_pcert = 0
-clause-processors/replace-impl.pcert0 : acl2x = 0
-clause-processors/replace-impl.pcert0 : \
- clause-processors/replace-impl.lisp
-clause-processors/replace-impl.pcert1 : acl2x = 0
-clause-processors/replace-impl.pcert1 : no_pcert = 0
-clause-processors/replace-impl.pcert1 : clause-processors/replace-impl.pcert0
-clause-processors/replace-impl.cert : | clause-processors/replace-impl.pcert1
-
-clause-processors/stobj-preservation.pcert0 : no_pcert = 0
-clause-processors/stobj-preservation.pcert0 : acl2x = 0
-clause-processors/stobj-preservation.pcert0 : \
- xdoc/top.pcert0 \
- clause-processors/just-expand.pcert0 \
- clause-processors/stobj-preservation.lisp
-clause-processors/stobj-preservation.pcert1 : acl2x = 0
-clause-processors/stobj-preservation.pcert1 : no_pcert = 0
-clause-processors/stobj-preservation.pcert1 : clause-processors/stobj-preservation.pcert0
-clause-processors/stobj-preservation.cert : | clause-processors/stobj-preservation.pcert1
-
-clause-processors/sublis-var-meaning.pcert0 : no_pcert = 0
-clause-processors/sublis-var-meaning.pcert0 : acl2x = 0
-clause-processors/sublis-var-meaning.pcert0 : \
- system/sublis-var.pcert0 \
- tools/flag.pcert0 \
- tools/mv-nth.pcert0 \
- tools/defevaluator-fast.pcert0 \
- clause-processors/sublis-var-meaning.lisp
-clause-processors/sublis-var-meaning.pcert1 : acl2x = 0
-clause-processors/sublis-var-meaning.pcert1 : no_pcert = 0
-clause-processors/sublis-var-meaning.pcert1 : clause-processors/sublis-var-meaning.pcert0
-clause-processors/sublis-var-meaning.cert : | clause-processors/sublis-var-meaning.pcert1
-
-clause-processors/term-patterns.pcert0 : no_pcert = 0
-clause-processors/term-patterns.pcert0 : acl2x = 0
-clause-processors/term-patterns.pcert0 : \
- tools/flag.pcert0 \
- tools/flag.pcert0 \
- clause-processors/term-patterns.lisp \
- clause-processors/term-patterns.acl2
-clause-processors/term-patterns.pcert1 : acl2x = 0
-clause-processors/term-patterns.pcert1 : no_pcert = 0
-clause-processors/term-patterns.pcert1 : clause-processors/term-patterns.pcert0
-clause-processors/term-patterns.cert : | clause-processors/term-patterns.pcert1
-
-clause-processors/unify-subst.pcert0 : no_pcert = 0
-clause-processors/unify-subst.pcert0 : acl2x = 0
-clause-processors/unify-subst.pcert0 : \
- tools/flag.pcert0 \
- tools/bstar.pcert0 \
- tools/mv-nth.pcert0 \
- tools/def-functional-instance.pcert0 \
- clause-processors/ev-find-rules.pcert0 \
- clause-processors/unify-subst.lisp \
- clause-processors/unify-subst.acl2 \
- tools/flag-package.lsp
-clause-processors/unify-subst.pcert1 : acl2x = 0
-clause-processors/unify-subst.pcert1 : no_pcert = 0
-clause-processors/unify-subst.pcert1 : clause-processors/unify-subst.pcert0
-clause-processors/unify-subst.cert : | clause-processors/unify-subst.pcert1
-
-clause-processors/use-by-hint.pcert0 : no_pcert = 0
-clause-processors/use-by-hint.pcert0 : acl2x = 0
-clause-processors/use-by-hint.pcert0 : \
- clause-processors/join-thms.pcert0 \
- clause-processors/use-by-hint.lisp
-clause-processors/use-by-hint.pcert1 : acl2x = 0
-clause-processors/use-by-hint.pcert1 : no_pcert = 0
-clause-processors/use-by-hint.pcert1 : clause-processors/use-by-hint.pcert0
-clause-processors/use-by-hint.cert : | clause-processors/use-by-hint.pcert1
-
-clause-processors/witness-cp.pcert0 : no_pcert = 0
-clause-processors/witness-cp.pcert0 : acl2x = 0
-clause-processors/witness-cp.pcert0 : \
- clause-processors/use-by-hint.pcert0 \
- clause-processors/generalize.pcert0 \
- clause-processors/unify-subst.pcert0 \
- tools/bstar.pcert0 \
- clause-processors/ev-theoremp.pcert0 \
- tools/def-functional-instance.pcert0 \
- tools/oracle-eval.pcert0 \
- data-structures/no-duplicates.pcert0 \
- clause-processors/witness-cp.lisp \
- clause-processors/witness-cp.acl2 \
- tools/flag-package.lsp
-clause-processors/witness-cp.pcert1 : acl2x = 0
-clause-processors/witness-cp.pcert1 : no_pcert = 0
-clause-processors/witness-cp.pcert1 : clause-processors/witness-cp.pcert0
-clause-processors/witness-cp.cert : | clause-processors/witness-cp.pcert1
-
-coi/adviser/adviser-pkg.pcert0 : no_pcert = 0
-coi/adviser/adviser-pkg.pcert0 : acl2x = 0
-coi/adviser/adviser-pkg.pcert0 : \
- coi/adviser/adviser-pkg.lisp \
- coi/adviser/cert.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/adviser/adviser-pkg.pcert1 : acl2x = 0
-coi/adviser/adviser-pkg.pcert1 : no_pcert = 0
-coi/adviser/adviser-pkg.pcert1 : coi/adviser/adviser-pkg.pcert0
-coi/adviser/adviser-pkg.cert : | coi/adviser/adviser-pkg.pcert1
-
-coi/adviser/adviser.pcert0 : no_pcert = 0
-coi/adviser/adviser.pcert0 : acl2x = 0
-coi/adviser/adviser.pcert0 : \
- misc/symbol-btree.pcert0 \
- coi/symbol-fns/symbol-fns.pcert0 \
- coi/adviser/adviser.lisp \
- coi/adviser/cert.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/adviser/adviser.pcert1 : acl2x = 0
-coi/adviser/adviser.pcert1 : no_pcert = 0
-coi/adviser/adviser.pcert1 : coi/adviser/adviser.pcert0
-coi/adviser/adviser.cert : | coi/adviser/adviser.pcert1
-
-coi/adviser/test.pcert0 : no_pcert = 0
-coi/adviser/test.pcert0 : acl2x = 0
-coi/adviser/test.pcert0 : \
- coi/adviser/adviser.pcert0 \
- coi/adviser/test.lisp \
- coi/adviser/cert.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/adviser/test.pcert1 : acl2x = 0
-coi/adviser/test.pcert1 : no_pcert = 0
-coi/adviser/test.pcert1 : coi/adviser/test.pcert0
-coi/adviser/test.cert : | coi/adviser/test.pcert1
-
-coi/alists/alist-pkg.pcert0 : no_pcert = 0
-coi/alists/alist-pkg.pcert0 : acl2x = 0
-coi/alists/alist-pkg.pcert0 : \
- coi/alists/alist-pkg.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/alists/alist-pkg.pcert1 : acl2x = 0
-coi/alists/alist-pkg.pcert1 : no_pcert = 0
-coi/alists/alist-pkg.pcert1 : coi/alists/alist-pkg.pcert0
-coi/alists/alist-pkg.cert : | coi/alists/alist-pkg.pcert1
-
-coi/alists/bindequiv.pcert0 : no_pcert = 0
-coi/alists/bindequiv.pcert0 : acl2x = 0
-coi/alists/bindequiv.pcert0 : \
- coi/util/mv-nth.pcert0 \
- coi/nary/nary.pcert0 \
- coi/util/good-rewrite-order.pcert0 \
- coi/alists/keyquiv.pcert0 \
- coi/bags/top.pcert0 \
- misc/total-order.pcert0 \
- coi/alists/bindequiv.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/alists/bindequiv.pcert1 : acl2x = 0
-coi/alists/bindequiv.pcert1 : no_pcert = 0
-coi/alists/bindequiv.pcert1 : coi/alists/bindequiv.pcert0
-coi/alists/bindequiv.cert : | coi/alists/bindequiv.pcert1
-
-coi/alists/clearkey.pcert0 : no_pcert = 0
-coi/alists/clearkey.pcert0 : acl2x = 0
-coi/alists/clearkey.pcert0 : \
- coi/alists/equiv.pcert0 \
- coi/bags/basic.pcert0 \
- coi/alists/clearkey.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/alists/clearkey.pcert1 : acl2x = 0
-coi/alists/clearkey.pcert1 : no_pcert = 0
-coi/alists/clearkey.pcert1 : coi/alists/clearkey.pcert0
-coi/alists/clearkey.cert : | coi/alists/clearkey.pcert1
-
-coi/alists/deshadow.pcert0 : no_pcert = 0
-coi/alists/deshadow.pcert0 : acl2x = 0
-coi/alists/deshadow.pcert0 : \
- coi/alists/strip.pcert0 \
- coi/alists/clearkey.pcert0 \
- coi/bags/basic.pcert0 \
- coi/util/iff.pcert0 \
- coi/bags/pick-a-point.pcert0 \
- coi/alists/deshadow.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/alists/deshadow.pcert1 : acl2x = 0
-coi/alists/deshadow.pcert1 : no_pcert = 0
-coi/alists/deshadow.pcert1 : coi/alists/deshadow.pcert0
-coi/alists/deshadow.cert : | coi/alists/deshadow.pcert1
-
-coi/alists/equiv.pcert0 : no_pcert = 0
-coi/alists/equiv.pcert0 : acl2x = 0
-coi/alists/equiv.pcert0 : \
- coi/lists/basic.pcert0 \
- coi/util/iff.pcert0 \
- coi/alists/equiv.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/alists/equiv.pcert1 : acl2x = 0
-coi/alists/equiv.pcert1 : no_pcert = 0
-coi/alists/equiv.pcert1 : coi/alists/equiv.pcert0
-coi/alists/equiv.cert : | coi/alists/equiv.pcert1
-
-coi/alists/keyquiv.pcert0 : no_pcert = 0
-coi/alists/keyquiv.pcert0 : acl2x = 0
-coi/alists/keyquiv.pcert0 : \
- coi/util/iff.pcert0 \
- coi/lists/basic.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/lists/set.pcert0 \
- coi/util/good-rewrite-order.pcert0 \
- coi/alists/equiv.pcert0 \
- coi/util/iff.pcert0 \
- coi/lists/remove-induction.pcert0 \
- coi/lists/remove.pcert0 \
- coi/alists/keyquiv.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/alists/keyquiv.pcert1 : acl2x = 0
-coi/alists/keyquiv.pcert1 : no_pcert = 0
-coi/alists/keyquiv.pcert1 : coi/alists/keyquiv.pcert0
-coi/alists/keyquiv.cert : | coi/alists/keyquiv.pcert1
-
-coi/alists/preimage.pcert0 : no_pcert = 0
-coi/alists/preimage.pcert0 : acl2x = 0
-coi/alists/preimage.pcert0 : \
- coi/alists/deshadow.pcert0 \
- coi/alists/strip.pcert0 \
- coi/alists/preimage.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/alists/preimage.pcert1 : acl2x = 0
-coi/alists/preimage.pcert1 : no_pcert = 0
-coi/alists/preimage.pcert1 : coi/alists/preimage.pcert0
-coi/alists/preimage.cert : | coi/alists/preimage.pcert1
-
-coi/alists/strip.pcert0 : no_pcert = 0
-coi/alists/strip.pcert0 : acl2x = 0
-coi/alists/strip.pcert0 : \
- coi/alists/equiv.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/util/iff.pcert0 \
- coi/alists/strip.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/alists/strip.pcert1 : acl2x = 0
-coi/alists/strip.pcert1 : no_pcert = 0
-coi/alists/strip.pcert1 : coi/alists/strip.pcert0
-coi/alists/strip.cert : | coi/alists/strip.pcert1
-
-coi/alists/subkeyquiv.pcert0 : no_pcert = 0
-coi/alists/subkeyquiv.pcert0 : acl2x = 0
-coi/alists/subkeyquiv.pcert0 : \
- coi/lists/set.pcert0 \
- coi/alists/keyquiv.pcert0 \
- coi/util/good-rewrite-order.pcert0 \
- coi/nary/nary.pcert0 \
- coi/alists/subkeyquiv.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/alists/subkeyquiv.pcert1 : acl2x = 0
-coi/alists/subkeyquiv.pcert1 : no_pcert = 0
-coi/alists/subkeyquiv.pcert1 : coi/alists/subkeyquiv.pcert0
-coi/alists/subkeyquiv.cert : | coi/alists/subkeyquiv.pcert1
-
-coi/alists/top.pcert0 : no_pcert = 0
-coi/alists/top.pcert0 : acl2x = 0
-coi/alists/top.pcert0 : \
- coi/alists/equiv.pcert0 \
- coi/alists/strip.pcert0 \
- coi/alists/clearkey.pcert0 \
- coi/alists/deshadow.pcert0 \
- coi/alists/preimage.pcert0 \
- coi/alists/top.lisp \
- coi/alists/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/alists/top.pcert1 : acl2x = 0
-coi/alists/top.pcert1 : no_pcert = 0
-coi/alists/top.pcert1 : coi/alists/top.pcert0
-coi/alists/top.cert : | coi/alists/top.pcert1
-
-coi/bags/basic.pcert0 : no_pcert = 0
-coi/bags/basic.pcert0 : acl2x = 0
-coi/bags/basic.pcert0 : \
- coi/lists/basic.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/lists/disjoint.pcert0 \
- coi/bags/basic.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/bags/basic.pcert1 : acl2x = 0
-coi/bags/basic.pcert1 : no_pcert = 0
-coi/bags/basic.pcert1 : coi/bags/basic.pcert0
-coi/bags/basic.cert : | coi/bags/basic.pcert1
-
-coi/bags/bind-free-rules.pcert0 : no_pcert = 0
-coi/bags/bind-free-rules.pcert0 : acl2x = 0
-coi/bags/bind-free-rules.pcert0 : \
- coi/bags/meta.pcert0 \
- coi/bags/bind-free-rules.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/bags/bind-free-rules.pcert1 : acl2x = 0
-coi/bags/bind-free-rules.pcert1 : no_pcert = 0
-coi/bags/bind-free-rules.pcert1 : coi/bags/bind-free-rules.pcert0
-coi/bags/bind-free-rules.cert : | coi/bags/bind-free-rules.pcert1
-
-coi/bags/cons.pcert0 : no_pcert = 0
-coi/bags/cons.pcert0 : acl2x = 0
-coi/bags/cons.pcert0 : \
- coi/syntax/syntax.pcert0 \
- coi/bags/cons.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/bags/cons.pcert1 : acl2x = 0
-coi/bags/cons.pcert1 : no_pcert = 0
-coi/bags/cons.pcert1 : coi/bags/cons.pcert0
-coi/bags/cons.cert : | coi/bags/cons.pcert1
-
-coi/bags/eric-meta.pcert0 : no_pcert = 0
-coi/bags/eric-meta.pcert0 : acl2x = 0
-coi/bags/eric-meta.pcert0 : \
- coi/bags/bind-free-rules.pcert0 \
- coi/util/iff.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- coi/bags/eric-meta.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/bags/eric-meta.pcert1 : acl2x = 0
-coi/bags/eric-meta.pcert1 : no_pcert = 0
-coi/bags/eric-meta.pcert1 : coi/bags/eric-meta.pcert0
-coi/bags/eric-meta.cert : | coi/bags/eric-meta.pcert1
-
-coi/bags/extras.pcert0 : no_pcert = 0
-coi/bags/extras.pcert0 : acl2x = 0
-coi/bags/extras.pcert0 : \
- coi/bags/basic.pcert0 \
- coi/lists/find-index.pcert0 \
- coi/bags/extras.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/bags/extras.pcert1 : acl2x = 0
-coi/bags/extras.pcert1 : no_pcert = 0
-coi/bags/extras.pcert1 : coi/bags/extras.pcert0
-coi/bags/extras.cert : | coi/bags/extras.pcert1
-
-coi/bags/meta.pcert0 : no_pcert = 0
-coi/bags/meta.pcert0 : acl2x = 0
-coi/bags/meta.pcert0 : \
- coi/bags/basic.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- coi/util/mv-nth.pcert0 \
- coi/util/iff.pcert0 \
- coi/syntax/syntax.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/bags/meta.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/bags/meta.pcert1 : acl2x = 0
-coi/bags/meta.pcert1 : no_pcert = 0
-coi/bags/meta.pcert1 : coi/bags/meta.pcert0
-coi/bags/meta.cert : | coi/bags/meta.pcert1
-
-coi/bags/neq.pcert0 : no_pcert = 0
-coi/bags/neq.pcert0 : acl2x = 0
-coi/bags/neq.pcert0 : \
- coi/bags/bind-free-rules.pcert0 \
- coi/bags/neq.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/bags/neq.pcert1 : acl2x = 0
-coi/bags/neq.pcert1 : no_pcert = 0
-coi/bags/neq.pcert1 : coi/bags/neq.pcert0
-coi/bags/neq.cert : | coi/bags/neq.pcert1
-
-coi/bags/pick-a-point.pcert0 : no_pcert = 0
-coi/bags/pick-a-point.pcert0 : acl2x = 0
-coi/bags/pick-a-point.pcert0 : \
- coi/bags/basic.pcert0 \
- coi/adviser/adviser.pcert0 \
- coi/bags/pick-a-point.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/bags/pick-a-point.pcert1 : acl2x = 0
-coi/bags/pick-a-point.pcert1 : no_pcert = 0
-coi/bags/pick-a-point.pcert1 : coi/bags/pick-a-point.pcert0
-coi/bags/pick-a-point.cert : | coi/bags/pick-a-point.pcert1
-
-coi/bags/top.pcert0 : no_pcert = 0
-coi/bags/top.pcert0 : acl2x = 0
-coi/bags/top.pcert0 : \
- coi/bags/bind-free-rules.pcert0 \
- coi/bags/cons.pcert0 \
- coi/bags/neq.pcert0 \
- coi/bags/eric-meta.pcert0 \
- coi/bags/top.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/bags/top.pcert1 : acl2x = 0
-coi/bags/top.pcert1 : no_pcert = 0
-coi/bags/top.pcert1 : coi/bags/top.pcert0
-coi/bags/top.cert : | coi/bags/top.pcert1
-
-coi/bags/two-level-meta.pcert0 : no_pcert = 0
-coi/bags/two-level-meta.pcert0 : acl2x = 0
-coi/bags/two-level-meta.pcert0 : \
- coi/bags/two-level.pcert0 \
- coi/bags/two-level-meta.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/bags/two-level-meta.pcert1 : acl2x = 0
-coi/bags/two-level-meta.pcert1 : no_pcert = 0
-coi/bags/two-level-meta.pcert1 : coi/bags/two-level-meta.pcert0
-coi/bags/two-level-meta.cert : | coi/bags/two-level-meta.pcert1
-
-coi/bags/two-level.pcert0 : no_pcert = 0
-coi/bags/two-level.pcert0 : acl2x = 0
-coi/bags/two-level.pcert0 : \
- coi/bags/bind-free-rules.pcert0 \
- coi/bags/two-level.lisp \
- coi/bags/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/bags/two-level.pcert1 : acl2x = 0
-coi/bags/two-level.pcert1 : no_pcert = 0
-coi/bags/two-level.pcert1 : coi/bags/two-level.pcert0
-coi/bags/two-level.cert : | coi/bags/two-level.pcert1
-
-coi/defpun/ack.pcert0 : no_pcert = 0
-coi/defpun/ack.pcert0 : acl2x = 0
-coi/defpun/ack.pcert0 : \
- coi/defpun/defminterm.pcert0 \
- coi/defpun/ack.lisp
-coi/defpun/ack.pcert1 : acl2x = 0
-coi/defpun/ack.pcert1 : no_pcert = 0
-coi/defpun/ack.pcert1 : coi/defpun/ack.pcert0
-coi/defpun/ack.cert : | coi/defpun/ack.pcert1
-
-coi/defpun/defminterm.pcert0 : no_pcert = 0
-coi/defpun/defminterm.pcert0 : acl2x = 0
-coi/defpun/defminterm.pcert0 : \
- coi/defpun/defxch.pcert0 \
- coi/defpun/defpun.pcert0 \
- coi/defpun/defminterm.lisp
-coi/defpun/defminterm.pcert1 : acl2x = 0
-coi/defpun/defminterm.pcert1 : no_pcert = 0
-coi/defpun/defminterm.pcert1 : coi/defpun/defminterm.pcert0
-coi/defpun/defminterm.cert : | coi/defpun/defminterm.pcert1
-
-coi/defpun/defpun.pcert0 : no_pcert = 0
-coi/defpun/defpun.pcert0 : acl2x = 0
-coi/defpun/defpun.pcert0 : \
- coi/defpun/defpun.lisp
-coi/defpun/defpun.pcert1 : acl2x = 0
-coi/defpun/defpun.pcert1 : no_pcert = 0
-coi/defpun/defpun.pcert1 : coi/defpun/defpun.pcert0
-coi/defpun/defpun.cert : | coi/defpun/defpun.pcert1
-
-coi/defpun/defxch.pcert0 : no_pcert = 0
-coi/defpun/defxch.pcert0 : acl2x = 0
-coi/defpun/defxch.pcert0 : \
- arithmetic-2/meta/top.pcert0 \
- misc/defpun.pcert0 \
- coi/defpun/defxch.lisp
-coi/defpun/defxch.pcert1 : acl2x = 0
-coi/defpun/defxch.pcert1 : no_pcert = 0
-coi/defpun/defxch.pcert1 : coi/defpun/defxch.pcert0
-coi/defpun/defxch.cert : | coi/defpun/defxch.pcert1
-
-coi/defstructure/defstructure-pkg.pcert0 : no_pcert = 0
-coi/defstructure/defstructure-pkg.pcert0 : acl2x = 0
-coi/defstructure/defstructure-pkg.pcert0 : \
- coi/defstructure/defstructure-pkg.lisp \
- coi/defstructure/cert.acl2 \
- coi/defstructure/structures-defpkg.lsp \
- coi/symbol-fns/symbol-fns-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/define-u-package.lsp
-coi/defstructure/defstructure-pkg.pcert1 : acl2x = 0
-coi/defstructure/defstructure-pkg.pcert1 : no_pcert = 0
-coi/defstructure/defstructure-pkg.pcert1 : coi/defstructure/defstructure-pkg.pcert0
-coi/defstructure/defstructure-pkg.cert : | coi/defstructure/defstructure-pkg.pcert1
-
-coi/defstructure/defstructure.pcert0 : no_pcert = 0
-coi/defstructure/defstructure.pcert0 : acl2x = 0
-coi/defstructure/defstructure.pcert0 : \
- coi/paths/path.pcert0 \
- data-structures/utilities.pcert0 \
- coi/defstructure/defstructure.lisp \
- coi/defstructure/cert.acl2 \
- coi/defstructure/structures-defpkg.lsp \
- coi/symbol-fns/symbol-fns-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/define-u-package.lsp
-coi/defstructure/defstructure.pcert1 : acl2x = 0
-coi/defstructure/defstructure.pcert1 : no_pcert = 0
-coi/defstructure/defstructure.pcert1 : coi/defstructure/defstructure.pcert0
-coi/defstructure/defstructure.cert : | coi/defstructure/defstructure.pcert1
-
-coi/dtrees/base.pcert0 : no_pcert = 0
-coi/dtrees/base.pcert0 : acl2x = 0
-coi/dtrees/base.pcert0 : \
- coi/util/iff.pcert0 \
- coi/maps/maps.pcert0 \
- coi/lists/basic.pcert0 \
- coi/osets/multicons.pcert0 \
- coi/maps/typed-maps.pcert0 \
- coi/dtrees/base.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/dtrees/base.pcert1 : acl2x = 0
-coi/dtrees/base.pcert1 : no_pcert = 0
-coi/dtrees/base.pcert1 : coi/dtrees/base.pcert0
-coi/dtrees/base.cert : | coi/dtrees/base.pcert1
-
-coi/dtrees/child.pcert0 : no_pcert = 0
-coi/dtrees/child.pcert0 : acl2x = 0
-coi/dtrees/child.pcert0 : \
- coi/dtrees/raw.pcert0 \
- coi/dtrees/set.pcert0 \
- coi/dtrees/erase.pcert0 \
- coi/dtrees/child.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/dtrees/child.pcert1 : acl2x = 0
-coi/dtrees/child.pcert1 : no_pcert = 0
-coi/dtrees/child.pcert1 : coi/dtrees/child.pcert0
-coi/dtrees/child.cert : | coi/dtrees/child.pcert1
-
-coi/dtrees/deps.pcert0 : no_pcert = 0
-coi/dtrees/deps.pcert0 : acl2x = 0
-coi/dtrees/deps.pcert0 : \
- coi/dtrees/base.pcert0 \
- coi/dtrees/deps.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/dtrees/deps.pcert1 : acl2x = 0
-coi/dtrees/deps.pcert1 : no_pcert = 0
-coi/dtrees/deps.pcert1 : coi/dtrees/deps.pcert0
-coi/dtrees/deps.cert : | coi/dtrees/deps.pcert1
-
-coi/dtrees/equiv.pcert0 : no_pcert = 0
-coi/dtrees/equiv.pcert0 : acl2x = 0
-coi/dtrees/equiv.pcert0 : \
- coi/dtrees/deps.pcert0 \
- coi/dtrees/equiv.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/dtrees/equiv.pcert1 : acl2x = 0
-coi/dtrees/equiv.pcert1 : no_pcert = 0
-coi/dtrees/equiv.pcert1 : coi/dtrees/equiv.pcert0
-coi/dtrees/equiv.cert : | coi/dtrees/equiv.pcert1
-
-coi/dtrees/erase.pcert0 : no_pcert = 0
-coi/dtrees/erase.pcert0 : acl2x = 0
-coi/dtrees/erase.pcert0 : \
- coi/dtrees/set.pcert0 \
- coi/paths/dominates.pcert0 \
- coi/paths/diverge.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/dtrees/erase.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/dtrees/erase.pcert1 : acl2x = 0
-coi/dtrees/erase.pcert1 : no_pcert = 0
-coi/dtrees/erase.pcert1 : coi/dtrees/erase.pcert0
-coi/dtrees/erase.cert : | coi/dtrees/erase.pcert1
-
-coi/dtrees/leafp.pcert0 : no_pcert = 0
-coi/dtrees/leafp.pcert0 : acl2x = 0
-coi/dtrees/leafp.pcert0 : \
- coi/dtrees/equiv.pcert0 \
- coi/paths/dominates.pcert0 \
- coi/paths/diverge.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/dtrees/leafp.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/dtrees/leafp.pcert1 : acl2x = 0
-coi/dtrees/leafp.pcert1 : no_pcert = 0
-coi/dtrees/leafp.pcert1 : coi/dtrees/leafp.pcert0
-coi/dtrees/leafp.cert : | coi/dtrees/leafp.pcert1
-
-coi/dtrees/raw.pcert0 : no_pcert = 0
-coi/dtrees/raw.pcert0 : acl2x = 0
-coi/dtrees/raw.pcert0 : \
- coi/dtrees/equiv.pcert0 \
- coi/dtrees/raw.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/dtrees/raw.pcert1 : acl2x = 0
-coi/dtrees/raw.pcert1 : no_pcert = 0
-coi/dtrees/raw.pcert1 : coi/dtrees/raw.pcert0
-coi/dtrees/raw.cert : | coi/dtrees/raw.pcert1
-
-coi/dtrees/royalp.pcert0 : no_pcert = 0
-coi/dtrees/royalp.pcert0 : acl2x = 0
-coi/dtrees/royalp.pcert0 : \
- coi/dtrees/equiv.pcert0 \
- coi/paths/dominates.pcert0 \
- coi/paths/diverge.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/dtrees/royalp.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/dtrees/royalp.pcert1 : acl2x = 0
-coi/dtrees/royalp.pcert1 : no_pcert = 0
-coi/dtrees/royalp.pcert1 : coi/dtrees/royalp.pcert0
-coi/dtrees/royalp.cert : | coi/dtrees/royalp.pcert1
-
-coi/dtrees/set.pcert0 : no_pcert = 0
-coi/dtrees/set.pcert0 : acl2x = 0
-coi/dtrees/set.pcert0 : \
- coi/dtrees/raw.pcert0 \
- coi/paths/dominates.pcert0 \
- coi/paths/diverge.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/dtrees/set.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/dtrees/set.pcert1 : acl2x = 0
-coi/dtrees/set.pcert1 : no_pcert = 0
-coi/dtrees/set.pcert1 : coi/dtrees/set.pcert0
-coi/dtrees/set.cert : | coi/dtrees/set.pcert1
-
-coi/dtrees/top.pcert0 : no_pcert = 0
-coi/dtrees/top.pcert0 : acl2x = 0
-coi/dtrees/top.pcert0 : \
- coi/dtrees/base.pcert0 \
- coi/dtrees/deps.pcert0 \
- coi/dtrees/equiv.pcert0 \
- coi/dtrees/raw.pcert0 \
- coi/dtrees/set.pcert0 \
- coi/dtrees/erase.pcert0 \
- coi/dtrees/leafp.pcert0 \
- coi/dtrees/royalp.pcert0 \
- coi/dtrees/child.pcert0 \
- coi/dtrees/top.lisp \
- coi/dtrees/cert.acl2 \
- coi/dtrees/dtree-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/maps/map-exports.lsp \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/dtrees/top.pcert1 : acl2x = 0
-coi/dtrees/top.pcert1 : no_pcert = 0
-coi/dtrees/top.pcert1 : coi/dtrees/top.pcert0
-coi/dtrees/top.cert : | coi/dtrees/top.pcert1
-
-coi/gacc/abstract-gacc.pcert0 : no_pcert = 0
-coi/gacc/abstract-gacc.pcert0 : acl2x = 0
-coi/gacc/abstract-gacc.pcert0 : \
- coi/records/defrecord.pcert0 \
- coi/gacc/abstract-gacc.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/abstract-gacc.pcert1 : acl2x = 0
-coi/gacc/abstract-gacc.pcert1 : no_pcert = 0
-coi/gacc/abstract-gacc.pcert1 : coi/gacc/abstract-gacc.pcert0
-coi/gacc/abstract-gacc.cert : | coi/gacc/abstract-gacc.pcert1
-
-coi/gacc/addr-range.pcert0 : no_pcert = 0
-coi/gacc/addr-range.pcert0 : acl2x = 0
-coi/gacc/addr-range.pcert0 : \
- coi/bags/basic.pcert0 \
- coi/gacc/addr-range.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/addr-range.pcert1 : acl2x = 0
-coi/gacc/addr-range.pcert1 : no_pcert = 0
-coi/gacc/addr-range.pcert1 : coi/gacc/addr-range.pcert0
-coi/gacc/addr-range.cert : | coi/gacc/addr-range.pcert1
-
-coi/gacc/bits.pcert0 : no_pcert = 0
-coi/gacc/bits.pcert0 : acl2x = 0
-coi/gacc/bits.pcert0 : \
- coi/super-ihs/super-ihs.pcert0 \
- coi/gacc/bits.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/bits.pcert1 : acl2x = 0
-coi/gacc/bits.pcert1 : no_pcert = 0
-coi/gacc/bits.pcert1 : coi/gacc/bits.pcert0
-coi/gacc/bits.cert : | coi/gacc/bits.pcert1
-
-coi/gacc/block.pcert0 : no_pcert = 0
-coi/gacc/block.pcert0 : acl2x = 0
-coi/gacc/block.pcert0 : \
- coi/bags/basic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/gacc/block.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/block.pcert1 : acl2x = 0
-coi/gacc/block.pcert1 : no_pcert = 0
-coi/gacc/block.pcert1 : coi/gacc/block.pcert0
-coi/gacc/block.cert : | coi/gacc/block.pcert1
-
-coi/gacc/finite.pcert0 : no_pcert = 0
-coi/gacc/finite.pcert0 : acl2x = 0
-coi/gacc/finite.pcert0 : \
- coi/gacc/gax.pcert0 \
- coi/gacc/gax.pcert0 \
- coi/gacc/finite.lisp \
- coi/gacc/finite.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/finite.pcert1 : acl2x = 0
-coi/gacc/finite.pcert1 : no_pcert = 0
-coi/gacc/finite.pcert1 : coi/gacc/finite.pcert0
-coi/gacc/finite.cert : | coi/gacc/finite.pcert1
-
-coi/gacc/fr-path-connection.pcert0 : no_pcert = 0
-coi/gacc/fr-path-connection.pcert0 : acl2x = 0
-coi/gacc/fr-path-connection.pcert0 : \
- coi/gacc/mem-fast.pcert0 \
- coi/paths/path.pcert0 \
- coi/records/mem-domain.pcert0 \
- coi/osets/extras.pcert0 \
- coi/paths/path.pcert0 \
- coi/gacc/fr-path-connection.lisp \
- coi/gacc/fr-path-connection.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/fr-path-connection.pcert1 : acl2x = 0
-coi/gacc/fr-path-connection.pcert1 : no_pcert = 0
-coi/gacc/fr-path-connection.pcert1 : coi/gacc/fr-path-connection.pcert0
-coi/gacc/fr-path-connection.cert : | coi/gacc/fr-path-connection.pcert1
-
-coi/gacc/gacc-exports.pcert0 : no_pcert = 0
-coi/gacc/gacc-exports.pcert0 : acl2x = 0
-coi/gacc/gacc-exports.pcert0 : \
- coi/gacc/gacc-exports.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/gacc-exports.pcert1 : acl2x = 0
-coi/gacc/gacc-exports.pcert1 : no_pcert = 0
-coi/gacc/gacc-exports.pcert1 : coi/gacc/gacc-exports.pcert0
-coi/gacc/gacc-exports.cert : | coi/gacc/gacc-exports.pcert1
-
-coi/gacc/gacc-pkg.pcert0 : no_pcert = 0
-coi/gacc/gacc-pkg.pcert0 : acl2x = 0
-coi/gacc/gacc-pkg.pcert0 : \
- coi/gacc/gacc-pkg.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/gacc-pkg.pcert1 : acl2x = 0
-coi/gacc/gacc-pkg.pcert1 : no_pcert = 0
-coi/gacc/gacc-pkg.pcert1 : coi/gacc/gacc-pkg.pcert0
-coi/gacc/gacc-pkg.cert : | coi/gacc/gacc-pkg.pcert1
-
-coi/gacc/gacc.pcert0 : no_pcert = 0
-coi/gacc/gacc.pcert0 : acl2x = 0
-coi/gacc/gacc.pcert0 : \
- coi/gacc/ram.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- coi/bags/top.pcert0 \
- coi/gacc/ram.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- coi/gacc/gacc.lisp \
- coi/gacc/gacc.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/gacc.pcert1 : acl2x = 0
-coi/gacc/gacc.pcert1 : no_pcert = 0
-coi/gacc/gacc.pcert1 : coi/gacc/gacc.pcert0
-coi/gacc/gacc.cert : | coi/gacc/gacc.pcert1
-
-coi/gacc/gacc2.pcert0 : no_pcert = 0
-coi/gacc/gacc2.pcert0 : acl2x = 0
-coi/gacc/gacc2.pcert0 : \
- coi/defstructure/defstructure.pcert0 \
- coi/gacc/ram.pcert0 \
- coi/defstructure/defstructure.pcert0 \
- coi/gacc/ram.pcert0 \
- coi/gacc/gacc2.lisp \
- coi/gacc/gacc2.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/gacc2.pcert1 : acl2x = 0
-coi/gacc/gacc2.pcert1 : no_pcert = 0
-coi/gacc/gacc2.pcert1 : coi/gacc/gacc2.pcert0
-coi/gacc/gacc2.cert : | coi/gacc/gacc2.pcert1
-
-coi/gacc/gacc3.pcert0 : no_pcert = 0
-coi/gacc/gacc3.pcert0 : acl2x = 0
-coi/gacc/gacc3.pcert0 : \
- coi/gacc/finite.pcert0 \
- coi/gacc/finite.pcert0 \
- coi/gacc/gacc3.lisp \
- coi/gacc/gacc3.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/gacc3.pcert1 : acl2x = 0
-coi/gacc/gacc3.pcert1 : no_pcert = 0
-coi/gacc/gacc3.pcert1 : coi/gacc/gacc3.pcert0
-coi/gacc/gacc3.cert : | coi/gacc/gacc3.pcert1
-
-coi/gacc/gax.pcert0 : no_pcert = 0
-coi/gacc/gax.pcert0 : acl2x = 0
-coi/gacc/gax.pcert0 : \
- coi/gacc/gacc2.pcert0 \
- coi/gacc/gacc.pcert0 \
- coi/util/mv-nth.pcert0 \
- coi/gacc/gacc2.pcert0 \
- coi/gacc/gacc.pcert0 \
- coi/gacc/gax.lisp \
- coi/gacc/gax.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/gax.pcert1 : acl2x = 0
-coi/gacc/gax.pcert1 : no_pcert = 0
-coi/gacc/gax.pcert1 : coi/gacc/gax.pcert0
-coi/gacc/gax.cert : | coi/gacc/gax.pcert1
-
-coi/gacc/list-ops-common.pcert0 : no_pcert = 0
-coi/gacc/list-ops-common.pcert0 : acl2x = 0
-coi/gacc/list-ops-common.pcert0 : \
- coi/super-ihs/super-ihs.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/lists/repeat.pcert0 \
- coi/bags/basic.pcert0 \
- coi/lists/find-index.pcert0 \
- coi/bags/pick-a-point.pcert0 \
- coi/gacc/list-ops-common.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/list-ops-common.pcert1 : acl2x = 0
-coi/gacc/list-ops-common.pcert1 : no_pcert = 0
-coi/gacc/list-ops-common.pcert1 : coi/gacc/list-ops-common.pcert0
-coi/gacc/list-ops-common.cert : | coi/gacc/list-ops-common.pcert1
-
-coi/gacc/list-ops-fast.pcert0 : no_pcert = 0
-coi/gacc/list-ops-fast.pcert0 : acl2x = 0
-coi/gacc/list-ops-fast.pcert0 : \
- coi/gacc/mem-fast.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/bags/extras.pcert0 \
- coi/super-ihs/super-ihs.pcert0 \
- coi/gacc/list-ops-common.pcert0 \
- coi/gacc/list-ops-fast.lisp \
- coi/gacc/list-ops-fast.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp
-coi/gacc/list-ops-fast.pcert1 : acl2x = 0
-coi/gacc/list-ops-fast.pcert1 : no_pcert = 0
-coi/gacc/list-ops-fast.pcert1 : coi/gacc/list-ops-fast.pcert0
-coi/gacc/list-ops-fast.cert : | coi/gacc/list-ops-fast.pcert1
-
-coi/gacc/list-ops.pcert0 : no_pcert = 0
-coi/gacc/list-ops.pcert0 : acl2x = 0
-coi/gacc/list-ops.pcert0 : \
- coi/gacc/mem.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/bags/basic.pcert0 \
- coi/gacc/list-ops-common.pcert0 \
- coi/super-ihs/super-ihs.pcert0 \
- coi/gacc/list-ops.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/list-ops.pcert1 : acl2x = 0
-coi/gacc/list-ops.pcert1 : no_pcert = 0
-coi/gacc/list-ops.pcert1 : coi/gacc/list-ops.pcert0
-coi/gacc/list-ops.cert : | coi/gacc/list-ops.pcert1
-
-coi/gacc/mem-fast.pcert0 : no_pcert = 0
-coi/gacc/mem-fast.pcert0 : acl2x = 0
-coi/gacc/mem-fast.pcert0 : \
- coi/records/defrecord-fast.pcert0 \
- coi/super-ihs/loghead.pcert0 \
- coi/super-ihs/unsigned-byte-p.pcert0 \
- coi/util/syntaxp.pcert0 \
- coi/gacc/mem-fast.lisp \
- coi/gacc/mem-fast.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp
-coi/gacc/mem-fast.pcert1 : acl2x = 0
-coi/gacc/mem-fast.pcert1 : no_pcert = 0
-coi/gacc/mem-fast.pcert1 : coi/gacc/mem-fast.pcert0
-coi/gacc/mem-fast.cert : | coi/gacc/mem-fast.pcert1
-
-coi/gacc/mem.pcert0 : no_pcert = 0
-coi/gacc/mem.pcert0 : acl2x = 0
-coi/gacc/mem.pcert0 : \
- coi/records/defrecord.pcert0 \
- coi/super-ihs/loghead.pcert0 \
- coi/super-ihs/unsigned-byte-p.pcert0 \
- coi/util/syntaxp.pcert0 \
- coi/gacc/mem.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/mem.pcert1 : acl2x = 0
-coi/gacc/mem.pcert1 : no_pcert = 0
-coi/gacc/mem.pcert1 : coi/gacc/mem.pcert0
-coi/gacc/mem.cert : | coi/gacc/mem.pcert1
-
-coi/gacc/ram.pcert0 : no_pcert = 0
-coi/gacc/ram.pcert0 : acl2x = 0
-coi/gacc/ram.pcert0 : \
- coi/gacc/ram0.pcert0 \
- coi/gacc/block.pcert0 \
- coi/bags/two-level-meta.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- coi/super-ihs/super-ihs.pcert0 \
- coi/gacc/addr-range.pcert0 \
- coi/gacc/list-ops.pcert0 \
- coi/gacc/ram.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/ram.pcert1 : acl2x = 0
-coi/gacc/ram.pcert1 : no_pcert = 0
-coi/gacc/ram.pcert1 : coi/gacc/ram.pcert0
-coi/gacc/ram.cert : | coi/gacc/ram.pcert1
-
-coi/gacc/ram0.pcert0 : no_pcert = 0
-coi/gacc/ram0.pcert0 : acl2x = 0
-coi/gacc/ram0.pcert0 : \
- coi/gacc/mem.pcert0 \
- coi/super-ihs/byte-p.pcert0 \
- coi/gacc/ram0.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/ram0.pcert1 : acl2x = 0
-coi/gacc/ram0.pcert1 : no_pcert = 0
-coi/gacc/ram0.pcert1 : coi/gacc/ram0.pcert0
-coi/gacc/ram0.cert : | coi/gacc/ram0.pcert1
-
-coi/gacc/ram2.pcert0 : no_pcert = 0
-coi/gacc/ram2.pcert0 : acl2x = 0
-coi/gacc/ram2.pcert0 : \
- coi/gacc/list-ops-fast.pcert0 \
- coi/gacc/addr-range.pcert0 \
- coi/gacc/wrap.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- coi/super-ihs/super-ihs.pcert0 \
- coi/gacc/ram2.lisp \
- coi/gacc/ram2.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp
-coi/gacc/ram2.pcert1 : acl2x = 0
-coi/gacc/ram2.pcert1 : no_pcert = 0
-coi/gacc/ram2.pcert1 : coi/gacc/ram2.pcert0
-coi/gacc/ram2.cert : | coi/gacc/ram2.pcert1
-
-coi/gacc/ram2b.pcert0 : no_pcert = 0
-coi/gacc/ram2b.pcert0 : acl2x = 0
-coi/gacc/ram2b.pcert0 : \
- coi/gacc/list-ops-fast.pcert0 \
- coi/gacc/addr-range.pcert0 \
- coi/gacc/ram3.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- coi/super-ihs/super-ihs.pcert0 \
- coi/gacc/ram2b.lisp \
- coi/gacc/ram2b.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp
-coi/gacc/ram2b.pcert1 : acl2x = 0
-coi/gacc/ram2b.pcert1 : no_pcert = 0
-coi/gacc/ram2b.pcert1 : coi/gacc/ram2b.pcert0
-coi/gacc/ram2b.cert : | coi/gacc/ram2b.pcert1
-
-coi/gacc/ram3.pcert0 : no_pcert = 0
-coi/gacc/ram3.pcert0 : acl2x = 0
-coi/gacc/ram3.pcert0 : \
- coi/util/iff.pcert0 \
- coi/gacc/list-ops-fast.pcert0 \
- coi/gacc/wrap.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- coi/super-ihs/super-ihs.pcert0 \
- coi/super-ihs/fast.pcert0 \
- coi/lists/mixed.pcert0 \
- coi/bags/pick-a-point.pcert0 \
- coi/lists/repeat.pcert0 \
- coi/gacc/ram3.lisp \
- coi/gacc/ram3.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- data-structures/memories/package.lsp
-coi/gacc/ram3.pcert1 : acl2x = 0
-coi/gacc/ram3.pcert1 : no_pcert = 0
-coi/gacc/ram3.pcert1 : coi/gacc/ram3.pcert0
-coi/gacc/ram3.cert : | coi/gacc/ram3.pcert1
-
-coi/gacc/top.pcert0 : no_pcert = 0
-coi/gacc/top.pcert0 : acl2x = 0
-coi/gacc/top.pcert0 : \
- coi/gacc/gacc3.pcert0 \
- coi/gacc/gacc3.pcert0 \
- coi/gacc/top.lisp \
- coi/gacc/top.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/top.pcert1 : acl2x = 0
-coi/gacc/top.pcert1 : no_pcert = 0
-coi/gacc/top.pcert1 : coi/gacc/top.pcert0
-coi/gacc/top.cert : | coi/gacc/top.pcert1
-
-coi/gacc/tr-path-connection.pcert0 : no_pcert = 0
-coi/gacc/tr-path-connection.pcert0 : acl2x = 0
-coi/gacc/tr-path-connection.pcert0 : \
- coi/gacc/mem.pcert0 \
- coi/paths/path.pcert0 \
- coi/records/domain.pcert0 \
- coi/osets/conversions.pcert0 \
- coi/osets/quantify.pcert0 \
- coi/gacc/tr-path-connection.lisp \
- coi/gacc/tr-path-connection.acl2 \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/tr-path-connection.pcert1 : acl2x = 0
-coi/gacc/tr-path-connection.pcert1 : no_pcert = 0
-coi/gacc/tr-path-connection.pcert1 : coi/gacc/tr-path-connection.pcert0
-coi/gacc/tr-path-connection.cert : | coi/gacc/tr-path-connection.pcert1
-
-coi/gacc/wrap.pcert0 : no_pcert = 0
-coi/gacc/wrap.pcert0 : acl2x = 0
-coi/gacc/wrap.pcert0 : \
- coi/bags/basic.pcert0 \
- coi/super-ihs/super-ihs.pcert0 \
- coi/gacc/addr-range.pcert0 \
- coi/lists/mixed.pcert0 \
- coi/lists/find-index.pcert0 \
- coi/util/syntaxp.pcert0 \
- coi/gacc/wrap.lisp \
- coi/gacc/cert.acl2 \
- coi/gacc/gacc-defpkg.lsp \
- coi/super-ihs/symbols.lsp \
- coi/super-ihs/symbols-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/bags/bag-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp
-coi/gacc/wrap.pcert1 : acl2x = 0
-coi/gacc/wrap.pcert1 : no_pcert = 0
-coi/gacc/wrap.pcert1 : coi/gacc/wrap.pcert0
-coi/gacc/wrap.cert : | coi/gacc/wrap.pcert1
-
-coi/generalize/generalize.pcert0 : no_pcert = 0
-coi/generalize/generalize.pcert0 : acl2x = 0
-coi/generalize/generalize.pcert0 : \
- coi/symbol-fns/symbol-fns.pcert0 \
- coi/util/mv-nth.pcert0 \
- coi/gensym/gensym.pcert0 \
- coi/bags/top.pcert0 \
- coi/lists/set.pcert0 \
- coi/util/clause-processor.pcert0 \
- coi/generalize/generalize.lisp \
- coi/generalize/cert.acl2 \
- coi/util/def-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/generalize/generalize.pcert1 : acl2x = 0
-coi/generalize/generalize.pcert1 : no_pcert = 0
-coi/generalize/generalize.pcert1 : coi/generalize/generalize.pcert0
-coi/generalize/generalize.cert : | coi/generalize/generalize.pcert1
-
-coi/gensym/gensym-list.pcert0 : no_pcert = 0
-coi/gensym/gensym-list.pcert0 : acl2x = 0
-coi/gensym/gensym-list.pcert0 : \
- coi/gensym/gensym.pcert0 \
- coi/lists/disjoint.pcert0 \
- coi/bags/basic.pcert0 \
- coi/gensym/gensym-list.lisp \
- coi/gensym/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/gensym/gensym-list.pcert1 : acl2x = 0
-coi/gensym/gensym-list.pcert1 : no_pcert = 0
-coi/gensym/gensym-list.pcert1 : coi/gensym/gensym-list.pcert0
-coi/gensym/gensym-list.cert : | coi/gensym/gensym-list.pcert1
-
-coi/gensym/gensym.pcert0 : no_pcert = 0
-coi/gensym/gensym.pcert0 : acl2x = 0
-coi/gensym/gensym.pcert0 : \
- coi/symbol-fns/symbol-fns.pcert0 \
- coi/util/ordinal-order.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- coi/bags/top.pcert0 \
- coi/lists/set.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/gensym/gensym.lisp \
- coi/gensym/cert.acl2 \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/gensym/gensym.pcert1 : acl2x = 0
-coi/gensym/gensym.pcert1 : no_pcert = 0
-coi/gensym/gensym.pcert1 : coi/gensym/gensym.pcert0
-coi/gensym/gensym.cert : | coi/gensym/gensym.pcert1
-
-coi/lists/acl2-count.pcert0 : no_pcert = 0
-coi/lists/acl2-count.pcert0 : acl2x = 0
-coi/lists/acl2-count.pcert0 : \
- coi/lists/acl2-count.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/acl2-count.pcert1 : acl2x = 0
-coi/lists/acl2-count.pcert1 : no_pcert = 0
-coi/lists/acl2-count.pcert1 : coi/lists/acl2-count.pcert0
-coi/lists/acl2-count.cert : | coi/lists/acl2-count.pcert1
-
-coi/lists/basic.pcert0 : no_pcert = 0
-coi/lists/basic.pcert0 : acl2x = 0
-coi/lists/basic.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- coi/util/debug.pcert0 \
- coi/lists/acl2-count.pcert0 \
- coi/util/iff.pcert0 \
- coi/adviser/adviser.pcert0 \
- coi/lists/basic.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/basic.pcert1 : acl2x = 0
-coi/lists/basic.pcert1 : no_pcert = 0
-coi/lists/basic.pcert1 : coi/lists/basic.pcert0
-coi/lists/basic.cert : | coi/lists/basic.pcert1
-
-coi/lists/disjoint.pcert0 : no_pcert = 0
-coi/lists/disjoint.pcert0 : acl2x = 0
-coi/lists/disjoint.pcert0 : \
- coi/lists/memberp.pcert0 \
- coi/util/iff.pcert0 \
- coi/lists/remove.pcert0 \
- coi/lists/disjoint.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/disjoint.pcert1 : acl2x = 0
-coi/lists/disjoint.pcert1 : no_pcert = 0
-coi/lists/disjoint.pcert1 : coi/lists/disjoint.pcert0
-coi/lists/disjoint.cert : | coi/lists/disjoint.pcert1
-
-coi/lists/find-index.pcert0 : no_pcert = 0
-coi/lists/find-index.pcert0 : acl2x = 0
-coi/lists/find-index.pcert0 : \
- coi/lists/nth-and-update-nth.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/util/iff.pcert0 \
- coi/lists/find-index.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/find-index.pcert1 : acl2x = 0
-coi/lists/find-index.pcert1 : no_pcert = 0
-coi/lists/find-index.pcert1 : coi/lists/find-index.pcert0
-coi/lists/find-index.cert : | coi/lists/find-index.pcert1
-
-coi/lists/list-top.pcert0 : no_pcert = 0
-coi/lists/list-top.pcert0 : acl2x = 0
-coi/lists/list-top.pcert0 : \
- coi/lists/basic.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/lists/map-cons.pcert0 \
- coi/lists/repeat.pcert0 \
- coi/lists/nth-and-update-nth.pcert0 \
- coi/lists/update-nth-array.pcert0 \
- coi/lists/list-top.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/list-top.pcert1 : acl2x = 0
-coi/lists/list-top.pcert1 : no_pcert = 0
-coi/lists/list-top.pcert1 : coi/lists/list-top.pcert0
-coi/lists/list-top.cert : | coi/lists/list-top.pcert1
-
-coi/lists/listset-induction.pcert0 : no_pcert = 0
-coi/lists/listset-induction.pcert0 : acl2x = 0
-coi/lists/listset-induction.pcert0 : \
- coi/lists/subsetp.pcert0 \
- coi/lists/remove.pcert0 \
- coi/lists/set.pcert0 \
- coi/lists/listset-induction.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/listset-induction.pcert1 : acl2x = 0
-coi/lists/listset-induction.pcert1 : no_pcert = 0
-coi/lists/listset-induction.pcert1 : coi/lists/listset-induction.pcert0
-coi/lists/listset-induction.cert : | coi/lists/listset-induction.pcert1
-
-coi/lists/map-cons.pcert0 : no_pcert = 0
-coi/lists/map-cons.pcert0 : acl2x = 0
-coi/lists/map-cons.pcert0 : \
- coi/lists/basic.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/util/iff.pcert0 \
- coi/lists/map-cons.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/map-cons.pcert1 : acl2x = 0
-coi/lists/map-cons.pcert1 : no_pcert = 0
-coi/lists/map-cons.pcert1 : coi/lists/map-cons.pcert0
-coi/lists/map-cons.cert : | coi/lists/map-cons.pcert1
-
-coi/lists/memberp.pcert0 : no_pcert = 0
-coi/lists/memberp.pcert0 : acl2x = 0
-coi/lists/memberp.pcert0 : \
- coi/lists/basic.pcert0 \
- coi/lists/memberp.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/memberp.pcert1 : acl2x = 0
-coi/lists/memberp.pcert1 : no_pcert = 0
-coi/lists/memberp.pcert1 : coi/lists/memberp.pcert0
-coi/lists/memberp.cert : | coi/lists/memberp.pcert1
-
-coi/lists/mixed.pcert0 : no_pcert = 0
-coi/lists/mixed.pcert0 : acl2x = 0
-coi/lists/mixed.pcert0 : \
- coi/lists/repeat.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/lists/mixed.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/mixed.pcert1 : acl2x = 0
-coi/lists/mixed.pcert1 : no_pcert = 0
-coi/lists/mixed.pcert1 : coi/lists/mixed.pcert0
-coi/lists/mixed.cert : | coi/lists/mixed.pcert1
-
-coi/lists/mv-nth.pcert0 : no_pcert = 0
-coi/lists/mv-nth.pcert0 : acl2x = 0
-coi/lists/mv-nth.pcert0 : \
- coi/lists/mv-nth.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/mv-nth.pcert1 : acl2x = 0
-coi/lists/mv-nth.pcert1 : no_pcert = 0
-coi/lists/mv-nth.pcert1 : coi/lists/mv-nth.pcert0
-coi/lists/mv-nth.cert : | coi/lists/mv-nth.pcert1
-
-coi/lists/nth-and-update-nth.pcert0 : no_pcert = 0
-coi/lists/nth-and-update-nth.pcert0 : acl2x = 0
-coi/lists/nth-and-update-nth.pcert0 : \
- coi/lists/basic.pcert0 \
- coi/lists/repeat.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/lists/nth-and-update-nth.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/nth-and-update-nth.pcert1 : acl2x = 0
-coi/lists/nth-and-update-nth.pcert1 : no_pcert = 0
-coi/lists/nth-and-update-nth.pcert1 : coi/lists/nth-and-update-nth.pcert0
-coi/lists/nth-and-update-nth.cert : | coi/lists/nth-and-update-nth.pcert1
-
-coi/lists/nth-meta.pcert0 : no_pcert = 0
-coi/lists/nth-meta.pcert0 : acl2x = 0
-coi/lists/nth-meta.pcert0 : \
- coi/lists/nth-meta.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/nth-meta.pcert1 : acl2x = 0
-coi/lists/nth-meta.pcert1 : no_pcert = 0
-coi/lists/nth-meta.pcert1 : coi/lists/nth-meta.pcert0
-coi/lists/nth-meta.cert : | coi/lists/nth-meta.pcert1
-
-coi/lists/nth-meta2.pcert0 : no_pcert = 0
-coi/lists/nth-meta2.pcert0 : acl2x = 0
-coi/lists/nth-meta2.pcert0 : \
- coi/lists/nth-meta2.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/nth-meta2.pcert1 : acl2x = 0
-coi/lists/nth-meta2.pcert1 : no_pcert = 0
-coi/lists/nth-meta2.pcert1 : coi/lists/nth-meta2.pcert0
-coi/lists/nth-meta2.cert : | coi/lists/nth-meta2.pcert1
-
-coi/lists/remove-induction.pcert0 : no_pcert = 0
-coi/lists/remove-induction.pcert0 : acl2x = 0
-coi/lists/remove-induction.pcert0 : \
- coi/lists/remove.pcert0 \
- coi/lists/remove-induction.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/remove-induction.pcert1 : acl2x = 0
-coi/lists/remove-induction.pcert1 : no_pcert = 0
-coi/lists/remove-induction.pcert1 : coi/lists/remove-induction.pcert0
-coi/lists/remove-induction.cert : | coi/lists/remove-induction.pcert1
-
-coi/lists/remove.pcert0 : no_pcert = 0
-coi/lists/remove.pcert0 : acl2x = 0
-coi/lists/remove.pcert0 : \
- coi/lists/subsetp.pcert0 \
- coi/lists/remove.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/remove.pcert1 : acl2x = 0
-coi/lists/remove.pcert1 : no_pcert = 0
-coi/lists/remove.pcert1 : coi/lists/remove.pcert0
-coi/lists/remove.cert : | coi/lists/remove.pcert1
-
-coi/lists/repeat.pcert0 : no_pcert = 0
-coi/lists/repeat.pcert0 : acl2x = 0
-coi/lists/repeat.pcert0 : \
- coi/lists/basic.pcert0 \
- coi/lists/repeat.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/repeat.pcert1 : acl2x = 0
-coi/lists/repeat.pcert1 : no_pcert = 0
-coi/lists/repeat.pcert1 : coi/lists/repeat.pcert0
-coi/lists/repeat.cert : | coi/lists/repeat.pcert1
-
-coi/lists/set.pcert0 : no_pcert = 0
-coi/lists/set.pcert0 : acl2x = 0
-coi/lists/set.pcert0 : \
- coi/lists/remove.pcert0 \
- coi/lists/disjoint.pcert0 \
- coi/util/defbinding.pcert0 \
- coi/util/iff.pcert0 \
- coi/lists/remove-induction.pcert0 \
- coi/lists/remove-induction.pcert0 \
- coi/lists/set.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/set.pcert1 : acl2x = 0
-coi/lists/set.pcert1 : no_pcert = 0
-coi/lists/set.pcert1 : coi/lists/set.pcert0
-coi/lists/set.cert : | coi/lists/set.pcert1
-
-coi/lists/subsetp.pcert0 : no_pcert = 0
-coi/lists/subsetp.pcert0 : acl2x = 0
-coi/lists/subsetp.pcert0 : \
- coi/adviser/adviser.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/lists/subsetp.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/subsetp.pcert1 : acl2x = 0
-coi/lists/subsetp.pcert1 : no_pcert = 0
-coi/lists/subsetp.pcert1 : coi/lists/subsetp.pcert0
-coi/lists/subsetp.cert : | coi/lists/subsetp.pcert1
-
-coi/lists/update-nth-array.pcert0 : no_pcert = 0
-coi/lists/update-nth-array.pcert0 : acl2x = 0
-coi/lists/update-nth-array.pcert0 : \
- coi/lists/nth-and-update-nth.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/lists/update-nth-array.lisp \
- coi/lists/cert.acl2 \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/lists/update-nth-array.pcert1 : acl2x = 0
-coi/lists/update-nth-array.pcert1 : no_pcert = 0
-coi/lists/update-nth-array.pcert1 : coi/lists/update-nth-array.pcert0
-coi/lists/update-nth-array.cert : | coi/lists/update-nth-array.pcert1
-
-coi/maps/aliases.pcert0 : no_pcert = 0
-coi/maps/aliases.pcert0 : acl2x = 0
-coi/maps/aliases.pcert0 : \
- coi/maps/maps.pcert0 \
- coi/maps/aliases.lisp \
- coi/maps/cert.acl2 \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/maps/aliases.pcert1 : acl2x = 0
-coi/maps/aliases.pcert1 : no_pcert = 0
-coi/maps/aliases.pcert1 : coi/maps/aliases.pcert0
-coi/maps/aliases.cert : | coi/maps/aliases.pcert1
-
-coi/maps/maps.pcert0 : no_pcert = 0
-coi/maps/maps.pcert0 : acl2x = 0
-coi/maps/maps.pcert0 : \
- coi/osets/sets.pcert0 \
- coi/adviser/adviser.pcert0 \
- misc/untranslate-patterns.pcert0 \
- coi/maps/maps.lisp \
- coi/maps/cert.acl2 \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/maps/maps.pcert1 : acl2x = 0
-coi/maps/maps.pcert1 : no_pcert = 0
-coi/maps/maps.pcert1 : coi/maps/maps.pcert0
-coi/maps/maps.cert : | coi/maps/maps.pcert1
-
-coi/maps/typed-maps.pcert0 : no_pcert = 0
-coi/maps/typed-maps.pcert0 : acl2x = 0
-coi/maps/typed-maps.pcert0 : \
- coi/maps/maps.pcert0 \
- coi/maps/typed-maps.lisp \
- coi/maps/cert.acl2 \
- coi/maps/map-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/maps/typed-maps.pcert1 : acl2x = 0
-coi/maps/typed-maps.pcert1 : no_pcert = 0
-coi/maps/typed-maps.pcert1 : coi/maps/typed-maps.pcert0
-coi/maps/typed-maps.cert : | coi/maps/typed-maps.pcert1
-
-coi/nary/example.pcert0 : no_pcert = 0
-coi/nary/example.pcert0 : acl2x = 0
-coi/nary/example.pcert0 : \
- coi/nary/nary.pcert0 \
- ihs/ihs-definitions.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- coi/nary/nth-rules.pcert0 \
- coi/nary/example.lisp \
- coi/nary/cert.acl2
-coi/nary/example.pcert1 : acl2x = 0
-coi/nary/example.pcert1 : no_pcert = 0
-coi/nary/example.pcert1 : coi/nary/example.pcert0
-coi/nary/example.cert : | coi/nary/example.pcert1
-
-coi/nary/nary.pcert0 : no_pcert = 0
-coi/nary/nary.pcert0 : acl2x = 0
-coi/nary/nary.pcert0 : \
- coi/util/in-conclusion.pcert0 \
- coi/util/implies.pcert0 \
- coi/nary/nary.lisp \
- coi/nary/cert.acl2
-coi/nary/nary.pcert1 : acl2x = 0
-coi/nary/nary.pcert1 : no_pcert = 0
-coi/nary/nary.pcert1 : coi/nary/nary.pcert0
-coi/nary/nary.cert : | coi/nary/nary.pcert1
-
-coi/nary/nth-rules.pcert0 : no_pcert = 0
-coi/nary/nth-rules.pcert0 : acl2x = 0
-coi/nary/nth-rules.pcert0 : \
- coi/nary/nth-rules.lisp \
- coi/nary/cert.acl2
-coi/nary/nth-rules.pcert1 : acl2x = 0
-coi/nary/nth-rules.pcert1 : no_pcert = 0
-coi/nary/nth-rules.pcert1 : coi/nary/nth-rules.pcert0
-coi/nary/nth-rules.cert : | coi/nary/nth-rules.pcert1
-
-coi/nary/ordinal-order.pcert0 : no_pcert = 0
-coi/nary/ordinal-order.pcert0 : acl2x = 0
-coi/nary/ordinal-order.pcert0 : \
- ordinals/lexicographic-ordering.pcert0 \
- coi/nary/ordinal-order.lisp \
- coi/nary/cert.acl2
-coi/nary/ordinal-order.pcert1 : acl2x = 0
-coi/nary/ordinal-order.pcert1 : no_pcert = 0
-coi/nary/ordinal-order.pcert1 : coi/nary/ordinal-order.pcert0
-coi/nary/ordinal-order.cert : | coi/nary/ordinal-order.pcert1
-
-coi/nary/rewrite-equal-hint.pcert0 : no_pcert = 0
-coi/nary/rewrite-equal-hint.pcert0 : acl2x = 0
-coi/nary/rewrite-equal-hint.pcert0 : \
- coi/nary/rewrite-equal-hint.lisp \
- coi/nary/cert.acl2
-coi/nary/rewrite-equal-hint.pcert1 : acl2x = 0
-coi/nary/rewrite-equal-hint.pcert1 : no_pcert = 0
-coi/nary/rewrite-equal-hint.pcert1 : coi/nary/rewrite-equal-hint.pcert0
-coi/nary/rewrite-equal-hint.cert : | coi/nary/rewrite-equal-hint.pcert1
-
-coi/osets/computed-hints.pcert0 : no_pcert = 0
-coi/osets/computed-hints.pcert0 : acl2x = 0
-coi/osets/computed-hints.pcert0 : \
- coi/osets/instance.pcert0 \
- coi/osets/computed-hints.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/computed-hints.pcert1 : acl2x = 0
-coi/osets/computed-hints.pcert1 : no_pcert = 0
-coi/osets/computed-hints.pcert1 : coi/osets/computed-hints.pcert0
-coi/osets/computed-hints.cert : | coi/osets/computed-hints.pcert1
-
-coi/osets/conversions.pcert0 : no_pcert = 0
-coi/osets/conversions.pcert0 : acl2x = 0
-coi/osets/conversions.pcert0 : \
- coi/osets/sets.pcert0 \
- coi/lists/set.pcert0 \
- coi/osets/conversions.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/conversions.pcert1 : acl2x = 0
-coi/osets/conversions.pcert1 : no_pcert = 0
-coi/osets/conversions.pcert1 : coi/osets/conversions.pcert0
-coi/osets/conversions.cert : | coi/osets/conversions.pcert1
-
-coi/osets/extras.pcert0 : no_pcert = 0
-coi/osets/extras.pcert0 : acl2x = 0
-coi/osets/extras.pcert0 : \
- coi/osets/sets.pcert0 \
- coi/osets/set-order.pcert0 \
- coi/osets/conversions.pcert0 \
- coi/util/iff.pcert0 \
- misc/total-order.pcert0 \
- coi/osets/extras.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/extras.pcert1 : acl2x = 0
-coi/osets/extras.pcert1 : no_pcert = 0
-coi/osets/extras.pcert1 : coi/osets/extras.pcert0
-coi/osets/extras.cert : | coi/osets/extras.pcert1
-
-coi/osets/fast.pcert0 : no_pcert = 0
-coi/osets/fast.pcert0 : acl2x = 0
-coi/osets/fast.pcert0 : \
- coi/osets/membership.pcert0 \
- coi/osets/fast.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/fast.pcert1 : acl2x = 0
-coi/osets/fast.pcert1 : no_pcert = 0
-coi/osets/fast.pcert1 : coi/osets/fast.pcert0
-coi/osets/fast.cert : | coi/osets/fast.pcert1
-
-coi/osets/instance.pcert0 : no_pcert = 0
-coi/osets/instance.pcert0 : acl2x = 0
-coi/osets/instance.pcert0 : \
- coi/osets/instance.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/instance.pcert1 : acl2x = 0
-coi/osets/instance.pcert1 : no_pcert = 0
-coi/osets/instance.pcert1 : coi/osets/instance.pcert0
-coi/osets/instance.cert : | coi/osets/instance.pcert1
-
-coi/osets/listsets.pcert0 : no_pcert = 0
-coi/osets/listsets.pcert0 : acl2x = 0
-coi/osets/listsets.pcert0 : \
- misc/untranslate-patterns.pcert0 \
- coi/lists/basic.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/osets/map.pcert0 \
- coi/osets/listsets.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/listsets.pcert1 : acl2x = 0
-coi/osets/listsets.pcert1 : no_pcert = 0
-coi/osets/listsets.pcert1 : coi/osets/listsets.pcert0
-coi/osets/listsets.cert : | coi/osets/listsets.pcert1
-
-coi/osets/map.pcert0 : no_pcert = 0
-coi/osets/map.pcert0 : acl2x = 0
-coi/osets/map.pcert0 : \
- coi/osets/quantify.pcert0 \
- coi/osets/map.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/map.pcert1 : acl2x = 0
-coi/osets/map.pcert1 : no_pcert = 0
-coi/osets/map.pcert1 : coi/osets/map.pcert0
-coi/osets/map.cert : | coi/osets/map.pcert1
-
-coi/osets/membership.pcert0 : no_pcert = 0
-coi/osets/membership.pcert0 : acl2x = 0
-coi/osets/membership.pcert0 : \
- coi/osets/primitives.pcert0 \
- coi/osets/computed-hints.pcert0 \
- coi/osets/membership.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/membership.pcert1 : acl2x = 0
-coi/osets/membership.pcert1 : no_pcert = 0
-coi/osets/membership.pcert1 : coi/osets/membership.pcert0
-coi/osets/membership.cert : | coi/osets/membership.pcert1
-
-coi/osets/multiappend.pcert0 : no_pcert = 0
-coi/osets/multiappend.pcert0 : acl2x = 0
-coi/osets/multiappend.pcert0 : \
- coi/osets/multicons.pcert0 \
- coi/util/iff.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/osets/multiappend.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/multiappend.pcert1 : acl2x = 0
-coi/osets/multiappend.pcert1 : no_pcert = 0
-coi/osets/multiappend.pcert1 : coi/osets/multiappend.pcert0
-coi/osets/multiappend.cert : | coi/osets/multiappend.pcert1
-
-coi/osets/multicons.pcert0 : no_pcert = 0
-coi/osets/multicons.pcert0 : acl2x = 0
-coi/osets/multicons.pcert0 : \
- coi/osets/sets.pcert0 \
- coi/osets/listsets.pcert0 \
- coi/osets/multicons.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/multicons.pcert1 : acl2x = 0
-coi/osets/multicons.pcert1 : no_pcert = 0
-coi/osets/multicons.pcert1 : coi/osets/multicons.pcert0
-coi/osets/multicons.cert : | coi/osets/multicons.pcert1
-
-coi/osets/outer.pcert0 : no_pcert = 0
-coi/osets/outer.pcert0 : acl2x = 0
-coi/osets/outer.pcert0 : \
- coi/osets/fast.pcert0 \
- coi/osets/outer.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/outer.pcert1 : acl2x = 0
-coi/osets/outer.pcert1 : no_pcert = 0
-coi/osets/outer.pcert1 : coi/osets/outer.pcert0
-coi/osets/outer.cert : | coi/osets/outer.pcert1
-
-coi/osets/primitives.pcert0 : no_pcert = 0
-coi/osets/primitives.pcert0 : acl2x = 0
-coi/osets/primitives.pcert0 : \
- misc/total-order.pcert0 \
- coi/osets/primitives.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/primitives.pcert1 : acl2x = 0
-coi/osets/primitives.pcert1 : no_pcert = 0
-coi/osets/primitives.pcert1 : coi/osets/primitives.pcert0
-coi/osets/primitives.cert : | coi/osets/primitives.pcert1
-
-coi/osets/quantify.pcert0 : no_pcert = 0
-coi/osets/quantify.pcert0 : acl2x = 0
-coi/osets/quantify.pcert0 : \
- coi/osets/sets.pcert0 \
- coi/osets/quantify.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/quantify.pcert1 : acl2x = 0
-coi/osets/quantify.pcert1 : no_pcert = 0
-coi/osets/quantify.pcert1 : coi/osets/quantify.pcert0
-coi/osets/quantify.cert : | coi/osets/quantify.pcert1
-
-coi/osets/set-order.pcert0 : no_pcert = 0
-coi/osets/set-order.pcert0 : acl2x = 0
-coi/osets/set-order.pcert0 : \
- coi/osets/primitives.pcert0 \
- coi/osets/membership.pcert0 \
- coi/osets/fast.pcert0 \
- coi/osets/sets.pcert0 \
- misc/total-order.pcert0 \
- coi/osets/set-order.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/set-order.pcert1 : acl2x = 0
-coi/osets/set-order.pcert1 : no_pcert = 0
-coi/osets/set-order.pcert1 : coi/osets/set-order.pcert0
-coi/osets/set-order.cert : | coi/osets/set-order.pcert1
-
-coi/osets/set-processor.pcert0 : no_pcert = 0
-coi/osets/set-processor.pcert0 : acl2x = 0
-coi/osets/set-processor.pcert0 : \
- coi/osets/sets.pcert0 \
- coi/osets/set-processor.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/set-processor.pcert1 : acl2x = 0
-coi/osets/set-processor.pcert1 : no_pcert = 0
-coi/osets/set-processor.pcert1 : coi/osets/set-processor.pcert0
-coi/osets/set-processor.cert : | coi/osets/set-processor.pcert1
-
-coi/osets/sets.pcert0 : no_pcert = 0
-coi/osets/sets.pcert0 : acl2x = 0
-coi/osets/sets.pcert0 : \
- coi/osets/computed-hints.pcert0 \
- coi/osets/primitives.pcert0 \
- coi/osets/membership.pcert0 \
- coi/osets/fast.pcert0 \
- coi/osets/outer.pcert0 \
- coi/osets/sort.pcert0 \
- misc/total-order.pcert0 \
- coi/osets/sets.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/sets.pcert1 : acl2x = 0
-coi/osets/sets.pcert1 : no_pcert = 0
-coi/osets/sets.pcert1 : coi/osets/sets.pcert0
-coi/osets/sets.cert : | coi/osets/sets.pcert1
-
-coi/osets/sort.pcert0 : no_pcert = 0
-coi/osets/sort.pcert0 : acl2x = 0
-coi/osets/sort.pcert0 : \
- coi/osets/outer.pcert0 \
- coi/osets/sort.lisp \
- coi/osets/cert.acl2 \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/osets/sort.pcert1 : acl2x = 0
-coi/osets/sort.pcert1 : no_pcert = 0
-coi/osets/sort.pcert1 : coi/osets/sort.pcert0
-coi/osets/sort.cert : | coi/osets/sort.pcert1
-
-coi/paths/compatibility.pcert0 : no_pcert = 0
-coi/paths/compatibility.pcert0 : acl2x = 0
-coi/paths/compatibility.pcert0 : \
- coi/alists/top.pcert0 \
- coi/paths/compatibility.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-coi/paths/compatibility.pcert1 : acl2x = 0
-coi/paths/compatibility.pcert1 : no_pcert = 0
-coi/paths/compatibility.pcert1 : coi/paths/compatibility.pcert0
-coi/paths/compatibility.cert : | coi/paths/compatibility.pcert1
-
-coi/paths/cp-set.pcert0 : no_pcert = 0
-coi/paths/cp-set.pcert0 : acl2x = 0
-coi/paths/cp-set.pcert0 : \
- coi/osets/multicons.pcert0 \
- coi/paths/hints.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/osets/multiappend.pcert0 \
- coi/paths/cp-set.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-coi/paths/cp-set.pcert1 : acl2x = 0
-coi/paths/cp-set.pcert1 : no_pcert = 0
-coi/paths/cp-set.pcert1 : coi/paths/cp-set.pcert0
-coi/paths/cp-set.cert : | coi/paths/cp-set.pcert1
-
-coi/paths/defs.pcert0 : no_pcert = 0
-coi/paths/defs.pcert0 : acl2x = 0
-coi/paths/defs.pcert0 : \
- coi/lists/basic.pcert0 \
- coi/paths/defs.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-coi/paths/defs.pcert1 : acl2x = 0
-coi/paths/defs.pcert1 : no_pcert = 0
-coi/paths/defs.pcert1 : coi/paths/defs.pcert0
-coi/paths/defs.cert : | coi/paths/defs.pcert1
-
-coi/paths/diverge.pcert0 : no_pcert = 0
-coi/paths/diverge.pcert0 : acl2x = 0
-coi/paths/diverge.pcert0 : \
- coi/paths/dominates.pcert0 \
- coi/bags/basic.pcert0 \
- coi/util/iff.pcert0 \
- coi/paths/diverge.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-coi/paths/diverge.pcert1 : acl2x = 0
-coi/paths/diverge.pcert1 : no_pcert = 0
-coi/paths/diverge.pcert1 : coi/paths/diverge.pcert0
-coi/paths/diverge.cert : | coi/paths/diverge.pcert1
-
-coi/paths/dominates.pcert0 : no_pcert = 0
-coi/paths/dominates.pcert0 : acl2x = 0
-coi/paths/dominates.pcert0 : \
- coi/lists/basic.pcert0 \
- coi/lists/memberp.pcert0 \
- coi/bags/basic.pcert0 \
- coi/adviser/adviser.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/util/iff.pcert0 \
- coi/paths/dominates.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-coi/paths/dominates.pcert1 : acl2x = 0
-coi/paths/dominates.pcert1 : no_pcert = 0
-coi/paths/dominates.pcert1 : coi/paths/dominates.pcert0
-coi/paths/dominates.cert : | coi/paths/dominates.pcert1
-
-coi/paths/equiv.pcert0 : no_pcert = 0
-coi/paths/equiv.pcert0 : acl2x = 0
-coi/paths/equiv.pcert0 : \
- coi/util/iff.pcert0 \
- coi/paths/path.pcert0 \
- coi/paths/equiv.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-coi/paths/equiv.pcert1 : acl2x = 0
-coi/paths/equiv.pcert1 : no_pcert = 0
-coi/paths/equiv.pcert1 : coi/paths/equiv.pcert0
-coi/paths/equiv.cert : | coi/paths/equiv.pcert1
-
-coi/paths/hints.pcert0 : no_pcert = 0
-coi/paths/hints.pcert0 : acl2x = 0
-coi/paths/hints.pcert0 : \
- coi/paths/pm.pcert0 \
- coi/util/iff.pcert0 \
- coi/paths/hints.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-coi/paths/hints.pcert1 : acl2x = 0
-coi/paths/hints.pcert1 : no_pcert = 0
-coi/paths/hints.pcert1 : coi/paths/hints.pcert0
-coi/paths/hints.cert : | coi/paths/hints.pcert1
-
-coi/paths/list-path-connection.pcert0 : no_pcert = 0
-coi/paths/list-path-connection.pcert0 : acl2x = 0
-coi/paths/list-path-connection.pcert0 : \
- coi/records/domain.pcert0 \
- coi/bags/extras.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/paths/path.pcert0 \
- coi/paths/list-path-connection.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-coi/paths/list-path-connection.pcert1 : acl2x = 0
-coi/paths/list-path-connection.pcert1 : no_pcert = 0
-coi/paths/list-path-connection.pcert1 : coi/paths/list-path-connection.pcert0
-coi/paths/list-path-connection.cert : | coi/paths/list-path-connection.pcert1
-
-coi/paths/meta.pcert0 : no_pcert = 0
-coi/paths/meta.pcert0 : acl2x = 0
-coi/paths/meta.pcert0 : \
- coi/lists/basic.pcert0 \
- coi/lists/map-cons.pcert0 \
- coi/syntax/syntax.pcert0 \
- coi/util/mv-nth.pcert0 \
- coi/util/iff.pcert0 \
- coi/paths/path.pcert0 \
- coi/paths/meta.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-coi/paths/meta.pcert1 : acl2x = 0
-coi/paths/meta.pcert1 : no_pcert = 0
-coi/paths/meta.pcert1 : coi/paths/meta.pcert0
-coi/paths/meta.cert : | coi/paths/meta.pcert1
-
-coi/paths/path.pcert0 : no_pcert = 0
-coi/paths/path.pcert0 : acl2x = 0
-coi/paths/path.pcert0 : \
- coi/lists/repeat.pcert0 \
- coi/bags/top.pcert0 \
- coi/alists/top.pcert0 \
- coi/records/records.pcert0 \
- coi/records/domain.pcert0 \
- coi/paths/compatibility.pcert0 \
- coi/paths/dominates.pcert0 \
- coi/paths/diverge.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/util/iff.pcert0 \
- coi/util/syntaxp.pcert0 \
- coi/paths/path.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-coi/paths/path.pcert1 : acl2x = 0
-coi/paths/path.pcert1 : no_pcert = 0
-coi/paths/path.pcert1 : coi/paths/path.pcert0
-coi/paths/path.cert : | coi/paths/path.pcert1
-
-coi/paths/pm.pcert0 : no_pcert = 0
-coi/paths/pm.pcert0 : acl2x = 0
-coi/paths/pm.pcert0 : \
- coi/paths/meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/paths/equiv.pcert0 \
- coi/paths/pm.lisp \
- coi/paths/cert.acl2 \
- coi/paths/path-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp
-coi/paths/pm.pcert1 : acl2x = 0
-coi/paths/pm.pcert1 : no_pcert = 0
-coi/paths/pm.pcert1 : coi/paths/pm.pcert0
-coi/paths/pm.cert : | coi/paths/pm.pcert1
-
-coi/quantification/quantification.pcert0 : no_pcert = 0
-coi/quantification/quantification.pcert0 : acl2x = 0
-coi/quantification/quantification.pcert0 : \
- misc/records.pcert0 \
- misc/bash.pcert0 \
- coi/generalize/generalize.pcert0 \
- coi/util/mv-nth.pcert0 \
- coi/util/table.pcert0 \
- coi/util/skip-rewrite.pcert0 \
- coi/util/in-conclusion.pcert0 \
- coi/quantification/quantification.lisp \
- coi/quantification/quantification.acl2 \
- coi/quantification/cert.acl2 \
- coi/util/def-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/util/table-defpkg.lsp \
- coi/quantification/quant-defpkg.lsp
-coi/quantification/quantification.pcert1 : acl2x = 0
-coi/quantification/quantification.pcert1 : no_pcert = 0
-coi/quantification/quantification.pcert1 : coi/quantification/quantification.pcert0
-coi/quantification/quantification.cert : | coi/quantification/quantification.pcert1
-
-coi/records/defarray.pcert0 : no_pcert = 0
-coi/records/defarray.pcert0 : acl2x = 0
-coi/records/defarray.pcert0 : \
- coi/records/records.pcert0 \
- coi/symbol-fns/symbol-fns.pcert0 \
- coi/records/defarray.lisp \
- coi/records/defarray.acl2 \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp
-coi/records/defarray.pcert1 : acl2x = 0
-coi/records/defarray.pcert1 : no_pcert = 0
-coi/records/defarray.pcert1 : coi/records/defarray.pcert0
-coi/records/defarray.cert : | coi/records/defarray.pcert1
-
-coi/records/defrecord-fast.pcert0 : no_pcert = 0
-coi/records/defrecord-fast.pcert0 : acl2x = 0
-coi/records/defrecord-fast.pcert0 : \
- coi/records/memory.pcert0 \
- coi/records/records.pcert0 \
- data-structures/memories/memory.pcert0 \
- coi/records/defrecord-fast.lisp \
- coi/records/defrecord-fast.acl2 \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp \
- data-structures/memories/package.lsp
-coi/records/defrecord-fast.pcert1 : acl2x = 0
-coi/records/defrecord-fast.pcert1 : no_pcert = 0
-coi/records/defrecord-fast.pcert1 : coi/records/defrecord-fast.pcert0
-coi/records/defrecord-fast.cert : | coi/records/defrecord-fast.pcert1
-
-coi/records/defrecord.pcert0 : no_pcert = 0
-coi/records/defrecord.pcert0 : acl2x = 0
-coi/records/defrecord.pcert0 : \
- coi/records/records.pcert0 \
- coi/records/defrecord.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-coi/records/defrecord.pcert1 : acl2x = 0
-coi/records/defrecord.pcert1 : no_pcert = 0
-coi/records/defrecord.pcert1 : coi/records/defrecord.pcert0
-coi/records/defrecord.cert : | coi/records/defrecord.pcert1
-
-coi/records/domain.pcert0 : no_pcert = 0
-coi/records/domain.pcert0 : acl2x = 0
-coi/records/domain.pcert0 : \
- coi/alists/keyquiv.pcert0 \
- coi/records/records.pcert0 \
- coi/bags/basic.pcert0 \
- coi/bags/pick-a-point.pcert0 \
- coi/records/records.pcert0 \
- coi/records/domain.lisp \
- coi/records/domain.acl2 \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/adviser/adviser-defpkg.lsp
-coi/records/domain.pcert1 : acl2x = 0
-coi/records/domain.pcert1 : no_pcert = 0
-coi/records/domain.pcert1 : coi/records/domain.pcert0
-coi/records/domain.cert : | coi/records/domain.pcert1
-
-coi/records/fixedpoint.pcert0 : no_pcert = 0
-coi/records/fixedpoint.pcert0 : acl2x = 0
-coi/records/fixedpoint.pcert0 : \
- coi/records/domain.pcert0 \
- coi/util/rule-sets.pcert0 \
- coi/records/domain.pcert0 \
- coi/records/fixedpoint.lisp \
- coi/records/fixedpoint.acl2 \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp
-coi/records/fixedpoint.pcert1 : acl2x = 0
-coi/records/fixedpoint.pcert1 : no_pcert = 0
-coi/records/fixedpoint.pcert1 : coi/records/fixedpoint.pcert0
-coi/records/fixedpoint.cert : | coi/records/fixedpoint.pcert1
-
-coi/records/mem-domain.pcert0 : no_pcert = 0
-coi/records/mem-domain.pcert0 : acl2x = 0
-coi/records/mem-domain.pcert0 : \
- coi/records/memory.pcert0 \
- coi/records/domain.pcert0 \
- coi/osets/conversions.pcert0 \
- coi/osets/extras.pcert0 \
- coi/osets/map.pcert0 \
- coi/bags/basic.pcert0 \
- coi/util/iff.pcert0 \
- coi/osets/set-processor.pcert0 \
- data-structures/memories/log2.pcert0 \
- coi/records/set-domain.pcert0 \
- data-structures/memories/memory-impl.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- coi/records/mem-domain.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-coi/records/mem-domain.pcert1 : acl2x = 0
-coi/records/mem-domain.pcert1 : no_pcert = 0
-coi/records/mem-domain.pcert1 : coi/records/mem-domain.pcert0
-coi/records/mem-domain.cert : | coi/records/mem-domain.pcert1
-
-coi/records/memory.pcert0 : no_pcert = 0
-coi/records/memory.pcert0 : acl2x = 0
-coi/records/memory.pcert0 : \
- data-structures/memories/memory.pcert0 \
- coi/records/memory.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-coi/records/memory.pcert1 : acl2x = 0
-coi/records/memory.pcert1 : no_pcert = 0
-coi/records/memory.pcert1 : coi/records/memory.pcert0
-coi/records/memory.cert : | coi/records/memory.pcert1
-
-coi/records/record-exports.pcert0 : no_pcert = 0
-coi/records/record-exports.pcert0 : acl2x = 0
-coi/records/record-exports.pcert0 : \
- coi/records/record-exports.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-coi/records/record-exports.pcert1 : acl2x = 0
-coi/records/record-exports.pcert1 : no_pcert = 0
-coi/records/record-exports.pcert1 : coi/records/record-exports.pcert0
-coi/records/record-exports.cert : | coi/records/record-exports.pcert1
-
-coi/records/records.pcert0 : no_pcert = 0
-coi/records/records.pcert0 : acl2x = 0
-coi/records/records.pcert0 : \
- coi/lists/basic.pcert0 \
- misc/records.pcert0 \
- coi/records/records.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-coi/records/records.pcert1 : acl2x = 0
-coi/records/records.pcert1 : no_pcert = 0
-coi/records/records.pcert1 : coi/records/records.pcert0
-coi/records/records.cert : | coi/records/records.pcert1
-
-coi/records/set-domain.pcert0 : no_pcert = 0
-coi/records/set-domain.pcert0 : acl2x = 0
-coi/records/set-domain.pcert0 : \
- coi/records/domain.pcert0 \
- coi/osets/sets.pcert0 \
- coi/osets/extras.pcert0 \
- coi/records/records.pcert0 \
- coi/osets/sets.pcert0 \
- coi/osets/map.pcert0 \
- coi/osets/extras.pcert0 \
- coi/records/set-domain.lisp \
- coi/records/cert.acl2 \
- coi/records/rec-defpkg.lsp \
- coi/records/record-exports.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/osets/set-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- coi/osets/computed-hints-defpkg.lsp \
- coi/osets/instance-defpkg.lsp \
- coi/bags/bag-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/util/util-exports.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/lists/list-defpkg.lsp \
- data-structures/memories/package.lsp
-coi/records/set-domain.pcert1 : acl2x = 0
-coi/records/set-domain.pcert1 : no_pcert = 0
-coi/records/set-domain.pcert1 : coi/records/set-domain.pcert0
-coi/records/set-domain.cert : | coi/records/set-domain.pcert1
-
-coi/super-ihs/arithmetic.pcert0 : no_pcert = 0
-coi/super-ihs/arithmetic.pcert0 : acl2x = 0
-coi/super-ihs/arithmetic.pcert0 : \
- ihs/quotient-remainder-lemmas.pcert0 \
- ihs/math-lemmas.pcert0 \
- coi/super-ihs/eric.pcert0 \
- coi/super-ihs/from-rtl.pcert0 \
- rtl/rel4/arithmetic/floor.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/denominator.pcert0 \
- coi/super-ihs/arithmetic.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/arithmetic.pcert1 : acl2x = 0
-coi/super-ihs/arithmetic.pcert1 : no_pcert = 0
-coi/super-ihs/arithmetic.pcert1 : coi/super-ihs/arithmetic.pcert0
-coi/super-ihs/arithmetic.cert : | coi/super-ihs/arithmetic.pcert1
-
-coi/super-ihs/ash.pcert0 : no_pcert = 0
-coi/super-ihs/ash.pcert0 : acl2x = 0
-coi/super-ihs/ash.pcert0 : \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/evenp.pcert0 \
- coi/super-ihs/ash.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/ash.pcert1 : acl2x = 0
-coi/super-ihs/ash.pcert1 : no_pcert = 0
-coi/super-ihs/ash.pcert1 : coi/super-ihs/ash.pcert0
-coi/super-ihs/ash.cert : | coi/super-ihs/ash.pcert1
-
-coi/super-ihs/basics.pcert0 : no_pcert = 0
-coi/super-ihs/basics.pcert0 : acl2x = 0
-coi/super-ihs/basics.pcert0 : \
- coi/super-ihs/inductions.pcert0 \
- coi/super-ihs/evenp.pcert0 \
- coi/super-ihs/bit-functions.pcert0 \
- coi/super-ihs/from-rtl.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/loghead.pcert0 \
- coi/super-ihs/logext.pcert0 \
- coi/super-ihs/logcar.pcert0 \
- coi/super-ihs/ash.pcert0 \
- coi/super-ihs/basics.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/basics.pcert1 : acl2x = 0
-coi/super-ihs/basics.pcert1 : no_pcert = 0
-coi/super-ihs/basics.pcert1 : coi/super-ihs/basics.pcert0
-coi/super-ihs/basics.cert : | coi/super-ihs/basics.pcert1
-
-coi/super-ihs/bit-functions.pcert0 : no_pcert = 0
-coi/super-ihs/bit-functions.pcert0 : acl2x = 0
-coi/super-ihs/bit-functions.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/bit-functions.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/bit-functions.pcert1 : acl2x = 0
-coi/super-ihs/bit-functions.pcert1 : no_pcert = 0
-coi/super-ihs/bit-functions.pcert1 : coi/super-ihs/bit-functions.pcert0
-coi/super-ihs/bit-functions.cert : | coi/super-ihs/bit-functions.pcert1
-
-coi/super-ihs/bit-twiddling-logops.pcert0 : no_pcert = 0
-coi/super-ihs/bit-twiddling-logops.pcert0 : acl2x = 0
-coi/super-ihs/bit-twiddling-logops.pcert0 : \
- coi/super-ihs/logical-logops.pcert0 \
- coi/super-ihs/bit-twiddling-logops.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/bit-twiddling-logops.pcert1 : acl2x = 0
-coi/super-ihs/bit-twiddling-logops.pcert1 : no_pcert = 0
-coi/super-ihs/bit-twiddling-logops.pcert1 : coi/super-ihs/bit-twiddling-logops.pcert0
-coi/super-ihs/bit-twiddling-logops.cert : | coi/super-ihs/bit-twiddling-logops.pcert1
-
-coi/super-ihs/byte-p.pcert0 : no_pcert = 0
-coi/super-ihs/byte-p.pcert0 : acl2x = 0
-coi/super-ihs/byte-p.pcert0 : \
- coi/super-ihs/logpair.pcert0 \
- coi/super-ihs/byte-p.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/byte-p.pcert1 : acl2x = 0
-coi/super-ihs/byte-p.pcert1 : no_pcert = 0
-coi/super-ihs/byte-p.pcert1 : coi/super-ihs/byte-p.pcert0
-coi/super-ihs/byte-p.cert : | coi/super-ihs/byte-p.pcert1
-
-coi/super-ihs/c-functions.pcert0 : no_pcert = 0
-coi/super-ihs/c-functions.pcert0 : acl2x = 0
-coi/super-ihs/c-functions.pcert0 : \
- coi/super-ihs/hacks.pcert0 \
- coi/super-ihs/c-functions.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/c-functions.pcert1 : acl2x = 0
-coi/super-ihs/c-functions.pcert1 : no_pcert = 0
-coi/super-ihs/c-functions.pcert1 : coi/super-ihs/c-functions.pcert0
-coi/super-ihs/c-functions.cert : | coi/super-ihs/c-functions.pcert1
-
-coi/super-ihs/carry.pcert0 : no_pcert = 0
-coi/super-ihs/carry.pcert0 : acl2x = 0
-coi/super-ihs/carry.pcert0 : \
- coi/super-ihs/super-ihs.pcert0 \
- coi/super-ihs/carry.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/carry.pcert1 : acl2x = 0
-coi/super-ihs/carry.pcert1 : no_pcert = 0
-coi/super-ihs/carry.pcert1 : coi/super-ihs/carry.pcert0
-coi/super-ihs/carry.cert : | coi/super-ihs/carry.pcert1
-
-coi/super-ihs/eric.pcert0 : no_pcert = 0
-coi/super-ihs/eric.pcert0 : acl2x = 0
-coi/super-ihs/eric.pcert0 : \
- rtl/rel4/arithmetic/expo.pcert0 \
- rtl/rel4/arithmetic/expt.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- coi/super-ihs/eric.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/eric.pcert1 : acl2x = 0
-coi/super-ihs/eric.pcert1 : no_pcert = 0
-coi/super-ihs/eric.pcert1 : coi/super-ihs/eric.pcert0
-coi/super-ihs/eric.cert : | coi/super-ihs/eric.pcert1
-
-coi/super-ihs/evenp.pcert0 : no_pcert = 0
-coi/super-ihs/evenp.pcert0 : acl2x = 0
-coi/super-ihs/evenp.pcert0 : \
- coi/super-ihs/arithmetic.pcert0 \
- rtl/rel4/arithmetic/even-odd.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- coi/super-ihs/evenp.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/evenp.pcert1 : acl2x = 0
-coi/super-ihs/evenp.pcert1 : no_pcert = 0
-coi/super-ihs/evenp.pcert1 : coi/super-ihs/evenp.pcert0
-coi/super-ihs/evenp.cert : | coi/super-ihs/evenp.pcert1
-
-coi/super-ihs/fast.pcert0 : no_pcert = 0
-coi/super-ihs/fast.pcert0 : acl2x = 0
-coi/super-ihs/fast.pcert0 : \
- coi/super-ihs/super-ihs.pcert0 \
- coi/super-ihs/fast.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/fast.pcert1 : acl2x = 0
-coi/super-ihs/fast.pcert1 : no_pcert = 0
-coi/super-ihs/fast.pcert1 : coi/super-ihs/fast.pcert0
-coi/super-ihs/fast.cert : | coi/super-ihs/fast.pcert1
-
-coi/super-ihs/from-rtl.pcert0 : no_pcert = 0
-coi/super-ihs/from-rtl.pcert0 : acl2x = 0
-coi/super-ihs/from-rtl.pcert0 : \
- rtl/rel4/support/logand.pcert0 \
- rtl/rel4/support/logxor.pcert0 \
- rtl/rel4/support/logior.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/expt.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- coi/super-ihs/from-rtl.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/from-rtl.pcert1 : acl2x = 0
-coi/super-ihs/from-rtl.pcert1 : no_pcert = 0
-coi/super-ihs/from-rtl.pcert1 : coi/super-ihs/from-rtl.pcert0
-coi/super-ihs/from-rtl.cert : | coi/super-ihs/from-rtl.pcert1
-
-coi/super-ihs/hacks.pcert0 : no_pcert = 0
-coi/super-ihs/hacks.pcert0 : acl2x = 0
-coi/super-ihs/hacks.pcert0 : \
- coi/super-ihs/bit-twiddling-logops.pcert0 \
- coi/super-ihs/eric.pcert0 \
- coi/super-ihs/hacks.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/hacks.pcert1 : acl2x = 0
-coi/super-ihs/hacks.pcert1 : no_pcert = 0
-coi/super-ihs/hacks.pcert1 : coi/super-ihs/hacks.pcert0
-coi/super-ihs/hacks.cert : | coi/super-ihs/hacks.pcert1
-
-coi/super-ihs/inductions.pcert0 : no_pcert = 0
-coi/super-ihs/inductions.pcert0 : acl2x = 0
-coi/super-ihs/inductions.pcert0 : \
- coi/super-ihs/arithmetic.pcert0 \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/inductions.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/inductions.pcert1 : acl2x = 0
-coi/super-ihs/inductions.pcert1 : no_pcert = 0
-coi/super-ihs/inductions.pcert1 : coi/super-ihs/inductions.pcert0
-coi/super-ihs/inductions.cert : | coi/super-ihs/inductions.pcert1
-
-coi/super-ihs/iter-sqrt.pcert0 : no_pcert = 0
-coi/super-ihs/iter-sqrt.pcert0 : acl2x = 0
-coi/super-ihs/iter-sqrt.pcert0 : \
- coi/super-ihs/arithmetic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/super-ihs/iter-sqrt.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/iter-sqrt.pcert1 : acl2x = 0
-coi/super-ihs/iter-sqrt.pcert1 : no_pcert = 0
-coi/super-ihs/iter-sqrt.pcert1 : coi/super-ihs/iter-sqrt.pcert0
-coi/super-ihs/iter-sqrt.cert : | coi/super-ihs/iter-sqrt.pcert1
-
-coi/super-ihs/logapp.pcert0 : no_pcert = 0
-coi/super-ihs/logapp.pcert0 : acl2x = 0
-coi/super-ihs/logapp.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/logapp.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/logapp.pcert1 : acl2x = 0
-coi/super-ihs/logapp.pcert1 : no_pcert = 0
-coi/super-ihs/logapp.pcert1 : coi/super-ihs/logapp.pcert0
-coi/super-ihs/logapp.cert : | coi/super-ihs/logapp.pcert1
-
-coi/super-ihs/logbit.pcert0 : no_pcert = 0
-coi/super-ihs/logbit.pcert0 : acl2x = 0
-coi/super-ihs/logbit.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/logbit.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/logbit.pcert1 : acl2x = 0
-coi/super-ihs/logbit.pcert1 : no_pcert = 0
-coi/super-ihs/logbit.pcert1 : coi/super-ihs/logbit.pcert0
-coi/super-ihs/logbit.cert : | coi/super-ihs/logbit.pcert1
-
-coi/super-ihs/logbitp.pcert0 : no_pcert = 0
-coi/super-ihs/logbitp.pcert0 : acl2x = 0
-coi/super-ihs/logbitp.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/logbitp.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/logbitp.pcert1 : acl2x = 0
-coi/super-ihs/logbitp.pcert1 : no_pcert = 0
-coi/super-ihs/logbitp.pcert1 : coi/super-ihs/logbitp.pcert0
-coi/super-ihs/logbitp.cert : | coi/super-ihs/logbitp.pcert1
-
-coi/super-ihs/logcar.pcert0 : no_pcert = 0
-coi/super-ihs/logcar.pcert0 : acl2x = 0
-coi/super-ihs/logcar.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/evenp.pcert0 \
- coi/super-ihs/logcar.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/logcar.pcert1 : acl2x = 0
-coi/super-ihs/logcar.pcert1 : no_pcert = 0
-coi/super-ihs/logcar.pcert1 : coi/super-ihs/logcar.pcert0
-coi/super-ihs/logcar.cert : | coi/super-ihs/logcar.pcert1
-
-coi/super-ihs/logcdr.pcert0 : no_pcert = 0
-coi/super-ihs/logcdr.pcert0 : acl2x = 0
-coi/super-ihs/logcdr.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/evenp.pcert0 \
- coi/super-ihs/unsigned-byte-p.pcert0 \
- coi/super-ihs/ash.pcert0 \
- coi/super-ihs/logcdr.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/logcdr.pcert1 : acl2x = 0
-coi/super-ihs/logcdr.pcert1 : no_pcert = 0
-coi/super-ihs/logcdr.pcert1 : coi/super-ihs/logcdr.pcert0
-coi/super-ihs/logcdr.cert : | coi/super-ihs/logcdr.pcert1
-
-coi/super-ihs/logcons.pcert0 : no_pcert = 0
-coi/super-ihs/logcons.pcert0 : acl2x = 0
-coi/super-ihs/logcons.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/evenp.pcert0 \
- coi/super-ihs/logcons.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/logcons.pcert1 : acl2x = 0
-coi/super-ihs/logcons.pcert1 : no_pcert = 0
-coi/super-ihs/logcons.pcert1 : coi/super-ihs/logcons.pcert0
-coi/super-ihs/logcons.cert : | coi/super-ihs/logcons.pcert1
-
-coi/super-ihs/logext.pcert0 : no_pcert = 0
-coi/super-ihs/logext.pcert0 : acl2x = 0
-coi/super-ihs/logext.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/logbitp.pcert0 \
- coi/super-ihs/logapp.pcert0 \
- coi/super-ihs/loghead.pcert0 \
- coi/super-ihs/logext.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/logext.pcert1 : acl2x = 0
-coi/super-ihs/logext.pcert1 : no_pcert = 0
-coi/super-ihs/logext.pcert1 : coi/super-ihs/logext.pcert0
-coi/super-ihs/logext.cert : | coi/super-ihs/logext.pcert1
-
-coi/super-ihs/loghead.pcert0 : no_pcert = 0
-coi/super-ihs/loghead.pcert0 : acl2x = 0
-coi/super-ihs/loghead.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/ash.pcert0 \
- coi/super-ihs/unsigned-byte-p.pcert0 \
- coi/super-ihs/logcar.pcert0 \
- coi/super-ihs/logcdr.pcert0 \
- coi/super-ihs/logcons.pcert0 \
- coi/super-ihs/inductions.pcert0 \
- coi/util/syntaxp.pcert0 \
- coi/super-ihs/loghead.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/loghead.pcert1 : acl2x = 0
-coi/super-ihs/loghead.pcert1 : no_pcert = 0
-coi/super-ihs/loghead.pcert1 : coi/super-ihs/loghead.pcert0
-coi/super-ihs/loghead.cert : | coi/super-ihs/loghead.pcert1
-
-coi/super-ihs/logical-logops.pcert0 : no_pcert = 0
-coi/super-ihs/logical-logops.pcert0 : acl2x = 0
-coi/super-ihs/logical-logops.pcert0 : \
- coi/super-ihs/loglist.pcert0 \
- coi/super-ihs/logext.pcert0 \
- coi/super-ihs/logical-logops.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/logical-logops.pcert1 : acl2x = 0
-coi/super-ihs/logical-logops.pcert1 : no_pcert = 0
-coi/super-ihs/logical-logops.pcert1 : coi/super-ihs/logical-logops.pcert0
-coi/super-ihs/logical-logops.cert : | coi/super-ihs/logical-logops.pcert1
-
-coi/super-ihs/logior-logapp-crock.pcert0 : no_pcert = 0
-coi/super-ihs/logior-logapp-crock.pcert0 : acl2x = 0
-coi/super-ihs/logior-logapp-crock.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- coi/super-ihs/logior-logapp-crock.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/logior-logapp-crock.pcert1 : acl2x = 0
-coi/super-ihs/logior-logapp-crock.pcert1 : no_pcert = 0
-coi/super-ihs/logior-logapp-crock.pcert1 : coi/super-ihs/logior-logapp-crock.pcert0
-coi/super-ihs/logior-logapp-crock.cert : | coi/super-ihs/logior-logapp-crock.pcert1
-
-coi/super-ihs/loglist.pcert0 : no_pcert = 0
-coi/super-ihs/loglist.pcert0 : acl2x = 0
-coi/super-ihs/loglist.pcert0 : \
- coi/super-ihs/byte-p.pcert0 \
- coi/super-ihs/logapp.pcert0 \
- coi/super-ihs/loglist.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/loglist.pcert1 : acl2x = 0
-coi/super-ihs/loglist.pcert1 : no_pcert = 0
-coi/super-ihs/loglist.pcert1 : coi/super-ihs/loglist.pcert0
-coi/super-ihs/loglist.cert : | coi/super-ihs/loglist.pcert1
-
-coi/super-ihs/logpair.pcert0 : no_pcert = 0
-coi/super-ihs/logpair.pcert0 : acl2x = 0
-coi/super-ihs/logpair.pcert0 : \
- coi/super-ihs/basics.pcert0 \
- coi/super-ihs/loghead.pcert0 \
- coi/super-ihs/logtail.pcert0 \
- coi/super-ihs/logcons.pcert0 \
- coi/super-ihs/logcdr.pcert0 \
- coi/super-ihs/logtail.pcert0 \
- coi/super-ihs/logbitp.pcert0 \
- coi/super-ihs/logbit.pcert0 \
- coi/super-ihs/unsigned-byte-p.pcert0 \
- coi/super-ihs/logpair.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/logpair.pcert1 : acl2x = 0
-coi/super-ihs/logpair.pcert1 : no_pcert = 0
-coi/super-ihs/logpair.pcert1 : coi/super-ihs/logpair.pcert0
-coi/super-ihs/logpair.cert : | coi/super-ihs/logpair.pcert1
-
-coi/super-ihs/logtail.pcert0 : no_pcert = 0
-coi/super-ihs/logtail.pcert0 : acl2x = 0
-coi/super-ihs/logtail.pcert0 : \
- coi/super-ihs/arithmetic.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/ash.pcert0 \
- coi/super-ihs/logtail.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/logtail.pcert1 : acl2x = 0
-coi/super-ihs/logtail.pcert1 : no_pcert = 0
-coi/super-ihs/logtail.pcert1 : coi/super-ihs/logtail.pcert0
-coi/super-ihs/logtail.cert : | coi/super-ihs/logtail.pcert1
-
-coi/super-ihs/lshu.pcert0 : no_pcert = 0
-coi/super-ihs/lshu.pcert0 : acl2x = 0
-coi/super-ihs/lshu.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/hacks.pcert0 \
- coi/super-ihs/lshu.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/lshu.pcert1 : acl2x = 0
-coi/super-ihs/lshu.pcert1 : no_pcert = 0
-coi/super-ihs/lshu.pcert1 : coi/super-ihs/lshu.pcert0
-coi/super-ihs/lshu.cert : | coi/super-ihs/lshu.pcert1
-
-coi/super-ihs/meta.pcert0 : no_pcert = 0
-coi/super-ihs/meta.pcert0 : acl2x = 0
-coi/super-ihs/meta.pcert0 : \
- coi/super-ihs/loghead.pcert0 \
- coi/super-ihs/arithmetic.pcert0 \
- coi/super-ihs/meta.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/meta.pcert1 : acl2x = 0
-coi/super-ihs/meta.pcert1 : no_pcert = 0
-coi/super-ihs/meta.pcert1 : coi/super-ihs/meta.pcert0
-coi/super-ihs/meta.cert : | coi/super-ihs/meta.pcert1
-
-coi/super-ihs/min-max.pcert0 : no_pcert = 0
-coi/super-ihs/min-max.pcert0 : acl2x = 0
-coi/super-ihs/min-max.pcert0 : \
- coi/super-ihs/min-max.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/min-max.pcert1 : acl2x = 0
-coi/super-ihs/min-max.pcert1 : no_pcert = 0
-coi/super-ihs/min-max.pcert1 : coi/super-ihs/min-max.pcert0
-coi/super-ihs/min-max.cert : | coi/super-ihs/min-max.pcert1
-
-coi/super-ihs/plus-logapp-suck.pcert0 : no_pcert = 0
-coi/super-ihs/plus-logapp-suck.pcert0 : acl2x = 0
-coi/super-ihs/plus-logapp-suck.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/plus-logapp-suck.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/plus-logapp-suck.pcert1 : acl2x = 0
-coi/super-ihs/plus-logapp-suck.pcert1 : no_pcert = 0
-coi/super-ihs/plus-logapp-suck.pcert1 : coi/super-ihs/plus-logapp-suck.pcert0
-coi/super-ihs/plus-logapp-suck.cert : | coi/super-ihs/plus-logapp-suck.pcert1
-
-coi/super-ihs/signed-byte-p-overflow.pcert0 : no_pcert = 0
-coi/super-ihs/signed-byte-p-overflow.pcert0 : acl2x = 0
-coi/super-ihs/signed-byte-p-overflow.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/signed-byte-p-overflow.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/signed-byte-p-overflow.pcert1 : acl2x = 0
-coi/super-ihs/signed-byte-p-overflow.pcert1 : no_pcert = 0
-coi/super-ihs/signed-byte-p-overflow.pcert1 : coi/super-ihs/signed-byte-p-overflow.pcert0
-coi/super-ihs/signed-byte-p-overflow.cert : | coi/super-ihs/signed-byte-p-overflow.pcert1
-
-coi/super-ihs/super-ihs.pcert0 : no_pcert = 0
-coi/super-ihs/super-ihs.pcert0 : acl2x = 0
-coi/super-ihs/super-ihs.pcert0 : \
- coi/super-ihs/hacks.pcert0 \
- coi/super-ihs/eric.pcert0 \
- coi/super-ihs/c-functions.pcert0 \
- coi/super-ihs/lshu.pcert0 \
- coi/super-ihs/min-max.pcert0 \
- coi/super-ihs/meta.pcert0 \
- rtl/rel4/arithmetic/expo.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/super-ihs/super-ihs.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/super-ihs.pcert1 : acl2x = 0
-coi/super-ihs/super-ihs.pcert1 : no_pcert = 0
-coi/super-ihs/super-ihs.pcert1 : coi/super-ihs/super-ihs.pcert0
-coi/super-ihs/super-ihs.cert : | coi/super-ihs/super-ihs.pcert1
-
-coi/super-ihs/unsigned-byte-p.pcert0 : no_pcert = 0
-coi/super-ihs/unsigned-byte-p.pcert0 : acl2x = 0
-coi/super-ihs/unsigned-byte-p.pcert0 : \
- coi/super-ihs/arithmetic.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- coi/super-ihs/eric.pcert0 \
- coi/super-ihs/unsigned-byte-p.lisp \
- coi/super-ihs/cert.acl2
-coi/super-ihs/unsigned-byte-p.pcert1 : acl2x = 0
-coi/super-ihs/unsigned-byte-p.pcert1 : no_pcert = 0
-coi/super-ihs/unsigned-byte-p.pcert1 : coi/super-ihs/unsigned-byte-p.pcert0
-coi/super-ihs/unsigned-byte-p.cert : | coi/super-ihs/unsigned-byte-p.pcert1
-
-coi/symbol-fns/symbol-fns-exports.pcert0 : no_pcert = 0
-coi/symbol-fns/symbol-fns-exports.pcert0 : acl2x = 0
-coi/symbol-fns/symbol-fns-exports.pcert0 : \
- coi/symbol-fns/symbol-fns-exports.lisp \
- coi/symbol-fns/cert.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/symbol-fns/symbol-fns-exports.pcert1 : acl2x = 0
-coi/symbol-fns/symbol-fns-exports.pcert1 : no_pcert = 0
-coi/symbol-fns/symbol-fns-exports.pcert1 : coi/symbol-fns/symbol-fns-exports.pcert0
-coi/symbol-fns/symbol-fns-exports.cert : | coi/symbol-fns/symbol-fns-exports.pcert1
-
-coi/symbol-fns/symbol-fns.pcert0 : no_pcert = 0
-coi/symbol-fns/symbol-fns.pcert0 : acl2x = 0
-coi/symbol-fns/symbol-fns.pcert0 : \
- coi/symbol-fns/symbol-fns.lisp \
- coi/symbol-fns/cert.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/symbol-fns/symbol-fns.pcert1 : acl2x = 0
-coi/symbol-fns/symbol-fns.pcert1 : no_pcert = 0
-coi/symbol-fns/symbol-fns.pcert1 : coi/symbol-fns/symbol-fns.pcert0
-coi/symbol-fns/symbol-fns.cert : | coi/symbol-fns/symbol-fns.pcert1
-
-coi/syntax/auxilary.pcert0 : no_pcert = 0
-coi/syntax/auxilary.pcert0 : acl2x = 0
-coi/syntax/auxilary.pcert0 : \
- coi/symbol-fns/symbol-fns.pcert0 \
- coi/syntax/auxilary.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/syntax/auxilary.pcert1 : acl2x = 0
-coi/syntax/auxilary.pcert1 : no_pcert = 0
-coi/syntax/auxilary.pcert1 : coi/syntax/auxilary.pcert0
-coi/syntax/auxilary.cert : | coi/syntax/auxilary.pcert1
-
-coi/syntax/defbinding.pcert0 : no_pcert = 0
-coi/syntax/defbinding.pcert0 : acl2x = 0
-coi/syntax/defbinding.pcert0 : \
- coi/symbol-fns/symbol-fns.pcert0 \
- coi/syntax/defbinding.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/syntax/defbinding.pcert1 : acl2x = 0
-coi/syntax/defbinding.pcert1 : no_pcert = 0
-coi/syntax/defbinding.pcert1 : coi/syntax/defbinding.pcert0
-coi/syntax/defbinding.cert : | coi/syntax/defbinding.pcert1
-
-coi/syntax/defevaluator.pcert0 : no_pcert = 0
-coi/syntax/defevaluator.pcert0 : acl2x = 0
-coi/syntax/defevaluator.pcert0 : \
- coi/syntax/defevaluator.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/syntax/defevaluator.pcert1 : acl2x = 0
-coi/syntax/defevaluator.pcert1 : no_pcert = 0
-coi/syntax/defevaluator.pcert1 : coi/syntax/defevaluator.pcert0
-coi/syntax/defevaluator.cert : | coi/syntax/defevaluator.pcert1
-
-coi/syntax/quine.pcert0 : no_pcert = 0
-coi/syntax/quine.pcert0 : acl2x = 0
-coi/syntax/quine.pcert0 : \
- coi/syntax/syntax.pcert0 \
- coi/syntax/quine.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/syntax/quine.pcert1 : acl2x = 0
-coi/syntax/quine.pcert1 : no_pcert = 0
-coi/syntax/quine.pcert1 : coi/syntax/quine.pcert0
-coi/syntax/quine.cert : | coi/syntax/quine.pcert1
-
-coi/syntax/syn-pkg.pcert0 : no_pcert = 0
-coi/syntax/syn-pkg.pcert0 : acl2x = 0
-coi/syntax/syn-pkg.pcert0 : \
- coi/syntax/syn-pkg.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/syntax/syn-pkg.pcert1 : acl2x = 0
-coi/syntax/syn-pkg.pcert1 : no_pcert = 0
-coi/syntax/syn-pkg.pcert1 : coi/syntax/syn-pkg.pcert0
-coi/syntax/syn-pkg.cert : | coi/syntax/syn-pkg.pcert1
-
-coi/syntax/syntax-extensions.pcert0 : no_pcert = 0
-coi/syntax/syntax-extensions.pcert0 : acl2x = 0
-coi/syntax/syntax-extensions.pcert0 : \
- coi/syntax/auxilary.pcert0 \
- coi/util/mv-nth.pcert0 \
- coi/syntax/syntax-extensions.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/syntax/syntax-extensions.pcert1 : acl2x = 0
-coi/syntax/syntax-extensions.pcert1 : no_pcert = 0
-coi/syntax/syntax-extensions.pcert1 : coi/syntax/syntax-extensions.pcert0
-coi/syntax/syntax-extensions.cert : | coi/syntax/syntax-extensions.pcert1
-
-coi/syntax/syntax.pcert0 : no_pcert = 0
-coi/syntax/syntax.pcert0 : acl2x = 0
-coi/syntax/syntax.pcert0 : \
- coi/syntax/syntax-extensions.pcert0 \
- coi/syntax/defevaluator.pcert0 \
- coi/syntax/syntax.lisp \
- coi/syntax/cert.acl2 \
- coi/syntax/syn-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/syntax/syntax.pcert1 : acl2x = 0
-coi/syntax/syntax.pcert1 : no_pcert = 0
-coi/syntax/syntax.pcert1 : coi/syntax/syntax.pcert0
-coi/syntax/syntax.cert : | coi/syntax/syntax.pcert1
-
-coi/termination/assuming/compiler-proof.pcert0 : no_pcert = 0
-coi/termination/assuming/compiler-proof.pcert0 : acl2x = 0
-coi/termination/assuming/compiler-proof.pcert0 : \
- coi/defpun/defminterm.pcert0 \
- coi/defpun/ack.pcert0 \
- coi/nary/nary.pcert0 \
- coi/util/mv-nth.pcert0 \
- coi/termination/assuming/compiler-proof.lisp \
- coi/termination/assuming/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/util/def-defpkg.lsp \
- coi/util/defun-defpkg.lsp
-coi/termination/assuming/compiler-proof.pcert1 : acl2x = 0
-coi/termination/assuming/compiler-proof.pcert1 : no_pcert = 0
-coi/termination/assuming/compiler-proof.pcert1 : coi/termination/assuming/compiler-proof.pcert0
-coi/termination/assuming/compiler-proof.cert : | coi/termination/assuming/compiler-proof.pcert1
-
-coi/termination/assuming/compiler.pcert0 : no_pcert = 0
-coi/termination/assuming/compiler.pcert0 : acl2x = 0
-coi/termination/assuming/compiler.pcert0 : \
- coi/syntax/syntax.pcert0 \
- coi/util/mv-nth.pcert0 \
- coi/termination/assuming/compiler-proof.pcert0 \
- make-event/eval.pcert0 \
- coi/util/pseudo-translate.pcert0 \
- coi/util/recursion-support.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- coi/termination/assuming/compiler.lisp \
- coi/termination/assuming/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/util/def-defpkg.lsp \
- coi/util/defun-defpkg.lsp
-coi/termination/assuming/compiler.pcert1 : acl2x = 0
-coi/termination/assuming/compiler.pcert1 : no_pcert = 0
-coi/termination/assuming/compiler.pcert1 : coi/termination/assuming/compiler.pcert0
-coi/termination/assuming/compiler.cert : | coi/termination/assuming/compiler.pcert1
-
-coi/termination/assuming/zero.pcert0 : no_pcert = 0
-coi/termination/assuming/zero.pcert0 : acl2x = 0
-coi/termination/assuming/zero.pcert0 : \
- coi/termination/assuming/compiler.pcert0 \
- ordinals/lexicographic-ordering.pcert0 \
- coi/termination/assuming/zero.lisp \
- coi/termination/assuming/cert.acl2 \
- coi/alists/alist-defpkg.lsp \
- coi/lists/list-exports.lsp \
- coi/lists/list-defpkg.lsp \
- coi/syntax/syn-defpkg.lsp \
- coi/util/gensym-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/util/def-defpkg.lsp \
- coi/util/defun-defpkg.lsp
-coi/termination/assuming/zero.pcert1 : acl2x = 0
-coi/termination/assuming/zero.pcert1 : no_pcert = 0
-coi/termination/assuming/zero.pcert1 : coi/termination/assuming/zero.pcert0
-coi/termination/assuming/zero.cert : | coi/termination/assuming/zero.pcert1
-
-coi/util/clause-processor.pcert0 : no_pcert = 0
-coi/util/clause-processor.pcert0 : acl2x = 0
-coi/util/clause-processor.pcert0 : \
- coi/util/clause-processor.lisp \
- coi/util/cert.acl2
-coi/util/clause-processor.pcert1 : acl2x = 0
-coi/util/clause-processor.pcert1 : no_pcert = 0
-coi/util/clause-processor.pcert1 : coi/util/clause-processor.pcert0
-coi/util/clause-processor.cert : | coi/util/clause-processor.pcert1
-
-coi/util/debug.pcert0 : no_pcert = 0
-coi/util/debug.pcert0 : acl2x = 0
-coi/util/debug.pcert0 : \
- coi/util/defdoc.pcert0 \
- coi/util/debug.lisp \
- coi/util/debug.acl2 \
- coi/util/def-defpkg.lsp \
- coi/util/debug-defpkg.lsp
-coi/util/debug.pcert1 : acl2x = 0
-coi/util/debug.pcert1 : no_pcert = 0
-coi/util/debug.pcert1 : coi/util/debug.pcert0
-coi/util/debug.cert : | coi/util/debug.pcert1
-
-coi/util/defbinding.pcert0 : no_pcert = 0
-coi/util/defbinding.pcert0 : acl2x = 0
-coi/util/defbinding.pcert0 : \
- coi/util/defbinding.lisp \
- coi/util/defbinding.acl2 \
- coi/util/def-defpkg.lsp
-coi/util/defbinding.pcert1 : acl2x = 0
-coi/util/defbinding.pcert1 : no_pcert = 0
-coi/util/defbinding.pcert1 : coi/util/defbinding.pcert0
-coi/util/defbinding.cert : | coi/util/defbinding.pcert1
-
-coi/util/defdoc.pcert0 : no_pcert = 0
-coi/util/defdoc.pcert0 : acl2x = 0
-coi/util/defdoc.pcert0 : \
- coi/util/defdoc.lisp \
- coi/util/defdoc.acl2 \
- coi/util/def-defpkg.lsp
-coi/util/defdoc.pcert1 : acl2x = 0
-coi/util/defdoc.pcert1 : no_pcert = 0
-coi/util/defdoc.pcert1 : coi/util/defdoc.pcert0
-coi/util/defdoc.cert : | coi/util/defdoc.pcert1
-
-coi/util/deffix.pcert0 : no_pcert = 0
-coi/util/deffix.pcert0 : acl2x = 0
-coi/util/deffix.pcert0 : \
- coi/symbol-fns/symbol-fns.pcert0 \
- coi/util/deffix.lisp \
- coi/util/deffix.acl2 \
- coi/util/def-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/util/deffix.pcert1 : acl2x = 0
-coi/util/deffix.pcert1 : no_pcert = 0
-coi/util/deffix.pcert1 : coi/util/deffix.pcert0
-coi/util/deffix.cert : | coi/util/deffix.pcert1
-
-coi/util/defsubtype.pcert0 : no_pcert = 0
-coi/util/defsubtype.pcert0 : acl2x = 0
-coi/util/defsubtype.pcert0 : \
- coi/util/rule-sets.pcert0 \
- coi/util/mv-nth.pcert0 \
- coi/util/defun-support.pcert0 \
- coi/util/rule-sets.pcert0 \
- coi/util/defsubtype.lisp \
- coi/util/defsubtype.acl2 \
- coi/util/def-defpkg.lsp \
- coi/util/defun-defpkg.lsp
-coi/util/defsubtype.pcert1 : acl2x = 0
-coi/util/defsubtype.pcert1 : no_pcert = 0
-coi/util/defsubtype.pcert1 : coi/util/defsubtype.pcert0
-coi/util/defsubtype.cert : | coi/util/defsubtype.pcert1
-
-coi/util/defun-support.pcert0 : no_pcert = 0
-coi/util/defun-support.pcert0 : acl2x = 0
-coi/util/defun-support.pcert0 : \
- misc/beta-reduce.pcert0 \
- coi/util/debug.pcert0 \
- coi/symbol-fns/symbol-fns.pcert0 \
- coi/util/mv-nth.pcert0 \
- coi/symbol-fns/symbol-fns.pcert0 \
- coi/util/defun-support.lisp \
- coi/util/defun-support.acl2 \
- coi/util/cert.acl2 \
- coi/util/defun-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/util/defun-support.pcert1 : acl2x = 0
-coi/util/defun-support.pcert1 : no_pcert = 0
-coi/util/defun-support.pcert1 : coi/util/defun-support.pcert0
-coi/util/defun-support.cert : | coi/util/defun-support.pcert1
-
-coi/util/defun.pcert0 : no_pcert = 0
-coi/util/defun.pcert0 : acl2x = 0
-coi/util/defun.pcert0 : \
- coi/util/recursion-support.pcert0 \
- coi/util/pseudo-translate.pcert0 \
- coi/util/mv-nth.pcert0 \
- coi/util/defun.lisp \
- coi/util/defun.acl2 \
- coi/util/cert.acl2 \
- coi/util/defun-defpkg.lsp \
- coi/util/def-defpkg.lsp \
- coi/util/debug-defpkg.lsp \
- coi/symbol-fns/symbol-fns-defpkg.lsp
-coi/util/defun.pcert1 : acl2x = 0
-coi/util/defun.pcert1 : no_pcert = 0
-coi/util/defun.pcert1 : coi/util/defun.pcert0
-coi/util/defun.cert : | coi/util/defun.pcert1
-
-coi/util/extra-info-test.pcert0 : no_pcert = 0
-coi/util/extra-info-test.pcert0 : acl2x = 0
-coi/util/extra-info-test.pcert0 : \
- coi/util/extra-info.pcert0 \
- make-event/eval.pcert0 \
- coi/util/extra-info-test.lisp \
- coi/util/cert.acl2
-coi/util/extra-info-test.pcert1 : acl2x = 0
-coi/util/extra-info-test.pcert1 : no_pcert = 0
-coi/util/extra-info-test.pcert1 : coi/util/extra-info-test.pcert0
-coi/util/extra-info-test.cert : | coi/util/extra-info-test.pcert1
-
-coi/util/extra-info.pcert0 : no_pcert = 0
-coi/util/extra-info.pcert0 : acl2x = 0
-coi/util/extra-info.pcert0 : \
- coi/util/in-conclusion.pcert0 \
- coi/util/extra-info.lisp \
- coi/util/cert.acl2
-coi/util/extra-info.pcert1 : acl2x = 0
-coi/util/extra-info.pcert1 : no_pcert = 0
-coi/util/extra-info.pcert1 : coi/util/extra-info.pcert0
-coi/util/extra-info.cert : | coi/util/extra-info.pcert1
-
-coi/util/fixequiv.pcert0 : no_pcert = 0
-coi/util/fixequiv.pcert0 : acl2x = 0
-coi/util/fixequiv.pcert0 : \
- coi/util/fixequiv.lisp \
- coi/util/cert.acl2
-coi/util/fixequiv.pcert1 : acl2x = 0
-coi/util/fixequiv.pcert1 : no_pcert = 0
-coi/util/fixequiv.pcert1 : coi/util/fixequiv.pcert0
-coi/util/fixequiv.cert : | coi/util/fixequiv.pcert1
-
-coi/util/good-rewrite-order.pcert0 : no_pcert = 0
-coi/util/good-rewrite-order.pcert0 : acl2x = 0
-coi/util/good-rewrite-order.pcert0 : \
- coi/util/syntaxp.pcert0 \
- misc/total-order.pcert0 \
- coi/util/good-rewrite-order.lisp \
- coi/util/cert.acl2
-coi/util/good-rewrite-order.pcert1 : acl2x = 0
-coi/util/good-rewrite-order.pcert1 : no_pcert = 0
-coi/util/good-rewrite-order.pcert1 : coi/util/good-rewrite-order.pcert0
-coi/util/good-rewrite-order.cert : | coi/util/good-rewrite-order.pcert1
-
-coi/util/ifdef.pcert0 : no_pcert = 0
-coi/util/ifdef.pcert0 : acl2x = 0
-coi/util/ifdef.pcert0 : \
- coi/util/defdoc.pcert0 \
- coi/util/ifdef.lisp \
- coi/util/ifdef.acl2 \
- coi/util/def-defpkg.lsp
-coi/util/ifdef.pcert1 : acl2x = 0
-coi/util/ifdef.pcert1 : no_pcert = 0
-coi/util/ifdef.pcert1 : coi/util/ifdef.pcert0
-coi/util/ifdef.cert : | coi/util/ifdef.pcert1
-
-coi/util/iff.pcert0 : no_pcert = 0
-coi/util/iff.pcert0 : acl2x = 0
-coi/util/iff.pcert0 : \
- coi/util/iff.lisp \
- coi/util/cert.acl2
-coi/util/iff.pcert1 : acl2x = 0
-coi/util/iff.pcert1 : no_pcert = 0
-coi/util/iff.pcert1 : coi/util/iff.pcert0
-coi/util/iff.cert : | coi/util/iff.pcert1
-
-coi/util/ifixequiv.pcert0 : no_pcert = 0
-coi/util/ifixequiv.pcert0 : acl2x = 0
-coi/util/ifixequiv.pcert0 : \
- coi/util/fixequiv.pcert0 \
- coi/util/ifixequiv.lisp \
- coi/util/cert.acl2
-coi/util/ifixequiv.pcert1 : acl2x = 0
-coi/util/ifixequiv.pcert1 : no_pcert = 0
-coi/util/ifixequiv.pcert1 : coi/util/ifixequiv.pcert0
-coi/util/ifixequiv.cert : | coi/util/ifixequiv.pcert1
-
-coi/util/implies.pcert0 : no_pcert = 0
-coi/util/implies.pcert0 : acl2x = 0
-coi/util/implies.pcert0 : \
- coi/util/in-conclusion.pcert0 \
- coi/util/implies.lisp \
- coi/util/cert.acl2
-coi/util/implies.pcert1 : acl2x = 0
-coi/util/implies.pcert1 : no_pcert = 0
-coi/util/implies.pcert1 : coi/util/implies.pcert0
-coi/util/implies.cert : | coi/util/implies.pcert1
-
-coi/util/in-conclusion.pcert0 : no_pcert = 0
-coi/util/in-conclusion.pcert0 : acl2x = 0
-coi/util/in-conclusion.pcert0 : \
- coi/util/in-conclusion.lisp \
- coi/util/cert.acl2
-coi/util/in-conclusion.pcert1 : acl2x = 0
-coi/util/in-conclusion.pcert1 : no_pcert = 0
-coi/util/in-conclusion.pcert1 : coi/util/in-conclusion.pcert0
-coi/util/in-conclusion.cert : | coi/util/in-conclusion.pcert1
-
-coi/util/ith.pcert0 : no_pcert = 0
-coi/util/ith.pcert0 : acl2x = 0
-coi/util/ith.pcert0 : \
- coi/util/ith.lisp \
- coi/util/cert.acl2
-coi/util/ith.pcert1 : acl2x = 0
-coi/util/ith.pcert1 : no_pcert = 0
-coi/util/ith.pcert1 : coi/util/ith.pcert0
-coi/util/ith.cert : | coi/util/ith.pcert1
-
-coi/util/mv-nth.pcert0 : no_pcert = 0
-coi/util/mv-nth.pcert0 : acl2x = 0
-coi/util/mv-nth.pcert0 : \
- coi/util/mv-nth.lisp \
- coi/util/mv-nth.acl2 \
- coi/util/gensym-defpkg.lsp
-coi/util/mv-nth.pcert1 : acl2x = 0
-coi/util/mv-nth.pcert1 : no_pcert = 0
-coi/util/mv-nth.pcert1 : coi/util/mv-nth.pcert0
-coi/util/mv-nth.cert : | coi/util/mv-nth.pcert1
-
-coi/util/nfixequiv.pcert0 : no_pcert = 0
-coi/util/nfixequiv.pcert0 : acl2x = 0
-coi/util/nfixequiv.pcert0 : \
- coi/util/ifixequiv.pcert0 \
- coi/util/nfixequiv.lisp \
- coi/util/cert.acl2
-coi/util/nfixequiv.pcert1 : acl2x = 0
-coi/util/nfixequiv.pcert1 : no_pcert = 0
-coi/util/nfixequiv.pcert1 : coi/util/nfixequiv.pcert0
-coi/util/nfixequiv.cert : | coi/util/nfixequiv.pcert1
-
-coi/util/ordinal-order.pcert0 : no_pcert = 0
-coi/util/ordinal-order.pcert0 : acl2x = 0
-coi/util/ordinal-order.pcert0 : \
- ordinals/lexicographic-ordering.pcert0 \
- coi/util/ordinal-order.lisp \
- coi/util/cert.acl2
-coi/util/ordinal-order.pcert1 : acl2x = 0
-coi/util/ordinal-order.pcert1 : no_pcert = 0
-coi/util/ordinal-order.pcert1 : coi/util/ordinal-order.pcert0
-coi/util/ordinal-order.cert : | coi/util/ordinal-order.pcert1
-
-coi/util/pseudo-translate.pcert0 : no_pcert = 0
-coi/util/pseudo-translate.pcert0 : acl2x = 0
-coi/util/pseudo-translate.pcert0 : \
- coi/util/pseudo-translate.lisp \
- coi/util/cert.acl2
-coi/util/pseudo-translate.pcert1 : acl2x = 0
-coi/util/pseudo-translate.pcert1 : no_pcert = 0
-coi/util/pseudo-translate.pcert1 : coi/util/pseudo-translate.pcert0
-coi/util/pseudo-translate.cert : | coi/util/pseudo-translate.pcert1
-
-coi/util/recursion-support.pcert0 : no_pcert = 0
-coi/util/recursion-support.pcert0 : acl2x = 0
-coi/util/recursion-support.pcert0 : \
- coi/util/mv-nth.pcert0 \
- coi/util/defun-support.pcert0 \
- coi/symbol-fns/symbol-fns.pcert0 \
- coi/util/recursion-support.lisp \
- coi/util/recursion-support.acl2 \
- coi/symbol-fns/symbol-fns-defpkg.lsp \
- coi/util/defun-defpkg.lsp
-coi/util/recursion-support.pcert1 : acl2x = 0
-coi/util/recursion-support.pcert1 : no_pcert = 0
-coi/util/recursion-support.pcert1 : coi/util/recursion-support.pcert0
-coi/util/recursion-support.cert : | coi/util/recursion-support.pcert1
-
-coi/util/rewrite-equiv.pcert0 : no_pcert = 0
-coi/util/rewrite-equiv.pcert0 : acl2x = 0
-coi/util/rewrite-equiv.pcert0 : \
- coi/util/good-rewrite-order.pcert0 \
- coi/util/clause-processor.pcert0 \
- coi/util/rewrite-equiv.lisp \
- coi/util/cert.acl2
-coi/util/rewrite-equiv.pcert1 : acl2x = 0
-coi/util/rewrite-equiv.pcert1 : no_pcert = 0
-coi/util/rewrite-equiv.pcert1 : coi/util/rewrite-equiv.pcert0
-coi/util/rewrite-equiv.cert : | coi/util/rewrite-equiv.pcert1
-
-coi/util/rule-sets-documentation.pcert0 : no_pcert = 0
-coi/util/rule-sets-documentation.pcert0 : acl2x = 0
-coi/util/rule-sets-documentation.pcert0 : \
- coi/util/defdoc.pcert0 \
- coi/util/rule-sets-documentation.lisp \
- coi/util/rule-sets-documentation.acl2 \
- coi/util/cert.acl2 \
- coi/util/def-defpkg.lsp
-coi/util/rule-sets-documentation.pcert1 : acl2x = 0
-coi/util/rule-sets-documentation.pcert1 : no_pcert = 0
-coi/util/rule-sets-documentation.pcert1 : coi/util/rule-sets-documentation.pcert0
-coi/util/rule-sets-documentation.cert : | coi/util/rule-sets-documentation.pcert1
-
-coi/util/rule-sets-support.pcert0 : no_pcert = 0
-coi/util/rule-sets-support.pcert0 : acl2x = 0
-coi/util/rule-sets-support.pcert0 : \
- coi/util/rule-sets-support.lisp \
- coi/util/rule-sets-support.acl2 \
- coi/util/cert.acl2 \
- coi/util/rule-sets-defpkg.lsp
-coi/util/rule-sets-support.pcert1 : acl2x = 0
-coi/util/rule-sets-support.pcert1 : no_pcert = 0
-coi/util/rule-sets-support.pcert1 : coi/util/rule-sets-support.pcert0
-coi/util/rule-sets-support.cert : | coi/util/rule-sets-support.pcert1
-
-coi/util/rule-sets.pcert0 : no_pcert = 0
-coi/util/rule-sets.pcert0 : acl2x = 0
-coi/util/rule-sets.pcert0 : \
- coi/util/rule-sets-documentation.pcert0 \
- coi/util/rule-sets-support.pcert0 \
- coi/util/table.pcert0 \
- coi/util/rule-sets.lisp \
- coi/util/rule-sets.acl2 \
- coi/util/cert.acl2 \
- coi/util/rule-sets-defpkg.lsp \
- coi/util/table-defpkg.lsp \
- coi/util/def-defpkg.lsp
-coi/util/rule-sets.pcert1 : acl2x = 0
-coi/util/rule-sets.pcert1 : no_pcert = 0
-coi/util/rule-sets.pcert1 : coi/util/rule-sets.pcert0
-coi/util/rule-sets.cert : | coi/util/rule-sets.pcert1
-
-coi/util/skip-rewrite.pcert0 : no_pcert = 0
-coi/util/skip-rewrite.pcert0 : acl2x = 0
-coi/util/skip-rewrite.pcert0 : \
- misc/beta-reduce.pcert0 \
- coi/util/skip-rewrite.lisp \
- coi/util/cert.acl2
-coi/util/skip-rewrite.pcert1 : acl2x = 0
-coi/util/skip-rewrite.pcert1 : no_pcert = 0
-coi/util/skip-rewrite.pcert1 : coi/util/skip-rewrite.pcert0
-coi/util/skip-rewrite.cert : | coi/util/skip-rewrite.pcert1
-
-coi/util/syntaxp.pcert0 : no_pcert = 0
-coi/util/syntaxp.pcert0 : acl2x = 0
-coi/util/syntaxp.pcert0 : \
- coi/util/syntaxp.lisp \
- coi/util/cert.acl2
-coi/util/syntaxp.pcert1 : acl2x = 0
-coi/util/syntaxp.pcert1 : no_pcert = 0
-coi/util/syntaxp.pcert1 : coi/util/syntaxp.pcert0
-coi/util/syntaxp.cert : | coi/util/syntaxp.pcert1
-
-coi/util/table.pcert0 : no_pcert = 0
-coi/util/table.pcert0 : acl2x = 0
-coi/util/table.pcert0 : \
- coi/util/table.lisp \
- coi/util/table.acl2 \
- coi/util/cert.acl2 \
- coi/util/table-defpkg.lsp
-coi/util/table.pcert1 : acl2x = 0
-coi/util/table.pcert1 : no_pcert = 0
-coi/util/table.pcert1 : coi/util/table.pcert0
-coi/util/table.cert : | coi/util/table.pcert1
-
-concurrent-programs/bakery/apply-total-order.pcert0 : no_pcert = 0
-concurrent-programs/bakery/apply-total-order.pcert0 : acl2x = 0
-concurrent-programs/bakery/apply-total-order.pcert0 : \
- misc/total-order.pcert0 \
- concurrent-programs/bakery/apply-total-order.lisp
-concurrent-programs/bakery/apply-total-order.pcert1 : acl2x = 0
-concurrent-programs/bakery/apply-total-order.pcert1 : no_pcert = 0
-concurrent-programs/bakery/apply-total-order.pcert1 : concurrent-programs/bakery/apply-total-order.pcert0
-concurrent-programs/bakery/apply-total-order.cert : | concurrent-programs/bakery/apply-total-order.pcert1
-
-concurrent-programs/bakery/fairenv.pcert0 : no_pcert = 0
-concurrent-programs/bakery/fairenv.pcert0 : acl2x = 0
-concurrent-programs/bakery/fairenv.pcert0 : \
- concurrent-programs/bakery/measures.pcert0 \
- concurrent-programs/bakery/records.pcert0 \
- concurrent-programs/bakery/fairenv.lisp
-concurrent-programs/bakery/fairenv.pcert1 : acl2x = 0
-concurrent-programs/bakery/fairenv.pcert1 : no_pcert = 0
-concurrent-programs/bakery/fairenv.pcert1 : concurrent-programs/bakery/fairenv.pcert0
-concurrent-programs/bakery/fairenv.cert : | concurrent-programs/bakery/fairenv.pcert1
-
-concurrent-programs/bakery/final-theorems.pcert0 : no_pcert = 0
-concurrent-programs/bakery/final-theorems.pcert0 : acl2x = 0
-concurrent-programs/bakery/final-theorems.pcert0 : \
- concurrent-programs/bakery/labels.pcert0 \
- concurrent-programs/bakery/stutter1-match.pcert0 \
- concurrent-programs/bakery/stutter2.pcert0 \
- concurrent-programs/bakery/initial-state.pcert0 \
- concurrent-programs/bakery/inv-persists.pcert0 \
- concurrent-programs/bakery/inv-sufficient.pcert0 \
- concurrent-programs/bakery/final-theorems.lisp
-concurrent-programs/bakery/final-theorems.pcert1 : acl2x = 0
-concurrent-programs/bakery/final-theorems.pcert1 : no_pcert = 0
-concurrent-programs/bakery/final-theorems.pcert1 : concurrent-programs/bakery/final-theorems.pcert0
-concurrent-programs/bakery/final-theorems.cert : | concurrent-programs/bakery/final-theorems.pcert1
-
-concurrent-programs/bakery/initial-state.pcert0 : no_pcert = 0
-concurrent-programs/bakery/initial-state.pcert0 : acl2x = 0
-concurrent-programs/bakery/initial-state.pcert0 : \
- concurrent-programs/bakery/programs.pcert0 \
- concurrent-programs/bakery/properties.pcert0 \
- concurrent-programs/bakery/initial-state.lisp
-concurrent-programs/bakery/initial-state.pcert1 : acl2x = 0
-concurrent-programs/bakery/initial-state.pcert1 : no_pcert = 0
-concurrent-programs/bakery/initial-state.pcert1 : concurrent-programs/bakery/initial-state.pcert0
-concurrent-programs/bakery/initial-state.cert : | concurrent-programs/bakery/initial-state.pcert1
-
-concurrent-programs/bakery/inv-persists.pcert0 : no_pcert = 0
-concurrent-programs/bakery/inv-persists.pcert0 : acl2x = 0
-concurrent-programs/bakery/inv-persists.pcert0 : \
- concurrent-programs/bakery/programs.pcert0 \
- concurrent-programs/bakery/properties.pcert0 \
- concurrent-programs/bakery/lexicographic-pos.pcert0 \
- concurrent-programs/bakery/inv-persists.lisp
-concurrent-programs/bakery/inv-persists.pcert1 : acl2x = 0
-concurrent-programs/bakery/inv-persists.pcert1 : no_pcert = 0
-concurrent-programs/bakery/inv-persists.pcert1 : concurrent-programs/bakery/inv-persists.pcert0
-concurrent-programs/bakery/inv-persists.cert : | concurrent-programs/bakery/inv-persists.pcert1
-
-concurrent-programs/bakery/inv-sufficient.pcert0 : no_pcert = 0
-concurrent-programs/bakery/inv-sufficient.pcert0 : acl2x = 0
-concurrent-programs/bakery/inv-sufficient.pcert0 : \
- concurrent-programs/bakery/programs.pcert0 \
- concurrent-programs/bakery/properties.pcert0 \
- concurrent-programs/bakery/lexicographic-pos.pcert0 \
- concurrent-programs/bakery/properties-of-sets.pcert0 \
- concurrent-programs/bakery/inv-sufficient.lisp
-concurrent-programs/bakery/inv-sufficient.pcert1 : acl2x = 0
-concurrent-programs/bakery/inv-sufficient.pcert1 : no_pcert = 0
-concurrent-programs/bakery/inv-sufficient.pcert1 : concurrent-programs/bakery/inv-sufficient.pcert0
-concurrent-programs/bakery/inv-sufficient.cert : | concurrent-programs/bakery/inv-sufficient.pcert1
-
-concurrent-programs/bakery/labels.pcert0 : no_pcert = 0
-concurrent-programs/bakery/labels.pcert0 : acl2x = 0
-concurrent-programs/bakery/labels.pcert0 : \
- concurrent-programs/bakery/properties.pcert0 \
- concurrent-programs/bakery/labels.lisp
-concurrent-programs/bakery/labels.pcert1 : acl2x = 0
-concurrent-programs/bakery/labels.pcert1 : no_pcert = 0
-concurrent-programs/bakery/labels.pcert1 : concurrent-programs/bakery/labels.pcert0
-concurrent-programs/bakery/labels.cert : | concurrent-programs/bakery/labels.pcert1
-
-concurrent-programs/bakery/lexicographic-pos.pcert0 : no_pcert = 0
-concurrent-programs/bakery/lexicographic-pos.pcert0 : acl2x = 0
-concurrent-programs/bakery/lexicographic-pos.pcert0 : \
- concurrent-programs/bakery/properties.pcert0 \
- concurrent-programs/bakery/pos-temp.pcert0 \
- concurrent-programs/bakery/lexicographic-pos.lisp
-concurrent-programs/bakery/lexicographic-pos.pcert1 : acl2x = 0
-concurrent-programs/bakery/lexicographic-pos.pcert1 : no_pcert = 0
-concurrent-programs/bakery/lexicographic-pos.pcert1 : concurrent-programs/bakery/lexicographic-pos.pcert0
-concurrent-programs/bakery/lexicographic-pos.cert : | concurrent-programs/bakery/lexicographic-pos.pcert1
-
-concurrent-programs/bakery/lexicographic.pcert0 : no_pcert = 0
-concurrent-programs/bakery/lexicographic.pcert0 : acl2x = 0
-concurrent-programs/bakery/lexicographic.pcert0 : \
- misc/total-order.pcert0 \
- concurrent-programs/bakery/measures.pcert0 \
- concurrent-programs/bakery/lexicographic.lisp
-concurrent-programs/bakery/lexicographic.pcert1 : acl2x = 0
-concurrent-programs/bakery/lexicographic.pcert1 : no_pcert = 0
-concurrent-programs/bakery/lexicographic.pcert1 : concurrent-programs/bakery/lexicographic.pcert0
-concurrent-programs/bakery/lexicographic.cert : | concurrent-programs/bakery/lexicographic.pcert1
-
-concurrent-programs/bakery/measures.pcert0 : no_pcert = 0
-concurrent-programs/bakery/measures.pcert0 : acl2x = 0
-concurrent-programs/bakery/measures.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- concurrent-programs/bakery/measures.lisp
-concurrent-programs/bakery/measures.pcert1 : acl2x = 0
-concurrent-programs/bakery/measures.pcert1 : no_pcert = 0
-concurrent-programs/bakery/measures.pcert1 : concurrent-programs/bakery/measures.pcert0
-concurrent-programs/bakery/measures.cert : | concurrent-programs/bakery/measures.pcert1
-
-concurrent-programs/bakery/pos-temp.pcert0 : no_pcert = 0
-concurrent-programs/bakery/pos-temp.pcert0 : acl2x = 0
-concurrent-programs/bakery/pos-temp.pcert0 : \
- concurrent-programs/bakery/variables.pcert0 \
- concurrent-programs/bakery/properties.pcert0 \
- concurrent-programs/bakery/pos-temp.lisp
-concurrent-programs/bakery/pos-temp.pcert1 : acl2x = 0
-concurrent-programs/bakery/pos-temp.pcert1 : no_pcert = 0
-concurrent-programs/bakery/pos-temp.pcert1 : concurrent-programs/bakery/pos-temp.pcert0
-concurrent-programs/bakery/pos-temp.cert : | concurrent-programs/bakery/pos-temp.pcert1
-
-concurrent-programs/bakery/programs.pcert0 : no_pcert = 0
-concurrent-programs/bakery/programs.pcert0 : acl2x = 0
-concurrent-programs/bakery/programs.pcert0 : \
- concurrent-programs/bakery/variables.pcert0 \
- concurrent-programs/bakery/lexicographic.pcert0 \
- concurrent-programs/bakery/fairenv.pcert0 \
- concurrent-programs/bakery/programs.lisp
-concurrent-programs/bakery/programs.pcert1 : acl2x = 0
-concurrent-programs/bakery/programs.pcert1 : no_pcert = 0
-concurrent-programs/bakery/programs.pcert1 : concurrent-programs/bakery/programs.pcert0
-concurrent-programs/bakery/programs.cert : | concurrent-programs/bakery/programs.pcert1
-
-concurrent-programs/bakery/properties-of-sets.pcert0 : no_pcert = 0
-concurrent-programs/bakery/properties-of-sets.pcert0 : acl2x = 0
-concurrent-programs/bakery/properties-of-sets.pcert0 : \
- concurrent-programs/bakery/records.pcert0 \
- concurrent-programs/bakery/properties-of-sets.lisp
-concurrent-programs/bakery/properties-of-sets.pcert1 : acl2x = 0
-concurrent-programs/bakery/properties-of-sets.pcert1 : no_pcert = 0
-concurrent-programs/bakery/properties-of-sets.pcert1 : concurrent-programs/bakery/properties-of-sets.pcert0
-concurrent-programs/bakery/properties-of-sets.cert : | concurrent-programs/bakery/properties-of-sets.pcert1
-
-concurrent-programs/bakery/properties.pcert0 : no_pcert = 0
-concurrent-programs/bakery/properties.pcert0 : acl2x = 0
-concurrent-programs/bakery/properties.pcert0 : \
- concurrent-programs/bakery/lexicographic.pcert0 \
- concurrent-programs/bakery/measures.pcert0 \
- concurrent-programs/bakery/properties-of-sets.pcert0 \
- concurrent-programs/bakery/variables.pcert0 \
- concurrent-programs/bakery/fairenv.pcert0 \
- concurrent-programs/bakery/properties.lisp
-concurrent-programs/bakery/properties.pcert1 : acl2x = 0
-concurrent-programs/bakery/properties.pcert1 : no_pcert = 0
-concurrent-programs/bakery/properties.pcert1 : concurrent-programs/bakery/properties.pcert0
-concurrent-programs/bakery/properties.cert : | concurrent-programs/bakery/properties.pcert1
-
-concurrent-programs/bakery/records.pcert0 : no_pcert = 0
-concurrent-programs/bakery/records.pcert0 : acl2x = 0
-concurrent-programs/bakery/records.pcert0 : \
- concurrent-programs/bakery/apply-total-order.pcert0 \
- concurrent-programs/bakery/records.lisp
-concurrent-programs/bakery/records.pcert1 : acl2x = 0
-concurrent-programs/bakery/records.pcert1 : no_pcert = 0
-concurrent-programs/bakery/records.pcert1 : concurrent-programs/bakery/records.pcert0
-concurrent-programs/bakery/records.cert : | concurrent-programs/bakery/records.pcert1
-
-concurrent-programs/bakery/stutter1-match.pcert0 : no_pcert = 0
-concurrent-programs/bakery/stutter1-match.pcert0 : acl2x = 0
-concurrent-programs/bakery/stutter1-match.pcert0 : \
- concurrent-programs/bakery/programs.pcert0 \
- concurrent-programs/bakery/properties.pcert0 \
- concurrent-programs/bakery/stutter1-match.lisp
-concurrent-programs/bakery/stutter1-match.pcert1 : acl2x = 0
-concurrent-programs/bakery/stutter1-match.pcert1 : no_pcert = 0
-concurrent-programs/bakery/stutter1-match.pcert1 : concurrent-programs/bakery/stutter1-match.pcert0
-concurrent-programs/bakery/stutter1-match.cert : | concurrent-programs/bakery/stutter1-match.pcert1
-
-concurrent-programs/bakery/stutter2.pcert0 : no_pcert = 0
-concurrent-programs/bakery/stutter2.pcert0 : acl2x = 0
-concurrent-programs/bakery/stutter2.pcert0 : \
- concurrent-programs/bakery/programs.pcert0 \
- concurrent-programs/bakery/properties.pcert0 \
- arithmetic-2/meta/top.pcert0 \
- concurrent-programs/bakery/lexicographic-pos.pcert0 \
- concurrent-programs/bakery/stutter2.lisp
-concurrent-programs/bakery/stutter2.pcert1 : acl2x = 0
-concurrent-programs/bakery/stutter2.pcert1 : no_pcert = 0
-concurrent-programs/bakery/stutter2.pcert1 : concurrent-programs/bakery/stutter2.pcert0
-concurrent-programs/bakery/stutter2.cert : | concurrent-programs/bakery/stutter2.pcert1
-
-concurrent-programs/bakery/variables.pcert0 : no_pcert = 0
-concurrent-programs/bakery/variables.pcert0 : acl2x = 0
-concurrent-programs/bakery/variables.pcert0 : \
- concurrent-programs/bakery/records.pcert0 \
- concurrent-programs/bakery/variables.lisp
-concurrent-programs/bakery/variables.pcert1 : acl2x = 0
-concurrent-programs/bakery/variables.pcert1 : no_pcert = 0
-concurrent-programs/bakery/variables.pcert1 : concurrent-programs/bakery/variables.pcert0
-concurrent-programs/bakery/variables.cert : | concurrent-programs/bakery/variables.pcert1
-
-concurrent-programs/german-protocol/german.pcert0 : no_pcert = 0
-concurrent-programs/german-protocol/german.pcert0 : acl2x = 0
-concurrent-programs/german-protocol/german.pcert0 : \
- misc/records.pcert0 \
- concurrent-programs/german-protocol/german.lisp
-concurrent-programs/german-protocol/german.pcert1 : acl2x = 0
-concurrent-programs/german-protocol/german.pcert1 : no_pcert = 0
-concurrent-programs/german-protocol/german.pcert1 : concurrent-programs/german-protocol/german.pcert0
-concurrent-programs/german-protocol/german.cert : | concurrent-programs/german-protocol/german.pcert1
-
-countereg-gen/acl2s-parameter.pcert0 : no_pcert = 0
-countereg-gen/acl2s-parameter.pcert0 : acl2x = 0
-countereg-gen/acl2s-parameter.pcert0 : \
- countereg-gen/utilities.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/acl2s-parameter.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/acl2s-parameter.pcert1 : acl2x = 0
-countereg-gen/acl2s-parameter.pcert1 : no_pcert = 0
-countereg-gen/acl2s-parameter.pcert1 : countereg-gen/acl2s-parameter.pcert0
-countereg-gen/acl2s-parameter.cert : | countereg-gen/acl2s-parameter.pcert1
-
-countereg-gen/base.pcert0 : no_pcert = 0
-countereg-gen/base.pcert0 : acl2x = 0
-countereg-gen/base.pcert0 : \
- countereg-gen/data.pcert0 \
- countereg-gen/splitnat.pcert0 \
- countereg-gen/switchnat.pcert0 \
- countereg-gen/graph.pcert0 \
- countereg-gen/library-support.pcert0 \
- arithmetic-5/top.pcert0 \
- arithmetic-5/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/base.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/base.pcert1 : acl2x = 0
-countereg-gen/base.pcert1 : no_pcert = 0
-countereg-gen/base.pcert1 : countereg-gen/base.pcert0
-countereg-gen/base.cert : | countereg-gen/base.pcert1
-
-countereg-gen/basis.pcert0 : no_pcert = 0
-countereg-gen/basis.pcert0 : acl2x = 0
-countereg-gen/basis.pcert0 : \
- tools/bstar.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/basis.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/basis.pcert1 : acl2x = 0
-countereg-gen/basis.pcert1 : no_pcert = 0
-countereg-gen/basis.pcert1 : countereg-gen/basis.pcert0
-countereg-gen/basis.cert : | countereg-gen/basis.pcert1
-
-countereg-gen/data.pcert0 : no_pcert = 0
-countereg-gen/data.pcert0 : acl2x = 0
-countereg-gen/data.pcert0 : \
- countereg-gen/utilities.pcert0 \
- countereg-gen/basis.pcert0 \
- countereg-gen/acl2s-parameter.pcert0 \
- countereg-gen/splitnat.pcert0 \
- countereg-gen/switchnat.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/data.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/data.pcert1 : acl2x = 0
-countereg-gen/data.pcert1 : no_pcert = 0
-countereg-gen/data.pcert1 : countereg-gen/data.pcert0
-countereg-gen/data.cert : | countereg-gen/data.pcert1
-
-countereg-gen/graph.pcert0 : no_pcert = 0
-countereg-gen/graph.pcert0 : acl2x = 0
-countereg-gen/graph.pcert0 : \
- countereg-gen/utilities.pcert0 \
- countereg-gen/data.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/graph.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/graph.pcert1 : acl2x = 0
-countereg-gen/graph.pcert1 : no_pcert = 0
-countereg-gen/graph.pcert1 : countereg-gen/graph.pcert0
-countereg-gen/graph.cert : | countereg-gen/graph.pcert1
-
-countereg-gen/library-support.pcert0 : no_pcert = 0
-countereg-gen/library-support.pcert0 : acl2x = 0
-countereg-gen/library-support.pcert0 : \
- defexec/other-apps/records/records.pcert0 \
- finite-set-theory/osets/sets.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/library-support.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/library-support.pcert1 : acl2x = 0
-countereg-gen/library-support.pcert1 : no_pcert = 0
-countereg-gen/library-support.pcert1 : countereg-gen/library-support.pcert0
-countereg-gen/library-support.cert : | countereg-gen/library-support.pcert1
-
-countereg-gen/main.pcert0 : no_pcert = 0
-countereg-gen/main.pcert0 : acl2x = 0
-countereg-gen/main.pcert0 : \
- tools/bstar.pcert0 \
- countereg-gen/basis.pcert0 \
- countereg-gen/with-timeout.pcert0 \
- countereg-gen/type.pcert0 \
- countereg-gen/acl2s-parameter.pcert0 \
- countereg-gen/simple-graph-array.pcert0 \
- countereg-gen/random-state.pcert0 \
- tools/easy-simplify.pcert0 \
- countereg-gen/data.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/main.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/main.pcert1 : acl2x = 0
-countereg-gen/main.pcert1 : no_pcert = 0
-countereg-gen/main.pcert1 : countereg-gen/main.pcert0
-countereg-gen/main.cert : | countereg-gen/main.pcert1
-
-countereg-gen/mv-proof.pcert0 : no_pcert = 0
-countereg-gen/mv-proof.pcert0 : acl2x = 0
-countereg-gen/mv-proof.pcert0 : \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/mv-proof.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/mv-proof.pcert1 : acl2x = 0
-countereg-gen/mv-proof.pcert1 : no_pcert = 0
-countereg-gen/mv-proof.pcert1 : countereg-gen/mv-proof.pcert0
-countereg-gen/mv-proof.cert : | countereg-gen/mv-proof.pcert1
-
-countereg-gen/num-list-fns.pcert0 : no_pcert = 0
-countereg-gen/num-list-fns.pcert0 : acl2x = 0
-countereg-gen/num-list-fns.pcert0 : \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/num-list-fns.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/num-list-fns.pcert1 : acl2x = 0
-countereg-gen/num-list-fns.pcert1 : no_pcert = 0
-countereg-gen/num-list-fns.pcert1 : countereg-gen/num-list-fns.pcert0
-countereg-gen/num-list-fns.cert : | countereg-gen/num-list-fns.pcert1
-
-countereg-gen/num-list-thms.pcert0 : no_pcert = 0
-countereg-gen/num-list-thms.pcert0 : acl2x = 0
-countereg-gen/num-list-thms.pcert0 : \
- countereg-gen/num-list-fns.pcert0 \
- arithmetic-5/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/num-list-thms.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/num-list-thms.pcert1 : acl2x = 0
-countereg-gen/num-list-thms.pcert1 : no_pcert = 0
-countereg-gen/num-list-thms.pcert1 : countereg-gen/num-list-thms.pcert0
-countereg-gen/num-list-thms.cert : | countereg-gen/num-list-thms.pcert1
-
-countereg-gen/random-state-basis1.pcert0 : no_pcert = 0
-countereg-gen/random-state-basis1.pcert0 : acl2x = 0
-countereg-gen/random-state-basis1.pcert0 : \
- tools/bstar.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/random-state-basis1.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/random-state-basis1.pcert1 : acl2x = 0
-countereg-gen/random-state-basis1.pcert1 : no_pcert = 0
-countereg-gen/random-state-basis1.pcert1 : countereg-gen/random-state-basis1.pcert0
-countereg-gen/random-state-basis1.cert : | countereg-gen/random-state-basis1.pcert1
-
-countereg-gen/random-state.pcert0 : no_pcert = 0
-countereg-gen/random-state.pcert0 : acl2x = 0
-countereg-gen/random-state.pcert0 : \
- countereg-gen/random-state-basis1.pcert0 \
- arithmetic/rationals.pcert0 \
- arithmetic-3/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/random-state.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/random-state.pcert1 : acl2x = 0
-countereg-gen/random-state.pcert1 : no_pcert = 0
-countereg-gen/random-state.pcert1 : countereg-gen/random-state.pcert0
-countereg-gen/random-state.cert : | countereg-gen/random-state.pcert1
-
-countereg-gen/random.pcert0 : no_pcert = 0
-countereg-gen/random.pcert0 : acl2x = 0
-countereg-gen/random.pcert0 : \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- arithmetic/rationals.pcert0 \
- arithmetic-3/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/random.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/random.pcert1 : acl2x = 0
-countereg-gen/random.pcert1 : no_pcert = 0
-countereg-gen/random.pcert1 : countereg-gen/random.pcert0
-countereg-gen/random.cert : | countereg-gen/random.pcert1
-
-countereg-gen/rem-and-floor.pcert0 : no_pcert = 0
-countereg-gen/rem-and-floor.pcert0 : acl2x = 0
-countereg-gen/rem-and-floor.pcert0 : \
- arithmetic-5/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/rem-and-floor.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/rem-and-floor.pcert1 : acl2x = 0
-countereg-gen/rem-and-floor.pcert1 : no_pcert = 0
-countereg-gen/rem-and-floor.pcert1 : countereg-gen/rem-and-floor.pcert0
-countereg-gen/rem-and-floor.cert : | countereg-gen/rem-and-floor.pcert1
-
-countereg-gen/simple-graph-array.pcert0 : no_pcert = 0
-countereg-gen/simple-graph-array.pcert0 : acl2x = 0
-countereg-gen/simple-graph-array.pcert0 : \
- countereg-gen/utilities.pcert0 \
- ordinals/lexicographic-ordering-without-arithmetic.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/simple-graph-array.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/simple-graph-array.pcert1 : acl2x = 0
-countereg-gen/simple-graph-array.pcert1 : no_pcert = 0
-countereg-gen/simple-graph-array.pcert1 : countereg-gen/simple-graph-array.pcert0
-countereg-gen/simple-graph-array.cert : | countereg-gen/simple-graph-array.pcert1
-
-countereg-gen/splitnat.pcert0 : no_pcert = 0
-countereg-gen/splitnat.pcert0 : acl2x = 0
-countereg-gen/splitnat.pcert0 : \
- countereg-gen/num-list-fns.pcert0 \
- countereg-gen/num-list-thms.pcert0 \
- countereg-gen/rem-and-floor.pcert0 \
- arithmetic-5/top.pcert0 \
- arithmetic-5/top.pcert0 \
- arithmetic-5/top.pcert0 \
- arithmetic-3/top.pcert0 \
- arithmetic-5/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/splitnat.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/splitnat.pcert1 : acl2x = 0
-countereg-gen/splitnat.pcert1 : no_pcert = 0
-countereg-gen/splitnat.pcert1 : countereg-gen/splitnat.pcert0
-countereg-gen/splitnat.cert : | countereg-gen/splitnat.pcert1
-
-countereg-gen/switchnat.pcert0 : no_pcert = 0
-countereg-gen/switchnat.pcert0 : acl2x = 0
-countereg-gen/switchnat.pcert0 : \
- countereg-gen/num-list-fns.pcert0 \
- countereg-gen/num-list-thms.pcert0 \
- countereg-gen/rem-and-floor.pcert0 \
- countereg-gen/mv-proof.pcert0 \
- arithmetic-5/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/switchnat.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/switchnat.pcert1 : acl2x = 0
-countereg-gen/switchnat.pcert1 : no_pcert = 0
-countereg-gen/switchnat.pcert1 : countereg-gen/switchnat.pcert0
-countereg-gen/switchnat.cert : | countereg-gen/switchnat.pcert1
-
-countereg-gen/top.pcert0 : no_pcert = 0
-countereg-gen/top.pcert0 : acl2x = 0
-countereg-gen/top.pcert0 : \
- countereg-gen/acl2s-parameter.pcert0 \
- countereg-gen/main.pcert0 \
- countereg-gen/base.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/top.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/top.pcert1 : acl2x = 0
-countereg-gen/top.pcert1 : no_pcert = 0
-countereg-gen/top.pcert1 : countereg-gen/top.pcert0
-countereg-gen/top.cert : | countereg-gen/top.pcert1
-
-countereg-gen/type.pcert0 : no_pcert = 0
-countereg-gen/type.pcert0 : acl2x = 0
-countereg-gen/type.pcert0 : \
- countereg-gen/graph.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/type.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/type.pcert1 : acl2x = 0
-countereg-gen/type.pcert1 : no_pcert = 0
-countereg-gen/type.pcert1 : countereg-gen/type.pcert0
-countereg-gen/type.cert : | countereg-gen/type.pcert1
-
-countereg-gen/utilities.pcert0 : no_pcert = 0
-countereg-gen/utilities.pcert0 : acl2x = 0
-countereg-gen/utilities.pcert0 : \
- tools/bstar.pcert0 \
- misc/total-order.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/utilities.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/utilities.pcert1 : acl2x = 0
-countereg-gen/utilities.pcert1 : no_pcert = 0
-countereg-gen/utilities.pcert1 : countereg-gen/utilities.pcert0
-countereg-gen/utilities.cert : | countereg-gen/utilities.pcert1
-
-countereg-gen/with-timeout.pcert0 : no_pcert = 0
-countereg-gen/with-timeout.pcert0 : acl2x = 0
-countereg-gen/with-timeout.pcert0 : \
- xdoc/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- countereg-gen/with-timeout.lisp \
- countereg-gen/cert.acl2 \
- countereg-gen/package.lsp
-countereg-gen/with-timeout.pcert1 : acl2x = 0
-countereg-gen/with-timeout.pcert1 : no_pcert = 0
-countereg-gen/with-timeout.pcert1 : countereg-gen/with-timeout.pcert0
-countereg-gen/with-timeout.cert : | countereg-gen/with-timeout.pcert1
-
-cowles/acl2-agp.pcert0 : no_pcert = 0
-cowles/acl2-agp.pcert0 : acl2x = 0
-cowles/acl2-agp.pcert0 : \
- cowles/acl2-asg.pcert0 \
- cowles/acl2-agp.lisp \
- cowles/cert.acl2 \
- cowles/packages.lsp
-cowles/acl2-agp.pcert1 : acl2x = 0
-cowles/acl2-agp.pcert1 : no_pcert = 0
-cowles/acl2-agp.pcert1 : cowles/acl2-agp.pcert0
-cowles/acl2-agp.cert : | cowles/acl2-agp.pcert1
-
-cowles/acl2-asg.pcert0 : no_pcert = 0
-cowles/acl2-asg.pcert0 : acl2x = 0
-cowles/acl2-asg.pcert0 : \
- cowles/acl2-asg.lisp \
- cowles/cert.acl2 \
- cowles/packages.lsp
-cowles/acl2-asg.pcert1 : acl2x = 0
-cowles/acl2-asg.pcert1 : no_pcert = 0
-cowles/acl2-asg.pcert1 : cowles/acl2-asg.pcert0
-cowles/acl2-asg.cert : | cowles/acl2-asg.pcert1
-
-cowles/acl2-crg.pcert0 : no_pcert = 0
-cowles/acl2-crg.pcert0 : acl2x = 0
-cowles/acl2-crg.pcert0 : \
- cowles/acl2-agp.pcert0 \
- cowles/acl2-crg.lisp \
- cowles/cert.acl2 \
- cowles/packages.lsp
-cowles/acl2-crg.pcert1 : acl2x = 0
-cowles/acl2-crg.pcert1 : no_pcert = 0
-cowles/acl2-crg.pcert1 : cowles/acl2-crg.pcert0
-cowles/acl2-crg.cert : | cowles/acl2-crg.pcert1
-
-cutil/da-base.pcert0 : no_pcert = 0
-cutil/da-base.pcert0 : acl2x = 0
-cutil/da-base.pcert0 : \
- cutil/support.pcert0 \
- tools/bstar.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/da-base.lisp \
- cutil/cert.acl2
-cutil/da-base.pcert1 : acl2x = 0
-cutil/da-base.pcert1 : no_pcert = 0
-cutil/da-base.pcert1 : cutil/da-base.pcert0
-cutil/da-base.cert : | cutil/da-base.pcert1
-
-cutil/defaggregate-tests.pcert0 : no_pcert = 0
-cutil/defaggregate-tests.pcert0 : acl2x = 0
-cutil/defaggregate-tests.pcert0 : \
- cutil/defaggregate.pcert0 \
- cutil/deflist.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/defaggregate-tests.lisp \
- cutil/cert.acl2
-cutil/defaggregate-tests.pcert1 : acl2x = 0
-cutil/defaggregate-tests.pcert1 : no_pcert = 0
-cutil/defaggregate-tests.pcert1 : cutil/defaggregate-tests.pcert0
-cutil/defaggregate-tests.cert : | cutil/defaggregate-tests.pcert1
-
-cutil/defaggregate.pcert0 : no_pcert = 0
-cutil/defaggregate.pcert0 : acl2x = 0
-cutil/defaggregate.pcert0 : \
- cutil/da-base.pcert0 \
- cutil/formals.pcert0 \
- xdoc-impl/fmt-to-str.pcert0 \
- tools/rulesets.pcert0 \
- xdoc/names.pcert0 \
- str/cat.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/defaggregate.lisp \
- cutil/cert.acl2
-cutil/defaggregate.pcert1 : acl2x = 0
-cutil/defaggregate.pcert1 : no_pcert = 0
-cutil/defaggregate.pcert1 : cutil/defaggregate.pcert0
-cutil/defaggregate.cert : | cutil/defaggregate.pcert1
-
-cutil/defalist-tests.pcert0 : no_pcert = 0
-cutil/defalist-tests.pcert0 : acl2x = 0
-cutil/defalist-tests.pcert0 : \
- cutil/defalist.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/defalist-tests.lisp \
- cutil/cert.acl2
-cutil/defalist-tests.pcert1 : acl2x = 0
-cutil/defalist-tests.pcert1 : no_pcert = 0
-cutil/defalist-tests.pcert1 : cutil/defalist-tests.pcert0
-cutil/defalist-tests.cert : | cutil/defalist-tests.pcert1
-
-cutil/defalist.pcert0 : no_pcert = 0
-cutil/defalist.pcert0 : acl2x = 0
-cutil/defalist.pcert0 : \
- cutil/deflist.pcert0 \
- misc/hons-help.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/defalist.lisp \
- cutil/cert.acl2
-cutil/defalist.pcert1 : acl2x = 0
-cutil/defalist.pcert1 : no_pcert = 0
-cutil/defalist.pcert1 : cutil/defalist.pcert0
-cutil/defalist.cert : | cutil/defalist.pcert1
-
-cutil/defenum.pcert0 : no_pcert = 0
-cutil/defenum.pcert0 : acl2x = 0
-cutil/defenum.pcert0 : \
- cutil/deflist.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/defenum.lisp \
- cutil/cert.acl2
-cutil/defenum.pcert1 : acl2x = 0
-cutil/defenum.pcert1 : no_pcert = 0
-cutil/defenum.pcert1 : cutil/defenum.pcert0
-cutil/defenum.cert : | cutil/defenum.pcert1
-
-cutil/define-tests.pcert0 : no_pcert = 0
-cutil/define-tests.pcert0 : acl2x = 0
-cutil/define-tests.pcert0 : \
- cutil/define.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/define-tests.lisp \
- cutil/define-tests.acl2
-cutil/define-tests.pcert1 : acl2x = 0
-cutil/define-tests.pcert1 : no_pcert = 0
-cutil/define-tests.pcert1 : cutil/define-tests.pcert0
-cutil/define-tests.cert : | cutil/define-tests.pcert1
-
-cutil/define.pcert0 : no_pcert = 0
-cutil/define.pcert0 : acl2x = 0
-cutil/define.pcert0 : \
- cutil/formals.pcert0 \
- cutil/returnspecs.pcert0 \
- xdoc-impl/fmt-to-str.pcert0 \
- tools/mv-nth.pcert0 \
- str/cat.pcert0 \
- misc/assert.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/define.lisp \
- cutil/cert.acl2
-cutil/define.pcert1 : acl2x = 0
-cutil/define.pcert1 : no_pcert = 0
-cutil/define.pcert1 : cutil/define.pcert0
-cutil/define.cert : | cutil/define.pcert1
-
-cutil/deflist-aux.pcert0 : no_pcert = 0
-cutil/deflist-aux.pcert0 : acl2x = 0
-cutil/deflist-aux.pcert0 : \
- finite-set-theory/osets/sets.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/deflist-aux.lisp \
- cutil/cert.acl2
-cutil/deflist-aux.pcert1 : acl2x = 0
-cutil/deflist-aux.pcert1 : no_pcert = 0
-cutil/deflist-aux.pcert1 : cutil/deflist-aux.pcert0
-cutil/deflist-aux.cert : | cutil/deflist-aux.pcert1
-
-cutil/deflist-tests.pcert0 : no_pcert = 0
-cutil/deflist-tests.pcert0 : acl2x = 0
-cutil/deflist-tests.pcert0 : \
- cutil/deflist.pcert0 \
- str/top.pcert0 \
- misc/assert.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/deflist-tests.lisp \
- cutil/cert.acl2
-cutil/deflist-tests.pcert1 : acl2x = 0
-cutil/deflist-tests.pcert1 : no_pcert = 0
-cutil/deflist-tests.pcert1 : cutil/deflist-tests.pcert0
-cutil/deflist-tests.cert : | cutil/deflist-tests.pcert1
-
-cutil/deflist.pcert0 : no_pcert = 0
-cutil/deflist.pcert0 : acl2x = 0
-cutil/deflist.pcert0 : \
- xdoc/top.pcert0 \
- tools/bstar.pcert0 \
- str/cat.pcert0 \
- finite-set-theory/osets/sets.pcert0 \
- defsort/duplicated-members.pcert0 \
- std/lists/sets.pcert0 \
- std/lists/list-fix.pcert0 \
- std/lists/take.pcert0 \
- std/lists/repeat.pcert0 \
- std/lists/rev.pcert0 \
- cutil/maybe-defthm.pcert0 \
- finite-set-theory/osets/under-set-equiv.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/deflist.lisp \
- cutil/cert.acl2
-cutil/deflist.pcert1 : acl2x = 0
-cutil/deflist.pcert1 : no_pcert = 0
-cutil/deflist.pcert1 : cutil/deflist.pcert0
-cutil/deflist.cert : | cutil/deflist.pcert1
-
-cutil/defmapappend-tests.pcert0 : no_pcert = 0
-cutil/defmapappend-tests.pcert0 : acl2x = 0
-cutil/defmapappend-tests.pcert0 : \
- cutil/defmapappend.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/defmapappend-tests.lisp \
- cutil/cert.acl2
-cutil/defmapappend-tests.pcert1 : acl2x = 0
-cutil/defmapappend-tests.pcert1 : no_pcert = 0
-cutil/defmapappend-tests.pcert1 : cutil/defmapappend-tests.pcert0
-cutil/defmapappend-tests.cert : | cutil/defmapappend-tests.pcert1
-
-cutil/defmapappend.pcert0 : no_pcert = 0
-cutil/defmapappend.pcert0 : acl2x = 0
-cutil/defmapappend.pcert0 : \
- cutil/defprojection.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/defmapappend.lisp \
- cutil/cert.acl2
-cutil/defmapappend.pcert1 : acl2x = 0
-cutil/defmapappend.pcert1 : no_pcert = 0
-cutil/defmapappend.pcert1 : cutil/defmapappend.pcert0
-cutil/defmapappend.cert : | cutil/defmapappend.pcert1
-
-cutil/defmvtypes.pcert0 : no_pcert = 0
-cutil/defmvtypes.pcert0 : acl2x = 0
-cutil/defmvtypes.pcert0 : \
- cutil/deflist.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/defmvtypes.lisp \
- cutil/cert.acl2
-cutil/defmvtypes.pcert1 : acl2x = 0
-cutil/defmvtypes.pcert1 : no_pcert = 0
-cutil/defmvtypes.pcert1 : cutil/defmvtypes.pcert0
-cutil/defmvtypes.cert : | cutil/defmvtypes.pcert1
-
-cutil/defprojection-tests.pcert0 : no_pcert = 0
-cutil/defprojection-tests.pcert0 : acl2x = 0
-cutil/defprojection-tests.pcert0 : \
- cutil/defprojection.pcert0 \
- misc/assert.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/defprojection-tests.lisp \
- cutil/defprojection-tests.acl2
-cutil/defprojection-tests.pcert1 : acl2x = 0
-cutil/defprojection-tests.pcert1 : no_pcert = 0
-cutil/defprojection-tests.pcert1 : cutil/defprojection-tests.pcert0
-cutil/defprojection-tests.cert : | cutil/defprojection-tests.pcert1
-
-cutil/defprojection.pcert0 : no_pcert = 0
-cutil/defprojection.pcert0 : acl2x = 0
-cutil/defprojection.pcert0 : \
- cutil/deflist.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/defprojection.lisp \
- cutil/cert.acl2
-cutil/defprojection.pcert1 : acl2x = 0
-cutil/defprojection.pcert1 : no_pcert = 0
-cutil/defprojection.pcert1 : cutil/defprojection.pcert0
-cutil/defprojection.cert : | cutil/defprojection.pcert1
-
-cutil/defsection.pcert0 : no_pcert = 0
-cutil/defsection.pcert0 : acl2x = 0
-cutil/defsection.pcert0 : \
- xdoc/top.pcert0 \
- tools/bstar.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/defsection.lisp \
- cutil/cert.acl2
-cutil/defsection.pcert1 : acl2x = 0
-cutil/defsection.pcert1 : no_pcert = 0
-cutil/defsection.pcert1 : cutil/defsection.pcert0
-cutil/defsection.cert : | cutil/defsection.pcert1
-
-cutil/formals.pcert0 : no_pcert = 0
-cutil/formals.pcert0 : acl2x = 0
-cutil/formals.pcert0 : \
- cutil/look-up.pcert0 \
- cutil/da-base.pcert0 \
- misc/assert.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/formals.lisp \
- cutil/cert.acl2
-cutil/formals.pcert1 : acl2x = 0
-cutil/formals.pcert1 : no_pcert = 0
-cutil/formals.pcert1 : cutil/formals.pcert0
-cutil/formals.cert : | cutil/formals.pcert1
-
-cutil/look-up.pcert0 : no_pcert = 0
-cutil/look-up.pcert0 : acl2x = 0
-cutil/look-up.pcert0 : \
- cutil/support.pcert0 \
- tools/bstar.pcert0 \
- misc/assert.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/look-up.lisp \
- cutil/cert.acl2
-cutil/look-up.pcert1 : acl2x = 0
-cutil/look-up.pcert1 : no_pcert = 0
-cutil/look-up.pcert1 : cutil/look-up.pcert0
-cutil/look-up.cert : | cutil/look-up.pcert1
-
-cutil/maybe-defthm.pcert0 : no_pcert = 0
-cutil/maybe-defthm.pcert0 : acl2x = 0
-cutil/maybe-defthm.pcert0 : \
- tools/bstar.pcert0 \
- misc/assert.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/maybe-defthm.lisp \
- cutil/cert.acl2
-cutil/maybe-defthm.pcert1 : acl2x = 0
-cutil/maybe-defthm.pcert1 : no_pcert = 0
-cutil/maybe-defthm.pcert1 : cutil/maybe-defthm.pcert0
-cutil/maybe-defthm.cert : | cutil/maybe-defthm.pcert1
-
-cutil/portcullis.pcert0 : no_pcert = 0
-cutil/portcullis.pcert0 : acl2x = 0
-cutil/portcullis.pcert0 : \
- cutil/portcullis.lisp \
- cutil/portcullis.acl2 \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-cutil/portcullis.pcert1 : acl2x = 0
-cutil/portcullis.pcert1 : no_pcert = 0
-cutil/portcullis.pcert1 : cutil/portcullis.pcert0
-cutil/portcullis.cert : | cutil/portcullis.pcert1
-
-cutil/returnspecs.pcert0 : no_pcert = 0
-cutil/returnspecs.pcert0 : acl2x = 0
-cutil/returnspecs.pcert0 : \
- cutil/da-base.pcert0 \
- cutil/look-up.pcert0 \
- misc/assert.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/returnspecs.lisp \
- cutil/cert.acl2
-cutil/returnspecs.pcert1 : acl2x = 0
-cutil/returnspecs.pcert1 : no_pcert = 0
-cutil/returnspecs.pcert1 : cutil/returnspecs.pcert0
-cutil/returnspecs.cert : | cutil/returnspecs.pcert1
-
-cutil/support.pcert0 : no_pcert = 0
-cutil/support.pcert0 : acl2x = 0
-cutil/support.pcert0 : \
- xdoc/top.pcert0 \
- misc/definline.pcert0 \
- tools/bstar.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/support.lisp \
- cutil/cert.acl2
-cutil/support.pcert1 : acl2x = 0
-cutil/support.pcert1 : no_pcert = 0
-cutil/support.pcert1 : cutil/support.pcert0
-cutil/support.cert : | cutil/support.pcert1
-
-cutil/top.pcert0 : no_pcert = 0
-cutil/top.pcert0 : acl2x = 0
-cutil/top.pcert0 : \
- cutil/defaggregate.pcert0 \
- cutil/defalist.pcert0 \
- cutil/defenum.pcert0 \
- cutil/deflist.pcert0 \
- cutil/defmapappend.pcert0 \
- cutil/defmvtypes.pcert0 \
- cutil/defprojection.pcert0 \
- cutil/define.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/top.lisp \
- cutil/top.acl2
-cutil/top.pcert1 : acl2x = 0
-cutil/top.pcert1 : no_pcert = 0
-cutil/top.pcert1 : cutil/top.pcert0
-cutil/top.cert : | cutil/top.pcert1
-
-cutil/wizard.pcert0 : no_pcert = 0
-cutil/wizard.pcert0 : acl2x = 0
-cutil/wizard.pcert0 : \
- cutil/defaggregate.pcert0 \
- cutil/deflist.pcert0 \
- clause-processors/unify-subst.pcert0 \
- cutil/portcullis.pcert0 \
- cutil/wizard.lisp \
- cutil/cert.acl2
-cutil/wizard.pcert1 : acl2x = 0
-cutil/wizard.pcert1 : no_pcert = 0
-cutil/wizard.pcert1 : cutil/wizard.pcert0
-cutil/wizard.cert : | cutil/wizard.pcert1
-
-data-structures/alist-defthms.pcert0 : no_pcert = 0
-data-structures/alist-defthms.pcert0 : acl2x = 0
-data-structures/alist-defthms.pcert0 : \
- data-structures/alist-defuns.pcert0 \
- data-structures/list-defuns.pcert0 \
- data-structures/set-defuns.pcert0 \
- arithmetic/equalities.pcert0 \
- data-structures/set-defthms.pcert0 \
- data-structures/alist-defthms.lisp
-data-structures/alist-defthms.pcert1 : acl2x = 0
-data-structures/alist-defthms.pcert1 : no_pcert = 0
-data-structures/alist-defthms.pcert1 : data-structures/alist-defthms.pcert0
-data-structures/alist-defthms.cert : | data-structures/alist-defthms.pcert1
-
-data-structures/alist-defuns.pcert0 : no_pcert = 0
-data-structures/alist-defuns.pcert0 : acl2x = 0
-data-structures/alist-defuns.pcert0 : \
- data-structures/alist-defuns.lisp
-data-structures/alist-defuns.pcert1 : acl2x = 0
-data-structures/alist-defuns.pcert1 : no_pcert = 0
-data-structures/alist-defuns.pcert1 : data-structures/alist-defuns.pcert0
-data-structures/alist-defuns.cert : | data-structures/alist-defuns.pcert1
-
-data-structures/alist-theory.pcert0 : no_pcert = 0
-data-structures/alist-theory.pcert0 : acl2x = 0
-data-structures/alist-theory.pcert0 : \
- data-structures/alist-defuns.pcert0 \
- data-structures/alist-defthms.pcert0 \
- data-structures/defalist.pcert0 \
- data-structures/alist-theory.lisp
-data-structures/alist-theory.pcert1 : acl2x = 0
-data-structures/alist-theory.pcert1 : no_pcert = 0
-data-structures/alist-theory.pcert1 : data-structures/alist-theory.pcert0
-data-structures/alist-theory.cert : | data-structures/alist-theory.pcert1
-
-data-structures/array1.pcert0 : no_pcert = 0
-data-structures/array1.pcert0 : acl2x = 0
-data-structures/array1.pcert0 : \
- data-structures/doc-section.pcert0 \
- data-structures/array1.lisp
-data-structures/array1.pcert1 : acl2x = 0
-data-structures/array1.pcert1 : no_pcert = 0
-data-structures/array1.pcert1 : data-structures/array1.pcert0
-data-structures/array1.cert : | data-structures/array1.pcert1
-
-data-structures/defalist.pcert0 : no_pcert = 0
-data-structures/defalist.pcert0 : acl2x = 0
-data-structures/defalist.pcert0 : \
- data-structures/alist-defuns.pcert0 \
- data-structures/list-defuns.pcert0 \
- data-structures/utilities.pcert0 \
- data-structures/defalist.lisp \
- data-structures/defalist.acl2 \
- data-structures/define-u-package.lsp
-data-structures/defalist.pcert1 : acl2x = 0
-data-structures/defalist.pcert1 : no_pcert = 0
-data-structures/defalist.pcert1 : data-structures/defalist.pcert0
-data-structures/defalist.cert : | data-structures/defalist.pcert1
-
-data-structures/deflist.pcert0 : no_pcert = 0
-data-structures/deflist.pcert0 : acl2x = 0
-data-structures/deflist.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/utilities.pcert0 \
- data-structures/list-defthms.pcert0 \
- data-structures/deflist.lisp \
- data-structures/deflist.acl2 \
- data-structures/define-u-package.lsp
-data-structures/deflist.pcert1 : acl2x = 0
-data-structures/deflist.pcert1 : no_pcert = 0
-data-structures/deflist.pcert1 : data-structures/deflist.pcert0
-data-structures/deflist.cert : | data-structures/deflist.pcert1
-
-data-structures/doc-section.pcert0 : no_pcert = 0
-data-structures/doc-section.pcert0 : acl2x = 0
-data-structures/doc-section.pcert0 : \
- data-structures/doc-section.lisp
-data-structures/doc-section.pcert1 : acl2x = 0
-data-structures/doc-section.pcert1 : no_pcert = 0
-data-structures/doc-section.pcert1 : data-structures/doc-section.pcert0
-data-structures/doc-section.cert : | data-structures/doc-section.pcert1
-
-data-structures/list-defthms.pcert0 : no_pcert = 0
-data-structures/list-defthms.pcert0 : acl2x = 0
-data-structures/list-defthms.pcert0 : \
- data-structures/list-defuns.pcert0 \
- arithmetic/equalities.pcert0 \
- data-structures/list-defthms.lisp
-data-structures/list-defthms.pcert1 : acl2x = 0
-data-structures/list-defthms.pcert1 : no_pcert = 0
-data-structures/list-defthms.pcert1 : data-structures/list-defthms.pcert0
-data-structures/list-defthms.cert : | data-structures/list-defthms.pcert1
-
-data-structures/list-defuns.pcert0 : no_pcert = 0
-data-structures/list-defuns.pcert0 : acl2x = 0
-data-structures/list-defuns.pcert0 : \
- data-structures/list-defuns.lisp
-data-structures/list-defuns.pcert1 : acl2x = 0
-data-structures/list-defuns.pcert1 : no_pcert = 0
-data-structures/list-defuns.pcert1 : data-structures/list-defuns.pcert0
-data-structures/list-defuns.cert : | data-structures/list-defuns.pcert1
-
-data-structures/list-theory.pcert0 : no_pcert = 0
-data-structures/list-theory.pcert0 : acl2x = 0
-data-structures/list-theory.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- data-structures/deflist.pcert0 \
- data-structures/list-theory.lisp
-data-structures/list-theory.pcert1 : acl2x = 0
-data-structures/list-theory.pcert1 : no_pcert = 0
-data-structures/list-theory.pcert1 : data-structures/list-theory.pcert0
-data-structures/list-theory.cert : | data-structures/list-theory.pcert1
-
-data-structures/memories/log2.pcert0 : no_pcert = 0
-data-structures/memories/log2.pcert0 : acl2x = 0
-data-structures/memories/log2.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- data-structures/memories/log2.lisp \
- data-structures/memories/cert.acl2 \
- data-structures/memories/package.lsp
-data-structures/memories/log2.pcert1 : acl2x = 0
-data-structures/memories/log2.pcert1 : no_pcert = 0
-data-structures/memories/log2.pcert1 : data-structures/memories/log2.pcert0
-data-structures/memories/log2.cert : | data-structures/memories/log2.pcert1
-
-data-structures/memories/memory-impl.pcert0 : no_pcert = 0
-data-structures/memories/memory-impl.pcert0 : acl2x = 0
-data-structures/memories/memory-impl.pcert0 : \
- data-structures/memories/log2.pcert0 \
- data-structures/memories/memtree.pcert0 \
- misc/records.pcert0 \
- data-structures/memories/memory-impl.lisp \
- data-structures/memories/cert.acl2 \
- data-structures/memories/package.lsp
-data-structures/memories/memory-impl.pcert1 : acl2x = 0
-data-structures/memories/memory-impl.pcert1 : no_pcert = 0
-data-structures/memories/memory-impl.pcert1 : data-structures/memories/memory-impl.pcert0
-data-structures/memories/memory-impl.cert : | data-structures/memories/memory-impl.pcert1
-
-data-structures/memories/memory.pcert0 : no_pcert = 0
-data-structures/memories/memory.pcert0 : acl2x = 0
-data-structures/memories/memory.pcert0 : \
- data-structures/memories/memory-impl.pcert0 \
- data-structures/doc-section.pcert0 \
- data-structures/memories/private.pcert0 \
- misc/records.pcert0 \
- data-structures/memories/memory.lisp \
- data-structures/memories/cert.acl2 \
- data-structures/memories/package.lsp
-data-structures/memories/memory.pcert1 : acl2x = 0
-data-structures/memories/memory.pcert1 : no_pcert = 0
-data-structures/memories/memory.pcert1 : data-structures/memories/memory.pcert0
-data-structures/memories/memory.cert : | data-structures/memories/memory.pcert1
-
-data-structures/memories/memtree.pcert0 : no_pcert = 0
-data-structures/memories/memtree.pcert0 : acl2x = 0
-data-structures/memories/memtree.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- data-structures/memories/memtree.lisp \
- data-structures/memories/cert.acl2 \
- data-structures/memories/package.lsp
-data-structures/memories/memtree.pcert1 : acl2x = 0
-data-structures/memories/memtree.pcert1 : no_pcert = 0
-data-structures/memories/memtree.pcert1 : data-structures/memories/memtree.pcert0
-data-structures/memories/memtree.cert : | data-structures/memories/memtree.pcert1
-
-data-structures/memories/private.pcert0 : no_pcert = 0
-data-structures/memories/private.pcert0 : acl2x = 0
-data-structures/memories/private.pcert0 : \
- data-structures/doc-section.pcert0 \
- data-structures/memories/private.lisp \
- data-structures/memories/cert.acl2 \
- data-structures/memories/package.lsp
-data-structures/memories/private.pcert1 : acl2x = 0
-data-structures/memories/private.pcert1 : no_pcert = 0
-data-structures/memories/private.pcert1 : data-structures/memories/private.pcert0
-data-structures/memories/private.cert : | data-structures/memories/private.pcert1
-
-data-structures/no-duplicates.pcert0 : no_pcert = 0
-data-structures/no-duplicates.pcert0 : acl2x = 0
-data-structures/no-duplicates.pcert0 : \
- data-structures/no-duplicates.lisp
-data-structures/no-duplicates.pcert1 : acl2x = 0
-data-structures/no-duplicates.pcert1 : no_pcert = 0
-data-structures/no-duplicates.pcert1 : data-structures/no-duplicates.pcert0
-data-structures/no-duplicates.cert : | data-structures/no-duplicates.pcert1
-
-data-structures/number-list-defthms.pcert0 : no_pcert = 0
-data-structures/number-list-defthms.pcert0 : acl2x = 0
-data-structures/number-list-defthms.pcert0 : \
- data-structures/number-list-defuns.pcert0 \
- data-structures/deflist.pcert0 \
- data-structures/number-list-defthms.lisp
-data-structures/number-list-defthms.pcert1 : acl2x = 0
-data-structures/number-list-defthms.pcert1 : no_pcert = 0
-data-structures/number-list-defthms.pcert1 : data-structures/number-list-defthms.pcert0
-data-structures/number-list-defthms.cert : | data-structures/number-list-defthms.pcert1
-
-data-structures/number-list-defuns.pcert0 : no_pcert = 0
-data-structures/number-list-defuns.pcert0 : acl2x = 0
-data-structures/number-list-defuns.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/number-list-defuns.lisp
-data-structures/number-list-defuns.pcert1 : acl2x = 0
-data-structures/number-list-defuns.pcert1 : no_pcert = 0
-data-structures/number-list-defuns.pcert1 : data-structures/number-list-defuns.pcert0
-data-structures/number-list-defuns.cert : | data-structures/number-list-defuns.pcert1
-
-data-structures/number-list-theory.pcert0 : no_pcert = 0
-data-structures/number-list-theory.pcert0 : acl2x = 0
-data-structures/number-list-theory.pcert0 : \
- data-structures/number-list-defuns.pcert0 \
- data-structures/number-list-defthms.pcert0 \
- data-structures/number-list-theory.lisp
-data-structures/number-list-theory.pcert1 : acl2x = 0
-data-structures/number-list-theory.pcert1 : no_pcert = 0
-data-structures/number-list-theory.pcert1 : data-structures/number-list-theory.pcert0
-data-structures/number-list-theory.cert : | data-structures/number-list-theory.pcert1
-
-data-structures/set-defthms.pcert0 : no_pcert = 0
-data-structures/set-defthms.pcert0 : acl2x = 0
-data-structures/set-defthms.pcert0 : \
- data-structures/set-defuns.pcert0 \
- data-structures/set-defthms.lisp
-data-structures/set-defthms.pcert1 : acl2x = 0
-data-structures/set-defthms.pcert1 : no_pcert = 0
-data-structures/set-defthms.pcert1 : data-structures/set-defthms.pcert0
-data-structures/set-defthms.cert : | data-structures/set-defthms.pcert1
-
-data-structures/set-defuns.pcert0 : no_pcert = 0
-data-structures/set-defuns.pcert0 : acl2x = 0
-data-structures/set-defuns.pcert0 : \
- data-structures/set-defuns.lisp
-data-structures/set-defuns.pcert1 : acl2x = 0
-data-structures/set-defuns.pcert1 : no_pcert = 0
-data-structures/set-defuns.pcert1 : data-structures/set-defuns.pcert0
-data-structures/set-defuns.cert : | data-structures/set-defuns.pcert1
-
-data-structures/set-theory.pcert0 : no_pcert = 0
-data-structures/set-theory.pcert0 : acl2x = 0
-data-structures/set-theory.pcert0 : \
- data-structures/set-defuns.pcert0 \
- data-structures/set-defthms.pcert0 \
- data-structures/set-theory.lisp
-data-structures/set-theory.pcert1 : acl2x = 0
-data-structures/set-theory.pcert1 : no_pcert = 0
-data-structures/set-theory.pcert1 : data-structures/set-theory.pcert0
-data-structures/set-theory.cert : | data-structures/set-theory.pcert1
-
-data-structures/structures.pcert0 : no_pcert = 0
-data-structures/structures.pcert0 : acl2x = 0
-data-structures/structures.pcert0 : \
- data-structures/utilities.pcert0 \
- data-structures/structures.lisp \
- data-structures/structures.acl2 \
- data-structures/define-u-package.lsp \
- data-structures/define-structures-package.lsp
-data-structures/structures.pcert1 : acl2x = 0
-data-structures/structures.pcert1 : no_pcert = 0
-data-structures/structures.pcert1 : data-structures/structures.pcert0
-data-structures/structures.cert : | data-structures/structures.pcert1
-
-data-structures/utilities.pcert0 : no_pcert = 0
-data-structures/utilities.pcert0 : acl2x = 0
-data-structures/utilities.pcert0 : \
- data-structures/doc-section.pcert0 \
- data-structures/utilities.lisp \
- data-structures/utilities.acl2 \
- data-structures/define-u-package.lsp
-data-structures/utilities.pcert1 : acl2x = 0
-data-structures/utilities.pcert1 : no_pcert = 0
-data-structures/utilities.pcert1 : data-structures/utilities.pcert0
-data-structures/utilities.cert : | data-structures/utilities.pcert1
-
-deduction/passmore/bewijs.pcert0 : no_pcert = 0
-deduction/passmore/bewijs.pcert0 : acl2x = 0
-deduction/passmore/bewijs.pcert0 : \
- deduction/passmore/bewijs.lisp
-deduction/passmore/bewijs.pcert1 : acl2x = 0
-deduction/passmore/bewijs.pcert1 : no_pcert = 0
-deduction/passmore/bewijs.pcert1 : deduction/passmore/bewijs.pcert0
-deduction/passmore/bewijs.cert : | deduction/passmore/bewijs.pcert1
-
-deduction/passmore/general.pcert0 : no_pcert = 0
-deduction/passmore/general.pcert0 : acl2x = 0
-deduction/passmore/general.pcert0 : \
- deduction/passmore/general.lisp
-deduction/passmore/general.pcert1 : acl2x = 0
-deduction/passmore/general.pcert1 : no_pcert = 0
-deduction/passmore/general.pcert1 : deduction/passmore/general.pcert0
-deduction/passmore/general.cert : | deduction/passmore/general.pcert1
-
-deduction/passmore/paramod.pcert0 : no_pcert = 0
-deduction/passmore/paramod.pcert0 : acl2x = 0
-deduction/passmore/paramod.pcert0 : \
- deduction/passmore/weighting.pcert0 \
- deduction/passmore/paramod.lisp
-deduction/passmore/paramod.pcert1 : acl2x = 0
-deduction/passmore/paramod.pcert1 : no_pcert = 0
-deduction/passmore/paramod.pcert1 : deduction/passmore/paramod.pcert0
-deduction/passmore/paramod.cert : | deduction/passmore/paramod.pcert1
-
-deduction/passmore/prover.pcert0 : no_pcert = 0
-deduction/passmore/prover.pcert0 : acl2x = 0
-deduction/passmore/prover.pcert0 : \
- deduction/passmore/general.pcert0 \
- deduction/passmore/unification.pcert0 \
- deduction/passmore/weighting.pcert0 \
- deduction/passmore/resolution.pcert0 \
- deduction/passmore/paramod.pcert0 \
- deduction/passmore/bewijs.pcert0 \
- deduction/passmore/prover.lisp
-deduction/passmore/prover.pcert1 : acl2x = 0
-deduction/passmore/prover.pcert1 : no_pcert = 0
-deduction/passmore/prover.pcert1 : deduction/passmore/prover.pcert0
-deduction/passmore/prover.cert : | deduction/passmore/prover.pcert1
-
-deduction/passmore/resolution.pcert0 : no_pcert = 0
-deduction/passmore/resolution.pcert0 : acl2x = 0
-deduction/passmore/resolution.pcert0 : \
- deduction/passmore/general.pcert0 \
- deduction/passmore/unification.pcert0 \
- deduction/passmore/weighting.pcert0 \
- deduction/passmore/resolution.lisp
-deduction/passmore/resolution.pcert1 : acl2x = 0
-deduction/passmore/resolution.pcert1 : no_pcert = 0
-deduction/passmore/resolution.pcert1 : deduction/passmore/resolution.pcert0
-deduction/passmore/resolution.cert : | deduction/passmore/resolution.pcert1
-
-deduction/passmore/unification.pcert0 : no_pcert = 0
-deduction/passmore/unification.pcert0 : acl2x = 0
-deduction/passmore/unification.pcert0 : \
- deduction/passmore/general.pcert0 \
- deduction/passmore/unification.lisp
-deduction/passmore/unification.pcert1 : acl2x = 0
-deduction/passmore/unification.pcert1 : no_pcert = 0
-deduction/passmore/unification.pcert1 : deduction/passmore/unification.pcert0
-deduction/passmore/unification.cert : | deduction/passmore/unification.pcert1
-
-deduction/passmore/weighting.pcert0 : no_pcert = 0
-deduction/passmore/weighting.pcert0 : acl2x = 0
-deduction/passmore/weighting.pcert0 : \
- deduction/passmore/unification.pcert0 \
- deduction/passmore/weighting.lisp
-deduction/passmore/weighting.pcert1 : acl2x = 0
-deduction/passmore/weighting.pcert1 : no_pcert = 0
-deduction/passmore/weighting.pcert1 : deduction/passmore/weighting.pcert0
-deduction/passmore/weighting.cert : | deduction/passmore/weighting.pcert1
-
-defexec/dag-unification/basic.pcert0 : no_pcert = 0
-defexec/dag-unification/basic.pcert0 : acl2x = 0
-defexec/dag-unification/basic.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- defexec/dag-unification/basic.lisp
-defexec/dag-unification/basic.pcert1 : acl2x = 0
-defexec/dag-unification/basic.pcert1 : no_pcert = 0
-defexec/dag-unification/basic.pcert1 : defexec/dag-unification/basic.pcert0
-defexec/dag-unification/basic.cert : | defexec/dag-unification/basic.pcert1
-
-defexec/dag-unification/dag-unification-l.pcert0 : no_pcert = 0
-defexec/dag-unification/dag-unification-l.pcert0 : acl2x = 0
-defexec/dag-unification/dag-unification-l.pcert0 : \
- defexec/dag-unification/dag-unification-rules.pcert0 \
- defexec/dag-unification/terms-as-dag.pcert0 \
- defexec/dag-unification/dag-unification-l.lisp
-defexec/dag-unification/dag-unification-l.pcert1 : acl2x = 0
-defexec/dag-unification/dag-unification-l.pcert1 : no_pcert = 0
-defexec/dag-unification/dag-unification-l.pcert1 : defexec/dag-unification/dag-unification-l.pcert0
-defexec/dag-unification/dag-unification-l.cert : | defexec/dag-unification/dag-unification-l.pcert1
-
-defexec/dag-unification/dag-unification-rules.pcert0 : no_pcert = 0
-defexec/dag-unification/dag-unification-rules.pcert0 : acl2x = 0
-defexec/dag-unification/dag-unification-rules.pcert0 : \
- defexec/dag-unification/dags.pcert0 \
- defexec/dag-unification/list-unification-rules.pcert0 \
- defexec/dag-unification/dag-unification-rules.lisp
-defexec/dag-unification/dag-unification-rules.pcert1 : acl2x = 0
-defexec/dag-unification/dag-unification-rules.pcert1 : no_pcert = 0
-defexec/dag-unification/dag-unification-rules.pcert1 : defexec/dag-unification/dag-unification-rules.pcert0
-defexec/dag-unification/dag-unification-rules.cert : | defexec/dag-unification/dag-unification-rules.pcert1
-
-defexec/dag-unification/dag-unification-st.pcert0 : no_pcert = 0
-defexec/dag-unification/dag-unification-st.pcert0 : acl2x = 0
-defexec/dag-unification/dag-unification-st.pcert0 : \
- defexec/dag-unification/dag-unification-l.pcert0 \
- defexec/dag-unification/terms-dag-stobj.pcert0 \
- defexec/dag-unification/dag-unification-st.lisp
-defexec/dag-unification/dag-unification-st.pcert1 : acl2x = 0
-defexec/dag-unification/dag-unification-st.pcert1 : no_pcert = 0
-defexec/dag-unification/dag-unification-st.pcert1 : defexec/dag-unification/dag-unification-st.pcert0
-defexec/dag-unification/dag-unification-st.cert : | defexec/dag-unification/dag-unification-st.pcert1
-
-defexec/dag-unification/dags.pcert0 : no_pcert = 0
-defexec/dag-unification/dags.pcert0 : acl2x = 0
-defexec/dag-unification/dags.pcert0 : \
- defexec/dag-unification/basic.pcert0 \
- defexec/dag-unification/dags.lisp
-defexec/dag-unification/dags.pcert1 : acl2x = 0
-defexec/dag-unification/dags.pcert1 : no_pcert = 0
-defexec/dag-unification/dags.pcert1 : defexec/dag-unification/dags.pcert0
-defexec/dag-unification/dags.cert : | defexec/dag-unification/dags.pcert1
-
-defexec/dag-unification/list-unification-rules.pcert0 : no_pcert = 0
-defexec/dag-unification/list-unification-rules.pcert0 : acl2x = 0
-defexec/dag-unification/list-unification-rules.pcert0 : \
- defexec/dag-unification/subsumption-subst.pcert0 \
- defexec/dag-unification/list-unification-rules.lisp
-defexec/dag-unification/list-unification-rules.pcert1 : acl2x = 0
-defexec/dag-unification/list-unification-rules.pcert1 : no_pcert = 0
-defexec/dag-unification/list-unification-rules.pcert1 : defexec/dag-unification/list-unification-rules.pcert0
-defexec/dag-unification/list-unification-rules.cert : | defexec/dag-unification/list-unification-rules.pcert1
-
-defexec/dag-unification/matching.pcert0 : no_pcert = 0
-defexec/dag-unification/matching.pcert0 : acl2x = 0
-defexec/dag-unification/matching.pcert0 : \
- defexec/dag-unification/terms.pcert0 \
- defexec/dag-unification/matching.lisp
-defexec/dag-unification/matching.pcert1 : acl2x = 0
-defexec/dag-unification/matching.pcert1 : no_pcert = 0
-defexec/dag-unification/matching.pcert1 : defexec/dag-unification/matching.pcert0
-defexec/dag-unification/matching.cert : | defexec/dag-unification/matching.pcert1
-
-defexec/dag-unification/subsumption-subst.pcert0 : no_pcert = 0
-defexec/dag-unification/subsumption-subst.pcert0 : acl2x = 0
-defexec/dag-unification/subsumption-subst.pcert0 : \
- defexec/dag-unification/subsumption.pcert0 \
- defexec/dag-unification/subsumption-subst.lisp
-defexec/dag-unification/subsumption-subst.pcert1 : acl2x = 0
-defexec/dag-unification/subsumption-subst.pcert1 : no_pcert = 0
-defexec/dag-unification/subsumption-subst.pcert1 : defexec/dag-unification/subsumption-subst.pcert0
-defexec/dag-unification/subsumption-subst.cert : | defexec/dag-unification/subsumption-subst.pcert1
-
-defexec/dag-unification/subsumption.pcert0 : no_pcert = 0
-defexec/dag-unification/subsumption.pcert0 : acl2x = 0
-defexec/dag-unification/subsumption.pcert0 : \
- defexec/dag-unification/matching.pcert0 \
- defexec/dag-unification/terms.pcert0 \
- defexec/dag-unification/subsumption.lisp
-defexec/dag-unification/subsumption.pcert1 : acl2x = 0
-defexec/dag-unification/subsumption.pcert1 : no_pcert = 0
-defexec/dag-unification/subsumption.pcert1 : defexec/dag-unification/subsumption.pcert0
-defexec/dag-unification/subsumption.cert : | defexec/dag-unification/subsumption.pcert1
-
-defexec/dag-unification/terms-as-dag.pcert0 : no_pcert = 0
-defexec/dag-unification/terms-as-dag.pcert0 : acl2x = 0
-defexec/dag-unification/terms-as-dag.pcert0 : \
- defexec/dag-unification/dag-unification-rules.pcert0 \
- defexec/dag-unification/terms-as-dag.lisp
-defexec/dag-unification/terms-as-dag.pcert1 : acl2x = 0
-defexec/dag-unification/terms-as-dag.pcert1 : no_pcert = 0
-defexec/dag-unification/terms-as-dag.pcert1 : defexec/dag-unification/terms-as-dag.pcert0
-defexec/dag-unification/terms-as-dag.cert : | defexec/dag-unification/terms-as-dag.pcert1
-
-defexec/dag-unification/terms-dag-stobj.pcert0 : no_pcert = 0
-defexec/dag-unification/terms-dag-stobj.pcert0 : acl2x = 0
-defexec/dag-unification/terms-dag-stobj.pcert0 : \
- defexec/dag-unification/dag-unification-rules.pcert0 \
- defexec/dag-unification/terms-dag-stobj.lisp
-defexec/dag-unification/terms-dag-stobj.pcert1 : acl2x = 0
-defexec/dag-unification/terms-dag-stobj.pcert1 : no_pcert = 0
-defexec/dag-unification/terms-dag-stobj.pcert1 : defexec/dag-unification/terms-dag-stobj.pcert0
-defexec/dag-unification/terms-dag-stobj.cert : | defexec/dag-unification/terms-dag-stobj.pcert1
-
-defexec/dag-unification/terms.pcert0 : no_pcert = 0
-defexec/dag-unification/terms.pcert0 : acl2x = 0
-defexec/dag-unification/terms.pcert0 : \
- defexec/dag-unification/basic.pcert0 \
- defexec/dag-unification/terms.lisp
-defexec/dag-unification/terms.pcert1 : acl2x = 0
-defexec/dag-unification/terms.pcert1 : no_pcert = 0
-defexec/dag-unification/terms.pcert1 : defexec/dag-unification/terms.pcert0
-defexec/dag-unification/terms.cert : | defexec/dag-unification/terms.pcert1
-
-defexec/defpun-exec/defpun-exec.pcert0 : no_pcert = 0
-defexec/defpun-exec/defpun-exec.pcert0 : acl2x = 0
-defexec/defpun-exec/defpun-exec.pcert0 : \
- misc/defpun.pcert0 \
- defexec/defpun-exec/defpun-exec.lisp
-defexec/defpun-exec/defpun-exec.pcert1 : acl2x = 0
-defexec/defpun-exec/defpun-exec.pcert1 : no_pcert = 0
-defexec/defpun-exec/defpun-exec.pcert1 : defexec/defpun-exec/defpun-exec.pcert0
-defexec/defpun-exec/defpun-exec.cert : | defexec/defpun-exec/defpun-exec.pcert1
-
-defexec/find-path/fpst.pcert0 : no_pcert = 0
-defexec/find-path/fpst.pcert0 : acl2x = 0
-defexec/find-path/fpst.pcert0 : \
- defexec/find-path/graph/linear-find-path.pcert0 \
- defexec/find-path/fpst.lisp
-defexec/find-path/fpst.pcert1 : acl2x = 0
-defexec/find-path/fpst.pcert1 : no_pcert = 0
-defexec/find-path/fpst.pcert1 : defexec/find-path/fpst.pcert0
-defexec/find-path/fpst.cert : | defexec/find-path/fpst.pcert1
-
-defexec/find-path/graph/find-path1.pcert0 : no_pcert = 0
-defexec/find-path/graph/find-path1.pcert0 : acl2x = 0
-defexec/find-path/graph/find-path1.pcert0 : \
- arithmetic/top.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- defexec/find-path/graph/find-path1.lisp
-defexec/find-path/graph/find-path1.pcert1 : acl2x = 0
-defexec/find-path/graph/find-path1.pcert1 : no_pcert = 0
-defexec/find-path/graph/find-path1.pcert1 : defexec/find-path/graph/find-path1.pcert0
-defexec/find-path/graph/find-path1.cert : | defexec/find-path/graph/find-path1.pcert1
-
-defexec/find-path/graph/find-path2.pcert0 : no_pcert = 0
-defexec/find-path/graph/find-path2.pcert0 : acl2x = 0
-defexec/find-path/graph/find-path2.pcert0 : \
- arithmetic/top.pcert0 \
- defexec/find-path/graph/helpers.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- defexec/find-path/graph/find-path2.lisp
-defexec/find-path/graph/find-path2.pcert1 : acl2x = 0
-defexec/find-path/graph/find-path2.pcert1 : no_pcert = 0
-defexec/find-path/graph/find-path2.pcert1 : defexec/find-path/graph/find-path2.pcert0
-defexec/find-path/graph/find-path2.cert : | defexec/find-path/graph/find-path2.pcert1
-
-defexec/find-path/graph/find-path3.pcert0 : no_pcert = 0
-defexec/find-path/graph/find-path3.pcert0 : acl2x = 0
-defexec/find-path/graph/find-path3.pcert0 : \
- arithmetic/top.pcert0 \
- defexec/find-path/graph/helpers.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- defexec/find-path/graph/find-path3.lisp
-defexec/find-path/graph/find-path3.pcert1 : acl2x = 0
-defexec/find-path/graph/find-path3.pcert1 : no_pcert = 0
-defexec/find-path/graph/find-path3.pcert1 : defexec/find-path/graph/find-path3.pcert0
-defexec/find-path/graph/find-path3.cert : | defexec/find-path/graph/find-path3.pcert1
-
-defexec/find-path/graph/helpers.pcert0 : no_pcert = 0
-defexec/find-path/graph/helpers.pcert0 : acl2x = 0
-defexec/find-path/graph/helpers.pcert0 : \
- defexec/find-path/graph/helpers.lisp
-defexec/find-path/graph/helpers.pcert1 : acl2x = 0
-defexec/find-path/graph/helpers.pcert1 : no_pcert = 0
-defexec/find-path/graph/helpers.pcert1 : defexec/find-path/graph/helpers.pcert0
-defexec/find-path/graph/helpers.cert : | defexec/find-path/graph/helpers.pcert1
-
-defexec/find-path/graph/linear-find-path.pcert0 : no_pcert = 0
-defexec/find-path/graph/linear-find-path.pcert0 : acl2x = 0
-defexec/find-path/graph/linear-find-path.pcert0 : \
- defexec/find-path/graph/find-path3.pcert0 \
- defexec/find-path/graph/linear-find-path.lisp
-defexec/find-path/graph/linear-find-path.pcert1 : acl2x = 0
-defexec/find-path/graph/linear-find-path.pcert1 : no_pcert = 0
-defexec/find-path/graph/linear-find-path.pcert1 : defexec/find-path/graph/linear-find-path.pcert0
-defexec/find-path/graph/linear-find-path.cert : | defexec/find-path/graph/linear-find-path.pcert1
-
-defexec/find-path/run-fpst.pcert0 : no_pcert = 0
-defexec/find-path/run-fpst.pcert0 : acl2x = 0
-defexec/find-path/run-fpst.pcert0 : \
- defexec/find-path/fpst.pcert0 \
- defexec/find-path/run-fpst.lisp
-defexec/find-path/run-fpst.pcert1 : acl2x = 0
-defexec/find-path/run-fpst.pcert1 : no_pcert = 0
-defexec/find-path/run-fpst.pcert1 : defexec/find-path/run-fpst.pcert0
-defexec/find-path/run-fpst.cert : | defexec/find-path/run-fpst.pcert1
-
-defexec/ordinals/supporting-ordinals.pcert0 : no_pcert = 0
-defexec/ordinals/supporting-ordinals.pcert0 : acl2x = 0
-defexec/ordinals/supporting-ordinals.pcert0 : \
- ordinals/ordinals.pcert0 \
- defexec/ordinals/supporting-ordinals.lisp
-defexec/ordinals/supporting-ordinals.pcert1 : acl2x = 0
-defexec/ordinals/supporting-ordinals.pcert1 : no_pcert = 0
-defexec/ordinals/supporting-ordinals.pcert1 : defexec/ordinals/supporting-ordinals.pcert0
-defexec/ordinals/supporting-ordinals.cert : | defexec/ordinals/supporting-ordinals.pcert1
-
-defexec/other-apps/misc/memos.pcert0 : no_pcert = 0
-defexec/other-apps/misc/memos.pcert0 : acl2x = 0
-defexec/other-apps/misc/memos.pcert0 : \
- defexec/other-apps/misc/memos.lisp
-defexec/other-apps/misc/memos.pcert1 : acl2x = 0
-defexec/other-apps/misc/memos.pcert1 : no_pcert = 0
-defexec/other-apps/misc/memos.pcert1 : defexec/other-apps/misc/memos.pcert0
-defexec/other-apps/misc/memos.cert : | defexec/other-apps/misc/memos.pcert1
-
-defexec/other-apps/misc/stobjsim.pcert0 : no_pcert = 0
-defexec/other-apps/misc/stobjsim.pcert0 : acl2x = 0
-defexec/other-apps/misc/stobjsim.pcert0 : \
- defexec/other-apps/misc/stobjsim.lisp
-defexec/other-apps/misc/stobjsim.pcert1 : acl2x = 0
-defexec/other-apps/misc/stobjsim.pcert1 : no_pcert = 0
-defexec/other-apps/misc/stobjsim.pcert1 : defexec/other-apps/misc/stobjsim.pcert0
-defexec/other-apps/misc/stobjsim.cert : | defexec/other-apps/misc/stobjsim.pcert1
-
-defexec/other-apps/qsort/extraction.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/extraction.pcert0 : acl2x = 0
-defexec/other-apps/qsort/extraction.pcert0 : \
- defexec/other-apps/qsort/programs.pcert0 \
- defexec/other-apps/qsort/intermediate-program.pcert0 \
- defexec/other-apps/qsort/first-last.pcert0 \
- defexec/other-apps/qsort/extraction.lisp
-defexec/other-apps/qsort/extraction.pcert1 : acl2x = 0
-defexec/other-apps/qsort/extraction.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/extraction.pcert1 : defexec/other-apps/qsort/extraction.pcert0
-defexec/other-apps/qsort/extraction.cert : | defexec/other-apps/qsort/extraction.pcert1
-
-defexec/other-apps/qsort/final-theorem.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/final-theorem.pcert0 : acl2x = 0
-defexec/other-apps/qsort/final-theorem.pcert0 : \
- defexec/other-apps/qsort/sort-qs-properties.pcert0 \
- defexec/other-apps/qsort/load-extract.pcert0 \
- defexec/other-apps/qsort/final-theorem.lisp
-defexec/other-apps/qsort/final-theorem.pcert1 : acl2x = 0
-defexec/other-apps/qsort/final-theorem.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/final-theorem.pcert1 : defexec/other-apps/qsort/final-theorem.pcert0
-defexec/other-apps/qsort/final-theorem.cert : | defexec/other-apps/qsort/final-theorem.pcert1
-
-defexec/other-apps/qsort/first-last.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/first-last.pcert0 : acl2x = 0
-defexec/other-apps/qsort/first-last.pcert0 : \
- defexec/other-apps/qsort/programs.pcert0 \
- defexec/other-apps/qsort/first-last.lisp
-defexec/other-apps/qsort/first-last.pcert1 : acl2x = 0
-defexec/other-apps/qsort/first-last.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/first-last.pcert1 : defexec/other-apps/qsort/first-last.pcert0
-defexec/other-apps/qsort/first-last.cert : | defexec/other-apps/qsort/first-last.pcert1
-
-defexec/other-apps/qsort/intermediate-program.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/intermediate-program.pcert0 : acl2x = 0
-defexec/other-apps/qsort/intermediate-program.pcert0 : \
- defexec/other-apps/qsort/total-order.pcert0 \
- defexec/other-apps/qsort/permutations.pcert0 \
- defexec/other-apps/qsort/intermediate-program.lisp
-defexec/other-apps/qsort/intermediate-program.pcert1 : acl2x = 0
-defexec/other-apps/qsort/intermediate-program.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/intermediate-program.pcert1 : defexec/other-apps/qsort/intermediate-program.pcert0
-defexec/other-apps/qsort/intermediate-program.cert : | defexec/other-apps/qsort/intermediate-program.pcert1
-
-defexec/other-apps/qsort/intermediate-to-spec.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/intermediate-to-spec.pcert0 : acl2x = 0
-defexec/other-apps/qsort/intermediate-to-spec.pcert0 : \
- defexec/other-apps/qsort/intermediate-program.pcert0 \
- defexec/other-apps/qsort/spec-properties.pcert0 \
- defexec/other-apps/qsort/intermediate-to-spec.lisp
-defexec/other-apps/qsort/intermediate-to-spec.pcert1 : acl2x = 0
-defexec/other-apps/qsort/intermediate-to-spec.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/intermediate-to-spec.pcert1 : defexec/other-apps/qsort/intermediate-to-spec.pcert0
-defexec/other-apps/qsort/intermediate-to-spec.cert : | defexec/other-apps/qsort/intermediate-to-spec.pcert1
-
-defexec/other-apps/qsort/load-extract.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/load-extract.pcert0 : acl2x = 0
-defexec/other-apps/qsort/load-extract.pcert0 : \
- defexec/other-apps/qsort/programs.pcert0 \
- defexec/other-apps/qsort/first-last.pcert0 \
- defexec/other-apps/qsort/extraction.pcert0 \
- defexec/other-apps/qsort/load-extract.lisp
-defexec/other-apps/qsort/load-extract.pcert1 : acl2x = 0
-defexec/other-apps/qsort/load-extract.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/load-extract.pcert1 : defexec/other-apps/qsort/load-extract.pcert0
-defexec/other-apps/qsort/load-extract.cert : | defexec/other-apps/qsort/load-extract.pcert1
-
-defexec/other-apps/qsort/merge-intermediate.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/merge-intermediate.pcert0 : acl2x = 0
-defexec/other-apps/qsort/merge-intermediate.pcert0 : \
- defexec/other-apps/qsort/programs.pcert0 \
- defexec/other-apps/qsort/intermediate-to-spec.pcert0 \
- defexec/other-apps/qsort/first-last.pcert0 \
- defexec/other-apps/qsort/merge-intermediate.lisp
-defexec/other-apps/qsort/merge-intermediate.pcert1 : acl2x = 0
-defexec/other-apps/qsort/merge-intermediate.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/merge-intermediate.pcert1 : defexec/other-apps/qsort/merge-intermediate.pcert0
-defexec/other-apps/qsort/merge-intermediate.cert : | defexec/other-apps/qsort/merge-intermediate.pcert1
-
-defexec/other-apps/qsort/nth-update-nth.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/nth-update-nth.pcert0 : acl2x = 0
-defexec/other-apps/qsort/nth-update-nth.pcert0 : \
- defexec/other-apps/qsort/nth-update-nth.lisp
-defexec/other-apps/qsort/nth-update-nth.pcert1 : acl2x = 0
-defexec/other-apps/qsort/nth-update-nth.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/nth-update-nth.pcert1 : defexec/other-apps/qsort/nth-update-nth.pcert0
-defexec/other-apps/qsort/nth-update-nth.cert : | defexec/other-apps/qsort/nth-update-nth.pcert1
-
-defexec/other-apps/qsort/permutations.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/permutations.pcert0 : acl2x = 0
-defexec/other-apps/qsort/permutations.pcert0 : \
- defexec/other-apps/qsort/permutations.lisp
-defexec/other-apps/qsort/permutations.pcert1 : acl2x = 0
-defexec/other-apps/qsort/permutations.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/permutations.pcert1 : defexec/other-apps/qsort/permutations.pcert0
-defexec/other-apps/qsort/permutations.cert : | defexec/other-apps/qsort/permutations.pcert1
-
-defexec/other-apps/qsort/programs.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/programs.pcert0 : acl2x = 0
-defexec/other-apps/qsort/programs.pcert0 : \
- defexec/other-apps/qsort/total-order.pcert0 \
- defexec/other-apps/qsort/nth-update-nth.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- defexec/other-apps/qsort/programs.lisp
-defexec/other-apps/qsort/programs.pcert1 : acl2x = 0
-defexec/other-apps/qsort/programs.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/programs.pcert1 : defexec/other-apps/qsort/programs.pcert0
-defexec/other-apps/qsort/programs.cert : | defexec/other-apps/qsort/programs.pcert1
-
-defexec/other-apps/qsort/sort-qs-properties.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/sort-qs-properties.pcert0 : acl2x = 0
-defexec/other-apps/qsort/sort-qs-properties.pcert0 : \
- defexec/other-apps/qsort/split-qs-properties.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- defexec/other-apps/qsort/load-extract.pcert0 \
- defexec/other-apps/qsort/sort-qs-properties.lisp
-defexec/other-apps/qsort/sort-qs-properties.pcert1 : acl2x = 0
-defexec/other-apps/qsort/sort-qs-properties.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/sort-qs-properties.pcert1 : defexec/other-apps/qsort/sort-qs-properties.pcert0
-defexec/other-apps/qsort/sort-qs-properties.cert : | defexec/other-apps/qsort/sort-qs-properties.pcert1
-
-defexec/other-apps/qsort/spec-properties.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/spec-properties.pcert0 : acl2x = 0
-defexec/other-apps/qsort/spec-properties.pcert0 : \
- defexec/other-apps/qsort/programs.pcert0 \
- defexec/other-apps/qsort/permutations.pcert0 \
- defexec/other-apps/qsort/spec-properties.lisp
-defexec/other-apps/qsort/spec-properties.pcert1 : acl2x = 0
-defexec/other-apps/qsort/spec-properties.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/spec-properties.pcert1 : defexec/other-apps/qsort/spec-properties.pcert0
-defexec/other-apps/qsort/spec-properties.cert : | defexec/other-apps/qsort/spec-properties.pcert1
-
-defexec/other-apps/qsort/split-qs-properties.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/split-qs-properties.pcert0 : acl2x = 0
-defexec/other-apps/qsort/split-qs-properties.pcert0 : \
- defexec/other-apps/qsort/programs.pcert0 \
- defexec/other-apps/qsort/merge-intermediate.pcert0 \
- defexec/other-apps/qsort/extraction.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- defexec/other-apps/qsort/split-qs-properties.lisp
-defexec/other-apps/qsort/split-qs-properties.pcert1 : acl2x = 0
-defexec/other-apps/qsort/split-qs-properties.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/split-qs-properties.pcert1 : defexec/other-apps/qsort/split-qs-properties.pcert0
-defexec/other-apps/qsort/split-qs-properties.cert : | defexec/other-apps/qsort/split-qs-properties.pcert1
-
-defexec/other-apps/qsort/total-order.pcert0 : no_pcert = 0
-defexec/other-apps/qsort/total-order.pcert0 : acl2x = 0
-defexec/other-apps/qsort/total-order.pcert0 : \
- defexec/other-apps/qsort/total-order.lisp
-defexec/other-apps/qsort/total-order.pcert1 : acl2x = 0
-defexec/other-apps/qsort/total-order.pcert1 : no_pcert = 0
-defexec/other-apps/qsort/total-order.pcert1 : defexec/other-apps/qsort/total-order.pcert0
-defexec/other-apps/qsort/total-order.cert : | defexec/other-apps/qsort/total-order.pcert1
-
-defexec/other-apps/records/inline.pcert0 : no_pcert = 0
-defexec/other-apps/records/inline.pcert0 : acl2x = 0
-defexec/other-apps/records/inline.pcert0 : \
- defexec/other-apps/records/inline.lisp
-defexec/other-apps/records/inline.pcert1 : acl2x = 0
-defexec/other-apps/records/inline.pcert1 : no_pcert = 0
-defexec/other-apps/records/inline.pcert1 : defexec/other-apps/records/inline.pcert0
-defexec/other-apps/records/inline.cert : | defexec/other-apps/records/inline.pcert1
-
-defexec/other-apps/records/records-bsd.pcert0 : no_pcert = 0
-defexec/other-apps/records/records-bsd.pcert0 : acl2x = 0
-defexec/other-apps/records/records-bsd.pcert0 : \
- misc/total-order-bsd.pcert0 \
- defexec/other-apps/records/records-bsd.lisp
-defexec/other-apps/records/records-bsd.pcert1 : acl2x = 0
-defexec/other-apps/records/records-bsd.pcert1 : no_pcert = 0
-defexec/other-apps/records/records-bsd.pcert1 : defexec/other-apps/records/records-bsd.pcert0
-defexec/other-apps/records/records-bsd.cert : | defexec/other-apps/records/records-bsd.pcert1
-
-defexec/other-apps/records/records.pcert0 : no_pcert = 0
-defexec/other-apps/records/records.pcert0 : acl2x = 0
-defexec/other-apps/records/records.pcert0 : \
- misc/total-order.pcert0 \
- defexec/other-apps/records/records.lisp
-defexec/other-apps/records/records.pcert1 : acl2x = 0
-defexec/other-apps/records/records.pcert1 : no_pcert = 0
-defexec/other-apps/records/records.pcert1 : defexec/other-apps/records/records.pcert0
-defexec/other-apps/records/records.cert : | defexec/other-apps/records/records.pcert1
-
-defexec/other-apps/records/recordsim.pcert0 : no_pcert = 0
-defexec/other-apps/records/recordsim.pcert0 : acl2x = 0
-defexec/other-apps/records/recordsim.pcert0 : \
- defexec/other-apps/records/records.pcert0 \
- defexec/other-apps/records/inline.pcert0 \
- defexec/other-apps/records/recordsim.lisp
-defexec/other-apps/records/recordsim.pcert1 : acl2x = 0
-defexec/other-apps/records/recordsim.pcert1 : no_pcert = 0
-defexec/other-apps/records/recordsim.pcert1 : defexec/other-apps/records/recordsim.pcert0
-defexec/other-apps/records/recordsim.cert : | defexec/other-apps/records/recordsim.pcert1
-
-defexec/reflexive/reflexive.pcert0 : no_pcert = 0
-defexec/reflexive/reflexive.pcert0 : acl2x = 0
-defexec/reflexive/reflexive.pcert0 : \
- misc/eval.pcert0 \
- defexec/reflexive/reflexive.lisp
-defexec/reflexive/reflexive.pcert1 : acl2x = 0
-defexec/reflexive/reflexive.pcert1 : no_pcert = 0
-defexec/reflexive/reflexive.pcert1 : defexec/reflexive/reflexive.pcert0
-defexec/reflexive/reflexive.cert : | defexec/reflexive/reflexive.pcert1
-
-defsort/defsort.pcert0 : no_pcert = 0
-defsort/defsort.pcert0 : acl2x = 0
-defsort/defsort.pcert0 : \
- defsort/generic.pcert0 \
- defsort/defsort.lisp
-defsort/defsort.pcert1 : acl2x = 0
-defsort/defsort.pcert1 : no_pcert = 0
-defsort/defsort.pcert1 : defsort/defsort.pcert0
-defsort/defsort.cert : | defsort/defsort.pcert1
-
-defsort/duplicated-members.pcert0 : no_pcert = 0
-defsort/duplicated-members.pcert0 : acl2x = 0
-defsort/duplicated-members.pcert0 : \
- defsort/uniquep.pcert0 \
- defsort/duplicity.pcert0 \
- defsort/duplicated-members.lisp
-defsort/duplicated-members.pcert1 : acl2x = 0
-defsort/duplicated-members.pcert1 : no_pcert = 0
-defsort/duplicated-members.pcert1 : defsort/duplicated-members.pcert0
-defsort/duplicated-members.cert : | defsort/duplicated-members.pcert1
-
-defsort/duplicity.pcert0 : no_pcert = 0
-defsort/duplicity.pcert0 : acl2x = 0
-defsort/duplicity.pcert0 : \
- defsort/duplicity.lisp
-defsort/duplicity.pcert1 : acl2x = 0
-defsort/duplicity.pcert1 : no_pcert = 0
-defsort/duplicity.pcert1 : defsort/duplicity.pcert0
-defsort/duplicity.cert : | defsort/duplicity.pcert1
-
-defsort/examples.pcert0 : no_pcert = 0
-defsort/examples.pcert0 : acl2x = 0
-defsort/examples.pcert0 : \
- defsort/defsort.pcert0 \
- misc/total-order.pcert0 \
- misc/assert.pcert0 \
- defsort/examples.lisp
-defsort/examples.pcert1 : acl2x = 0
-defsort/examples.pcert1 : no_pcert = 0
-defsort/examples.pcert1 : defsort/examples.pcert0
-defsort/examples.cert : | defsort/examples.pcert1
-
-defsort/generic-impl.pcert0 : no_pcert = 0
-defsort/generic-impl.pcert0 : acl2x = 0
-defsort/generic-impl.pcert0 : \
- std/lists/take.pcert0 \
- std/lists/nthcdr.pcert0 \
- std/lists/list-fix.pcert0 \
- defsort/duplicity.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- defsort/generic-impl.lisp
-defsort/generic-impl.pcert1 : acl2x = 0
-defsort/generic-impl.pcert1 : no_pcert = 0
-defsort/generic-impl.pcert1 : defsort/generic-impl.pcert0
-defsort/generic-impl.cert : | defsort/generic-impl.pcert1
-
-defsort/generic.pcert0 : no_pcert = 0
-defsort/generic.pcert0 : acl2x = 0
-defsort/generic.pcert0 : \
- defsort/generic-impl.pcert0 \
- defsort/generic.lisp
-defsort/generic.pcert1 : acl2x = 0
-defsort/generic.pcert1 : no_pcert = 0
-defsort/generic.pcert1 : defsort/generic.pcert0
-defsort/generic.cert : | defsort/generic.pcert1
-
-defsort/remove-dups.pcert0 : no_pcert = 0
-defsort/remove-dups.pcert0 : acl2x = 0
-defsort/remove-dups.pcert0 : \
- defsort/uniquep.pcert0 \
- misc/hons-help.pcert0 \
- defsort/remove-dups.lisp
-defsort/remove-dups.pcert1 : acl2x = 0
-defsort/remove-dups.pcert1 : no_pcert = 0
-defsort/remove-dups.pcert1 : defsort/remove-dups.pcert0
-defsort/remove-dups.cert : | defsort/remove-dups.pcert1
-
-defsort/uniquep.pcert0 : no_pcert = 0
-defsort/uniquep.pcert0 : acl2x = 0
-defsort/uniquep.pcert0 : \
- defsort/defsort.pcert0 \
- misc/total-order.pcert0 \
- defsort/uniquep.lisp
-defsort/uniquep.pcert1 : acl2x = 0
-defsort/uniquep.pcert1 : no_pcert = 0
-defsort/uniquep.pcert1 : defsort/uniquep.pcert0
-defsort/uniquep.cert : | defsort/uniquep.pcert1
-
-demos/list-theory.pcert0 : no_pcert = 0
-demos/list-theory.pcert0 : acl2x = 0
-demos/list-theory.pcert0 : \
- demos/list-theory.lisp
-demos/list-theory.pcert1 : acl2x = 0
-demos/list-theory.pcert1 : no_pcert = 0
-demos/list-theory.pcert1 : demos/list-theory.pcert0
-demos/list-theory.cert : | demos/list-theory.pcert1
-
-demos/modeling/memories.pcert0 : no_pcert = 0
-demos/modeling/memories.pcert0 : acl2x = 0
-demos/modeling/memories.pcert0 : \
- defexec/other-apps/records/records.pcert0 \
- cutil/defalist.pcert0 \
- misc/defun-plus.pcert0 \
- cutil/portcullis.pcert0 \
- demos/modeling/memories.lisp \
- demos/modeling/cert.acl2
-demos/modeling/memories.pcert1 : acl2x = 0
-demos/modeling/memories.pcert1 : no_pcert = 0
-demos/modeling/memories.pcert1 : demos/modeling/memories.pcert0
-demos/modeling/memories.cert : | demos/modeling/memories.pcert1
-
-demos/modeling/network-state-basic.pcert0 : no_pcert = 0
-demos/modeling/network-state-basic.pcert0 : acl2x = 0
-demos/modeling/network-state-basic.pcert0 : \
- make-event/eval.pcert0 \
- cutil/portcullis.pcert0 \
- demos/modeling/network-state-basic.lisp \
- demos/modeling/cert.acl2
-demos/modeling/network-state-basic.pcert1 : acl2x = 0
-demos/modeling/network-state-basic.pcert1 : no_pcert = 0
-demos/modeling/network-state-basic.pcert1 : demos/modeling/network-state-basic.pcert0
-demos/modeling/network-state-basic.cert : | demos/modeling/network-state-basic.pcert1
-
-demos/modeling/network-state.pcert0 : no_pcert = 0
-demos/modeling/network-state.pcert0 : acl2x = 0
-demos/modeling/network-state.pcert0 : \
- make-event/eval.pcert0 \
- cutil/defaggregate.pcert0 \
- cutil/deflist.pcert0 \
- misc/defun-plus.pcert0 \
- tools/bstar.pcert0 \
- arithmetic/top.pcert0 \
- cutil/portcullis.pcert0 \
- demos/modeling/network-state.lisp \
- demos/modeling/cert.acl2
-demos/modeling/network-state.pcert1 : acl2x = 0
-demos/modeling/network-state.pcert1 : no_pcert = 0
-demos/modeling/network-state.pcert1 : demos/modeling/network-state.pcert0
-demos/modeling/network-state.cert : | demos/modeling/network-state.pcert1
-
-demos/modeling/nondeterminism.pcert0 : no_pcert = 0
-demos/modeling/nondeterminism.pcert0 : acl2x = 0
-demos/modeling/nondeterminism.pcert0 : \
- make-event/eval.pcert0 \
- cutil/portcullis.pcert0 \
- demos/modeling/nondeterminism.lisp \
- demos/modeling/cert.acl2
-demos/modeling/nondeterminism.pcert1 : acl2x = 0
-demos/modeling/nondeterminism.pcert1 : no_pcert = 0
-demos/modeling/nondeterminism.pcert1 : demos/modeling/nondeterminism.pcert0
-demos/modeling/nondeterminism.cert : | demos/modeling/nondeterminism.pcert1
-
-finite-set-theory/osets/cardinality.pcert0 : no_pcert = 0
-finite-set-theory/osets/cardinality.pcert0 : acl2x = 0
-finite-set-theory/osets/cardinality.pcert0 : \
- finite-set-theory/osets/delete.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/cardinality.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/cardinality.pcert1 : acl2x = 0
-finite-set-theory/osets/cardinality.pcert1 : no_pcert = 0
-finite-set-theory/osets/cardinality.pcert1 : finite-set-theory/osets/cardinality.pcert0
-finite-set-theory/osets/cardinality.cert : | finite-set-theory/osets/cardinality.pcert1
-
-finite-set-theory/osets/computed-hints.pcert0 : no_pcert = 0
-finite-set-theory/osets/computed-hints.pcert0 : acl2x = 0
-finite-set-theory/osets/computed-hints.pcert0 : \
- finite-set-theory/osets/instance.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/computed-hints.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/computed-hints.pcert1 : acl2x = 0
-finite-set-theory/osets/computed-hints.pcert1 : no_pcert = 0
-finite-set-theory/osets/computed-hints.pcert1 : finite-set-theory/osets/computed-hints.pcert0
-finite-set-theory/osets/computed-hints.cert : | finite-set-theory/osets/computed-hints.pcert1
-
-finite-set-theory/osets/delete.pcert0 : no_pcert = 0
-finite-set-theory/osets/delete.pcert0 : acl2x = 0
-finite-set-theory/osets/delete.pcert0 : \
- finite-set-theory/osets/membership.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/delete.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/delete.pcert1 : acl2x = 0
-finite-set-theory/osets/delete.pcert1 : no_pcert = 0
-finite-set-theory/osets/delete.pcert1 : finite-set-theory/osets/delete.pcert0
-finite-set-theory/osets/delete.cert : | finite-set-theory/osets/delete.pcert1
-
-finite-set-theory/osets/difference.pcert0 : no_pcert = 0
-finite-set-theory/osets/difference.pcert0 : acl2x = 0
-finite-set-theory/osets/difference.pcert0 : \
- finite-set-theory/osets/membership.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/difference.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/difference.pcert1 : acl2x = 0
-finite-set-theory/osets/difference.pcert1 : no_pcert = 0
-finite-set-theory/osets/difference.pcert1 : finite-set-theory/osets/difference.pcert0
-finite-set-theory/osets/difference.cert : | finite-set-theory/osets/difference.pcert1
-
-finite-set-theory/osets/instance.pcert0 : no_pcert = 0
-finite-set-theory/osets/instance.pcert0 : acl2x = 0
-finite-set-theory/osets/instance.pcert0 : \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/instance.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/instance.pcert1 : acl2x = 0
-finite-set-theory/osets/instance.pcert1 : no_pcert = 0
-finite-set-theory/osets/instance.pcert1 : finite-set-theory/osets/instance.pcert0
-finite-set-theory/osets/instance.cert : | finite-set-theory/osets/instance.pcert1
-
-finite-set-theory/osets/intersect.pcert0 : no_pcert = 0
-finite-set-theory/osets/intersect.pcert0 : acl2x = 0
-finite-set-theory/osets/intersect.pcert0 : \
- finite-set-theory/osets/membership.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/intersect.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/intersect.pcert1 : acl2x = 0
-finite-set-theory/osets/intersect.pcert1 : no_pcert = 0
-finite-set-theory/osets/intersect.pcert1 : finite-set-theory/osets/intersect.pcert0
-finite-set-theory/osets/intersect.cert : | finite-set-theory/osets/intersect.pcert1
-
-finite-set-theory/osets/map-tests.pcert0 : no_pcert = 0
-finite-set-theory/osets/map-tests.pcert0 : acl2x = 0
-finite-set-theory/osets/map-tests.pcert0 : \
- finite-set-theory/osets/map.pcert0 \
- misc/assert.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/map-tests.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/map-tests.pcert1 : acl2x = 0
-finite-set-theory/osets/map-tests.pcert1 : no_pcert = 0
-finite-set-theory/osets/map-tests.pcert1 : finite-set-theory/osets/map-tests.pcert0
-finite-set-theory/osets/map-tests.cert : | finite-set-theory/osets/map-tests.pcert1
-
-finite-set-theory/osets/map.pcert0 : no_pcert = 0
-finite-set-theory/osets/map.pcert0 : acl2x = 0
-finite-set-theory/osets/map.pcert0 : \
- finite-set-theory/osets/quantify.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/map.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/map.pcert1 : acl2x = 0
-finite-set-theory/osets/map.pcert1 : no_pcert = 0
-finite-set-theory/osets/map.pcert1 : finite-set-theory/osets/map.pcert0
-finite-set-theory/osets/map.cert : | finite-set-theory/osets/map.pcert1
-
-finite-set-theory/osets/membership.pcert0 : no_pcert = 0
-finite-set-theory/osets/membership.pcert0 : acl2x = 0
-finite-set-theory/osets/membership.pcert0 : \
- finite-set-theory/osets/primitives.pcert0 \
- finite-set-theory/osets/computed-hints.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/membership.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/membership.pcert1 : acl2x = 0
-finite-set-theory/osets/membership.pcert1 : no_pcert = 0
-finite-set-theory/osets/membership.pcert1 : finite-set-theory/osets/membership.pcert0
-finite-set-theory/osets/membership.cert : | finite-set-theory/osets/membership.pcert1
-
-finite-set-theory/osets/outer.pcert0 : no_pcert = 0
-finite-set-theory/osets/outer.pcert0 : acl2x = 0
-finite-set-theory/osets/outer.pcert0 : \
- finite-set-theory/osets/delete.pcert0 \
- finite-set-theory/osets/union.pcert0 \
- finite-set-theory/osets/intersect.pcert0 \
- finite-set-theory/osets/difference.pcert0 \
- finite-set-theory/osets/cardinality.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/outer.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/outer.pcert1 : acl2x = 0
-finite-set-theory/osets/outer.pcert1 : no_pcert = 0
-finite-set-theory/osets/outer.pcert1 : finite-set-theory/osets/outer.pcert0
-finite-set-theory/osets/outer.cert : | finite-set-theory/osets/outer.pcert1
-
-finite-set-theory/osets/portcullis.pcert0 : no_pcert = 0
-finite-set-theory/osets/portcullis.pcert0 : acl2x = 0
-finite-set-theory/osets/portcullis.pcert0 : \
- finite-set-theory/osets/portcullis.lisp \
- finite-set-theory/osets/portcullis.acl2 \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-finite-set-theory/osets/portcullis.pcert1 : acl2x = 0
-finite-set-theory/osets/portcullis.pcert1 : no_pcert = 0
-finite-set-theory/osets/portcullis.pcert1 : finite-set-theory/osets/portcullis.pcert0
-finite-set-theory/osets/portcullis.cert : | finite-set-theory/osets/portcullis.pcert1
-
-finite-set-theory/osets/primitives.pcert0 : no_pcert = 0
-finite-set-theory/osets/primitives.pcert0 : acl2x = 0
-finite-set-theory/osets/primitives.pcert0 : \
- misc/total-order.pcert0 \
- tools/rulesets.pcert0 \
- xdoc/top.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/primitives.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/primitives.pcert1 : acl2x = 0
-finite-set-theory/osets/primitives.pcert1 : no_pcert = 0
-finite-set-theory/osets/primitives.pcert1 : finite-set-theory/osets/primitives.pcert0
-finite-set-theory/osets/primitives.cert : | finite-set-theory/osets/primitives.pcert1
-
-finite-set-theory/osets/quantify.pcert0 : no_pcert = 0
-finite-set-theory/osets/quantify.pcert0 : acl2x = 0
-finite-set-theory/osets/quantify.pcert0 : \
- finite-set-theory/osets/sets.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/quantify.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/quantify.pcert1 : acl2x = 0
-finite-set-theory/osets/quantify.pcert1 : no_pcert = 0
-finite-set-theory/osets/quantify.pcert1 : finite-set-theory/osets/quantify.pcert0
-finite-set-theory/osets/quantify.cert : | finite-set-theory/osets/quantify.pcert1
-
-finite-set-theory/osets/sets.pcert0 : no_pcert = 0
-finite-set-theory/osets/sets.pcert0 : acl2x = 0
-finite-set-theory/osets/sets.pcert0 : \
- misc/total-order.pcert0 \
- tools/rulesets.pcert0 \
- std/lists/list-defuns.pcert0 \
- finite-set-theory/osets/computed-hints.pcert0 \
- finite-set-theory/osets/primitives.pcert0 \
- finite-set-theory/osets/membership.pcert0 \
- finite-set-theory/osets/outer.pcert0 \
- finite-set-theory/osets/sort.pcert0 \
- finite-set-theory/osets/under-set-equiv.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/sets.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/sets.pcert1 : acl2x = 0
-finite-set-theory/osets/sets.pcert1 : no_pcert = 0
-finite-set-theory/osets/sets.pcert1 : finite-set-theory/osets/sets.pcert0
-finite-set-theory/osets/sets.cert : | finite-set-theory/osets/sets.pcert1
-
-finite-set-theory/osets/sort.pcert0 : no_pcert = 0
-finite-set-theory/osets/sort.pcert0 : acl2x = 0
-finite-set-theory/osets/sort.pcert0 : \
- finite-set-theory/osets/union.pcert0 \
- std/lists/app.pcert0 \
- std/lists/rev.pcert0 \
- tools/mv-nth.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/sort.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/sort.pcert1 : acl2x = 0
-finite-set-theory/osets/sort.pcert1 : no_pcert = 0
-finite-set-theory/osets/sort.pcert1 : finite-set-theory/osets/sort.pcert0
-finite-set-theory/osets/sort.cert : | finite-set-theory/osets/sort.pcert1
-
-finite-set-theory/osets/under-set-equiv.pcert0 : no_pcert = 0
-finite-set-theory/osets/under-set-equiv.pcert0 : acl2x = 0
-finite-set-theory/osets/under-set-equiv.pcert0 : \
- finite-set-theory/osets/outer.pcert0 \
- finite-set-theory/osets/sort.pcert0 \
- std/lists/sets.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/under-set-equiv.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/under-set-equiv.pcert1 : acl2x = 0
-finite-set-theory/osets/under-set-equiv.pcert1 : no_pcert = 0
-finite-set-theory/osets/under-set-equiv.pcert1 : finite-set-theory/osets/under-set-equiv.pcert0
-finite-set-theory/osets/under-set-equiv.cert : | finite-set-theory/osets/under-set-equiv.pcert1
-
-finite-set-theory/osets/union.pcert0 : no_pcert = 0
-finite-set-theory/osets/union.pcert0 : acl2x = 0
-finite-set-theory/osets/union.pcert0 : \
- finite-set-theory/osets/membership.pcert0 \
- finite-set-theory/osets/portcullis.pcert0 \
- finite-set-theory/osets/union.lisp \
- finite-set-theory/osets/cert.acl2
-finite-set-theory/osets/union.pcert1 : acl2x = 0
-finite-set-theory/osets/union.pcert1 : no_pcert = 0
-finite-set-theory/osets/union.pcert1 : finite-set-theory/osets/union.pcert0
-finite-set-theory/osets/union.cert : | finite-set-theory/osets/union.pcert1
-
-finite-set-theory/set-theory.pcert0 : no_pcert = 0
-finite-set-theory/set-theory.pcert0 : acl2x = 0
-finite-set-theory/set-theory.pcert0 : \
- finite-set-theory/total-ordering.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- finite-set-theory/set-theory.lisp \
- finite-set-theory/set-theory.acl2
-finite-set-theory/set-theory.pcert1 : acl2x = 0
-finite-set-theory/set-theory.pcert1 : no_pcert = 0
-finite-set-theory/set-theory.pcert1 : finite-set-theory/set-theory.pcert0
-finite-set-theory/set-theory.cert : | finite-set-theory/set-theory.pcert1
-
-finite-set-theory/total-ordering.pcert0 : no_pcert = 0
-finite-set-theory/total-ordering.pcert0 : acl2x = 0
-finite-set-theory/total-ordering.pcert0 : \
- finite-set-theory/total-ordering.lisp
-finite-set-theory/total-ordering.pcert1 : acl2x = 0
-finite-set-theory/total-ordering.pcert1 : no_pcert = 0
-finite-set-theory/total-ordering.pcert1 : finite-set-theory/total-ordering.pcert0
-finite-set-theory/total-ordering.cert : | finite-set-theory/total-ordering.pcert1
-
-hacking/all.pcert0 : no_pcert = 0
-hacking/all.pcert0 : acl2x = 0
-hacking/all.pcert0 : \
- hacking/hacker.pcert0 \
- hacking/defstruct-parsing.pcert0 \
- hacking/rewrite-code.pcert0 \
- hacking/defcode.pcert0 \
- hacking/raw.pcert0 \
- hacking/redefun.pcert0 \
- hacking/bridge.pcert0 \
- hacking/subsumption.pcert0 \
- hacking/table-guard.pcert0 \
- hacking/all.lisp \
- hacking/all.acl2 \
- hacking/hacker-pkg.lsp \
- hacking/rewrite-code-pkg.lsp
-hacking/all.pcert1 : acl2x = 0
-hacking/all.pcert1 : no_pcert = 0
-hacking/all.pcert1 : hacking/all.pcert0
-hacking/all.cert : | hacking/all.pcert1
-
-hacking/bridge.pcert0 : no_pcert = 0
-hacking/bridge.pcert0 : acl2x = 0
-hacking/bridge.pcert0 : \
- hacking/doc-section.pcert0 \
- hacking/bridge.lisp \
- hacking/bridge.acl2 \
- hacking/hacker-pkg.lsp
-hacking/bridge.pcert1 : acl2x = 0
-hacking/bridge.pcert1 : no_pcert = 0
-hacking/bridge.pcert1 : hacking/bridge.pcert0
-hacking/bridge.cert : | hacking/bridge.pcert1
-
-hacking/defcode.pcert0 : no_pcert = 0
-hacking/defcode.pcert0 : acl2x = 0
-hacking/defcode.pcert0 : \
- hacking/hacker.pcert0 \
- hacking/progn-bang-enh.pcert0 \
- hacking/defcode.lisp \
- hacking/defcode.acl2 \
- hacking/hacker-pkg.lsp
-hacking/defcode.pcert1 : acl2x = 0
-hacking/defcode.pcert1 : no_pcert = 0
-hacking/defcode.pcert1 : hacking/defcode.pcert0
-hacking/defcode.cert : | hacking/defcode.pcert1
-
-hacking/defstruct-parsing.pcert0 : no_pcert = 0
-hacking/defstruct-parsing.pcert0 : acl2x = 0
-hacking/defstruct-parsing.pcert0 : \
- hacking/defstruct-parsing.lisp \
- hacking/defstruct-parsing.acl2 \
- hacking/hacker-pkg.lsp
-hacking/defstruct-parsing.pcert1 : acl2x = 0
-hacking/defstruct-parsing.pcert1 : no_pcert = 0
-hacking/defstruct-parsing.pcert1 : hacking/defstruct-parsing.pcert0
-hacking/defstruct-parsing.cert : | hacking/defstruct-parsing.pcert1
-
-hacking/doc-section.pcert0 : no_pcert = 0
-hacking/doc-section.pcert0 : acl2x = 0
-hacking/doc-section.pcert0 : \
- hacking/doc-section.lisp
-hacking/doc-section.pcert1 : acl2x = 0
-hacking/doc-section.pcert1 : no_pcert = 0
-hacking/doc-section.pcert1 : hacking/doc-section.pcert0
-hacking/doc-section.cert : | hacking/doc-section.pcert1
-
-hacking/dynamic-make-event-test.pcert0 : no_pcert = 0
-hacking/dynamic-make-event-test.pcert0 : acl2x = 0
-hacking/dynamic-make-event-test.pcert0 : \
- hacking/defcode.pcert0 \
- hacking/rewrite-code.pcert0 \
- hacking/redefun.pcert0 \
- hacking/dynamic-make-event.pcert0 \
- hacking/rewrite-code.pcert0 \
- hacking/dynamic-make-event-test.lisp \
- hacking/dynamic-make-event-test.acl2 \
- hacking/hacker-pkg.lsp
-hacking/dynamic-make-event-test.pcert1 : acl2x = 0
-hacking/dynamic-make-event-test.pcert1 : no_pcert = 0
-hacking/dynamic-make-event-test.pcert1 : hacking/dynamic-make-event-test.pcert0
-hacking/dynamic-make-event-test.cert : | hacking/dynamic-make-event-test.pcert1
-
-hacking/dynamic-make-event.pcert0 : no_pcert = 0
-hacking/dynamic-make-event.pcert0 : acl2x = 0
-hacking/dynamic-make-event.pcert0 : \
- hacking/rewrite-code.pcert0 \
- hacking/dynamic-make-event.lisp \
- hacking/dynamic-make-event.acl2 \
- hacking/hacker-pkg.lsp
-hacking/dynamic-make-event.pcert1 : acl2x = 0
-hacking/dynamic-make-event.pcert1 : no_pcert = 0
-hacking/dynamic-make-event.pcert1 : hacking/dynamic-make-event.pcert0
-hacking/dynamic-make-event.cert : | hacking/dynamic-make-event.pcert1
-
-hacking/evalable-ld-printing.pcert0 : no_pcert = 0
-hacking/evalable-ld-printing.pcert0 : acl2x = 0
-hacking/evalable-ld-printing.pcert0 : \
- misc/evalable-printing.pcert0 \
- hacking/hacker.pcert0 \
- hacking/defcode.pcert0 \
- hacking/subsumption.pcert0 \
- hacking/raw.pcert0 \
- hacking/evalable-ld-printing.lisp \
- hacking/evalable-ld-printing.acl2
-hacking/evalable-ld-printing.pcert1 : acl2x = 0
-hacking/evalable-ld-printing.pcert1 : no_pcert = 0
-hacking/evalable-ld-printing.pcert1 : hacking/evalable-ld-printing.pcert0
-hacking/evalable-ld-printing.cert : | hacking/evalable-ld-printing.pcert1
-
-hacking/hacker.pcert0 : no_pcert = 0
-hacking/hacker.pcert0 : acl2x = 0
-hacking/hacker.pcert0 : \
- hacking/doc-section.pcert0 \
- hacking/hacker.lisp \
- hacking/hacker.acl2 \
- hacking/hacker-pkg.lsp
-hacking/hacker.pcert1 : acl2x = 0
-hacking/hacker.pcert1 : no_pcert = 0
-hacking/hacker.pcert1 : hacking/hacker.pcert0
-hacking/hacker.cert : | hacking/hacker.pcert1
-
-hacking/progn-bang-enh.pcert0 : no_pcert = 0
-hacking/progn-bang-enh.pcert0 : acl2x = 0
-hacking/progn-bang-enh.pcert0 : \
- hacking/progn-bang-enh.lisp \
- hacking/progn-bang-enh.acl2
-hacking/progn-bang-enh.pcert1 : acl2x = 0
-hacking/progn-bang-enh.pcert1 : no_pcert = 0
-hacking/progn-bang-enh.pcert1 : hacking/progn-bang-enh.pcert0
-hacking/progn-bang-enh.cert : | hacking/progn-bang-enh.pcert1
-
-hacking/raw.pcert0 : no_pcert = 0
-hacking/raw.pcert0 : acl2x = 0
-hacking/raw.pcert0 : \
- hacking/defstruct-parsing.pcert0 \
- hacking/raw.lisp \
- hacking/raw.acl2 \
- hacking/hacker-pkg.lsp
-hacking/raw.pcert1 : acl2x = 0
-hacking/raw.pcert1 : no_pcert = 0
-hacking/raw.pcert1 : hacking/raw.pcert0
-hacking/raw.cert : | hacking/raw.pcert1
-
-hacking/redefun.pcert0 : no_pcert = 0
-hacking/redefun.pcert0 : acl2x = 0
-hacking/redefun.pcert0 : \
- hacking/redefun.lisp \
- hacking/redefun.acl2 \
- hacking/hacker-pkg.lsp
-hacking/redefun.pcert1 : acl2x = 0
-hacking/redefun.pcert1 : no_pcert = 0
-hacking/redefun.pcert1 : hacking/redefun.pcert0
-hacking/redefun.cert : | hacking/redefun.pcert1
-
-hacking/rewrite-code.pcert0 : no_pcert = 0
-hacking/rewrite-code.pcert0 : acl2x = 0
-hacking/rewrite-code.pcert0 : \
- hacking/rewrite-code.lisp \
- hacking/rewrite-code.acl2 \
- hacking/rewrite-code-pkg.lsp
-hacking/rewrite-code.pcert1 : acl2x = 0
-hacking/rewrite-code.pcert1 : no_pcert = 0
-hacking/rewrite-code.pcert1 : hacking/rewrite-code.pcert0
-hacking/rewrite-code.cert : | hacking/rewrite-code.pcert1
-
-hacking/subsumption.pcert0 : no_pcert = 0
-hacking/subsumption.pcert0 : acl2x = 0
-hacking/subsumption.pcert0 : \
- hacking/doc-section.pcert0 \
- hacking/subsumption.lisp \
- hacking/subsumption.acl2 \
- hacking/hacker-pkg.lsp
-hacking/subsumption.pcert1 : acl2x = 0
-hacking/subsumption.pcert1 : no_pcert = 0
-hacking/subsumption.pcert1 : hacking/subsumption.pcert0
-hacking/subsumption.cert : | hacking/subsumption.pcert1
-
-hacking/table-guard.pcert0 : no_pcert = 0
-hacking/table-guard.pcert0 : acl2x = 0
-hacking/table-guard.pcert0 : \
- hacking/defcode.pcert0 \
- hacking/rewrite-code.pcert0 \
- hacking/redefun.pcert0 \
- hacking/rewrite-code.pcert0 \
- hacking/table-guard.lisp \
- hacking/table-guard.acl2 \
- hacking/hacker-pkg.lsp
-hacking/table-guard.pcert1 : acl2x = 0
-hacking/table-guard.pcert1 : no_pcert = 0
-hacking/table-guard.pcert1 : hacking/table-guard.pcert0
-hacking/table-guard.cert : | hacking/table-guard.pcert1
-
-hints/basic-tests.pcert0 : no_pcert = 0
-hints/basic-tests.pcert0 : acl2x = 0
-hints/basic-tests.pcert0 : \
- misc/eval.pcert0 \
- hints/basic-tests.lisp \
- hints/basic-tests.acl2
-hints/basic-tests.pcert1 : acl2x = 0
-hints/basic-tests.pcert1 : no_pcert = 0
-hints/basic-tests.pcert1 : hints/basic-tests.pcert0
-hints/basic-tests.cert : | hints/basic-tests.pcert1
-
-hints/consider-hint-tests.pcert0 : no_pcert = 0
-hints/consider-hint-tests.pcert0 : acl2x = 0
-hints/consider-hint-tests.pcert0 : \
- hints/consider-hint.pcert0 \
- misc/eval.pcert0 \
- hints/consider-hint-tests.lisp \
- hints/consider-hint-tests.acl2
-hints/consider-hint-tests.pcert1 : acl2x = 0
-hints/consider-hint-tests.pcert1 : no_pcert = 0
-hints/consider-hint-tests.pcert1 : hints/consider-hint-tests.pcert0
-hints/consider-hint-tests.cert : | hints/consider-hint-tests.pcert1
-
-hints/consider-hint.pcert0 : no_pcert = 0
-hints/consider-hint.pcert0 : acl2x = 0
-hints/consider-hint.pcert0 : \
- hints/huet-lang-algorithm.pcert0 \
- hints/merge-hint.pcert0 \
- hints/consider-hint.lisp
-hints/consider-hint.pcert1 : acl2x = 0
-hints/consider-hint.pcert1 : no_pcert = 0
-hints/consider-hint.pcert1 : hints/consider-hint.pcert0
-hints/consider-hint.cert : | hints/consider-hint.pcert1
-
-hints/huet-lang-algorithm-tests.pcert0 : no_pcert = 0
-hints/huet-lang-algorithm-tests.pcert0 : acl2x = 0
-hints/huet-lang-algorithm-tests.pcert0 : \
- hints/huet-lang-algorithm.pcert0 \
- misc/eval.pcert0 \
- hints/huet-lang-algorithm-tests.lisp
-hints/huet-lang-algorithm-tests.pcert1 : acl2x = 0
-hints/huet-lang-algorithm-tests.pcert1 : no_pcert = 0
-hints/huet-lang-algorithm-tests.pcert1 : hints/huet-lang-algorithm-tests.pcert0
-hints/huet-lang-algorithm-tests.cert : | hints/huet-lang-algorithm-tests.pcert1
-
-hints/huet-lang-algorithm.pcert0 : no_pcert = 0
-hints/huet-lang-algorithm.pcert0 : acl2x = 0
-hints/huet-lang-algorithm.pcert0 : \
- hints/huet-lang-algorithm.lisp
-hints/huet-lang-algorithm.pcert1 : acl2x = 0
-hints/huet-lang-algorithm.pcert1 : no_pcert = 0
-hints/huet-lang-algorithm.pcert1 : hints/huet-lang-algorithm.pcert0
-hints/huet-lang-algorithm.cert : | hints/huet-lang-algorithm.pcert1
-
-hints/merge-hint.pcert0 : no_pcert = 0
-hints/merge-hint.pcert0 : acl2x = 0
-hints/merge-hint.pcert0 : \
- misc/eval.pcert0 \
- hints/merge-hint.lisp
-hints/merge-hint.pcert1 : acl2x = 0
-hints/merge-hint.pcert1 : no_pcert = 0
-hints/merge-hint.pcert1 : hints/merge-hint.pcert0
-hints/merge-hint.cert : | hints/merge-hint.pcert1
-
-ihs/@logops.pcert0 : no_pcert = 0
-ihs/@logops.pcert0 : acl2x = 0
-ihs/@logops.pcert0 : \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- ihs/@logops.lisp
-ihs/@logops.pcert1 : acl2x = 0
-ihs/@logops.pcert1 : no_pcert = 0
-ihs/@logops.pcert1 : ihs/@logops.pcert0
-ihs/@logops.cert : | ihs/@logops.pcert1
-
-ihs/basic-definitions.pcert0 : no_pcert = 0
-ihs/basic-definitions.pcert0 : acl2x = 0
-ihs/basic-definitions.pcert0 : \
- ihs/ihs-doc-topic.pcert0 \
- ihs/math-lemmas.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- ihs/basic-definitions.lisp
-ihs/basic-definitions.pcert1 : acl2x = 0
-ihs/basic-definitions.pcert1 : no_pcert = 0
-ihs/basic-definitions.pcert1 : ihs/basic-definitions.pcert0
-ihs/basic-definitions.cert : | ihs/basic-definitions.pcert1
-
-ihs/ihs-definitions.pcert0 : no_pcert = 0
-ihs/ihs-definitions.pcert0 : acl2x = 0
-ihs/ihs-definitions.pcert0 : \
- ihs/ihs-init.pcert0 \
- ihs/ihs-theories.pcert0 \
- ihs/logops-definitions.pcert0 \
- ihs/ihs-definitions.lisp
-ihs/ihs-definitions.pcert1 : acl2x = 0
-ihs/ihs-definitions.pcert1 : no_pcert = 0
-ihs/ihs-definitions.pcert1 : ihs/ihs-definitions.pcert0
-ihs/ihs-definitions.cert : | ihs/ihs-definitions.pcert1
-
-ihs/ihs-doc-topic.pcert0 : no_pcert = 0
-ihs/ihs-doc-topic.pcert0 : acl2x = 0
-ihs/ihs-doc-topic.pcert0 : \
- ihs/ihs-doc-topic.lisp
-ihs/ihs-doc-topic.pcert1 : acl2x = 0
-ihs/ihs-doc-topic.pcert1 : no_pcert = 0
-ihs/ihs-doc-topic.pcert1 : ihs/ihs-doc-topic.pcert0
-ihs/ihs-doc-topic.cert : | ihs/ihs-doc-topic.pcert1
-
-ihs/ihs-init.pcert0 : no_pcert = 0
-ihs/ihs-init.pcert0 : acl2x = 0
-ihs/ihs-init.pcert0 : \
- ihs/ihs-doc-topic.pcert0 \
- data-structures/utilities.pcert0 \
- ihs/ihs-init.lisp \
- ihs/ihs-init.acl2 \
- data-structures/define-u-package.lsp
-ihs/ihs-init.pcert1 : acl2x = 0
-ihs/ihs-init.pcert1 : no_pcert = 0
-ihs/ihs-init.pcert1 : ihs/ihs-init.pcert0
-ihs/ihs-init.cert : | ihs/ihs-init.pcert1
-
-ihs/ihs-lemmas.pcert0 : no_pcert = 0
-ihs/ihs-lemmas.pcert0 : acl2x = 0
-ihs/ihs-lemmas.pcert0 : \
- ihs/math-lemmas.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- ihs/logops-lemmas.pcert0 \
- ihs/ihs-lemmas.lisp
-ihs/ihs-lemmas.pcert1 : acl2x = 0
-ihs/ihs-lemmas.pcert1 : no_pcert = 0
-ihs/ihs-lemmas.pcert1 : ihs/ihs-lemmas.pcert0
-ihs/ihs-lemmas.cert : | ihs/ihs-lemmas.pcert1
-
-ihs/ihs-theories.pcert0 : no_pcert = 0
-ihs/ihs-theories.pcert0 : acl2x = 0
-ihs/ihs-theories.pcert0 : \
- ihs/ihs-init.pcert0 \
- ihs/ihs-theories.lisp
-ihs/ihs-theories.pcert1 : acl2x = 0
-ihs/ihs-theories.pcert1 : no_pcert = 0
-ihs/ihs-theories.pcert1 : ihs/ihs-theories.pcert0
-ihs/ihs-theories.cert : | ihs/ihs-theories.pcert1
-
-ihs/logops-definitions.pcert0 : no_pcert = 0
-ihs/logops-definitions.pcert0 : acl2x = 0
-ihs/logops-definitions.pcert0 : \
- ihs/ihs-init.pcert0 \
- ihs/ihs-theories.pcert0 \
- ihs/math-lemmas.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- ihs/basic-definitions.pcert0 \
- ihs/logops-definitions.lisp
-ihs/logops-definitions.pcert1 : acl2x = 0
-ihs/logops-definitions.pcert1 : no_pcert = 0
-ihs/logops-definitions.pcert1 : ihs/logops-definitions.pcert0
-ihs/logops-definitions.cert : | ihs/logops-definitions.pcert1
-
-ihs/logops-lemmas.pcert0 : no_pcert = 0
-ihs/logops-lemmas.pcert0 : acl2x = 0
-ihs/logops-lemmas.pcert0 : \
- ihs/ihs-init.pcert0 \
- ihs/ihs-theories.pcert0 \
- ihs/math-lemmas.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- ihs/logops-definitions.pcert0 \
- ihs/logops-lemmas.lisp
-ihs/logops-lemmas.pcert1 : acl2x = 0
-ihs/logops-lemmas.pcert1 : no_pcert = 0
-ihs/logops-lemmas.pcert1 : ihs/logops-lemmas.pcert0
-ihs/logops-lemmas.cert : | ihs/logops-lemmas.pcert1
-
-ihs/math-lemmas.pcert0 : no_pcert = 0
-ihs/math-lemmas.pcert0 : acl2x = 0
-ihs/math-lemmas.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/ihs-init.pcert0 \
- ihs/math-lemmas.lisp
-ihs/math-lemmas.pcert1 : acl2x = 0
-ihs/math-lemmas.pcert1 : no_pcert = 0
-ihs/math-lemmas.pcert1 : ihs/math-lemmas.pcert0
-ihs/math-lemmas.cert : | ihs/math-lemmas.pcert1
-
-ihs/quotient-remainder-lemmas.pcert0 : no_pcert = 0
-ihs/quotient-remainder-lemmas.pcert0 : acl2x = 0
-ihs/quotient-remainder-lemmas.pcert0 : \
- ihs/ihs-init.pcert0 \
- ihs/ihs-theories.pcert0 \
- ihs/math-lemmas.pcert0 \
- ihs/quotient-remainder-lemmas.lisp
-ihs/quotient-remainder-lemmas.pcert1 : acl2x = 0
-ihs/quotient-remainder-lemmas.pcert1 : no_pcert = 0
-ihs/quotient-remainder-lemmas.pcert1 : ihs/quotient-remainder-lemmas.pcert0
-ihs/quotient-remainder-lemmas.cert : | ihs/quotient-remainder-lemmas.pcert1
-
-leftist-trees/leftist-tree-defthms.pcert0 : no_pcert = 0
-leftist-trees/leftist-tree-defthms.pcert0 : acl2x = 0
-leftist-trees/leftist-tree-defthms.pcert0 : \
- leftist-trees/leftist-tree-defuns.pcert0 \
- arithmetic-5/top.pcert0 \
- leftist-trees/leftist-tree-defthms.lisp
-leftist-trees/leftist-tree-defthms.pcert1 : acl2x = 0
-leftist-trees/leftist-tree-defthms.pcert1 : no_pcert = 0
-leftist-trees/leftist-tree-defthms.pcert1 : leftist-trees/leftist-tree-defthms.pcert0
-leftist-trees/leftist-tree-defthms.cert : | leftist-trees/leftist-tree-defthms.pcert1
-
-leftist-trees/leftist-tree-defuns.pcert0 : no_pcert = 0
-leftist-trees/leftist-tree-defuns.pcert0 : acl2x = 0
-leftist-trees/leftist-tree-defuns.pcert0 : \
- leftist-trees/leftist-tree-defuns.lisp
-leftist-trees/leftist-tree-defuns.pcert1 : acl2x = 0
-leftist-trees/leftist-tree-defuns.pcert1 : no_pcert = 0
-leftist-trees/leftist-tree-defuns.pcert1 : leftist-trees/leftist-tree-defuns.pcert0
-leftist-trees/leftist-tree-defuns.cert : | leftist-trees/leftist-tree-defuns.pcert1
-
-leftist-trees/leftist-tree-sort-equivalent.pcert0 : no_pcert = 0
-leftist-trees/leftist-tree-sort-equivalent.pcert0 : acl2x = 0
-leftist-trees/leftist-tree-sort-equivalent.pcert0 : \
- sorting/equisort.pcert0 \
- sorting/isort.pcert0 \
- leftist-trees/leftist-tree-sort.pcert0 \
- leftist-trees/leftist-tree-sort-equivalent.lisp
-leftist-trees/leftist-tree-sort-equivalent.pcert1 : acl2x = 0
-leftist-trees/leftist-tree-sort-equivalent.pcert1 : no_pcert = 0
-leftist-trees/leftist-tree-sort-equivalent.pcert1 : leftist-trees/leftist-tree-sort-equivalent.pcert0
-leftist-trees/leftist-tree-sort-equivalent.cert : | leftist-trees/leftist-tree-sort-equivalent.pcert1
-
-leftist-trees/leftist-tree-sort-equivalent2.pcert0 : no_pcert = 0
-leftist-trees/leftist-tree-sort-equivalent2.pcert0 : acl2x = 0
-leftist-trees/leftist-tree-sort-equivalent2.pcert0 : \
- sorting/equisort2.pcert0 \
- sorting/isort.pcert0 \
- leftist-trees/leftist-tree-sort.pcert0 \
- leftist-trees/leftist-tree-sort-equivalent2.lisp
-leftist-trees/leftist-tree-sort-equivalent2.pcert1 : acl2x = 0
-leftist-trees/leftist-tree-sort-equivalent2.pcert1 : no_pcert = 0
-leftist-trees/leftist-tree-sort-equivalent2.pcert1 : leftist-trees/leftist-tree-sort-equivalent2.pcert0
-leftist-trees/leftist-tree-sort-equivalent2.cert : | leftist-trees/leftist-tree-sort-equivalent2.pcert1
-
-leftist-trees/leftist-tree-sort-equivalent3.pcert0 : no_pcert = 0
-leftist-trees/leftist-tree-sort-equivalent3.pcert0 : acl2x = 0
-leftist-trees/leftist-tree-sort-equivalent3.pcert0 : \
- sorting/equisort3.pcert0 \
- sorting/isort.pcert0 \
- leftist-trees/leftist-tree-sort.pcert0 \
- leftist-trees/leftist-tree-sort-equivalent3.lisp
-leftist-trees/leftist-tree-sort-equivalent3.pcert1 : acl2x = 0
-leftist-trees/leftist-tree-sort-equivalent3.pcert1 : no_pcert = 0
-leftist-trees/leftist-tree-sort-equivalent3.pcert1 : leftist-trees/leftist-tree-sort-equivalent3.pcert0
-leftist-trees/leftist-tree-sort-equivalent3.cert : | leftist-trees/leftist-tree-sort-equivalent3.pcert1
-
-leftist-trees/leftist-tree-sort.pcert0 : no_pcert = 0
-leftist-trees/leftist-tree-sort.pcert0 : acl2x = 0
-leftist-trees/leftist-tree-sort.pcert0 : \
- sorting/perm.pcert0 \
- sorting/ordered-perms.pcert0 \
- sorting/convert-perm-to-how-many.pcert0 \
- leftist-trees/leftist-tree-defuns.pcert0 \
- leftist-trees/leftist-tree-defthms.pcert0 \
- leftist-trees/leftist-tree-sort.lisp
-leftist-trees/leftist-tree-sort.pcert1 : acl2x = 0
-leftist-trees/leftist-tree-sort.pcert1 : no_pcert = 0
-leftist-trees/leftist-tree-sort.pcert1 : leftist-trees/leftist-tree-sort.pcert0
-leftist-trees/leftist-tree-sort.cert : | leftist-trees/leftist-tree-sort.pcert1
-
-leftist-trees/top.pcert0 : no_pcert = 0
-leftist-trees/top.pcert0 : acl2x = 0
-leftist-trees/top.pcert0 : \
- leftist-trees/leftist-tree-defuns.pcert0 \
- leftist-trees/leftist-tree-defthms.pcert0 \
- leftist-trees/leftist-tree-sort.pcert0 \
- leftist-trees/top.lisp
-leftist-trees/top.pcert1 : acl2x = 0
-leftist-trees/top.pcert1 : no_pcert = 0
-leftist-trees/top.pcert1 : leftist-trees/top.pcert0
-leftist-trees/top.cert : | leftist-trees/top.pcert1
-
-make-event/acl2x-help.pcert0 : no_pcert = 0
-make-event/acl2x-help.pcert0 : acl2x = 0
-make-event/acl2x-help.pcert0 : \
- misc/hons-help.pcert0 \
- make-event/acl2x-help.lisp
-make-event/acl2x-help.pcert1 : acl2x = 0
-make-event/acl2x-help.pcert1 : no_pcert = 0
-make-event/acl2x-help.pcert1 : make-event/acl2x-help.pcert0
-make-event/acl2x-help.cert : | make-event/acl2x-help.pcert1
-
-make-event/assert-check-include-1.pcert0 : no_pcert = 0
-make-event/assert-check-include-1.pcert0 : acl2x = 0
-make-event/assert-check-include-1.pcert0 : \
- make-event/assert-check.pcert0 \
- make-event/eval.pcert0 \
- make-event/assert-check-include-1.lisp \
- make-event/assert-check-include-1.acl2
-make-event/assert-check-include-1.pcert1 : acl2x = 0
-make-event/assert-check-include-1.pcert1 : no_pcert = 0
-make-event/assert-check-include-1.pcert1 : make-event/assert-check-include-1.pcert0
-make-event/assert-check-include-1.cert : | make-event/assert-check-include-1.pcert1
-
-make-event/assert-check-include.pcert0 : no_pcert = 0
-make-event/assert-check-include.pcert0 : acl2x = 0
-make-event/assert-check-include.pcert0 : \
- make-event/assert-check.pcert0 \
- make-event/assert-check-include.lisp
-make-event/assert-check-include.pcert1 : acl2x = 0
-make-event/assert-check-include.pcert1 : no_pcert = 0
-make-event/assert-check-include.pcert1 : make-event/assert-check-include.pcert0
-make-event/assert-check-include.cert : | make-event/assert-check-include.pcert1
-
-make-event/assert-check.pcert0 : no_pcert = 0
-make-event/assert-check.pcert0 : acl2x = 0
-make-event/assert-check.pcert0 : \
- make-event/eval-check.pcert0 \
- make-event/assert-check.lisp
-make-event/assert-check.pcert1 : acl2x = 0
-make-event/assert-check.pcert1 : no_pcert = 0
-make-event/assert-check.pcert1 : make-event/assert-check.pcert0
-make-event/assert-check.cert : | make-event/assert-check.pcert1
-
-make-event/assert-include.pcert0 : no_pcert = 0
-make-event/assert-include.pcert0 : acl2x = 0
-make-event/assert-include.pcert0 : \
- make-event/assert.pcert0 \
- make-event/assert-include.lisp \
- make-event/assert-include.acl2
-make-event/assert-include.pcert1 : acl2x = 0
-make-event/assert-include.pcert1 : no_pcert = 0
-make-event/assert-include.pcert1 : make-event/assert-include.pcert0
-make-event/assert-include.cert : | make-event/assert-include.pcert1
-
-make-event/assert.pcert0 : no_pcert = 0
-make-event/assert.pcert0 : acl2x = 0
-make-event/assert.pcert0 : \
- misc/assert.pcert0 \
- make-event/assert.lisp
-make-event/assert.pcert1 : acl2x = 0
-make-event/assert.pcert1 : no_pcert = 0
-make-event/assert.pcert1 : make-event/assert.pcert0
-make-event/assert.cert : | make-event/assert.pcert1
-
-make-event/basic-check.pcert0 : no_pcert = 0
-make-event/basic-check.pcert0 : acl2x = 0
-make-event/basic-check.pcert0 : \
- make-event/basic-check.lisp
-make-event/basic-check.pcert1 : acl2x = 0
-make-event/basic-check.pcert1 : no_pcert = 0
-make-event/basic-check.pcert1 : make-event/basic-check.pcert0
-make-event/basic-check.cert : | make-event/basic-check.pcert1
-
-make-event/basic-pkg-check.pcert0 : no_pcert = 0
-make-event/basic-pkg-check.pcert0 : acl2x = 0
-make-event/basic-pkg-check.pcert0 : \
- make-event/basic-pkg-check.lisp \
- make-event/basic-pkg-check.acl2
-make-event/basic-pkg-check.pcert1 : acl2x = 0
-make-event/basic-pkg-check.pcert1 : no_pcert = 0
-make-event/basic-pkg-check.pcert1 : make-event/basic-pkg-check.pcert0
-make-event/basic-pkg-check.cert : | make-event/basic-pkg-check.pcert1
-
-make-event/basic-pkg.pcert0 : no_pcert = 0
-make-event/basic-pkg.pcert0 : acl2x = 0
-make-event/basic-pkg.pcert0 : \
- make-event/basic-pkg.lisp \
- make-event/basic-pkg.acl2
-make-event/basic-pkg.pcert1 : acl2x = 0
-make-event/basic-pkg.pcert1 : no_pcert = 0
-make-event/basic-pkg.pcert1 : make-event/basic-pkg.pcert0
-make-event/basic-pkg.cert : | make-event/basic-pkg.pcert1
-
-make-event/basic.pcert0 : no_pcert = 0
-make-event/basic.pcert0 : acl2x = 0
-make-event/basic.pcert0 : \
- make-event/basic.lisp
-make-event/basic.pcert1 : acl2x = 0
-make-event/basic.pcert1 : no_pcert = 0
-make-event/basic.pcert1 : make-event/basic.pcert0
-make-event/basic.cert : | make-event/basic.pcert1
-
-make-event/defconst-fast-examples.pcert0 : no_pcert = 0
-make-event/defconst-fast-examples.pcert0 : acl2x = 0
-make-event/defconst-fast-examples.pcert0 : \
- make-event/defconst-fast.pcert0 \
- make-event/defconst-fast-examples.lisp
-make-event/defconst-fast-examples.pcert1 : acl2x = 0
-make-event/defconst-fast-examples.pcert1 : no_pcert = 0
-make-event/defconst-fast-examples.pcert1 : make-event/defconst-fast-examples.pcert0
-make-event/defconst-fast-examples.cert : | make-event/defconst-fast-examples.pcert1
-
-make-event/defconst-fast.pcert0 : no_pcert = 0
-make-event/defconst-fast.pcert0 : acl2x = 0
-make-event/defconst-fast.pcert0 : \
- make-event/defconst-fast.lisp
-make-event/defconst-fast.pcert1 : acl2x = 0
-make-event/defconst-fast.pcert1 : no_pcert = 0
-make-event/defconst-fast.pcert1 : make-event/defconst-fast.pcert0
-make-event/defconst-fast.cert : | make-event/defconst-fast.pcert1
-
-make-event/defrefine.pcert0 : no_pcert = 0
-make-event/defrefine.pcert0 : acl2x = 0
-make-event/defrefine.pcert0 : \
- make-event/eval.pcert0 \
- make-event/defrefine.lisp
-make-event/defrefine.pcert1 : acl2x = 0
-make-event/defrefine.pcert1 : no_pcert = 0
-make-event/defrefine.pcert1 : make-event/defrefine.pcert0
-make-event/defrefine.cert : | make-event/defrefine.pcert1
-
-make-event/defrule.pcert0 : no_pcert = 0
-make-event/defrule.pcert0 : acl2x = 0
-make-event/defrule.pcert0 : \
- make-event/defrule.lisp
-make-event/defrule.pcert1 : acl2x = 0
-make-event/defrule.pcert1 : no_pcert = 0
-make-event/defrule.pcert1 : make-event/defrule.pcert0
-make-event/defrule.cert : | make-event/defrule.pcert1
-
-make-event/defspec.pcert0 : no_pcert = 0
-make-event/defspec.pcert0 : acl2x = 0
-make-event/defspec.pcert0 : \
- make-event/eval.pcert0 \
- make-event/defspec.lisp
-make-event/defspec.pcert1 : acl2x = 0
-make-event/defspec.pcert1 : no_pcert = 0
-make-event/defspec.pcert1 : make-event/defspec.pcert0
-make-event/defspec.cert : | make-event/defspec.pcert1
-
-make-event/dotimes.pcert0 : no_pcert = 0
-make-event/dotimes.pcert0 : acl2x = 0
-make-event/dotimes.pcert0 : \
- make-event/dotimes.lisp
-make-event/dotimes.pcert1 : acl2x = 0
-make-event/dotimes.pcert1 : no_pcert = 0
-make-event/dotimes.pcert1 : make-event/dotimes.pcert0
-make-event/dotimes.cert : | make-event/dotimes.pcert1
-
-make-event/embeddable-event-forms.pcert0 : no_pcert = 0
-make-event/embeddable-event-forms.pcert0 : acl2x = 0
-make-event/embeddable-event-forms.pcert0 : \
- make-event/embeddable-event-forms.lisp
-make-event/embeddable-event-forms.pcert1 : acl2x = 0
-make-event/embeddable-event-forms.pcert1 : no_pcert = 0
-make-event/embeddable-event-forms.pcert1 : make-event/embeddable-event-forms.pcert0
-make-event/embeddable-event-forms.cert : | make-event/embeddable-event-forms.pcert1
-
-make-event/eval-check-tests.pcert0 : no_pcert = 0
-make-event/eval-check-tests.pcert0 : acl2x = 0
-make-event/eval-check-tests.pcert0 : \
- make-event/eval-check.pcert0 \
- make-event/eval-check-tests.lisp
-make-event/eval-check-tests.pcert1 : acl2x = 0
-make-event/eval-check-tests.pcert1 : no_pcert = 0
-make-event/eval-check-tests.pcert1 : make-event/eval-check-tests.pcert0
-make-event/eval-check-tests.cert : | make-event/eval-check-tests.pcert1
-
-make-event/eval-check.pcert0 : no_pcert = 0
-make-event/eval-check.pcert0 : acl2x = 0
-make-event/eval-check.pcert0 : \
- make-event/eval-check.lisp
-make-event/eval-check.pcert1 : acl2x = 0
-make-event/eval-check.pcert1 : no_pcert = 0
-make-event/eval-check.pcert1 : make-event/eval-check.pcert0
-make-event/eval-check.cert : | make-event/eval-check.pcert1
-
-make-event/eval-tests.pcert0 : no_pcert = 0
-make-event/eval-tests.pcert0 : acl2x = 0
-make-event/eval-tests.pcert0 : \
- make-event/eval.pcert0 \
- make-event/eval-tests.lisp
-make-event/eval-tests.pcert1 : acl2x = 0
-make-event/eval-tests.pcert1 : no_pcert = 0
-make-event/eval-tests.pcert1 : make-event/eval-tests.pcert0
-make-event/eval-tests.cert : | make-event/eval-tests.pcert1
-
-make-event/eval.pcert0 : no_pcert = 0
-make-event/eval.pcert0 : acl2x = 0
-make-event/eval.pcert0 : \
- misc/eval.pcert0 \
- make-event/eval.lisp
-make-event/eval.pcert1 : acl2x = 0
-make-event/eval.pcert1 : no_pcert = 0
-make-event/eval.pcert1 : make-event/eval.pcert0
-make-event/eval.cert : | make-event/eval.pcert1
-
-make-event/gen-defthm-check.pcert0 : no_pcert = 0
-make-event/gen-defthm-check.pcert0 : acl2x = 0
-make-event/gen-defthm-check.pcert0 : \
- misc/expander.pcert0 \
- make-event/gen-defthm-check.lisp
-make-event/gen-defthm-check.pcert1 : acl2x = 0
-make-event/gen-defthm-check.pcert1 : no_pcert = 0
-make-event/gen-defthm-check.pcert1 : make-event/gen-defthm-check.pcert0
-make-event/gen-defthm-check.cert : | make-event/gen-defthm-check.pcert1
-
-make-event/gen-defthm.pcert0 : no_pcert = 0
-make-event/gen-defthm.pcert0 : acl2x = 0
-make-event/gen-defthm.pcert0 : \
- misc/expander.pcert0 \
- make-event/gen-defthm.lisp
-make-event/gen-defthm.pcert1 : acl2x = 0
-make-event/gen-defthm.pcert1 : no_pcert = 0
-make-event/gen-defthm.pcert1 : make-event/gen-defthm.pcert0
-make-event/gen-defthm.cert : | make-event/gen-defthm.pcert1
-
-make-event/gen-defun-check.pcert0 : no_pcert = 0
-make-event/gen-defun-check.pcert0 : acl2x = 0
-make-event/gen-defun-check.pcert0 : \
- make-event/gen-defun-check.lisp
-make-event/gen-defun-check.pcert1 : acl2x = 0
-make-event/gen-defun-check.pcert1 : no_pcert = 0
-make-event/gen-defun-check.pcert1 : make-event/gen-defun-check.pcert0
-make-event/gen-defun-check.cert : | make-event/gen-defun-check.pcert1
-
-make-event/gen-defun.pcert0 : no_pcert = 0
-make-event/gen-defun.pcert0 : acl2x = 0
-make-event/gen-defun.pcert0 : \
- make-event/gen-defun.lisp
-make-event/gen-defun.pcert1 : acl2x = 0
-make-event/gen-defun.pcert1 : no_pcert = 0
-make-event/gen-defun.pcert1 : make-event/gen-defun.pcert0
-make-event/gen-defun.cert : | make-event/gen-defun.pcert1
-
-make-event/inline-book.pcert0 : no_pcert = 0
-make-event/inline-book.pcert0 : acl2x = 0
-make-event/inline-book.pcert0 : \
- make-event/inline-book.lisp
-make-event/inline-book.pcert1 : acl2x = 0
-make-event/inline-book.pcert1 : no_pcert = 0
-make-event/inline-book.pcert1 : make-event/inline-book.pcert0
-make-event/inline-book.cert : | make-event/inline-book.pcert1
-
-make-event/local-elided-include.pcert0 : no_pcert = 0
-make-event/local-elided-include.pcert0 : acl2x = 0
-make-event/local-elided-include.pcert0 : \
- make-event/local-elided.pcert0 \
- make-event/eval.pcert0 \
- misc/file-io.pcert0 \
- make-event/local-elided-include.lisp
-make-event/local-elided-include.pcert1 : acl2x = 0
-make-event/local-elided-include.pcert1 : no_pcert = 0
-make-event/local-elided-include.pcert1 : make-event/local-elided-include.pcert0
-make-event/local-elided-include.cert : | make-event/local-elided-include.pcert1
-
-make-event/local-elided.pcert0 : no_pcert = 0
-make-event/local-elided.pcert0 : acl2x = 0
-make-event/local-elided.pcert0 : \
- make-event/eval.pcert0 \
- make-event/local-elided.lisp
-make-event/local-elided.pcert1 : acl2x = 0
-make-event/local-elided.pcert1 : no_pcert = 0
-make-event/local-elided.pcert1 : make-event/local-elided.pcert0
-make-event/local-elided.cert : | make-event/local-elided.pcert1
-
-make-event/local-requires-skip-check-include.pcert0 : no_pcert = 0
-make-event/local-requires-skip-check-include.pcert0 : acl2x = 0
-make-event/local-requires-skip-check-include.pcert0 : \
- misc/file-io.pcert0 \
- make-event/local-requires-skip-check.pcert0 \
- make-event/eval.pcert0 \
- make-event/local-requires-skip-check-include.lisp
-make-event/local-requires-skip-check-include.pcert1 : acl2x = 0
-make-event/local-requires-skip-check-include.pcert1 : no_pcert = 0
-make-event/local-requires-skip-check-include.pcert1 : make-event/local-requires-skip-check-include.pcert0
-make-event/local-requires-skip-check-include.cert : | make-event/local-requires-skip-check-include.pcert1
-
-make-event/local-requires-skip-check.pcert0 : no_pcert = 0
-make-event/local-requires-skip-check.pcert0 : acl2x = 0
-make-event/local-requires-skip-check.pcert0 : \
- make-event/eval.pcert0 \
- make-event/local-requires-skip-check.lisp
-make-event/local-requires-skip-check.pcert1 : acl2x = 0
-make-event/local-requires-skip-check.pcert1 : no_pcert = 0
-make-event/local-requires-skip-check.pcert1 : make-event/local-requires-skip-check.pcert0
-make-event/local-requires-skip-check.cert : | make-event/local-requires-skip-check.pcert1
-
-make-event/logical-tangent.pcert0 : no_pcert = 0
-make-event/logical-tangent.pcert0 : acl2x = 0
-make-event/logical-tangent.pcert0 : \
- make-event/logical-tangent.lisp
-make-event/logical-tangent.pcert1 : acl2x = 0
-make-event/logical-tangent.pcert1 : no_pcert = 0
-make-event/logical-tangent.pcert1 : make-event/logical-tangent.pcert0
-make-event/logical-tangent.cert : | make-event/logical-tangent.pcert1
-
-make-event/macros-include.pcert0 : no_pcert = 0
-make-event/macros-include.pcert0 : acl2x = 0
-make-event/macros-include.pcert0 : \
- make-event/macros.pcert0 \
- make-event/eval.pcert0 \
- misc/file-io.pcert0 \
- make-event/macros-include.lisp
-make-event/macros-include.pcert1 : acl2x = 0
-make-event/macros-include.pcert1 : no_pcert = 0
-make-event/macros-include.pcert1 : make-event/macros-include.pcert0
-make-event/macros-include.cert : | make-event/macros-include.pcert1
-
-make-event/macros-skip-proofs-include.pcert0 : no_pcert = 0
-make-event/macros-skip-proofs-include.pcert0 : acl2x = 0
-make-event/macros-skip-proofs-include.pcert0 : \
- make-event/macros-skip-proofs.pcert0 \
- make-event/eval.pcert0 \
- misc/file-io.pcert0 \
- make-event/macros-skip-proofs-include.lisp \
- make-event/macros-skip-proofs-include.acl2
-make-event/macros-skip-proofs-include.pcert1 : acl2x = 0
-make-event/macros-skip-proofs-include.pcert1 : no_pcert = 0
-make-event/macros-skip-proofs-include.pcert1 : make-event/macros-skip-proofs-include.pcert0
-make-event/macros-skip-proofs-include.cert : | make-event/macros-skip-proofs-include.pcert1
-
-make-event/macros-skip-proofs.pcert0 : no_pcert = 0
-make-event/macros-skip-proofs.pcert0 : acl2x = 0
-make-event/macros-skip-proofs.pcert0 : \
- make-event/macros-skip-proofs.lisp \
- make-event/macros-skip-proofs.acl2
-make-event/macros-skip-proofs.pcert1 : acl2x = 0
-make-event/macros-skip-proofs.pcert1 : no_pcert = 0
-make-event/macros-skip-proofs.pcert1 : make-event/macros-skip-proofs.pcert0
-make-event/macros-skip-proofs.cert : | make-event/macros-skip-proofs.pcert1
-
-make-event/macros.pcert0 : no_pcert = 0
-make-event/macros.pcert0 : acl2x = 0
-make-event/macros.pcert0 : \
- make-event/eval.pcert0 \
- make-event/macros.lisp
-make-event/macros.pcert1 : acl2x = 0
-make-event/macros.pcert1 : no_pcert = 0
-make-event/macros.pcert1 : make-event/macros.pcert0
-make-event/macros.cert : | make-event/macros.pcert1
-
-make-event/make-redundant.pcert0 : no_pcert = 0
-make-event/make-redundant.pcert0 : acl2x = 0
-make-event/make-redundant.pcert0 : \
- make-event/make-redundant.lisp
-make-event/make-redundant.pcert1 : acl2x = 0
-make-event/make-redundant.pcert1 : no_pcert = 0
-make-event/make-redundant.pcert1 : make-event/make-redundant.pcert0
-make-event/make-redundant.cert : | make-event/make-redundant.pcert1
-
-make-event/nested-check.pcert0 : no_pcert = 0
-make-event/nested-check.pcert0 : acl2x = 0
-make-event/nested-check.pcert0 : \
- make-event/nested-check.lisp
-make-event/nested-check.pcert1 : acl2x = 0
-make-event/nested-check.pcert1 : no_pcert = 0
-make-event/nested-check.pcert1 : make-event/nested-check.pcert0
-make-event/nested-check.cert : | make-event/nested-check.pcert1
-
-make-event/nested.pcert0 : no_pcert = 0
-make-event/nested.pcert0 : acl2x = 0
-make-event/nested.pcert0 : \
- make-event/nested.lisp
-make-event/nested.pcert1 : acl2x = 0
-make-event/nested.pcert1 : no_pcert = 0
-make-event/nested.pcert1 : make-event/nested.pcert0
-make-event/nested.cert : | make-event/nested.pcert1
-
-make-event/portcullis-expansion-include.pcert0 : no_pcert = 0
-make-event/portcullis-expansion-include.pcert0 : acl2x = 0
-make-event/portcullis-expansion-include.pcert0 : \
- make-event/portcullis-expansion.pcert0 \
- make-event/portcullis-expansion.pcert0 \
- make-event/portcullis-expansion-include.lisp \
- make-event/portcullis-expansion-include.acl2
-make-event/portcullis-expansion-include.pcert1 : acl2x = 0
-make-event/portcullis-expansion-include.pcert1 : no_pcert = 0
-make-event/portcullis-expansion-include.pcert1 : make-event/portcullis-expansion-include.pcert0
-make-event/portcullis-expansion-include.cert : | make-event/portcullis-expansion-include.pcert1
-
-make-event/portcullis-expansion.pcert0 : no_pcert = 0
-make-event/portcullis-expansion.pcert0 : acl2x = 0
-make-event/portcullis-expansion.pcert0 : \
- make-event/eval.pcert0 \
- make-event/portcullis-expansion.lisp \
- make-event/portcullis-expansion.acl2
-make-event/portcullis-expansion.pcert1 : acl2x = 0
-make-event/portcullis-expansion.pcert1 : no_pcert = 0
-make-event/portcullis-expansion.pcert1 : make-event/portcullis-expansion.pcert0
-make-event/portcullis-expansion.cert : | make-event/portcullis-expansion.pcert1
-
-make-event/proof-by-arith.pcert0 : no_pcert = 0
-make-event/proof-by-arith.pcert0 : acl2x = 0
-make-event/proof-by-arith.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- arithmetic-3/top.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- arithmetic-5/top.pcert0 \
- make-event/proof-by-arith.lisp
-make-event/proof-by-arith.pcert1 : acl2x = 0
-make-event/proof-by-arith.pcert1 : no_pcert = 0
-make-event/proof-by-arith.pcert1 : make-event/proof-by-arith.pcert0
-make-event/proof-by-arith.cert : | make-event/proof-by-arith.pcert1
-
-make-event/read-from-file.pcert0 : no_pcert = 0
-make-event/read-from-file.pcert0 : acl2x = 0
-make-event/read-from-file.pcert0 : \
- misc/file-io.pcert0 \
- misc/file-io.pcert0 \
- make-event/read-from-file.lisp
-make-event/read-from-file.pcert1 : acl2x = 0
-make-event/read-from-file.pcert1 : no_pcert = 0
-make-event/read-from-file.pcert1 : make-event/read-from-file.pcert0
-make-event/read-from-file.cert : | make-event/read-from-file.pcert1
-
-make-event/require-book.pcert0 : no_pcert = 0
-make-event/require-book.pcert0 : acl2x = 0
-make-event/require-book.pcert0 : \
- make-event/require-book.lisp
-make-event/require-book.pcert1 : acl2x = 0
-make-event/require-book.pcert1 : no_pcert = 0
-make-event/require-book.pcert1 : make-event/require-book.pcert0
-make-event/require-book.cert : | make-event/require-book.pcert1
-
-make-event/test-case-check.pcert0 : no_pcert = 0
-make-event/test-case-check.pcert0 : acl2x = 0
-make-event/test-case-check.pcert0 : \
- make-event/assert-check.pcert0 \
- make-event/test-case-check.lisp
-make-event/test-case-check.pcert1 : acl2x = 0
-make-event/test-case-check.pcert1 : no_pcert = 0
-make-event/test-case-check.pcert1 : make-event/test-case-check.pcert0
-make-event/test-case-check.cert : | make-event/test-case-check.pcert1
-
-make-event/test-case.pcert0 : no_pcert = 0
-make-event/test-case.pcert0 : acl2x = 0
-make-event/test-case.pcert0 : \
- make-event/assert.pcert0 \
- make-event/test-case.lisp
-make-event/test-case.pcert1 : acl2x = 0
-make-event/test-case.pcert1 : no_pcert = 0
-make-event/test-case.pcert1 : make-event/test-case.pcert0
-make-event/test-case.cert : | make-event/test-case.pcert1
-
-meta/meta-plus-equal.pcert0 : no_pcert = 0
-meta/meta-plus-equal.pcert0 : acl2x = 0
-meta/meta-plus-equal.pcert0 : \
- meta/term-defuns.pcert0 \
- meta/term-lemmas.pcert0 \
- meta/meta-plus-equal.lisp
-meta/meta-plus-equal.pcert1 : acl2x = 0
-meta/meta-plus-equal.pcert1 : no_pcert = 0
-meta/meta-plus-equal.pcert1 : meta/meta-plus-equal.pcert0
-meta/meta-plus-equal.cert : | meta/meta-plus-equal.pcert1
-
-meta/meta-plus-lessp.pcert0 : no_pcert = 0
-meta/meta-plus-lessp.pcert0 : acl2x = 0
-meta/meta-plus-lessp.pcert0 : \
- meta/term-defuns.pcert0 \
- meta/term-lemmas.pcert0 \
- meta/meta-plus-lessp.lisp
-meta/meta-plus-lessp.pcert1 : acl2x = 0
-meta/meta-plus-lessp.pcert1 : no_pcert = 0
-meta/meta-plus-lessp.pcert1 : meta/meta-plus-lessp.pcert0
-meta/meta-plus-lessp.cert : | meta/meta-plus-lessp.pcert1
-
-meta/meta-times-equal.pcert0 : no_pcert = 0
-meta/meta-times-equal.pcert0 : acl2x = 0
-meta/meta-times-equal.pcert0 : \
- meta/term-defuns.pcert0 \
- meta/term-lemmas.pcert0 \
- arithmetic/equalities.pcert0 \
- meta/meta-times-equal.lisp
-meta/meta-times-equal.pcert1 : acl2x = 0
-meta/meta-times-equal.pcert1 : no_pcert = 0
-meta/meta-times-equal.pcert1 : meta/meta-times-equal.pcert0
-meta/meta-times-equal.cert : | meta/meta-times-equal.pcert1
-
-meta/meta.pcert0 : no_pcert = 0
-meta/meta.pcert0 : acl2x = 0
-meta/meta.pcert0 : \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- meta/meta-times-equal.pcert0 \
- meta/meta.lisp
-meta/meta.pcert1 : acl2x = 0
-meta/meta.pcert1 : no_pcert = 0
-meta/meta.pcert1 : meta/meta.pcert0
-meta/meta.cert : | meta/meta.pcert1
-
-meta/pseudo-termp-lemmas.pcert0 : no_pcert = 0
-meta/pseudo-termp-lemmas.pcert0 : acl2x = 0
-meta/pseudo-termp-lemmas.pcert0 : \
- meta/term-lemmas.pcert0 \
- meta/pseudo-termp-lemmas.lisp
-meta/pseudo-termp-lemmas.pcert1 : acl2x = 0
-meta/pseudo-termp-lemmas.pcert1 : no_pcert = 0
-meta/pseudo-termp-lemmas.pcert1 : meta/pseudo-termp-lemmas.pcert0
-meta/pseudo-termp-lemmas.cert : | meta/pseudo-termp-lemmas.pcert1
-
-meta/term-defuns.pcert0 : no_pcert = 0
-meta/term-defuns.pcert0 : acl2x = 0
-meta/term-defuns.pcert0 : \
- meta/term-defuns.lisp
-meta/term-defuns.pcert1 : acl2x = 0
-meta/term-defuns.pcert1 : no_pcert = 0
-meta/term-defuns.pcert1 : meta/term-defuns.pcert0
-meta/term-defuns.cert : | meta/term-defuns.pcert1
-
-meta/term-lemmas.pcert0 : no_pcert = 0
-meta/term-lemmas.pcert0 : acl2x = 0
-meta/term-lemmas.pcert0 : \
- meta/term-defuns.pcert0 \
- meta/term-lemmas.lisp
-meta/term-lemmas.pcert1 : acl2x = 0
-meta/term-lemmas.pcert1 : no_pcert = 0
-meta/term-lemmas.pcert1 : meta/term-lemmas.pcert0
-meta/term-lemmas.cert : | meta/term-lemmas.pcert1
-
-misc/assert.pcert0 : no_pcert = 0
-misc/assert.pcert0 : acl2x = 0
-misc/assert.pcert0 : \
- misc/eval.pcert0 \
- misc/assert.lisp
-misc/assert.pcert1 : acl2x = 0
-misc/assert.pcert1 : no_pcert = 0
-misc/assert.pcert1 : misc/assert.pcert0
-misc/assert.cert : | misc/assert.pcert1
-
-misc/bash.pcert0 : no_pcert = 0
-misc/bash.pcert0 : acl2x = 0
-misc/bash.pcert0 : \
- misc/bash.lisp
-misc/bash.pcert1 : acl2x = 0
-misc/bash.pcert1 : no_pcert = 0
-misc/bash.pcert1 : misc/bash.pcert0
-misc/bash.cert : | misc/bash.pcert1
-
-misc/beta-reduce.pcert0 : no_pcert = 0
-misc/beta-reduce.pcert0 : acl2x = 0
-misc/beta-reduce.pcert0 : \
- misc/beta-reduce.lisp
-misc/beta-reduce.pcert1 : acl2x = 0
-misc/beta-reduce.pcert1 : no_pcert = 0
-misc/beta-reduce.pcert1 : misc/beta-reduce.pcert0
-misc/beta-reduce.cert : | misc/beta-reduce.pcert1
-
-misc/callers-and-ancestors.pcert0 : no_pcert = 0
-misc/callers-and-ancestors.pcert0 : acl2x = 0
-misc/callers-and-ancestors.pcert0 : \
- misc/callers-and-ancestors.lisp
-misc/callers-and-ancestors.pcert1 : acl2x = 0
-misc/callers-and-ancestors.pcert1 : no_pcert = 0
-misc/callers-and-ancestors.pcert1 : misc/callers-and-ancestors.pcert0
-misc/callers-and-ancestors.cert : | misc/callers-and-ancestors.pcert1
-
-misc/character-encoding-test.pcert0 : no_pcert = 0
-misc/character-encoding-test.pcert0 : acl2x = 0
-misc/character-encoding-test.pcert0 : \
- misc/character-encoding-test.lisp
-misc/character-encoding-test.pcert1 : acl2x = 0
-misc/character-encoding-test.pcert1 : no_pcert = 0
-misc/character-encoding-test.pcert1 : misc/character-encoding-test.pcert0
-misc/character-encoding-test.cert : | misc/character-encoding-test.pcert1
-
-misc/check-acl2-exports.pcert0 : no_pcert = 0
-misc/check-acl2-exports.pcert0 : acl2x = 0
-misc/check-acl2-exports.pcert0 : \
- misc/check-acl2-exports.lisp
-misc/check-acl2-exports.pcert1 : acl2x = 0
-misc/check-acl2-exports.pcert1 : no_pcert = 0
-misc/check-acl2-exports.pcert1 : misc/check-acl2-exports.pcert0
-misc/check-acl2-exports.cert : | misc/check-acl2-exports.pcert1
-
-misc/check-state.pcert0 : no_pcert = 0
-misc/check-state.pcert0 : acl2x = 0
-misc/check-state.pcert0 : \
- misc/check-state.lisp
-misc/check-state.pcert1 : acl2x = 0
-misc/check-state.pcert1 : no_pcert = 0
-misc/check-state.pcert1 : misc/check-state.pcert0
-misc/check-state.cert : | misc/check-state.pcert1
-
-misc/computed-hint-rewrite.pcert0 : no_pcert = 0
-misc/computed-hint-rewrite.pcert0 : acl2x = 0
-misc/computed-hint-rewrite.pcert0 : \
- misc/computed-hint-rewrite.lisp
-misc/computed-hint-rewrite.pcert1 : acl2x = 0
-misc/computed-hint-rewrite.pcert1 : no_pcert = 0
-misc/computed-hint-rewrite.pcert1 : misc/computed-hint-rewrite.pcert0
-misc/computed-hint-rewrite.cert : | misc/computed-hint-rewrite.pcert1
-
-misc/computed-hint.pcert0 : no_pcert = 0
-misc/computed-hint.pcert0 : acl2x = 0
-misc/computed-hint.pcert0 : \
- misc/computed-hint.lisp
-misc/computed-hint.pcert1 : acl2x = 0
-misc/computed-hint.pcert1 : no_pcert = 0
-misc/computed-hint.pcert1 : misc/computed-hint.pcert0
-misc/computed-hint.cert : | misc/computed-hint.pcert1
-
-misc/congruent-stobjs-test.pcert0 : no_pcert = 0
-misc/congruent-stobjs-test.pcert0 : acl2x = 0
-misc/congruent-stobjs-test.pcert0 : \
- misc/eval.pcert0 \
- misc/congruent-stobjs-test.lisp
-misc/congruent-stobjs-test.pcert1 : acl2x = 0
-misc/congruent-stobjs-test.pcert1 : no_pcert = 0
-misc/congruent-stobjs-test.pcert1 : misc/congruent-stobjs-test.pcert0
-misc/congruent-stobjs-test.cert : | misc/congruent-stobjs-test.pcert1
-
-misc/csort.pcert0 : no_pcert = 0
-misc/csort.pcert0 : acl2x = 0
-misc/csort.pcert0 : \
- misc/csort.lisp
-misc/csort.pcert1 : acl2x = 0
-misc/csort.pcert1 : no_pcert = 0
-misc/csort.pcert1 : misc/csort.pcert0
-misc/csort.cert : | misc/csort.pcert1
-
-misc/dead-events.pcert0 : no_pcert = 0
-misc/dead-events.pcert0 : acl2x = 0
-misc/dead-events.pcert0 : \
- misc/dead-events.lisp
-misc/dead-events.pcert1 : acl2x = 0
-misc/dead-events.pcert1 : no_pcert = 0
-misc/dead-events.pcert1 : misc/dead-events.pcert0
-misc/dead-events.cert : | misc/dead-events.pcert1
-
-misc/defabsstobj-example-1.pcert0 : no_pcert = 0
-misc/defabsstobj-example-1.pcert0 : acl2x = 0
-misc/defabsstobj-example-1.pcert0 : \
- misc/defabsstobj-example-1.lisp
-misc/defabsstobj-example-1.pcert1 : acl2x = 0
-misc/defabsstobj-example-1.pcert1 : no_pcert = 0
-misc/defabsstobj-example-1.pcert1 : misc/defabsstobj-example-1.pcert0
-misc/defabsstobj-example-1.cert : | misc/defabsstobj-example-1.pcert1
-
-misc/defabsstobj-example-2.pcert0 : no_pcert = 0
-misc/defabsstobj-example-2.pcert0 : acl2x = 0
-misc/defabsstobj-example-2.pcert0 : \
- misc/defabsstobj-example-2.lisp
-misc/defabsstobj-example-2.pcert1 : acl2x = 0
-misc/defabsstobj-example-2.pcert1 : no_pcert = 0
-misc/defabsstobj-example-2.pcert1 : misc/defabsstobj-example-2.pcert0
-misc/defabsstobj-example-2.cert : | misc/defabsstobj-example-2.pcert1
-
-misc/defabsstobj-example-3.pcert0 : no_pcert = 0
-misc/defabsstobj-example-3.pcert0 : acl2x = 0
-misc/defabsstobj-example-3.pcert0 : \
- misc/defabsstobj-example-3.lisp
-misc/defabsstobj-example-3.pcert1 : acl2x = 0
-misc/defabsstobj-example-3.pcert1 : no_pcert = 0
-misc/defabsstobj-example-3.pcert1 : misc/defabsstobj-example-3.pcert0
-misc/defabsstobj-example-3.cert : | misc/defabsstobj-example-3.pcert1
-
-misc/defabsstobj-example-4.pcert0 : no_pcert = 0
-misc/defabsstobj-example-4.pcert0 : acl2x = 0
-misc/defabsstobj-example-4.pcert0 : \
- misc/defabsstobj-example-4.lisp \
- misc/defabsstobj-example-4.acl2
-misc/defabsstobj-example-4.pcert1 : acl2x = 0
-misc/defabsstobj-example-4.pcert1 : no_pcert = 0
-misc/defabsstobj-example-4.pcert1 : misc/defabsstobj-example-4.pcert0
-misc/defabsstobj-example-4.cert : | misc/defabsstobj-example-4.pcert1
-
-misc/defattach-bang.pcert0 : no_pcert = 0
-misc/defattach-bang.pcert0 : acl2x = 0
-misc/defattach-bang.pcert0 : \
- misc/defattach-bang.lisp
-misc/defattach-bang.pcert1 : acl2x = 0
-misc/defattach-bang.pcert1 : no_pcert = 0
-misc/defattach-bang.pcert1 : misc/defattach-bang.pcert0
-misc/defattach-bang.cert : | misc/defattach-bang.pcert1
-
-misc/defattach-example.pcert0 : no_pcert = 0
-misc/defattach-example.pcert0 : acl2x = 0
-misc/defattach-example.pcert0 : \
- arithmetic/top.pcert0 \
- misc/defattach-example.lisp
-misc/defattach-example.pcert1 : acl2x = 0
-misc/defattach-example.pcert1 : no_pcert = 0
-misc/defattach-example.pcert1 : misc/defattach-example.pcert0
-misc/defattach-example.cert : | misc/defattach-example.pcert1
-
-misc/definline.pcert0 : no_pcert = 0
-misc/definline.pcert0 : acl2x = 0
-misc/definline.pcert0 : \
- misc/doc-section.pcert0 \
- misc/definline.lisp
-misc/definline.pcert1 : acl2x = 0
-misc/definline.pcert1 : no_pcert = 0
-misc/definline.pcert1 : misc/definline.pcert0
-misc/definline.cert : | misc/definline.pcert1
-
-misc/defmac.pcert0 : no_pcert = 0
-misc/defmac.pcert0 : acl2x = 0
-misc/defmac.pcert0 : \
- misc/doc-section.pcert0 \
- misc/defmac.lisp
-misc/defmac.pcert1 : acl2x = 0
-misc/defmac.pcert1 : no_pcert = 0
-misc/defmac.pcert1 : misc/defmac.pcert0
-misc/defmac.cert : | misc/defmac.pcert1
-
-misc/defopener.pcert0 : no_pcert = 0
-misc/defopener.pcert0 : acl2x = 0
-misc/defopener.pcert0 : \
- misc/doc-section.pcert0 \
- misc/bash.pcert0 \
- misc/defopener.lisp
-misc/defopener.pcert1 : acl2x = 0
-misc/defopener.pcert1 : no_pcert = 0
-misc/defopener.pcert1 : misc/defopener.pcert0
-misc/defopener.cert : | misc/defopener.pcert1
-
-misc/defp.pcert0 : no_pcert = 0
-misc/defp.pcert0 : acl2x = 0
-misc/defp.pcert0 : \
- misc/defpun.pcert0 \
- misc/defp.lisp
-misc/defp.pcert1 : acl2x = 0
-misc/defp.pcert1 : no_pcert = 0
-misc/defp.pcert1 : misc/defp.pcert0
-misc/defp.cert : | misc/defp.pcert1
-
-misc/defproxy-test.pcert0 : no_pcert = 0
-misc/defproxy-test.pcert0 : acl2x = 0
-misc/defproxy-test.pcert0 : \
- misc/defproxy-test.lisp \
- misc/defproxy-test.acl2
-misc/defproxy-test.pcert1 : acl2x = 0
-misc/defproxy-test.pcert1 : no_pcert = 0
-misc/defproxy-test.pcert1 : misc/defproxy-test.pcert0
-misc/defproxy-test.cert : | misc/defproxy-test.pcert1
-
-misc/defpun.pcert0 : no_pcert = 0
-misc/defpun.pcert0 : acl2x = 0
-misc/defpun.pcert0 : \
- misc/defpun.lisp
-misc/defpun.pcert1 : acl2x = 0
-misc/defpun.pcert1 : no_pcert = 0
-misc/defpun.pcert1 : misc/defpun.pcert0
-misc/defpun.cert : | misc/defpun.pcert1
-
-misc/defun-plus.pcert0 : no_pcert = 0
-misc/defun-plus.pcert0 : acl2x = 0
-misc/defun-plus.pcert0 : \
- misc/defun-plus.lisp
-misc/defun-plus.pcert1 : acl2x = 0
-misc/defun-plus.pcert1 : no_pcert = 0
-misc/defun-plus.pcert1 : misc/defun-plus.pcert0
-misc/defun-plus.cert : | misc/defun-plus.pcert1
-
-misc/dft-ex.pcert0 : no_pcert = 0
-misc/dft-ex.pcert0 : acl2x = 0
-misc/dft-ex.pcert0 : \
- misc/dft.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- misc/dft-ex.lisp \
- misc/dft-ex.acl2
-misc/dft-ex.pcert1 : acl2x = 0
-misc/dft-ex.pcert1 : no_pcert = 0
-misc/dft-ex.pcert1 : misc/dft-ex.pcert0
-misc/dft-ex.cert : | misc/dft-ex.pcert1
-
-misc/dft.pcert0 : no_pcert = 0
-misc/dft.pcert0 : acl2x = 0
-misc/dft.pcert0 : \
- misc/dft.lisp
-misc/dft.pcert1 : acl2x = 0
-misc/dft.pcert1 : no_pcert = 0
-misc/dft.pcert1 : misc/dft.pcert0
-misc/dft.cert : | misc/dft.pcert1
-
-misc/dijkstra-shortest-path.pcert0 : no_pcert = 0
-misc/dijkstra-shortest-path.pcert0 : acl2x = 0
-misc/dijkstra-shortest-path.pcert0 : \
- misc/dijkstra-shortest-path.lisp
-misc/dijkstra-shortest-path.pcert1 : acl2x = 0
-misc/dijkstra-shortest-path.pcert1 : no_pcert = 0
-misc/dijkstra-shortest-path.pcert1 : misc/dijkstra-shortest-path.pcert0
-misc/dijkstra-shortest-path.cert : | misc/dijkstra-shortest-path.pcert1
-
-misc/disassemble.pcert0 : no_pcert = 0
-misc/disassemble.pcert0 : acl2x = 0
-misc/disassemble.pcert0 : \
- misc/disassemble.lisp \
- misc/disassemble.acl2
-misc/disassemble.pcert1 : acl2x = 0
-misc/disassemble.pcert1 : no_pcert = 0
-misc/disassemble.pcert1 : misc/disassemble.pcert0
-misc/disassemble.cert : | misc/disassemble.pcert1
-
-misc/doc-section.pcert0 : no_pcert = 0
-misc/doc-section.pcert0 : acl2x = 0
-misc/doc-section.pcert0 : \
- misc/doc-section.lisp
-misc/doc-section.pcert1 : acl2x = 0
-misc/doc-section.pcert1 : no_pcert = 0
-misc/doc-section.pcert1 : misc/doc-section.pcert0
-misc/doc-section.cert : | misc/doc-section.pcert1
-
-misc/dump-events.pcert0 : no_pcert = 0
-misc/dump-events.pcert0 : acl2x = 0
-misc/dump-events.pcert0 : \
- misc/doc-section.pcert0 \
- misc/dump-events.lisp
-misc/dump-events.pcert1 : acl2x = 0
-misc/dump-events.pcert1 : no_pcert = 0
-misc/dump-events.pcert1 : misc/dump-events.pcert0
-misc/dump-events.cert : | misc/dump-events.pcert1
-
-misc/equal-by-g-help.pcert0 : no_pcert = 0
-misc/equal-by-g-help.pcert0 : acl2x = 0
-misc/equal-by-g-help.pcert0 : \
- misc/records.pcert0 \
- misc/equal-by-g-help.lisp
-misc/equal-by-g-help.pcert1 : acl2x = 0
-misc/equal-by-g-help.pcert1 : no_pcert = 0
-misc/equal-by-g-help.pcert1 : misc/equal-by-g-help.pcert0
-misc/equal-by-g-help.cert : | misc/equal-by-g-help.pcert1
-
-misc/equal-by-g.pcert0 : no_pcert = 0
-misc/equal-by-g.pcert0 : acl2x = 0
-misc/equal-by-g.pcert0 : \
- misc/records.pcert0 \
- misc/equal-by-g-help.pcert0 \
- misc/equal-by-g.lisp
-misc/equal-by-g.pcert1 : acl2x = 0
-misc/equal-by-g.pcert1 : no_pcert = 0
-misc/equal-by-g.pcert1 : misc/equal-by-g.pcert0
-misc/equal-by-g.cert : | misc/equal-by-g.pcert1
-
-misc/eval.pcert0 : no_pcert = 0
-misc/eval.pcert0 : acl2x = 0
-misc/eval.pcert0 : \
- misc/eval.lisp
-misc/eval.pcert1 : acl2x = 0
-misc/eval.pcert1 : no_pcert = 0
-misc/eval.pcert1 : misc/eval.pcert0
-misc/eval.cert : | misc/eval.pcert1
-
-misc/evalable-printing.pcert0 : no_pcert = 0
-misc/evalable-printing.pcert0 : acl2x = 0
-misc/evalable-printing.pcert0 : \
- misc/evalable-printing.lisp
-misc/evalable-printing.pcert1 : acl2x = 0
-misc/evalable-printing.pcert1 : no_pcert = 0
-misc/evalable-printing.pcert1 : misc/evalable-printing.pcert0
-misc/evalable-printing.cert : | misc/evalable-printing.pcert1
-
-misc/expander.pcert0 : no_pcert = 0
-misc/expander.pcert0 : acl2x = 0
-misc/expander.pcert0 : \
- misc/doc-section.pcert0 \
- misc/expander.lisp
-misc/expander.pcert1 : acl2x = 0
-misc/expander.pcert1 : no_pcert = 0
-misc/expander.pcert1 : misc/expander.pcert0
-misc/expander.cert : | misc/expander.pcert1
-
-misc/fast-coerce.pcert0 : no_pcert = 0
-misc/fast-coerce.pcert0 : acl2x = 0
-misc/fast-coerce.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- data-structures/list-defthms.pcert0 \
- misc/fast-coerce.lisp
-misc/fast-coerce.pcert1 : acl2x = 0
-misc/fast-coerce.pcert1 : no_pcert = 0
-misc/fast-coerce.pcert1 : misc/fast-coerce.pcert0
-misc/fast-coerce.cert : | misc/fast-coerce.pcert1
-
-misc/fibonacci.pcert0 : no_pcert = 0
-misc/fibonacci.pcert0 : acl2x = 0
-misc/fibonacci.pcert0 : \
- misc/int-division.pcert0 \
- misc/grcd.pcert0 \
- misc/fibonacci.lisp
-misc/fibonacci.pcert1 : acl2x = 0
-misc/fibonacci.pcert1 : no_pcert = 0
-misc/fibonacci.pcert1 : misc/fibonacci.pcert0
-misc/fibonacci.cert : | misc/fibonacci.pcert1
-
-misc/file-io.pcert0 : no_pcert = 0
-misc/file-io.pcert0 : acl2x = 0
-misc/file-io.pcert0 : \
- misc/file-io.lisp
-misc/file-io.pcert1 : acl2x = 0
-misc/file-io.pcert1 : no_pcert = 0
-misc/file-io.pcert1 : misc/file-io.pcert0
-misc/file-io.cert : | misc/file-io.pcert1
-
-misc/find-lemmas.pcert0 : no_pcert = 0
-misc/find-lemmas.pcert0 : acl2x = 0
-misc/find-lemmas.pcert0 : \
- misc/find-lemmas.lisp
-misc/find-lemmas.pcert1 : acl2x = 0
-misc/find-lemmas.pcert1 : no_pcert = 0
-misc/find-lemmas.pcert1 : misc/find-lemmas.pcert0
-misc/find-lemmas.cert : | misc/find-lemmas.pcert1
-
-misc/gentle.pcert0 : no_pcert = 0
-misc/gentle.pcert0 : acl2x = 0
-misc/gentle.pcert0 : \
- misc/gentle.lisp
-misc/gentle.pcert1 : acl2x = 0
-misc/gentle.pcert1 : no_pcert = 0
-misc/gentle.pcert1 : misc/gentle.pcert0
-misc/gentle.cert : | misc/gentle.pcert1
-
-misc/getprop.pcert0 : no_pcert = 0
-misc/getprop.pcert0 : acl2x = 0
-misc/getprop.pcert0 : \
- misc/getprop.lisp
-misc/getprop.pcert1 : acl2x = 0
-misc/getprop.pcert1 : no_pcert = 0
-misc/getprop.pcert1 : misc/getprop.pcert0
-misc/getprop.cert : | misc/getprop.pcert1
-
-misc/goodstein.pcert0 : no_pcert = 0
-misc/goodstein.pcert0 : acl2x = 0
-misc/goodstein.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- misc/goodstein.lisp
-misc/goodstein.pcert1 : acl2x = 0
-misc/goodstein.pcert1 : no_pcert = 0
-misc/goodstein.pcert1 : misc/goodstein.pcert0
-misc/goodstein.cert : | misc/goodstein.pcert1
-
-misc/grcd.pcert0 : no_pcert = 0
-misc/grcd.pcert0 : acl2x = 0
-misc/grcd.pcert0 : \
- misc/int-division.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- misc/grcd.lisp
-misc/grcd.pcert1 : acl2x = 0
-misc/grcd.pcert1 : no_pcert = 0
-misc/grcd.pcert1 : misc/grcd.pcert0
-misc/grcd.cert : | misc/grcd.pcert1
-
-misc/hanoi.pcert0 : no_pcert = 0
-misc/hanoi.pcert0 : acl2x = 0
-misc/hanoi.pcert0 : \
- misc/hanoi.lisp \
- misc/hanoi.acl2
-misc/hanoi.pcert1 : acl2x = 0
-misc/hanoi.pcert1 : no_pcert = 0
-misc/hanoi.pcert1 : misc/hanoi.pcert0
-misc/hanoi.cert : | misc/hanoi.pcert1
-
-misc/hons-help.pcert0 : no_pcert = 0
-misc/hons-help.pcert0 : acl2x = 0
-misc/hons-help.pcert0 : \
- misc/gentle.pcert0 \
- misc/hons-help.lisp
-misc/hons-help.pcert1 : acl2x = 0
-misc/hons-help.pcert1 : no_pcert = 0
-misc/hons-help.pcert1 : misc/hons-help.pcert0
-misc/hons-help.cert : | misc/hons-help.pcert1
-
-misc/hons-help2.pcert0 : no_pcert = 0
-misc/hons-help2.pcert0 : acl2x = 0
-misc/hons-help2.pcert0 : \
- misc/hons-help.pcert0 \
- misc/hons-help2.lisp
-misc/hons-help2.pcert1 : acl2x = 0
-misc/hons-help2.pcert1 : no_pcert = 0
-misc/hons-help2.pcert1 : misc/hons-help2.pcert0
-misc/hons-help2.cert : | misc/hons-help2.pcert1
-
-misc/hons-tests.pcert0 : no_pcert = 0
-misc/hons-tests.pcert0 : acl2x = 0
-misc/hons-tests.pcert0 : \
- misc/qi.pcert0 \
- misc/hons-tests.lisp
-misc/hons-tests.pcert1 : acl2x = 0
-misc/hons-tests.pcert1 : no_pcert = 0
-misc/hons-tests.pcert1 : misc/hons-tests.pcert0
-misc/hons-tests.cert : | misc/hons-tests.pcert1
-
-misc/how-to-prove-thms.pcert0 : no_pcert = 0
-misc/how-to-prove-thms.pcert0 : acl2x = 0
-misc/how-to-prove-thms.pcert0 : \
- misc/how-to-prove-thms.lisp
-misc/how-to-prove-thms.pcert1 : acl2x = 0
-misc/how-to-prove-thms.pcert1 : no_pcert = 0
-misc/how-to-prove-thms.pcert1 : misc/how-to-prove-thms.pcert0
-misc/how-to-prove-thms.cert : | misc/how-to-prove-thms.pcert1
-
-misc/int-division.pcert0 : no_pcert = 0
-misc/int-division.pcert0 : acl2x = 0
-misc/int-division.pcert0 : \
- arithmetic/equalities.pcert0 \
- arithmetic/inequalities.pcert0 \
- misc/int-division.lisp
-misc/int-division.pcert1 : acl2x = 0
-misc/int-division.pcert1 : no_pcert = 0
-misc/int-division.pcert1 : misc/int-division.pcert0
-misc/int-division.cert : | misc/int-division.pcert1
-
-misc/integer-type-set-test.pcert0 : no_pcert = 0
-misc/integer-type-set-test.pcert0 : acl2x = 0
-misc/integer-type-set-test.pcert0 : \
- misc/integer-type-set-test.lisp
-misc/integer-type-set-test.pcert1 : acl2x = 0
-misc/integer-type-set-test.pcert1 : no_pcert = 0
-misc/integer-type-set-test.pcert1 : misc/integer-type-set-test.pcert0
-misc/integer-type-set-test.cert : | misc/integer-type-set-test.pcert1
-
-misc/invariants.pcert0 : no_pcert = 0
-misc/invariants.pcert0 : acl2x = 0
-misc/invariants.pcert0 : \
- misc/bash.pcert0 \
- misc/invariants.lisp
-misc/invariants.pcert1 : acl2x = 0
-misc/invariants.pcert1 : no_pcert = 0
-misc/invariants.pcert1 : misc/invariants.pcert0
-misc/invariants.cert : | misc/invariants.pcert1
-
-misc/meta-lemmas.pcert0 : no_pcert = 0
-misc/meta-lemmas.pcert0 : acl2x = 0
-misc/meta-lemmas.pcert0 : \
- misc/doc-section.pcert0 \
- misc/meta-lemmas.lisp
-misc/meta-lemmas.pcert1 : acl2x = 0
-misc/meta-lemmas.pcert1 : no_pcert = 0
-misc/meta-lemmas.pcert1 : misc/meta-lemmas.pcert0
-misc/meta-lemmas.cert : | misc/meta-lemmas.pcert1
-
-misc/misc2/defpun-exec-domain-example.pcert0 : no_pcert = 0
-misc/misc2/defpun-exec-domain-example.pcert0 : acl2x = 0
-misc/misc2/defpun-exec-domain-example.pcert0 : \
- misc/defpun.pcert0 \
- misc/eval.pcert0 \
- misc/misc2/defpun-exec-domain-example.lisp
-misc/misc2/defpun-exec-domain-example.pcert1 : acl2x = 0
-misc/misc2/defpun-exec-domain-example.pcert1 : no_pcert = 0
-misc/misc2/defpun-exec-domain-example.pcert1 : misc/misc2/defpun-exec-domain-example.pcert0
-misc/misc2/defpun-exec-domain-example.cert : | misc/misc2/defpun-exec-domain-example.pcert1
-
-misc/misc2/misc.pcert0 : no_pcert = 0
-misc/misc2/misc.pcert0 : acl2x = 0
-misc/misc2/misc.pcert0 : \
- rtl/rel8/arithmetic/top.pcert0 \
- misc/misc2/misc.lisp
-misc/misc2/misc.pcert1 : acl2x = 0
-misc/misc2/misc.pcert1 : no_pcert = 0
-misc/misc2/misc.pcert1 : misc/misc2/misc.pcert0
-misc/misc2/misc.cert : | misc/misc2/misc.pcert1
-
-misc/misc2/reverse-by-separation.pcert0 : no_pcert = 0
-misc/misc2/reverse-by-separation.pcert0 : acl2x = 0
-misc/misc2/reverse-by-separation.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- coi/bags/top.pcert0 \
- coi/bags/top.pcert0 \
- misc/misc2/reverse-by-separation.lisp \
- misc/misc2/reverse-by-separation.acl2
-misc/misc2/reverse-by-separation.pcert1 : acl2x = 0
-misc/misc2/reverse-by-separation.pcert1 : no_pcert = 0
-misc/misc2/reverse-by-separation.pcert1 : misc/misc2/reverse-by-separation.pcert0
-misc/misc2/reverse-by-separation.cert : | misc/misc2/reverse-by-separation.pcert1
-
-misc/misc2/ruler-extenders-tests.pcert0 : no_pcert = 0
-misc/misc2/ruler-extenders-tests.pcert0 : acl2x = 0
-misc/misc2/ruler-extenders-tests.pcert0 : \
- misc/eval.pcert0 \
- misc/misc2/ruler-extenders-tests.lisp \
- misc/misc2/ruler-extenders-tests.acl2
-misc/misc2/ruler-extenders-tests.pcert1 : acl2x = 0
-misc/misc2/ruler-extenders-tests.pcert1 : no_pcert = 0
-misc/misc2/ruler-extenders-tests.pcert1 : misc/misc2/ruler-extenders-tests.pcert0
-misc/misc2/ruler-extenders-tests.cert : | misc/misc2/ruler-extenders-tests.pcert1
-
-misc/misc2/step-limits.pcert0 : no_pcert = 0
-misc/misc2/step-limits.pcert0 : acl2x = 0
-misc/misc2/step-limits.pcert0 : \
- misc/eval.pcert0 \
- misc/misc2/step-limits.lisp
-misc/misc2/step-limits.pcert1 : acl2x = 0
-misc/misc2/step-limits.pcert1 : no_pcert = 0
-misc/misc2/step-limits.pcert1 : misc/misc2/step-limits.pcert0
-misc/misc2/step-limits.cert : | misc/misc2/step-limits.pcert1
-
-misc/mult.pcert0 : no_pcert = 0
-misc/mult.pcert0 : acl2x = 0
-misc/mult.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- data-structures/structures.pcert0 \
- data-structures/array1.pcert0 \
- ihs/@logops.pcert0 \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- data-structures/deflist.pcert0 \
- data-structures/defalist.pcert0 \
- misc/meta-lemmas.pcert0 \
- misc/mult.lisp
-misc/mult.pcert1 : acl2x = 0
-misc/mult.pcert1 : no_pcert = 0
-misc/mult.pcert1 : misc/mult.pcert0
-misc/mult.cert : | misc/mult.pcert1
-
-misc/oprof.pcert0 : no_pcert = 0
-misc/oprof.pcert0 : acl2x = 0
-misc/oprof.pcert0 : \
- misc/oprof.lisp \
- misc/oprof.acl2
-misc/oprof.pcert1 : acl2x = 0
-misc/oprof.pcert1 : no_pcert = 0
-misc/oprof.pcert1 : misc/oprof.pcert0
-misc/oprof.cert : | misc/oprof.pcert1
-
-misc/priorities.pcert0 : no_pcert = 0
-misc/priorities.pcert0 : acl2x = 0
-misc/priorities.pcert0 : \
- misc/priorities.lisp
-misc/priorities.pcert1 : acl2x = 0
-misc/priorities.pcert1 : no_pcert = 0
-misc/priorities.pcert1 : misc/priorities.pcert0
-misc/priorities.cert : | misc/priorities.pcert1
-
-misc/problem13.pcert0 : no_pcert = 0
-misc/problem13.pcert0 : acl2x = 0
-misc/problem13.pcert0 : \
- arithmetic/equalities.pcert0 \
- arithmetic/inequalities.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- misc/problem13.lisp
-misc/problem13.pcert1 : acl2x = 0
-misc/problem13.pcert1 : no_pcert = 0
-misc/problem13.pcert1 : misc/problem13.pcert0
-misc/problem13.cert : | misc/problem13.pcert1
-
-misc/process-book-readme.pcert0 : no_pcert = 0
-misc/process-book-readme.pcert0 : acl2x = 0
-misc/process-book-readme.pcert0 : \
- misc/process-book-readme.lisp
-misc/process-book-readme.pcert1 : acl2x = 0
-misc/process-book-readme.pcert1 : no_pcert = 0
-misc/process-book-readme.pcert1 : misc/process-book-readme.pcert0
-misc/process-book-readme.cert : | misc/process-book-readme.pcert1
-
-misc/profiling.pcert0 : no_pcert = 0
-misc/profiling.pcert0 : acl2x = 0
-misc/profiling.pcert0 : \
- misc/profiling.lisp \
- misc/profiling.acl2
-misc/profiling.pcert1 : acl2x = 0
-misc/profiling.pcert1 : no_pcert = 0
-misc/profiling.pcert1 : misc/profiling.pcert0
-misc/profiling.cert : | misc/profiling.pcert1
-
-misc/qi-correct.pcert0 : no_pcert = 0
-misc/qi-correct.pcert0 : acl2x = 0
-misc/qi-correct.pcert0 : \
- misc/qi.pcert0 \
- misc/qi-correct.lisp \
- misc/qi-correct.acl2
-misc/qi-correct.pcert1 : acl2x = 0
-misc/qi-correct.pcert1 : no_pcert = 0
-misc/qi-correct.pcert1 : misc/qi-correct.pcert0
-misc/qi-correct.cert : | misc/qi-correct.pcert1
-
-misc/qi.pcert0 : no_pcert = 0
-misc/qi.pcert0 : acl2x = 0
-misc/qi.pcert0 : \
- misc/hons-help2.pcert0 \
- misc/qi.lisp \
- misc/qi.acl2
-misc/qi.pcert1 : acl2x = 0
-misc/qi.pcert1 : no_pcert = 0
-misc/qi.pcert1 : misc/qi.pcert0
-misc/qi.cert : | misc/qi.pcert1
-
-misc/radix.pcert0 : no_pcert = 0
-misc/radix.pcert0 : acl2x = 0
-misc/radix.pcert0 : \
- arithmetic-2/meta/top.pcert0 \
- arithmetic-2/floor-mod/floor-mod.pcert0 \
- misc/radix.lisp \
- misc/radix.acl2
-misc/radix.pcert1 : acl2x = 0
-misc/radix.pcert1 : no_pcert = 0
-misc/radix.pcert1 : misc/radix.pcert0
-misc/radix.cert : | misc/radix.pcert1
-
-misc/random.pcert0 : no_pcert = 0
-misc/random.pcert0 : acl2x = 0
-misc/random.pcert0 : \
- arithmetic-2/floor-mod/floor-mod.pcert0 \
- misc/random.lisp
-misc/random.pcert1 : acl2x = 0
-misc/random.pcert1 : no_pcert = 0
-misc/random.pcert1 : misc/random.pcert0
-misc/random.cert : | misc/random.pcert1
-
-misc/records-bsd.pcert0 : no_pcert = 0
-misc/records-bsd.pcert0 : acl2x = 0
-misc/records-bsd.pcert0 : \
- misc/total-order-bsd.pcert0 \
- misc/records-bsd.lisp
-misc/records-bsd.pcert1 : acl2x = 0
-misc/records-bsd.pcert1 : no_pcert = 0
-misc/records-bsd.pcert1 : misc/records-bsd.pcert0
-misc/records-bsd.cert : | misc/records-bsd.pcert1
-
-misc/records.pcert0 : no_pcert = 0
-misc/records.pcert0 : acl2x = 0
-misc/records.pcert0 : \
- misc/total-order.pcert0 \
- misc/records.lisp
-misc/records.pcert1 : acl2x = 0
-misc/records.pcert1 : no_pcert = 0
-misc/records.pcert1 : misc/records.pcert0
-misc/records.cert : | misc/records.pcert1
-
-misc/records0.pcert0 : no_pcert = 0
-misc/records0.pcert0 : acl2x = 0
-misc/records0.pcert0 : \
- misc/total-order.pcert0 \
- misc/records0.lisp
-misc/records0.pcert1 : acl2x = 0
-misc/records0.pcert1 : no_pcert = 0
-misc/records0.pcert1 : misc/records0.pcert0
-misc/records0.cert : | misc/records0.pcert1
-
-misc/redef-pkg.pcert0 : no_pcert = 0
-misc/redef-pkg.pcert0 : acl2x = 0
-misc/redef-pkg.pcert0 : \
- misc/redef-pkg.lisp \
- misc/redef-pkg.acl2
-misc/redef-pkg.pcert1 : acl2x = 0
-misc/redef-pkg.pcert1 : no_pcert = 0
-misc/redef-pkg.pcert1 : misc/redef-pkg.pcert0
-misc/redef-pkg.cert : | misc/redef-pkg.pcert1
-
-misc/rtl-untranslate.pcert0 : no_pcert = 0
-misc/rtl-untranslate.pcert0 : acl2x = 0
-misc/rtl-untranslate.pcert0 : \
- misc/symbol-btree.pcert0 \
- misc/rtl-untranslate.lisp
-misc/rtl-untranslate.pcert1 : acl2x = 0
-misc/rtl-untranslate.pcert1 : no_pcert = 0
-misc/rtl-untranslate.pcert1 : misc/rtl-untranslate.pcert0
-misc/rtl-untranslate.cert : | misc/rtl-untranslate.pcert1
-
-misc/save-time.pcert0 : no_pcert = 0
-misc/save-time.pcert0 : acl2x = 0
-misc/save-time.pcert0 : \
- misc/save-time.lisp
-misc/save-time.pcert1 : acl2x = 0
-misc/save-time.pcert1 : no_pcert = 0
-misc/save-time.pcert1 : misc/save-time.pcert0
-misc/save-time.cert : | misc/save-time.pcert1
-
-misc/seq.pcert0 : no_pcert = 0
-misc/seq.pcert0 : acl2x = 0
-misc/seq.pcert0 : \
- misc/seq.lisp
-misc/seq.pcert1 : acl2x = 0
-misc/seq.pcert1 : no_pcert = 0
-misc/seq.pcert1 : misc/seq.pcert0
-misc/seq.cert : | misc/seq.pcert1
-
-misc/seqw.pcert0 : no_pcert = 0
-misc/seqw.pcert0 : acl2x = 0
-misc/seqw.pcert0 : \
- misc/seq.pcert0 \
- misc/seqw.lisp
-misc/seqw.pcert1 : acl2x = 0
-misc/seqw.pcert1 : no_pcert = 0
-misc/seqw.pcert1 : misc/seqw.pcert0
-misc/seqw.cert : | misc/seqw.pcert1
-
-misc/simplify-defuns.pcert0 : no_pcert = 0
-misc/simplify-defuns.pcert0 : acl2x = 0
-misc/simplify-defuns.pcert0 : \
- misc/file-io.pcert0 \
- misc/simplify-defuns.lisp
-misc/simplify-defuns.pcert1 : acl2x = 0
-misc/simplify-defuns.pcert1 : no_pcert = 0
-misc/simplify-defuns.pcert1 : misc/simplify-defuns.pcert0
-misc/simplify-defuns.cert : | misc/simplify-defuns.pcert1
-
-misc/simplify-thm.pcert0 : no_pcert = 0
-misc/simplify-thm.pcert0 : acl2x = 0
-misc/simplify-thm.pcert0 : \
- misc/bash.pcert0 \
- misc/simplify-thm.lisp
-misc/simplify-thm.pcert1 : acl2x = 0
-misc/simplify-thm.pcert1 : no_pcert = 0
-misc/simplify-thm.pcert1 : misc/simplify-thm.pcert0
-misc/simplify-thm.cert : | misc/simplify-thm.pcert1
-
-misc/sin-cos.pcert0 : no_pcert = 0
-misc/sin-cos.pcert0 : acl2x = 0
-misc/sin-cos.pcert0 : \
- misc/doc-section.pcert0 \
- misc/sin-cos.lisp
-misc/sin-cos.pcert1 : acl2x = 0
-misc/sin-cos.pcert1 : no_pcert = 0
-misc/sin-cos.pcert1 : misc/sin-cos.pcert0
-misc/sin-cos.cert : | misc/sin-cos.pcert1
-
-misc/sort-symbols.pcert0 : no_pcert = 0
-misc/sort-symbols.pcert0 : acl2x = 0
-misc/sort-symbols.pcert0 : \
- misc/sort-symbols.lisp
-misc/sort-symbols.pcert1 : acl2x = 0
-misc/sort-symbols.pcert1 : no_pcert = 0
-misc/sort-symbols.pcert1 : misc/sort-symbols.pcert0
-misc/sort-symbols.cert : | misc/sort-symbols.pcert1
-
-misc/sticky-disable.pcert0 : no_pcert = 0
-misc/sticky-disable.pcert0 : acl2x = 0
-misc/sticky-disable.pcert0 : \
- misc/sticky-disable.lisp
-misc/sticky-disable.pcert1 : acl2x = 0
-misc/sticky-disable.pcert1 : no_pcert = 0
-misc/sticky-disable.pcert1 : misc/sticky-disable.pcert0
-misc/sticky-disable.cert : | misc/sticky-disable.pcert1
-
-misc/symbol-btree.pcert0 : no_pcert = 0
-misc/symbol-btree.pcert0 : acl2x = 0
-misc/symbol-btree.pcert0 : \
- ihs/quotient-remainder-lemmas.pcert0 \
- arithmetic/top.pcert0 \
- std/lists/take.pcert0 \
- arithmetic/top.pcert0 \
- arithmetic/top.pcert0 \
- misc/symbol-btree.lisp
-misc/symbol-btree.pcert1 : acl2x = 0
-misc/symbol-btree.pcert1 : no_pcert = 0
-misc/symbol-btree.pcert1 : misc/symbol-btree.pcert0
-misc/symbol-btree.cert : | misc/symbol-btree.pcert1
-
-misc/total-order-bsd.pcert0 : no_pcert = 0
-misc/total-order-bsd.pcert0 : acl2x = 0
-misc/total-order-bsd.pcert0 : \
- misc/total-order-bsd.lisp
-misc/total-order-bsd.pcert1 : acl2x = 0
-misc/total-order-bsd.pcert1 : no_pcert = 0
-misc/total-order-bsd.pcert1 : misc/total-order-bsd.pcert0
-misc/total-order-bsd.cert : | misc/total-order-bsd.pcert1
-
-misc/total-order.pcert0 : no_pcert = 0
-misc/total-order.pcert0 : acl2x = 0
-misc/total-order.pcert0 : \
- xdoc/top.pcert0 \
- misc/total-order-bsd.pcert0 \
- misc/total-order.lisp
-misc/total-order.pcert1 : acl2x = 0
-misc/total-order.pcert1 : no_pcert = 0
-misc/total-order.pcert1 : misc/total-order.pcert0
-misc/total-order.cert : | misc/total-order.pcert1
-
-misc/trace-star.pcert0 : no_pcert = 0
-misc/trace-star.pcert0 : acl2x = 0
-misc/trace-star.pcert0 : \
- misc/evalable-printing.pcert0 \
- misc/trace-star.lisp
-misc/trace-star.pcert1 : acl2x = 0
-misc/trace-star.pcert1 : no_pcert = 0
-misc/trace-star.pcert1 : misc/trace-star.pcert0
-misc/trace-star.cert : | misc/trace-star.pcert1
-
-misc/transfinite.pcert0 : no_pcert = 0
-misc/transfinite.pcert0 : acl2x = 0
-misc/transfinite.pcert0 : \
- misc/transfinite.lisp
-misc/transfinite.pcert1 : acl2x = 0
-misc/transfinite.pcert1 : no_pcert = 0
-misc/transfinite.pcert1 : misc/transfinite.pcert0
-misc/transfinite.cert : | misc/transfinite.pcert1
-
-misc/untranslate-patterns.pcert0 : no_pcert = 0
-misc/untranslate-patterns.pcert0 : acl2x = 0
-misc/untranslate-patterns.pcert0 : \
- misc/symbol-btree.pcert0 \
- misc/untranslate-patterns.lisp
-misc/untranslate-patterns.pcert1 : acl2x = 0
-misc/untranslate-patterns.pcert1 : no_pcert = 0
-misc/untranslate-patterns.pcert1 : misc/untranslate-patterns.pcert0
-misc/untranslate-patterns.cert : | misc/untranslate-patterns.pcert1
-
-misc/wet.pcert0 : no_pcert = 0
-misc/wet.pcert0 : acl2x = 0
-misc/wet.pcert0 : \
- misc/wet.lisp
-misc/wet.pcert1 : acl2x = 0
-misc/wet.pcert1 : no_pcert = 0
-misc/wet.pcert1 : misc/wet.pcert0
-misc/wet.cert : | misc/wet.pcert1
-
-models/jvm/m1-original/m1-story.pcert0 : no_pcert = 0
-models/jvm/m1-original/m1-story.pcert0 : acl2x = 0
-models/jvm/m1-original/m1-story.pcert0 : \
- models/jvm/m1-original/problem-set-1-answers.pcert0 \
- arithmetic-3/extra/top-ext.pcert0 \
- models/jvm/m1-original/problem-set-1-answers.pcert0 \
- models/jvm/m1-original/m1-story.lisp \
- models/jvm/m1-original/m1-story.acl2
-models/jvm/m1-original/m1-story.pcert1 : acl2x = 0
-models/jvm/m1-original/m1-story.pcert1 : no_pcert = 0
-models/jvm/m1-original/m1-story.pcert1 : models/jvm/m1-original/m1-story.pcert0
-models/jvm/m1-original/m1-story.cert : | models/jvm/m1-original/m1-story.pcert1
-
-models/jvm/m1-original/problem-set-1-answers.pcert0 : no_pcert = 0
-models/jvm/m1-original/problem-set-1-answers.pcert0 : acl2x = 0
-models/jvm/m1-original/problem-set-1-answers.pcert0 : \
- models/jvm/m1-original/problem-set-1-answers.lisp \
- models/jvm/m1-original/problem-set-1-answers.acl2
-models/jvm/m1-original/problem-set-1-answers.pcert1 : acl2x = 0
-models/jvm/m1-original/problem-set-1-answers.pcert1 : no_pcert = 0
-models/jvm/m1-original/problem-set-1-answers.pcert1 : models/jvm/m1-original/problem-set-1-answers.pcert0
-models/jvm/m1-original/problem-set-1-answers.cert : | models/jvm/m1-original/problem-set-1-answers.pcert1
-
-models/jvm/m1/alternating-sum-variant.pcert0 : no_pcert = 0
-models/jvm/m1/alternating-sum-variant.pcert0 : acl2x = 0
-models/jvm/m1/alternating-sum-variant.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/alternating-sum-variant.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/alternating-sum-variant.pcert1 : acl2x = 0
-models/jvm/m1/alternating-sum-variant.pcert1 : no_pcert = 0
-models/jvm/m1/alternating-sum-variant.pcert1 : models/jvm/m1/alternating-sum-variant.pcert0
-models/jvm/m1/alternating-sum-variant.cert : | models/jvm/m1/alternating-sum-variant.pcert1
-
-models/jvm/m1/alternating-sum.pcert0 : no_pcert = 0
-models/jvm/m1/alternating-sum.pcert0 : acl2x = 0
-models/jvm/m1/alternating-sum.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/alternating-sum.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/alternating-sum.pcert1 : acl2x = 0
-models/jvm/m1/alternating-sum.pcert1 : no_pcert = 0
-models/jvm/m1/alternating-sum.pcert1 : models/jvm/m1/alternating-sum.pcert0
-models/jvm/m1/alternating-sum.cert : | models/jvm/m1/alternating-sum.pcert1
-
-models/jvm/m1/bexpt.pcert0 : no_pcert = 0
-models/jvm/m1/bexpt.pcert0 : acl2x = 0
-models/jvm/m1/bexpt.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/bexpt.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/bexpt.pcert1 : acl2x = 0
-models/jvm/m1/bexpt.pcert1 : no_pcert = 0
-models/jvm/m1/bexpt.pcert1 : models/jvm/m1/bexpt.pcert0
-models/jvm/m1/bexpt.cert : | models/jvm/m1/bexpt.pcert1
-
-models/jvm/m1/defsys-utilities.pcert0 : no_pcert = 0
-models/jvm/m1/defsys-utilities.pcert0 : acl2x = 0
-models/jvm/m1/defsys-utilities.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/defsys-utilities.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/defsys-utilities.pcert1 : acl2x = 0
-models/jvm/m1/defsys-utilities.pcert1 : no_pcert = 0
-models/jvm/m1/defsys-utilities.pcert1 : models/jvm/m1/defsys-utilities.pcert0
-models/jvm/m1/defsys-utilities.cert : | models/jvm/m1/defsys-utilities.pcert1
-
-models/jvm/m1/defsys.pcert0 : no_pcert = 0
-models/jvm/m1/defsys.pcert0 : acl2x = 0
-models/jvm/m1/defsys.pcert0 : \
- models/jvm/m1/defsys-utilities.pcert0 \
- models/jvm/m1/defsys.lisp \
- models/jvm/m1/defsys.acl2
-models/jvm/m1/defsys.pcert1 : acl2x = 0
-models/jvm/m1/defsys.pcert1 : no_pcert = 0
-models/jvm/m1/defsys.pcert1 : models/jvm/m1/defsys.pcert0
-models/jvm/m1/defsys.cert : | models/jvm/m1/defsys.pcert1
-
-models/jvm/m1/div.pcert0 : no_pcert = 0
-models/jvm/m1/div.pcert0 : acl2x = 0
-models/jvm/m1/div.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/div.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/div.pcert1 : acl2x = 0
-models/jvm/m1/div.pcert1 : no_pcert = 0
-models/jvm/m1/div.pcert1 : models/jvm/m1/div.pcert0
-models/jvm/m1/div.cert : | models/jvm/m1/div.pcert1
-
-models/jvm/m1/even-solution-1.pcert0 : no_pcert = 0
-models/jvm/m1/even-solution-1.pcert0 : acl2x = 0
-models/jvm/m1/even-solution-1.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/even-solution-1.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/even-solution-1.pcert1 : acl2x = 0
-models/jvm/m1/even-solution-1.pcert1 : no_pcert = 0
-models/jvm/m1/even-solution-1.pcert1 : models/jvm/m1/even-solution-1.pcert0
-models/jvm/m1/even-solution-1.cert : | models/jvm/m1/even-solution-1.pcert1
-
-models/jvm/m1/even-solution-2.pcert0 : no_pcert = 0
-models/jvm/m1/even-solution-2.pcert0 : acl2x = 0
-models/jvm/m1/even-solution-2.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/even-solution-2.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/even-solution-2.pcert1 : acl2x = 0
-models/jvm/m1/even-solution-2.pcert1 : no_pcert = 0
-models/jvm/m1/even-solution-2.pcert1 : models/jvm/m1/even-solution-2.pcert0
-models/jvm/m1/even-solution-2.cert : | models/jvm/m1/even-solution-2.pcert1
-
-models/jvm/m1/expt.pcert0 : no_pcert = 0
-models/jvm/m1/expt.pcert0 : acl2x = 0
-models/jvm/m1/expt.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/expt.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/expt.pcert1 : acl2x = 0
-models/jvm/m1/expt.pcert1 : no_pcert = 0
-models/jvm/m1/expt.pcert1 : models/jvm/m1/expt.pcert0
-models/jvm/m1/expt.cert : | models/jvm/m1/expt.pcert1
-
-models/jvm/m1/fact.pcert0 : no_pcert = 0
-models/jvm/m1/fact.pcert0 : acl2x = 0
-models/jvm/m1/fact.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/fact.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/fact.pcert1 : acl2x = 0
-models/jvm/m1/fact.pcert1 : no_pcert = 0
-models/jvm/m1/fact.pcert1 : models/jvm/m1/fact.pcert0
-models/jvm/m1/fact.cert : | models/jvm/m1/fact.pcert1
-
-models/jvm/m1/fib.pcert0 : no_pcert = 0
-models/jvm/m1/fib.pcert0 : acl2x = 0
-models/jvm/m1/fib.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/fib.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/fib.pcert1 : acl2x = 0
-models/jvm/m1/fib.pcert1 : no_pcert = 0
-models/jvm/m1/fib.pcert1 : models/jvm/m1/fib.pcert0
-models/jvm/m1/fib.cert : | models/jvm/m1/fib.pcert1
-
-models/jvm/m1/find-k!.pcert0 : no_pcert = 0
-models/jvm/m1/find-k!.pcert0 : acl2x = 0
-models/jvm/m1/find-k!.pcert0 : \
- models/jvm/m1/theorems-a-and-b.pcert0 \
- models/jvm/m1/find-k!.lisp \
- models/jvm/m1/find-k!.acl2
-models/jvm/m1/find-k!.pcert1 : acl2x = 0
-models/jvm/m1/find-k!.pcert1 : no_pcert = 0
-models/jvm/m1/find-k!.pcert1 : models/jvm/m1/find-k!.pcert0
-models/jvm/m1/find-k!.cert : | models/jvm/m1/find-k!.pcert1
-
-models/jvm/m1/funny-fact.pcert0 : no_pcert = 0
-models/jvm/m1/funny-fact.pcert0 : acl2x = 0
-models/jvm/m1/funny-fact.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/funny-fact.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/funny-fact.pcert1 : acl2x = 0
-models/jvm/m1/funny-fact.pcert1 : no_pcert = 0
-models/jvm/m1/funny-fact.pcert1 : models/jvm/m1/funny-fact.pcert0
-models/jvm/m1/funny-fact.cert : | models/jvm/m1/funny-fact.pcert1
-
-models/jvm/m1/implementation.pcert0 : no_pcert = 0
-models/jvm/m1/implementation.pcert0 : acl2x = 0
-models/jvm/m1/implementation.pcert0 : \
- models/jvm/m1/defsys.pcert0 \
- models/jvm/m1/tmi-reductions.pcert0 \
- models/jvm/m1/implementation.lisp \
- models/jvm/m1/implementation.acl2
-models/jvm/m1/implementation.pcert1 : acl2x = 0
-models/jvm/m1/implementation.pcert1 : no_pcert = 0
-models/jvm/m1/implementation.pcert1 : models/jvm/m1/implementation.pcert0
-models/jvm/m1/implementation.cert : | models/jvm/m1/implementation.pcert1
-
-models/jvm/m1/lessp.pcert0 : no_pcert = 0
-models/jvm/m1/lessp.pcert0 : acl2x = 0
-models/jvm/m1/lessp.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/lessp.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/lessp.pcert1 : acl2x = 0
-models/jvm/m1/lessp.pcert1 : no_pcert = 0
-models/jvm/m1/lessp.pcert1 : models/jvm/m1/lessp.pcert0
-models/jvm/m1/lessp.cert : | models/jvm/m1/lessp.pcert1
-
-models/jvm/m1/low-seven.pcert0 : no_pcert = 0
-models/jvm/m1/low-seven.pcert0 : acl2x = 0
-models/jvm/m1/low-seven.pcert0 : \
- models/jvm/m1/defsys.pcert0 \
- models/jvm/m1/low-seven.lisp \
- models/jvm/m1/low-seven.acl2
-models/jvm/m1/low-seven.pcert1 : acl2x = 0
-models/jvm/m1/low-seven.pcert1 : no_pcert = 0
-models/jvm/m1/low-seven.pcert1 : models/jvm/m1/low-seven.pcert0
-models/jvm/m1/low-seven.cert : | models/jvm/m1/low-seven.pcert1
-
-models/jvm/m1/m1.pcert0 : no_pcert = 0
-models/jvm/m1/m1.pcert0 : acl2x = 0
-models/jvm/m1/m1.pcert0 : \
- arithmetic-5/top.pcert0 \
- models/jvm/m1/m1.lisp \
- models/jvm/m1/m1.acl2
-models/jvm/m1/m1.pcert1 : acl2x = 0
-models/jvm/m1/m1.pcert1 : no_pcert = 0
-models/jvm/m1/m1.pcert1 : models/jvm/m1/m1.pcert0
-models/jvm/m1/m1.cert : | models/jvm/m1/m1.pcert1
-
-models/jvm/m1/magic.pcert0 : no_pcert = 0
-models/jvm/m1/magic.pcert0 : acl2x = 0
-models/jvm/m1/magic.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/magic.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/magic.pcert1 : acl2x = 0
-models/jvm/m1/magic.pcert1 : no_pcert = 0
-models/jvm/m1/magic.pcert1 : models/jvm/m1/magic.pcert0
-models/jvm/m1/magic.cert : | models/jvm/m1/magic.pcert1
-
-models/jvm/m1/power.pcert0 : no_pcert = 0
-models/jvm/m1/power.pcert0 : acl2x = 0
-models/jvm/m1/power.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/power.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/power.pcert1 : acl2x = 0
-models/jvm/m1/power.pcert1 : no_pcert = 0
-models/jvm/m1/power.pcert1 : models/jvm/m1/power.pcert0
-models/jvm/m1/power.cert : | models/jvm/m1/power.pcert1
-
-models/jvm/m1/sign.pcert0 : no_pcert = 0
-models/jvm/m1/sign.pcert0 : acl2x = 0
-models/jvm/m1/sign.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/sign.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/sign.pcert1 : acl2x = 0
-models/jvm/m1/sign.pcert1 : no_pcert = 0
-models/jvm/m1/sign.pcert1 : models/jvm/m1/sign.pcert0
-models/jvm/m1/sign.cert : | models/jvm/m1/sign.pcert1
-
-models/jvm/m1/sum.pcert0 : no_pcert = 0
-models/jvm/m1/sum.pcert0 : acl2x = 0
-models/jvm/m1/sum.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/sum.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/sum.pcert1 : acl2x = 0
-models/jvm/m1/sum.pcert1 : no_pcert = 0
-models/jvm/m1/sum.pcert1 : models/jvm/m1/sum.pcert0
-models/jvm/m1/sum.cert : | models/jvm/m1/sum.pcert1
-
-models/jvm/m1/sumsq.pcert0 : no_pcert = 0
-models/jvm/m1/sumsq.pcert0 : acl2x = 0
-models/jvm/m1/sumsq.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/sumsq.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/sumsq.pcert1 : acl2x = 0
-models/jvm/m1/sumsq.pcert1 : no_pcert = 0
-models/jvm/m1/sumsq.pcert1 : models/jvm/m1/sumsq.pcert0
-models/jvm/m1/sumsq.cert : | models/jvm/m1/sumsq.pcert1
-
-models/jvm/m1/template.pcert0 : no_pcert = 0
-models/jvm/m1/template.pcert0 : acl2x = 0
-models/jvm/m1/template.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/template.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/template.pcert1 : acl2x = 0
-models/jvm/m1/template.pcert1 : no_pcert = 0
-models/jvm/m1/template.pcert1 : models/jvm/m1/template.pcert0
-models/jvm/m1/template.cert : | models/jvm/m1/template.pcert1
-
-models/jvm/m1/theorems-a-and-b.pcert0 : no_pcert = 0
-models/jvm/m1/theorems-a-and-b.pcert0 : acl2x = 0
-models/jvm/m1/theorems-a-and-b.pcert0 : \
- models/jvm/m1/tmi-reductions.pcert0 \
- models/jvm/m1/implementation.pcert0 \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/theorems-a-and-b.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/theorems-a-and-b.pcert1 : acl2x = 0
-models/jvm/m1/theorems-a-and-b.pcert1 : no_pcert = 0
-models/jvm/m1/theorems-a-and-b.pcert1 : models/jvm/m1/theorems-a-and-b.pcert0
-models/jvm/m1/theorems-a-and-b.cert : | models/jvm/m1/theorems-a-and-b.pcert1
-
-models/jvm/m1/tmi-reductions.pcert0 : no_pcert = 0
-models/jvm/m1/tmi-reductions.pcert0 : acl2x = 0
-models/jvm/m1/tmi-reductions.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/tmi-reductions.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/tmi-reductions.pcert1 : acl2x = 0
-models/jvm/m1/tmi-reductions.pcert1 : no_pcert = 0
-models/jvm/m1/tmi-reductions.pcert1 : models/jvm/m1/tmi-reductions.pcert0
-models/jvm/m1/tmi-reductions.cert : | models/jvm/m1/tmi-reductions.pcert1
-
-models/jvm/m1/wormhole-abstraction.pcert0 : no_pcert = 0
-models/jvm/m1/wormhole-abstraction.pcert0 : acl2x = 0
-models/jvm/m1/wormhole-abstraction.pcert0 : \
- models/jvm/m1/m1.pcert0 \
- models/jvm/m1/wormhole-abstraction.lisp \
- models/jvm/m1/cert.acl2
-models/jvm/m1/wormhole-abstraction.pcert1 : acl2x = 0
-models/jvm/m1/wormhole-abstraction.pcert1 : no_pcert = 0
-models/jvm/m1/wormhole-abstraction.pcert1 : models/jvm/m1/wormhole-abstraction.pcert0
-models/jvm/m1/wormhole-abstraction.cert : | models/jvm/m1/wormhole-abstraction.pcert1
-
-models/jvm/m5/apprentice-state.pcert0 : no_pcert = 0
-models/jvm/m5/apprentice-state.pcert0 : acl2x = 0
-models/jvm/m5/apprentice-state.pcert0 : \
- models/jvm/m5/m5.pcert0 \
- models/jvm/m5/m5.pcert0 \
- models/jvm/m5/apprentice-state.lisp \
- models/jvm/m5/apprentice-state.acl2
-models/jvm/m5/apprentice-state.pcert1 : acl2x = 0
-models/jvm/m5/apprentice-state.pcert1 : no_pcert = 0
-models/jvm/m5/apprentice-state.pcert1 : models/jvm/m5/apprentice-state.pcert0
-models/jvm/m5/apprentice-state.cert : | models/jvm/m5/apprentice-state.pcert1
-
-models/jvm/m5/demo.pcert0 : no_pcert = 0
-models/jvm/m5/demo.pcert0 : acl2x = 0
-models/jvm/m5/demo.pcert0 : \
- models/jvm/m5/utilities.pcert0 \
- models/jvm/m5/utilities.pcert0 \
- models/jvm/m5/demo.lisp \
- models/jvm/m5/demo.acl2
-models/jvm/m5/demo.pcert1 : acl2x = 0
-models/jvm/m5/demo.pcert1 : no_pcert = 0
-models/jvm/m5/demo.pcert1 : models/jvm/m5/demo.pcert0
-models/jvm/m5/demo.cert : | models/jvm/m5/demo.pcert1
-
-models/jvm/m5/idemo.pcert0 : no_pcert = 0
-models/jvm/m5/idemo.pcert0 : acl2x = 0
-models/jvm/m5/idemo.pcert0 : \
- models/jvm/m5/utilities.pcert0 \
- models/jvm/m5/utilities.pcert0 \
- models/jvm/m5/idemo.lisp \
- models/jvm/m5/idemo.acl2
-models/jvm/m5/idemo.pcert1 : acl2x = 0
-models/jvm/m5/idemo.pcert1 : no_pcert = 0
-models/jvm/m5/idemo.pcert1 : models/jvm/m5/idemo.pcert0
-models/jvm/m5/idemo.cert : | models/jvm/m5/idemo.pcert1
-
-models/jvm/m5/infinite-fair-schedule.pcert0 : no_pcert = 0
-models/jvm/m5/infinite-fair-schedule.pcert0 : acl2x = 0
-models/jvm/m5/infinite-fair-schedule.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- models/jvm/m5/infinite-fair-schedule.lisp
-models/jvm/m5/infinite-fair-schedule.pcert1 : acl2x = 0
-models/jvm/m5/infinite-fair-schedule.pcert1 : no_pcert = 0
-models/jvm/m5/infinite-fair-schedule.pcert1 : models/jvm/m5/infinite-fair-schedule.pcert0
-models/jvm/m5/infinite-fair-schedule.cert : | models/jvm/m5/infinite-fair-schedule.pcert1
-
-models/jvm/m5/isort.pcert0 : no_pcert = 0
-models/jvm/m5/isort.pcert0 : acl2x = 0
-models/jvm/m5/isort.pcert0 : \
- models/jvm/m5/utilities.pcert0 \
- models/jvm/m5/perm.pcert0 \
- models/jvm/m5/utilities.pcert0 \
- models/jvm/m5/isort.lisp \
- models/jvm/m5/isort.acl2
-models/jvm/m5/isort.pcert1 : acl2x = 0
-models/jvm/m5/isort.pcert1 : no_pcert = 0
-models/jvm/m5/isort.pcert1 : models/jvm/m5/isort.pcert0
-models/jvm/m5/isort.cert : | models/jvm/m5/isort.pcert1
-
-models/jvm/m5/jvm-fact-setup.pcert0 : no_pcert = 0
-models/jvm/m5/jvm-fact-setup.pcert0 : acl2x = 0
-models/jvm/m5/jvm-fact-setup.pcert0 : \
- models/jvm/m5/utilities.pcert0 \
- misc/expander.pcert0 \
- models/jvm/m5/utilities.pcert0 \
- models/jvm/m5/jvm-fact-setup.lisp \
- models/jvm/m5/jvm-fact-setup.acl2
-models/jvm/m5/jvm-fact-setup.pcert1 : acl2x = 0
-models/jvm/m5/jvm-fact-setup.pcert1 : no_pcert = 0
-models/jvm/m5/jvm-fact-setup.pcert1 : models/jvm/m5/jvm-fact-setup.pcert0
-models/jvm/m5/jvm-fact-setup.cert : | models/jvm/m5/jvm-fact-setup.pcert1
-
-models/jvm/m5/m5.pcert0 : no_pcert = 0
-models/jvm/m5/m5.pcert0 : acl2x = 0
-models/jvm/m5/m5.pcert0 : \
- ordinals/lexicographic-ordering.pcert0 \
- models/jvm/m5/m5.lisp \
- models/jvm/m5/m5.acl2
-models/jvm/m5/m5.pcert1 : acl2x = 0
-models/jvm/m5/m5.pcert1 : no_pcert = 0
-models/jvm/m5/m5.pcert1 : models/jvm/m5/m5.pcert0
-models/jvm/m5/m5.cert : | models/jvm/m5/m5.pcert1
-
-models/jvm/m5/partial.pcert0 : no_pcert = 0
-models/jvm/m5/partial.pcert0 : acl2x = 0
-models/jvm/m5/partial.pcert0 : \
- misc/defpun.pcert0 \
- models/jvm/m5/demo.pcert0 \
- models/jvm/m5/utilities.pcert0 \
- models/jvm/m5/partial.lisp \
- models/jvm/m5/partial.acl2
-models/jvm/m5/partial.pcert1 : acl2x = 0
-models/jvm/m5/partial.pcert1 : no_pcert = 0
-models/jvm/m5/partial.pcert1 : models/jvm/m5/partial.pcert0
-models/jvm/m5/partial.cert : | models/jvm/m5/partial.pcert1
-
-models/jvm/m5/perm.pcert0 : no_pcert = 0
-models/jvm/m5/perm.pcert0 : acl2x = 0
-models/jvm/m5/perm.pcert0 : \
- models/jvm/m5/perm.lisp
-models/jvm/m5/perm.pcert1 : acl2x = 0
-models/jvm/m5/perm.pcert1 : no_pcert = 0
-models/jvm/m5/perm.pcert1 : models/jvm/m5/perm.pcert0
-models/jvm/m5/perm.cert : | models/jvm/m5/perm.pcert1
-
-models/jvm/m5/universal-never-returns.pcert0 : no_pcert = 0
-models/jvm/m5/universal-never-returns.pcert0 : acl2x = 0
-models/jvm/m5/universal-never-returns.pcert0 : \
- models/jvm/m5/universal.pcert0 \
- models/jvm/m5/universal.pcert0 \
- models/jvm/m5/universal-never-returns.lisp \
- models/jvm/m5/universal-never-returns.acl2
-models/jvm/m5/universal-never-returns.pcert1 : acl2x = 0
-models/jvm/m5/universal-never-returns.pcert1 : no_pcert = 0
-models/jvm/m5/universal-never-returns.pcert1 : models/jvm/m5/universal-never-returns.pcert0
-models/jvm/m5/universal-never-returns.cert : | models/jvm/m5/universal-never-returns.pcert1
-
-models/jvm/m5/universal.pcert0 : no_pcert = 0
-models/jvm/m5/universal.pcert0 : acl2x = 0
-models/jvm/m5/universal.pcert0 : \
- models/jvm/m5/utilities.pcert0 \
- models/jvm/m5/utilities.pcert0 \
- models/jvm/m5/universal.lisp \
- models/jvm/m5/universal.acl2
-models/jvm/m5/universal.pcert1 : acl2x = 0
-models/jvm/m5/universal.pcert1 : no_pcert = 0
-models/jvm/m5/universal.pcert1 : models/jvm/m5/universal.pcert0
-models/jvm/m5/universal.cert : | models/jvm/m5/universal.pcert1
-
-models/jvm/m5/utilities.pcert0 : no_pcert = 0
-models/jvm/m5/utilities.pcert0 : acl2x = 0
-models/jvm/m5/utilities.pcert0 : \
- models/jvm/m5/m5.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- models/jvm/m5/m5.pcert0 \
- models/jvm/m5/utilities.lisp \
- models/jvm/m5/utilities.acl2
-models/jvm/m5/utilities.pcert1 : acl2x = 0
-models/jvm/m5/utilities.pcert1 : no_pcert = 0
-models/jvm/m5/utilities.pcert1 : models/jvm/m5/utilities.pcert0
-models/jvm/m5/utilities.cert : | models/jvm/m5/utilities.pcert1
-
-ordinals/e0-ordinal.pcert0 : no_pcert = 0
-ordinals/e0-ordinal.pcert0 : acl2x = 0
-ordinals/e0-ordinal.pcert0 : \
- ordinals/ordinal-definitions.pcert0 \
- ordinals/ordinal-isomorphism.pcert0 \
- ordinals/e0-ordinal.lisp
-ordinals/e0-ordinal.pcert1 : acl2x = 0
-ordinals/e0-ordinal.pcert1 : no_pcert = 0
-ordinals/e0-ordinal.pcert1 : ordinals/e0-ordinal.pcert0
-ordinals/e0-ordinal.cert : | ordinals/e0-ordinal.pcert1
-
-ordinals/lexicographic-book.pcert0 : no_pcert = 0
-ordinals/lexicographic-book.pcert0 : acl2x = 0
-ordinals/lexicographic-book.pcert0 : \
- ordinals/ordinals-without-arithmetic.pcert0 \
- ordinals/top-with-meta.pcert0 \
- ordinals/lexicographic-book.lisp
-ordinals/lexicographic-book.pcert1 : acl2x = 0
-ordinals/lexicographic-book.pcert1 : no_pcert = 0
-ordinals/lexicographic-book.pcert1 : ordinals/lexicographic-book.pcert0
-ordinals/lexicographic-book.cert : | ordinals/lexicographic-book.pcert1
-
-ordinals/lexicographic-ordering-without-arithmetic.pcert0 : no_pcert = 0
-ordinals/lexicographic-ordering-without-arithmetic.pcert0 : acl2x = 0
-ordinals/lexicographic-ordering-without-arithmetic.pcert0 : \
- ordinals/lexicographic-book.pcert0 \
- ordinals/lexicographic-ordering-without-arithmetic.lisp
-ordinals/lexicographic-ordering-without-arithmetic.pcert1 : acl2x = 0
-ordinals/lexicographic-ordering-without-arithmetic.pcert1 : no_pcert = 0
-ordinals/lexicographic-ordering-without-arithmetic.pcert1 : ordinals/lexicographic-ordering-without-arithmetic.pcert0
-ordinals/lexicographic-ordering-without-arithmetic.cert : | ordinals/lexicographic-ordering-without-arithmetic.pcert1
-
-ordinals/lexicographic-ordering.pcert0 : no_pcert = 0
-ordinals/lexicographic-ordering.pcert0 : acl2x = 0
-ordinals/lexicographic-ordering.pcert0 : \
- ordinals/top-with-meta.pcert0 \
- ordinals/lexicographic-book.pcert0 \
- ordinals/lexicographic-ordering.lisp
-ordinals/lexicographic-ordering.pcert1 : acl2x = 0
-ordinals/lexicographic-ordering.pcert1 : no_pcert = 0
-ordinals/lexicographic-ordering.pcert1 : ordinals/lexicographic-ordering.pcert0
-ordinals/lexicographic-ordering.cert : | ordinals/lexicographic-ordering.pcert1
-
-ordinals/limits.pcert0 : no_pcert = 0
-ordinals/limits.pcert0 : acl2x = 0
-ordinals/limits.pcert0 : \
- ordinals/ordinal-exponentiation.pcert0 \
- ordinals/top-with-meta.pcert0 \
- ordinals/limits.lisp
-ordinals/limits.pcert1 : acl2x = 0
-ordinals/limits.pcert1 : no_pcert = 0
-ordinals/limits.pcert1 : ordinals/limits.pcert0
-ordinals/limits.cert : | ordinals/limits.pcert1
-
-ordinals/ordinal-addition.pcert0 : no_pcert = 0
-ordinals/ordinal-addition.pcert0 : acl2x = 0
-ordinals/ordinal-addition.pcert0 : \
- ordinals/ordinal-basic-thms.pcert0 \
- ordinals/top-with-meta.pcert0 \
- ordinals/ordinal-addition.lisp
-ordinals/ordinal-addition.pcert1 : acl2x = 0
-ordinals/ordinal-addition.pcert1 : no_pcert = 0
-ordinals/ordinal-addition.pcert1 : ordinals/ordinal-addition.pcert0
-ordinals/ordinal-addition.cert : | ordinals/ordinal-addition.pcert1
-
-ordinals/ordinal-basic-thms.pcert0 : no_pcert = 0
-ordinals/ordinal-basic-thms.pcert0 : acl2x = 0
-ordinals/ordinal-basic-thms.pcert0 : \
- ordinals/ordinal-total-order.pcert0 \
- ordinals/top-with-meta.pcert0 \
- ordinals/ordinal-basic-thms.lisp
-ordinals/ordinal-basic-thms.pcert1 : acl2x = 0
-ordinals/ordinal-basic-thms.pcert1 : no_pcert = 0
-ordinals/ordinal-basic-thms.pcert1 : ordinals/ordinal-basic-thms.pcert0
-ordinals/ordinal-basic-thms.cert : | ordinals/ordinal-basic-thms.pcert1
-
-ordinals/ordinal-counter-examples.pcert0 : no_pcert = 0
-ordinals/ordinal-counter-examples.pcert0 : acl2x = 0
-ordinals/ordinal-counter-examples.pcert0 : \
- ordinals/ordinal-definitions.pcert0 \
- ordinals/ordinal-counter-examples.lisp
-ordinals/ordinal-counter-examples.pcert1 : acl2x = 0
-ordinals/ordinal-counter-examples.pcert1 : no_pcert = 0
-ordinals/ordinal-counter-examples.pcert1 : ordinals/ordinal-counter-examples.pcert0
-ordinals/ordinal-counter-examples.cert : | ordinals/ordinal-counter-examples.pcert1
-
-ordinals/ordinal-definitions.pcert0 : no_pcert = 0
-ordinals/ordinal-definitions.pcert0 : acl2x = 0
-ordinals/ordinal-definitions.pcert0 : \
- ordinals/ordinal-definitions.lisp
-ordinals/ordinal-definitions.pcert1 : acl2x = 0
-ordinals/ordinal-definitions.pcert1 : no_pcert = 0
-ordinals/ordinal-definitions.pcert1 : ordinals/ordinal-definitions.pcert0
-ordinals/ordinal-definitions.cert : | ordinals/ordinal-definitions.pcert1
-
-ordinals/ordinal-exponentiation.pcert0 : no_pcert = 0
-ordinals/ordinal-exponentiation.pcert0 : acl2x = 0
-ordinals/ordinal-exponentiation.pcert0 : \
- ordinals/ordinal-multiplication.pcert0 \
- ordinals/top-with-meta.pcert0 \
- ordinals/ordinal-exponentiation.lisp
-ordinals/ordinal-exponentiation.pcert1 : acl2x = 0
-ordinals/ordinal-exponentiation.pcert1 : no_pcert = 0
-ordinals/ordinal-exponentiation.pcert1 : ordinals/ordinal-exponentiation.pcert0
-ordinals/ordinal-exponentiation.cert : | ordinals/ordinal-exponentiation.pcert1
-
-ordinals/ordinal-isomorphism.pcert0 : no_pcert = 0
-ordinals/ordinal-isomorphism.pcert0 : acl2x = 0
-ordinals/ordinal-isomorphism.pcert0 : \
- ordinals/ordinal-addition.pcert0 \
- ordinals/top-with-meta.pcert0 \
- ordinals/ordinal-isomorphism.lisp
-ordinals/ordinal-isomorphism.pcert1 : acl2x = 0
-ordinals/ordinal-isomorphism.pcert1 : no_pcert = 0
-ordinals/ordinal-isomorphism.pcert1 : ordinals/ordinal-isomorphism.pcert0
-ordinals/ordinal-isomorphism.cert : | ordinals/ordinal-isomorphism.pcert1
-
-ordinals/ordinal-multiplication.pcert0 : no_pcert = 0
-ordinals/ordinal-multiplication.pcert0 : acl2x = 0
-ordinals/ordinal-multiplication.pcert0 : \
- ordinals/ordinal-addition.pcert0 \
- ordinals/top-with-meta.pcert0 \
- ordinals/ordinal-multiplication.lisp
-ordinals/ordinal-multiplication.pcert1 : acl2x = 0
-ordinals/ordinal-multiplication.pcert1 : no_pcert = 0
-ordinals/ordinal-multiplication.pcert1 : ordinals/ordinal-multiplication.pcert0
-ordinals/ordinal-multiplication.cert : | ordinals/ordinal-multiplication.pcert1
-
-ordinals/ordinal-total-order.pcert0 : no_pcert = 0
-ordinals/ordinal-total-order.pcert0 : acl2x = 0
-ordinals/ordinal-total-order.pcert0 : \
- ordinals/ordinal-definitions.pcert0 \
- ordinals/ordinal-total-order.lisp
-ordinals/ordinal-total-order.pcert1 : acl2x = 0
-ordinals/ordinal-total-order.pcert1 : no_pcert = 0
-ordinals/ordinal-total-order.pcert1 : ordinals/ordinal-total-order.pcert0
-ordinals/ordinal-total-order.cert : | ordinals/ordinal-total-order.pcert1
-
-ordinals/ordinals-without-arithmetic.pcert0 : no_pcert = 0
-ordinals/ordinals-without-arithmetic.pcert0 : acl2x = 0
-ordinals/ordinals-without-arithmetic.pcert0 : \
- ordinals/limits.pcert0 \
- ordinals/ordinals-without-arithmetic.lisp
-ordinals/ordinals-without-arithmetic.pcert1 : acl2x = 0
-ordinals/ordinals-without-arithmetic.pcert1 : no_pcert = 0
-ordinals/ordinals-without-arithmetic.pcert1 : ordinals/ordinals-without-arithmetic.pcert0
-ordinals/ordinals-without-arithmetic.cert : | ordinals/ordinals-without-arithmetic.pcert1
-
-ordinals/ordinals.pcert0 : no_pcert = 0
-ordinals/ordinals.pcert0 : acl2x = 0
-ordinals/ordinals.pcert0 : \
- ordinals/top-with-meta.pcert0 \
- ordinals/limits.pcert0 \
- ordinals/ordinals.lisp
-ordinals/ordinals.pcert1 : acl2x = 0
-ordinals/ordinals.pcert1 : no_pcert = 0
-ordinals/ordinals.pcert1 : ordinals/ordinals.pcert0
-ordinals/ordinals.cert : | ordinals/ordinals.pcert1
-
-ordinals/proof-of-well-foundedness.pcert0 : no_pcert = 0
-ordinals/proof-of-well-foundedness.pcert0 : acl2x = 0
-ordinals/proof-of-well-foundedness.pcert0 : \
- ordinals/proof-of-well-foundedness.lisp \
- ordinals/proof-of-well-foundedness.acl2
-ordinals/proof-of-well-foundedness.pcert1 : acl2x = 0
-ordinals/proof-of-well-foundedness.pcert1 : no_pcert = 0
-ordinals/proof-of-well-foundedness.pcert1 : ordinals/proof-of-well-foundedness.pcert0
-ordinals/proof-of-well-foundedness.cert : | ordinals/proof-of-well-foundedness.pcert1
-
-ordinals/top-with-meta.pcert0 : no_pcert = 0
-ordinals/top-with-meta.pcert0 : acl2x = 0
-ordinals/top-with-meta.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- ordinals/top-with-meta.lisp
-ordinals/top-with-meta.pcert1 : acl2x = 0
-ordinals/top-with-meta.pcert1 : no_pcert = 0
-ordinals/top-with-meta.pcert1 : ordinals/top-with-meta.pcert0
-ordinals/top-with-meta.cert : | ordinals/top-with-meta.pcert1
-
-oslib/catpath.pcert0 : no_pcert = 0
-oslib/catpath.pcert0 : acl2x = 0
-oslib/catpath.pcert0 : \
- cutil/define.pcert0 \
- misc/assert.pcert0 \
- oslib/portcullis.pcert0 \
- oslib/catpath.lisp \
- oslib/cert.acl2
-oslib/catpath.pcert1 : acl2x = 0
-oslib/catpath.pcert1 : no_pcert = 0
-oslib/catpath.pcert1 : oslib/catpath.pcert0
-oslib/catpath.cert : | oslib/catpath.pcert1
-
-oslib/date.pcert0 : no_pcert = 0
-oslib/date.pcert0 : acl2x = 0
-oslib/date.pcert0 : \
- oslib/read-acl2-oracle.pcert0 \
- cutil/define.pcert0 \
- tools/include-raw.pcert0 \
- str/cat.pcert0 \
- str/natstr.pcert0 \
- oslib/portcullis.pcert0 \
- oslib/date.lisp \
- oslib/cert.acl2 \
- oslib/date-raw.lsp
-oslib/date.pcert1 : acl2x = 0
-oslib/date.pcert1 : no_pcert = 0
-oslib/date.pcert1 : oslib/date.pcert0
-oslib/date.cert : | oslib/date.pcert1
-
-oslib/getpid.pcert0 : no_pcert = 0
-oslib/getpid.pcert0 : acl2x = 0
-oslib/getpid.pcert0 : \
- oslib/read-acl2-oracle.pcert0 \
- cutil/define.pcert0 \
- tools/include-raw.pcert0 \
- oslib/portcullis.pcert0 \
- oslib/getpid.lisp \
- oslib/cert.acl2 \
- oslib/getpid-raw.lsp
-oslib/getpid.pcert1 : acl2x = 0
-oslib/getpid.pcert1 : no_pcert = 0
-oslib/getpid.pcert1 : oslib/getpid.pcert0
-oslib/getpid.cert : | oslib/getpid.pcert1
-
-oslib/ls.pcert0 : no_pcert = 0
-oslib/ls.pcert0 : acl2x = 0
-oslib/ls.pcert0 : \
- oslib/read-acl2-oracle.pcert0 \
- cutil/define.pcert0 \
- tools/include-raw.pcert0 \
- oslib/portcullis.pcert0 \
- oslib/ls.lisp \
- oslib/cert.acl2 \
- oslib/ls-raw.lsp
-oslib/ls.pcert1 : acl2x = 0
-oslib/ls.pcert1 : no_pcert = 0
-oslib/ls.pcert1 : oslib/ls.pcert0
-oslib/ls.cert : | oslib/ls.pcert1
-
-oslib/portcullis.pcert0 : no_pcert = 0
-oslib/portcullis.pcert0 : acl2x = 0
-oslib/portcullis.pcert0 : \
- oslib/portcullis.lisp \
- oslib/portcullis.acl2 \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-oslib/portcullis.pcert1 : acl2x = 0
-oslib/portcullis.pcert1 : no_pcert = 0
-oslib/portcullis.pcert1 : oslib/portcullis.pcert0
-oslib/portcullis.cert : | oslib/portcullis.pcert1
-
-oslib/read-acl2-oracle.pcert0 : no_pcert = 0
-oslib/read-acl2-oracle.pcert0 : acl2x = 0
-oslib/read-acl2-oracle.pcert0 : \
- oslib/portcullis.pcert0 \
- oslib/read-acl2-oracle.lisp \
- oslib/cert.acl2
-oslib/read-acl2-oracle.pcert1 : acl2x = 0
-oslib/read-acl2-oracle.pcert1 : no_pcert = 0
-oslib/read-acl2-oracle.pcert1 : oslib/read-acl2-oracle.pcert0
-oslib/read-acl2-oracle.cert : | oslib/read-acl2-oracle.pcert1
-
-oslib/tempfile.pcert0 : no_pcert = 0
-oslib/tempfile.pcert0 : acl2x = 0
-oslib/tempfile.pcert0 : \
- oslib/getpid.pcert0 \
- oslib/catpath.pcert0 \
- str/natstr.pcert0 \
- str/cat.pcert0 \
- oslib/portcullis.pcert0 \
- oslib/tempfile.lisp \
- oslib/cert.acl2
-oslib/tempfile.pcert1 : acl2x = 0
-oslib/tempfile.pcert1 : no_pcert = 0
-oslib/tempfile.pcert1 : oslib/tempfile.pcert0
-oslib/tempfile.cert : | oslib/tempfile.pcert1
-
-oslib/top.pcert0 : no_pcert = 0
-oslib/top.pcert0 : acl2x = 0
-oslib/top.pcert0 : \
- oslib/catpath.pcert0 \
- oslib/date.pcert0 \
- oslib/getpid.pcert0 \
- oslib/ls.pcert0 \
- oslib/tempfile.pcert0 \
- oslib/portcullis.pcert0 \
- oslib/top.lisp \
- oslib/cert.acl2
-oslib/top.pcert1 : acl2x = 0
-oslib/top.pcert1 : no_pcert = 0
-oslib/top.pcert1 : oslib/top.pcert0
-oslib/top.cert : | oslib/top.pcert1
-
-paco/database.pcert0 : no_pcert = 0
-paco/database.pcert0 : acl2x = 0
-paco/database.pcert0 : \
- paco/prove.pcert0 \
- paco/database.lisp \
- paco/database.acl2 \
- paco/acl2-customization.lsp
-paco/database.pcert1 : acl2x = 0
-paco/database.pcert1 : no_pcert = 0
-paco/database.pcert1 : paco/database.pcert0
-paco/database.cert : | paco/database.pcert1
-
-paco/elim-dest.pcert0 : no_pcert = 0
-paco/elim-dest.pcert0 : acl2x = 0
-paco/elim-dest.pcert0 : \
- paco/simplify.pcert0 \
- paco/elim-dest.lisp \
- paco/elim-dest.acl2 \
- paco/acl2-customization.lsp
-paco/elim-dest.pcert1 : acl2x = 0
-paco/elim-dest.pcert1 : no_pcert = 0
-paco/elim-dest.pcert1 : paco/elim-dest.pcert0
-paco/elim-dest.cert : | paco/elim-dest.pcert1
-
-paco/foundations.pcert0 : no_pcert = 0
-paco/foundations.pcert0 : acl2x = 0
-paco/foundations.pcert0 : \
- paco/output-module.pcert0 \
- paco/foundations.lisp \
- paco/foundations.acl2 \
- paco/acl2-customization.lsp
-paco/foundations.pcert1 : acl2x = 0
-paco/foundations.pcert1 : no_pcert = 0
-paco/foundations.pcert1 : paco/foundations.pcert0
-paco/foundations.cert : | paco/foundations.pcert1
-
-paco/induct.pcert0 : no_pcert = 0
-paco/induct.pcert0 : acl2x = 0
-paco/induct.pcert0 : \
- paco/elim-dest.pcert0 \
- paco/induct.lisp \
- paco/induct.acl2 \
- paco/acl2-customization.lsp
-paco/induct.pcert1 : acl2x = 0
-paco/induct.pcert1 : no_pcert = 0
-paco/induct.pcert1 : paco/induct.pcert0
-paco/induct.cert : | paco/induct.pcert1
-
-paco/output-module.pcert0 : no_pcert = 0
-paco/output-module.pcert0 : acl2x = 0
-paco/output-module.pcert0 : \
- paco/utilities.pcert0 \
- paco/output-module.lisp \
- paco/output-module.acl2 \
- paco/acl2-customization.lsp
-paco/output-module.pcert1 : acl2x = 0
-paco/output-module.pcert1 : no_pcert = 0
-paco/output-module.pcert1 : paco/output-module.pcert0
-paco/output-module.cert : | paco/output-module.pcert1
-
-paco/paco.pcert0 : no_pcert = 0
-paco/paco.pcert0 : acl2x = 0
-paco/paco.pcert0 : \
- paco/utilities.pcert0 \
- paco/foundations.pcert0 \
- paco/type-set.pcert0 \
- paco/rewrite.pcert0 \
- paco/simplify.pcert0 \
- paco/induct.pcert0 \
- paco/prove.pcert0 \
- paco/database.pcert0 \
- paco/database.pcert0 \
- paco/paco.lisp \
- paco/paco.acl2 \
- paco/acl2-customization.lsp
-paco/paco.pcert1 : acl2x = 0
-paco/paco.pcert1 : no_pcert = 0
-paco/paco.pcert1 : paco/paco.pcert0
-paco/paco.cert : | paco/paco.pcert1
-
-paco/prove.pcert0 : no_pcert = 0
-paco/prove.pcert0 : acl2x = 0
-paco/prove.pcert0 : \
- paco/induct.pcert0 \
- paco/prove.lisp \
- paco/prove.acl2 \
- paco/acl2-customization.lsp
-paco/prove.pcert1 : acl2x = 0
-paco/prove.pcert1 : no_pcert = 0
-paco/prove.pcert1 : paco/prove.pcert0
-paco/prove.cert : | paco/prove.pcert1
-
-paco/rewrite.pcert0 : no_pcert = 0
-paco/rewrite.pcert0 : acl2x = 0
-paco/rewrite.pcert0 : \
- paco/type-set.pcert0 \
- paco/rewrite.lisp \
- paco/rewrite.acl2 \
- paco/acl2-customization.lsp
-paco/rewrite.pcert1 : acl2x = 0
-paco/rewrite.pcert1 : no_pcert = 0
-paco/rewrite.pcert1 : paco/rewrite.pcert0
-paco/rewrite.cert : | paco/rewrite.pcert1
-
-paco/simplify.pcert0 : no_pcert = 0
-paco/simplify.pcert0 : acl2x = 0
-paco/simplify.pcert0 : \
- paco/rewrite.pcert0 \
- paco/simplify.lisp \
- paco/simplify.acl2 \
- paco/acl2-customization.lsp
-paco/simplify.pcert1 : acl2x = 0
-paco/simplify.pcert1 : no_pcert = 0
-paco/simplify.pcert1 : paco/simplify.pcert0
-paco/simplify.cert : | paco/simplify.pcert1
-
-paco/type-set.pcert0 : no_pcert = 0
-paco/type-set.pcert0 : acl2x = 0
-paco/type-set.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- paco/foundations.pcert0 \
- paco/type-set.lisp \
- paco/type-set.acl2 \
- paco/acl2-customization.lsp
-paco/type-set.pcert1 : acl2x = 0
-paco/type-set.pcert1 : no_pcert = 0
-paco/type-set.pcert1 : paco/type-set.pcert0
-paco/type-set.cert : | paco/type-set.pcert1
-
-paco/utilities.pcert0 : no_pcert = 0
-paco/utilities.pcert0 : acl2x = 0
-paco/utilities.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- paco/utilities.lisp \
- paco/utilities.acl2 \
- paco/acl2-customization.lsp
-paco/utilities.pcert1 : acl2x = 0
-paco/utilities.pcert1 : no_pcert = 0
-paco/utilities.pcert1 : paco/utilities.pcert0
-paco/utilities.cert : | paco/utilities.pcert1
-
-parallel/fibonacci.pcert0 : no_pcert = 0
-parallel/fibonacci.pcert0 : acl2x = 0
-parallel/fibonacci.pcert0 : \
- make-event/assert.pcert0 \
- parallel/fibonacci.lisp
-parallel/fibonacci.pcert1 : acl2x = 0
-parallel/fibonacci.pcert1 : no_pcert = 0
-parallel/fibonacci.pcert1 : parallel/fibonacci.pcert0
-parallel/fibonacci.cert : | parallel/fibonacci.pcert1
-
-parallel/hint-tests.pcert0 : no_pcert = 0
-parallel/hint-tests.pcert0 : acl2x = 0
-parallel/hint-tests.pcert0 : \
- make-event/eval.pcert0 \
- parallel/hint-tests.lisp \
- parallel/hint-tests.acl2
-parallel/hint-tests.pcert1 : acl2x = 0
-parallel/hint-tests.pcert1 : no_pcert = 0
-parallel/hint-tests.pcert1 : parallel/hint-tests.pcert0
-parallel/hint-tests.cert : | parallel/hint-tests.pcert1
-
-parallel/matrix-multiplication-parallel.pcert0 : no_pcert = 0
-parallel/matrix-multiplication-parallel.pcert0 : acl2x = 0
-parallel/matrix-multiplication-parallel.pcert0 : \
- make-event/assert.pcert0 \
- make-event/embeddable-event-forms.pcert0 \
- parallel/matrix-multiplication-setup.pcert0 \
- parallel/matrix-multiplication-parallel.lisp
-parallel/matrix-multiplication-parallel.pcert1 : acl2x = 0
-parallel/matrix-multiplication-parallel.pcert1 : no_pcert = 0
-parallel/matrix-multiplication-parallel.pcert1 : parallel/matrix-multiplication-parallel.pcert0
-parallel/matrix-multiplication-parallel.cert : | parallel/matrix-multiplication-parallel.pcert1
-
-parallel/matrix-multiplication-serial.pcert0 : no_pcert = 0
-parallel/matrix-multiplication-serial.pcert0 : acl2x = 0
-parallel/matrix-multiplication-serial.pcert0 : \
- make-event/assert.pcert0 \
- make-event/embeddable-event-forms.pcert0 \
- parallel/matrix-multiplication-setup.pcert0 \
- parallel/matrix-multiplication-serial.lisp
-parallel/matrix-multiplication-serial.pcert1 : acl2x = 0
-parallel/matrix-multiplication-serial.pcert1 : no_pcert = 0
-parallel/matrix-multiplication-serial.pcert1 : parallel/matrix-multiplication-serial.pcert0
-parallel/matrix-multiplication-serial.cert : | parallel/matrix-multiplication-serial.pcert1
-
-parallel/matrix-multiplication-setup.pcert0 : no_pcert = 0
-parallel/matrix-multiplication-setup.pcert0 : acl2x = 0
-parallel/matrix-multiplication-setup.pcert0 : \
- parallel/matrix-multiplication-setup.lisp
-parallel/matrix-multiplication-setup.pcert1 : acl2x = 0
-parallel/matrix-multiplication-setup.pcert1 : no_pcert = 0
-parallel/matrix-multiplication-setup.pcert1 : parallel/matrix-multiplication-setup.pcert0
-parallel/matrix-multiplication-setup.cert : | parallel/matrix-multiplication-setup.pcert1
-
-parallel/spec-mv-let.pcert0 : no_pcert = 0
-parallel/spec-mv-let.pcert0 : acl2x = 0
-parallel/spec-mv-let.pcert0 : \
- make-event/assert.pcert0 \
- make-event/eval.pcert0 \
- parallel/spec-mv-let.lisp
-parallel/spec-mv-let.pcert1 : acl2x = 0
-parallel/spec-mv-let.pcert1 : no_pcert = 0
-parallel/spec-mv-let.pcert1 : parallel/spec-mv-let.pcert0
-parallel/spec-mv-let.cert : | parallel/spec-mv-let.pcert1
-
-parallel/stress-tests.pcert0 : no_pcert = 0
-parallel/stress-tests.pcert0 : acl2x = 0
-parallel/stress-tests.pcert0 : \
- make-event/assert.pcert0 \
- make-event/eval.pcert0 \
- parallel/stress-tests.lisp
-parallel/stress-tests.pcert1 : acl2x = 0
-parallel/stress-tests.pcert1 : no_pcert = 0
-parallel/stress-tests.pcert1 : parallel/stress-tests.pcert0
-parallel/stress-tests.cert : | parallel/stress-tests.pcert1
-
-parallel/syntax-tests.pcert0 : no_pcert = 0
-parallel/syntax-tests.pcert0 : acl2x = 0
-parallel/syntax-tests.pcert0 : \
- make-event/assert.pcert0 \
- make-event/eval.pcert0 \
- parallel/syntax-tests.lisp
-parallel/syntax-tests.pcert1 : acl2x = 0
-parallel/syntax-tests.pcert1 : no_pcert = 0
-parallel/syntax-tests.pcert1 : parallel/syntax-tests.pcert0
-parallel/syntax-tests.cert : | parallel/syntax-tests.pcert1
-
-parallel/with-waterfall-parallelism.pcert0 : no_pcert = 0
-parallel/with-waterfall-parallelism.pcert0 : acl2x = 0
-parallel/with-waterfall-parallelism.pcert0 : \
- parallel/with-waterfall-parallelism.lisp
-parallel/with-waterfall-parallelism.pcert1 : acl2x = 0
-parallel/with-waterfall-parallelism.pcert1 : no_pcert = 0
-parallel/with-waterfall-parallelism.pcert1 : parallel/with-waterfall-parallelism.pcert0
-parallel/with-waterfall-parallelism.cert : | parallel/with-waterfall-parallelism.pcert1
-
-parallel/without-waterfall-parallelism.pcert0 : no_pcert = 0
-parallel/without-waterfall-parallelism.pcert0 : acl2x = 0
-parallel/without-waterfall-parallelism.pcert0 : \
- parallel/without-waterfall-parallelism.lisp
-parallel/without-waterfall-parallelism.pcert1 : acl2x = 0
-parallel/without-waterfall-parallelism.pcert1 : no_pcert = 0
-parallel/without-waterfall-parallelism.pcert1 : parallel/without-waterfall-parallelism.pcert0
-parallel/without-waterfall-parallelism.cert : | parallel/without-waterfall-parallelism.pcert1
-
-powerlists/algebra.pcert0 : no_pcert = 0
-powerlists/algebra.pcert0 : acl2x = 0
-powerlists/algebra.pcert0 : \
- data-structures/structures.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- powerlists/algebra.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-powerlists/algebra.pcert1 : acl2x = 0
-powerlists/algebra.pcert1 : no_pcert = 0
-powerlists/algebra.pcert1 : powerlists/algebra.pcert0
-powerlists/algebra.cert : | powerlists/algebra.pcert1
-
-powerlists/batcher-sort.pcert0 : no_pcert = 0
-powerlists/batcher-sort.pcert0 : acl2x = 0
-powerlists/batcher-sort.pcert0 : \
- powerlists/merge-sort.pcert0 \
- arithmetic/top.pcert0 \
- powerlists/batcher-sort.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-powerlists/batcher-sort.pcert1 : acl2x = 0
-powerlists/batcher-sort.pcert1 : no_pcert = 0
-powerlists/batcher-sort.pcert1 : powerlists/batcher-sort.pcert0
-powerlists/batcher-sort.cert : | powerlists/batcher-sort.pcert1
-
-powerlists/bitonic-sort.pcert0 : no_pcert = 0
-powerlists/bitonic-sort.pcert0 : acl2x = 0
-powerlists/bitonic-sort.pcert0 : \
- powerlists/algebra.pcert0 \
- powerlists/simple.pcert0 \
- powerlists/sort.pcert0 \
- powerlists/batcher-sort.pcert0 \
- arithmetic/top.pcert0 \
- powerlists/bitonic-sort.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-powerlists/bitonic-sort.pcert1 : acl2x = 0
-powerlists/bitonic-sort.pcert1 : no_pcert = 0
-powerlists/bitonic-sort.pcert1 : powerlists/bitonic-sort.pcert0
-powerlists/bitonic-sort.cert : | powerlists/bitonic-sort.pcert1
-
-powerlists/cla-adder.pcert0 : no_pcert = 0
-powerlists/cla-adder.pcert0 : acl2x = 0
-powerlists/cla-adder.pcert0 : \
- powerlists/prefix-sum.pcert0 \
- powerlists/algebra.pcert0 \
- arithmetic/top.pcert0 \
- powerlists/cla-adder.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-powerlists/cla-adder.pcert1 : acl2x = 0
-powerlists/cla-adder.pcert1 : no_pcert = 0
-powerlists/cla-adder.pcert1 : powerlists/cla-adder.pcert0
-powerlists/cla-adder.cert : | powerlists/cla-adder.pcert1
-
-powerlists/gray-code.pcert0 : no_pcert = 0
-powerlists/gray-code.pcert0 : acl2x = 0
-powerlists/gray-code.pcert0 : \
- powerlists/algebra.pcert0 \
- powerlists/simple.pcert0 \
- powerlists/gray-code.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-powerlists/gray-code.pcert1 : acl2x = 0
-powerlists/gray-code.pcert1 : no_pcert = 0
-powerlists/gray-code.pcert1 : powerlists/gray-code.pcert0
-powerlists/gray-code.cert : | powerlists/gray-code.pcert1
-
-powerlists/merge-sort.pcert0 : no_pcert = 0
-powerlists/merge-sort.pcert0 : acl2x = 0
-powerlists/merge-sort.pcert0 : \
- powerlists/algebra.pcert0 \
- powerlists/sort.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- powerlists/merge-sort.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-powerlists/merge-sort.pcert1 : acl2x = 0
-powerlists/merge-sort.pcert1 : no_pcert = 0
-powerlists/merge-sort.pcert1 : powerlists/merge-sort.pcert0
-powerlists/merge-sort.cert : | powerlists/merge-sort.pcert1
-
-powerlists/prefix-sum.pcert0 : no_pcert = 0
-powerlists/prefix-sum.pcert0 : acl2x = 0
-powerlists/prefix-sum.pcert0 : \
- powerlists/algebra.pcert0 \
- powerlists/simple.pcert0 \
- arithmetic/top.pcert0 \
- powerlists/prefix-sum.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-powerlists/prefix-sum.pcert1 : acl2x = 0
-powerlists/prefix-sum.pcert1 : no_pcert = 0
-powerlists/prefix-sum.pcert1 : powerlists/prefix-sum.pcert0
-powerlists/prefix-sum.cert : | powerlists/prefix-sum.pcert1
-
-powerlists/simple.pcert0 : no_pcert = 0
-powerlists/simple.pcert0 : acl2x = 0
-powerlists/simple.pcert0 : \
- powerlists/algebra.pcert0 \
- arithmetic/top.pcert0 \
- powerlists/simple.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-powerlists/simple.pcert1 : acl2x = 0
-powerlists/simple.pcert1 : no_pcert = 0
-powerlists/simple.pcert1 : powerlists/simple.pcert0
-powerlists/simple.cert : | powerlists/simple.pcert1
-
-powerlists/sort.pcert0 : no_pcert = 0
-powerlists/sort.pcert0 : acl2x = 0
-powerlists/sort.pcert0 : \
- powerlists/algebra.pcert0 \
- powerlists/sort.lisp \
- powerlists/cert.acl2 \
- powerlists/defpkg.lsp
-powerlists/sort.pcert1 : acl2x = 0
-powerlists/sort.pcert1 : no_pcert = 0
-powerlists/sort.pcert1 : powerlists/sort.pcert0
-powerlists/sort.cert : | powerlists/sort.pcert1
-
-proofstyles/completeness/assertions-partial.pcert0 : no_pcert = 0
-proofstyles/completeness/assertions-partial.pcert0 : acl2x = 0
-proofstyles/completeness/assertions-partial.pcert0 : \
- misc/defpun.pcert0 \
- ordinals/ordinals.pcert0 \
- proofstyles/completeness/stepwise-invariants-partial.pcert0 \
- proofstyles/completeness/assertions-partial.lisp
-proofstyles/completeness/assertions-partial.pcert1 : acl2x = 0
-proofstyles/completeness/assertions-partial.pcert1 : no_pcert = 0
-proofstyles/completeness/assertions-partial.pcert1 : proofstyles/completeness/assertions-partial.pcert0
-proofstyles/completeness/assertions-partial.cert : | proofstyles/completeness/assertions-partial.pcert1
-
-proofstyles/completeness/assertions-total.pcert0 : no_pcert = 0
-proofstyles/completeness/assertions-total.pcert0 : acl2x = 0
-proofstyles/completeness/assertions-total.pcert0 : \
- misc/defpun.pcert0 \
- ordinals/ordinals.pcert0 \
- proofstyles/completeness/stepwise-invariants-total.pcert0 \
- proofstyles/completeness/assertions-total.lisp
-proofstyles/completeness/assertions-total.pcert1 : acl2x = 0
-proofstyles/completeness/assertions-total.pcert1 : no_pcert = 0
-proofstyles/completeness/assertions-total.pcert1 : proofstyles/completeness/assertions-total.pcert0
-proofstyles/completeness/assertions-total.cert : | proofstyles/completeness/assertions-total.pcert1
-
-proofstyles/completeness/clock-partial.pcert0 : no_pcert = 0
-proofstyles/completeness/clock-partial.pcert0 : acl2x = 0
-proofstyles/completeness/clock-partial.pcert0 : \
- proofstyles/completeness/generic-partial.pcert0 \
- misc/defpun.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- proofstyles/completeness/clock-partial.lisp
-proofstyles/completeness/clock-partial.pcert1 : acl2x = 0
-proofstyles/completeness/clock-partial.pcert1 : no_pcert = 0
-proofstyles/completeness/clock-partial.pcert1 : proofstyles/completeness/clock-partial.pcert0
-proofstyles/completeness/clock-partial.cert : | proofstyles/completeness/clock-partial.pcert1
-
-proofstyles/completeness/clock-total.pcert0 : no_pcert = 0
-proofstyles/completeness/clock-total.pcert0 : acl2x = 0
-proofstyles/completeness/clock-total.pcert0 : \
- proofstyles/completeness/generic-total.pcert0 \
- misc/defpun.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- proofstyles/completeness/clock-total.lisp
-proofstyles/completeness/clock-total.pcert1 : acl2x = 0
-proofstyles/completeness/clock-total.pcert1 : no_pcert = 0
-proofstyles/completeness/clock-total.pcert1 : proofstyles/completeness/clock-total.pcert0
-proofstyles/completeness/clock-total.cert : | proofstyles/completeness/clock-total.pcert1
-
-proofstyles/completeness/generic-partial.pcert0 : no_pcert = 0
-proofstyles/completeness/generic-partial.pcert0 : acl2x = 0
-proofstyles/completeness/generic-partial.pcert0 : \
- proofstyles/completeness/generic-partial.lisp
-proofstyles/completeness/generic-partial.pcert1 : acl2x = 0
-proofstyles/completeness/generic-partial.pcert1 : no_pcert = 0
-proofstyles/completeness/generic-partial.pcert1 : proofstyles/completeness/generic-partial.pcert0
-proofstyles/completeness/generic-partial.cert : | proofstyles/completeness/generic-partial.pcert1
-
-proofstyles/completeness/generic-total.pcert0 : no_pcert = 0
-proofstyles/completeness/generic-total.pcert0 : acl2x = 0
-proofstyles/completeness/generic-total.pcert0 : \
- proofstyles/completeness/generic-total.lisp
-proofstyles/completeness/generic-total.pcert1 : acl2x = 0
-proofstyles/completeness/generic-total.pcert1 : no_pcert = 0
-proofstyles/completeness/generic-total.pcert1 : proofstyles/completeness/generic-total.pcert0
-proofstyles/completeness/generic-total.cert : | proofstyles/completeness/generic-total.pcert1
-
-proofstyles/completeness/stepwise-invariants-partial.pcert0 : no_pcert = 0
-proofstyles/completeness/stepwise-invariants-partial.pcert0 : acl2x = 0
-proofstyles/completeness/stepwise-invariants-partial.pcert0 : \
- proofstyles/completeness/clock-partial.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- proofstyles/completeness/stepwise-invariants-partial.lisp
-proofstyles/completeness/stepwise-invariants-partial.pcert1 : acl2x = 0
-proofstyles/completeness/stepwise-invariants-partial.pcert1 : no_pcert = 0
-proofstyles/completeness/stepwise-invariants-partial.pcert1 : proofstyles/completeness/stepwise-invariants-partial.pcert0
-proofstyles/completeness/stepwise-invariants-partial.cert : | proofstyles/completeness/stepwise-invariants-partial.pcert1
-
-proofstyles/completeness/stepwise-invariants-total.pcert0 : no_pcert = 0
-proofstyles/completeness/stepwise-invariants-total.pcert0 : acl2x = 0
-proofstyles/completeness/stepwise-invariants-total.pcert0 : \
- proofstyles/completeness/clock-total.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- proofstyles/completeness/stepwise-invariants-total.lisp
-proofstyles/completeness/stepwise-invariants-total.pcert1 : acl2x = 0
-proofstyles/completeness/stepwise-invariants-total.pcert1 : no_pcert = 0
-proofstyles/completeness/stepwise-invariants-total.pcert1 : proofstyles/completeness/stepwise-invariants-total.pcert0
-proofstyles/completeness/stepwise-invariants-total.cert : | proofstyles/completeness/stepwise-invariants-total.pcert1
-
-proofstyles/counterexamples/halt-flg.pcert0 : no_pcert = 0
-proofstyles/counterexamples/halt-flg.pcert0 : acl2x = 0
-proofstyles/counterexamples/halt-flg.pcert0 : \
- misc/defpun.pcert0 \
- proofstyles/counterexamples/halt-flg.lisp
-proofstyles/counterexamples/halt-flg.pcert1 : acl2x = 0
-proofstyles/counterexamples/halt-flg.pcert1 : no_pcert = 0
-proofstyles/counterexamples/halt-flg.pcert1 : proofstyles/counterexamples/halt-flg.pcert0
-proofstyles/counterexamples/halt-flg.cert : | proofstyles/counterexamples/halt-flg.pcert1
-
-proofstyles/counterexamples/memory-clearing.pcert0 : no_pcert = 0
-proofstyles/counterexamples/memory-clearing.pcert0 : acl2x = 0
-proofstyles/counterexamples/memory-clearing.pcert0 : \
- misc/defpun.pcert0 \
- proofstyles/counterexamples/memory-clearing.lisp
-proofstyles/counterexamples/memory-clearing.pcert1 : acl2x = 0
-proofstyles/counterexamples/memory-clearing.pcert1 : no_pcert = 0
-proofstyles/counterexamples/memory-clearing.pcert1 : proofstyles/counterexamples/memory-clearing.pcert0
-proofstyles/counterexamples/memory-clearing.cert : | proofstyles/counterexamples/memory-clearing.pcert1
-
-proofstyles/counterexamples/realistic.pcert0 : no_pcert = 0
-proofstyles/counterexamples/realistic.pcert0 : acl2x = 0
-proofstyles/counterexamples/realistic.pcert0 : \
- misc/records.pcert0 \
- misc/defpun.pcert0 \
- proofstyles/counterexamples/realistic.lisp
-proofstyles/counterexamples/realistic.pcert1 : acl2x = 0
-proofstyles/counterexamples/realistic.pcert1 : no_pcert = 0
-proofstyles/counterexamples/realistic.pcert1 : proofstyles/counterexamples/realistic.pcert0
-proofstyles/counterexamples/realistic.cert : | proofstyles/counterexamples/realistic.pcert1
-
-proofstyles/invclock/c2i/c2i-partial.pcert0 : no_pcert = 0
-proofstyles/invclock/c2i/c2i-partial.pcert0 : acl2x = 0
-proofstyles/invclock/c2i/c2i-partial.pcert0 : \
- arithmetic-2/meta/top.pcert0 \
- proofstyles/invclock/c2i/c2i-partial.lisp
-proofstyles/invclock/c2i/c2i-partial.pcert1 : acl2x = 0
-proofstyles/invclock/c2i/c2i-partial.pcert1 : no_pcert = 0
-proofstyles/invclock/c2i/c2i-partial.pcert1 : proofstyles/invclock/c2i/c2i-partial.pcert0
-proofstyles/invclock/c2i/c2i-partial.cert : | proofstyles/invclock/c2i/c2i-partial.pcert1
-
-proofstyles/invclock/c2i/c2i-total.pcert0 : no_pcert = 0
-proofstyles/invclock/c2i/c2i-total.pcert0 : acl2x = 0
-proofstyles/invclock/c2i/c2i-total.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- arithmetic-2/meta/top.pcert0 \
- proofstyles/invclock/c2i/c2i-total.lisp
-proofstyles/invclock/c2i/c2i-total.pcert1 : acl2x = 0
-proofstyles/invclock/c2i/c2i-total.pcert1 : no_pcert = 0
-proofstyles/invclock/c2i/c2i-total.pcert1 : proofstyles/invclock/c2i/c2i-total.pcert0
-proofstyles/invclock/c2i/c2i-total.cert : | proofstyles/invclock/c2i/c2i-total.pcert1
-
-proofstyles/invclock/c2i/clock-to-inv.pcert0 : no_pcert = 0
-proofstyles/invclock/c2i/clock-to-inv.pcert0 : acl2x = 0
-proofstyles/invclock/c2i/clock-to-inv.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- proofstyles/invclock/c2i/c2i-total.pcert0 \
- proofstyles/invclock/c2i/c2i-partial.pcert0 \
- proofstyles/invclock/c2i/clock-to-inv.lisp
-proofstyles/invclock/c2i/clock-to-inv.pcert1 : acl2x = 0
-proofstyles/invclock/c2i/clock-to-inv.pcert1 : no_pcert = 0
-proofstyles/invclock/c2i/clock-to-inv.pcert1 : proofstyles/invclock/c2i/clock-to-inv.pcert0
-proofstyles/invclock/c2i/clock-to-inv.cert : | proofstyles/invclock/c2i/clock-to-inv.pcert1
-
-proofstyles/invclock/compose/compose-c-c-partial.pcert0 : no_pcert = 0
-proofstyles/invclock/compose/compose-c-c-partial.pcert0 : acl2x = 0
-proofstyles/invclock/compose/compose-c-c-partial.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- arithmetic-2/meta/top.pcert0 \
- proofstyles/invclock/compose/compose-c-c-partial.lisp
-proofstyles/invclock/compose/compose-c-c-partial.pcert1 : acl2x = 0
-proofstyles/invclock/compose/compose-c-c-partial.pcert1 : no_pcert = 0
-proofstyles/invclock/compose/compose-c-c-partial.pcert1 : proofstyles/invclock/compose/compose-c-c-partial.pcert0
-proofstyles/invclock/compose/compose-c-c-partial.cert : | proofstyles/invclock/compose/compose-c-c-partial.pcert1
-
-proofstyles/invclock/compose/compose-c-c-total.pcert0 : no_pcert = 0
-proofstyles/invclock/compose/compose-c-c-total.pcert0 : acl2x = 0
-proofstyles/invclock/compose/compose-c-c-total.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- arithmetic-2/meta/top.pcert0 \
- proofstyles/invclock/compose/compose-c-c-total.lisp
-proofstyles/invclock/compose/compose-c-c-total.pcert1 : acl2x = 0
-proofstyles/invclock/compose/compose-c-c-total.pcert1 : no_pcert = 0
-proofstyles/invclock/compose/compose-c-c-total.pcert1 : proofstyles/invclock/compose/compose-c-c-total.pcert0
-proofstyles/invclock/compose/compose-c-c-total.cert : | proofstyles/invclock/compose/compose-c-c-total.pcert1
-
-proofstyles/invclock/i2c/i2c-partial.pcert0 : no_pcert = 0
-proofstyles/invclock/i2c/i2c-partial.pcert0 : acl2x = 0
-proofstyles/invclock/i2c/i2c-partial.pcert0 : \
- arithmetic-2/meta/top.pcert0 \
- proofstyles/invclock/i2c/i2c-partial.lisp
-proofstyles/invclock/i2c/i2c-partial.pcert1 : acl2x = 0
-proofstyles/invclock/i2c/i2c-partial.pcert1 : no_pcert = 0
-proofstyles/invclock/i2c/i2c-partial.pcert1 : proofstyles/invclock/i2c/i2c-partial.pcert0
-proofstyles/invclock/i2c/i2c-partial.cert : | proofstyles/invclock/i2c/i2c-partial.pcert1
-
-proofstyles/invclock/i2c/i2c-total.pcert0 : no_pcert = 0
-proofstyles/invclock/i2c/i2c-total.pcert0 : acl2x = 0
-proofstyles/invclock/i2c/i2c-total.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- arithmetic-2/meta/top.pcert0 \
- proofstyles/invclock/i2c/i2c-total.lisp
-proofstyles/invclock/i2c/i2c-total.pcert1 : acl2x = 0
-proofstyles/invclock/i2c/i2c-total.pcert1 : no_pcert = 0
-proofstyles/invclock/i2c/i2c-total.pcert1 : proofstyles/invclock/i2c/i2c-total.pcert0
-proofstyles/invclock/i2c/i2c-total.cert : | proofstyles/invclock/i2c/i2c-total.pcert1
-
-proofstyles/invclock/i2c/inv-to-clock.pcert0 : no_pcert = 0
-proofstyles/invclock/i2c/inv-to-clock.pcert0 : acl2x = 0
-proofstyles/invclock/i2c/inv-to-clock.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- proofstyles/invclock/i2c/i2c-total.pcert0 \
- proofstyles/invclock/i2c/i2c-partial.pcert0 \
- proofstyles/invclock/i2c/inv-to-clock.lisp
-proofstyles/invclock/i2c/inv-to-clock.pcert1 : acl2x = 0
-proofstyles/invclock/i2c/inv-to-clock.pcert1 : no_pcert = 0
-proofstyles/invclock/i2c/inv-to-clock.pcert1 : proofstyles/invclock/i2c/inv-to-clock.pcert0
-proofstyles/invclock/i2c/inv-to-clock.cert : | proofstyles/invclock/i2c/inv-to-clock.pcert1
-
-proofstyles/soundness/assertions-partial.pcert0 : no_pcert = 0
-proofstyles/soundness/assertions-partial.pcert0 : acl2x = 0
-proofstyles/soundness/assertions-partial.pcert0 : \
- misc/defpun.pcert0 \
- ordinals/ordinals.pcert0 \
- proofstyles/soundness/assertions-partial.lisp
-proofstyles/soundness/assertions-partial.pcert1 : acl2x = 0
-proofstyles/soundness/assertions-partial.pcert1 : no_pcert = 0
-proofstyles/soundness/assertions-partial.pcert1 : proofstyles/soundness/assertions-partial.pcert0
-proofstyles/soundness/assertions-partial.cert : | proofstyles/soundness/assertions-partial.pcert1
-
-proofstyles/soundness/assertions-total.pcert0 : no_pcert = 0
-proofstyles/soundness/assertions-total.pcert0 : acl2x = 0
-proofstyles/soundness/assertions-total.pcert0 : \
- misc/defpun.pcert0 \
- ordinals/ordinals.pcert0 \
- proofstyles/soundness/assertions-total.lisp
-proofstyles/soundness/assertions-total.pcert1 : acl2x = 0
-proofstyles/soundness/assertions-total.pcert1 : no_pcert = 0
-proofstyles/soundness/assertions-total.pcert1 : proofstyles/soundness/assertions-total.pcert0
-proofstyles/soundness/assertions-total.cert : | proofstyles/soundness/assertions-total.pcert1
-
-proofstyles/soundness/clock-partial.pcert0 : no_pcert = 0
-proofstyles/soundness/clock-partial.pcert0 : acl2x = 0
-proofstyles/soundness/clock-partial.pcert0 : \
- proofstyles/soundness/clock-partial.lisp
-proofstyles/soundness/clock-partial.pcert1 : acl2x = 0
-proofstyles/soundness/clock-partial.pcert1 : no_pcert = 0
-proofstyles/soundness/clock-partial.pcert1 : proofstyles/soundness/clock-partial.pcert0
-proofstyles/soundness/clock-partial.cert : | proofstyles/soundness/clock-partial.pcert1
-
-proofstyles/soundness/clock-total.pcert0 : no_pcert = 0
-proofstyles/soundness/clock-total.pcert0 : acl2x = 0
-proofstyles/soundness/clock-total.pcert0 : \
- proofstyles/soundness/clock-total.lisp
-proofstyles/soundness/clock-total.pcert1 : acl2x = 0
-proofstyles/soundness/clock-total.pcert1 : no_pcert = 0
-proofstyles/soundness/clock-total.pcert1 : proofstyles/soundness/clock-total.pcert0
-proofstyles/soundness/clock-total.cert : | proofstyles/soundness/clock-total.pcert1
-
-proofstyles/soundness/stepwise-invariants-partial.pcert0 : no_pcert = 0
-proofstyles/soundness/stepwise-invariants-partial.pcert0 : acl2x = 0
-proofstyles/soundness/stepwise-invariants-partial.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- proofstyles/soundness/stepwise-invariants-partial.lisp
-proofstyles/soundness/stepwise-invariants-partial.pcert1 : acl2x = 0
-proofstyles/soundness/stepwise-invariants-partial.pcert1 : no_pcert = 0
-proofstyles/soundness/stepwise-invariants-partial.pcert1 : proofstyles/soundness/stepwise-invariants-partial.pcert0
-proofstyles/soundness/stepwise-invariants-partial.cert : | proofstyles/soundness/stepwise-invariants-partial.pcert1
-
-proofstyles/soundness/stepwise-invariants-total.pcert0 : no_pcert = 0
-proofstyles/soundness/stepwise-invariants-total.pcert0 : acl2x = 0
-proofstyles/soundness/stepwise-invariants-total.pcert0 : \
- ordinals/ordinals.pcert0 \
- proofstyles/soundness/stepwise-invariants-total.lisp
-proofstyles/soundness/stepwise-invariants-total.pcert1 : acl2x = 0
-proofstyles/soundness/stepwise-invariants-total.pcert1 : no_pcert = 0
-proofstyles/soundness/stepwise-invariants-total.pcert1 : proofstyles/soundness/stepwise-invariants-total.pcert0
-proofstyles/soundness/stepwise-invariants-total.cert : | proofstyles/soundness/stepwise-invariants-total.pcert1
-
-quadratic-reciprocity/eisenstein.pcert0 : no_pcert = 0
-quadratic-reciprocity/eisenstein.pcert0 : acl2x = 0
-quadratic-reciprocity/eisenstein.pcert0 : \
- quadratic-reciprocity/gauss.pcert0 \
- quadratic-reciprocity/eisenstein.lisp
-quadratic-reciprocity/eisenstein.pcert1 : acl2x = 0
-quadratic-reciprocity/eisenstein.pcert1 : no_pcert = 0
-quadratic-reciprocity/eisenstein.pcert1 : quadratic-reciprocity/eisenstein.pcert0
-quadratic-reciprocity/eisenstein.cert : | quadratic-reciprocity/eisenstein.pcert1
-
-quadratic-reciprocity/euclid.pcert0 : no_pcert = 0
-quadratic-reciprocity/euclid.pcert0 : acl2x = 0
-quadratic-reciprocity/euclid.pcert0 : \
- rtl/rel8/lib/arith.pcert0 \
- rtl/rel8/lib/basic.pcert0 \
- quadratic-reciprocity/euclid.lisp
-quadratic-reciprocity/euclid.pcert1 : acl2x = 0
-quadratic-reciprocity/euclid.pcert1 : no_pcert = 0
-quadratic-reciprocity/euclid.pcert1 : quadratic-reciprocity/euclid.pcert0
-quadratic-reciprocity/euclid.cert : | quadratic-reciprocity/euclid.pcert1
-
-quadratic-reciprocity/euler.pcert0 : no_pcert = 0
-quadratic-reciprocity/euler.pcert0 : acl2x = 0
-quadratic-reciprocity/euler.pcert0 : \
- quadratic-reciprocity/fermat.pcert0 \
- quadratic-reciprocity/euler.lisp
-quadratic-reciprocity/euler.pcert1 : acl2x = 0
-quadratic-reciprocity/euler.pcert1 : no_pcert = 0
-quadratic-reciprocity/euler.pcert1 : quadratic-reciprocity/euler.pcert0
-quadratic-reciprocity/euler.cert : | quadratic-reciprocity/euler.pcert1
-
-quadratic-reciprocity/fermat.pcert0 : no_pcert = 0
-quadratic-reciprocity/fermat.pcert0 : acl2x = 0
-quadratic-reciprocity/fermat.pcert0 : \
- quadratic-reciprocity/euclid.pcert0 \
- quadratic-reciprocity/fermat.lisp
-quadratic-reciprocity/fermat.pcert1 : acl2x = 0
-quadratic-reciprocity/fermat.pcert1 : no_pcert = 0
-quadratic-reciprocity/fermat.pcert1 : quadratic-reciprocity/fermat.pcert0
-quadratic-reciprocity/fermat.cert : | quadratic-reciprocity/fermat.pcert1
-
-quadratic-reciprocity/gauss.pcert0 : no_pcert = 0
-quadratic-reciprocity/gauss.pcert0 : acl2x = 0
-quadratic-reciprocity/gauss.pcert0 : \
- quadratic-reciprocity/euler.pcert0 \
- quadratic-reciprocity/gauss.lisp
-quadratic-reciprocity/gauss.pcert1 : acl2x = 0
-quadratic-reciprocity/gauss.pcert1 : no_pcert = 0
-quadratic-reciprocity/gauss.pcert1 : quadratic-reciprocity/gauss.pcert0
-quadratic-reciprocity/gauss.cert : | quadratic-reciprocity/gauss.pcert1
-
-quadratic-reciprocity/mersenne.pcert0 : no_pcert = 0
-quadratic-reciprocity/mersenne.pcert0 : acl2x = 0
-quadratic-reciprocity/mersenne.pcert0 : \
- quadratic-reciprocity/gauss.pcert0 \
- quadratic-reciprocity/mersenne.lisp
-quadratic-reciprocity/mersenne.pcert1 : acl2x = 0
-quadratic-reciprocity/mersenne.pcert1 : no_pcert = 0
-quadratic-reciprocity/mersenne.pcert1 : quadratic-reciprocity/mersenne.pcert0
-quadratic-reciprocity/mersenne.cert : | quadratic-reciprocity/mersenne.pcert1
-
-regex/defset-encapsulates.pcert0 : no_pcert = 0
-regex/defset-encapsulates.pcert0 : acl2x = 0
-regex/defset-encapsulates.pcert0 : \
- regex/defset-macros.pcert0 \
- regex/portcullis.pcert0 \
- regex/defset-encapsulates.lisp \
- regex/cert.acl2
-regex/defset-encapsulates.pcert1 : acl2x = 0
-regex/defset-encapsulates.pcert1 : no_pcert = 0
-regex/defset-encapsulates.pcert1 : regex/defset-encapsulates.pcert0
-regex/defset-encapsulates.cert : | regex/defset-encapsulates.pcert1
-
-regex/defset-macros.pcert0 : no_pcert = 0
-regex/defset-macros.pcert0 : acl2x = 0
-regex/defset-macros.pcert0 : \
- regex/portcullis.pcert0 \
- regex/defset-macros.lisp \
- regex/cert.acl2
-regex/defset-macros.pcert1 : acl2x = 0
-regex/defset-macros.pcert1 : no_pcert = 0
-regex/defset-macros.pcert1 : regex/defset-macros.pcert0
-regex/defset-macros.cert : | regex/defset-macros.pcert1
-
-regex/equal-based-set.pcert0 : no_pcert = 0
-regex/equal-based-set.pcert0 : acl2x = 0
-regex/equal-based-set.pcert0 : \
- regex/defset-macros.pcert0 \
- regex/defset-encapsulates.pcert0 \
- regex/portcullis.pcert0 \
- regex/equal-based-set.lisp \
- regex/cert.acl2
-regex/equal-based-set.pcert1 : acl2x = 0
-regex/equal-based-set.pcert1 : no_pcert = 0
-regex/equal-based-set.pcert1 : regex/equal-based-set.pcert0
-regex/equal-based-set.cert : | regex/equal-based-set.pcert1
-
-regex/grep-command-line.pcert0 : no_pcert = 0
-regex/grep-command-line.pcert0 : acl2x = 0
-regex/grep-command-line.pcert0 : \
- tools/defsum.pcert0 \
- regex/regex-fileio.pcert0 \
- regex/regex-chartrans.pcert0 \
- regex/portcullis.pcert0 \
- regex/grep-command-line.lisp \
- regex/cert.acl2
-regex/grep-command-line.pcert1 : acl2x = 0
-regex/grep-command-line.pcert1 : no_pcert = 0
-regex/grep-command-line.pcert1 : regex/grep-command-line.pcert0
-regex/grep-command-line.cert : | regex/grep-command-line.pcert1
-
-regex/input-list.pcert0 : no_pcert = 0
-regex/input-list.pcert0 : acl2x = 0
-regex/input-list.pcert0 : \
- cutil/deflist.pcert0 \
- regex/portcullis.pcert0 \
- regex/input-list.lisp \
- regex/cert.acl2
-regex/input-list.pcert1 : acl2x = 0
-regex/input-list.pcert1 : no_pcert = 0
-regex/input-list.pcert1 : regex/input-list.pcert0
-regex/input-list.cert : | regex/input-list.pcert1
-
-regex/portcullis.pcert0 : no_pcert = 0
-regex/portcullis.pcert0 : acl2x = 0
-regex/portcullis.pcert0 : \
- xdoc/top.pcert0 \
- regex/portcullis.lisp \
- regex/portcullis.acl2 \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- tools/flag-package.lsp
-regex/portcullis.pcert1 : acl2x = 0
-regex/portcullis.pcert1 : no_pcert = 0
-regex/portcullis.pcert1 : regex/portcullis.pcert0
-regex/portcullis.cert : | regex/portcullis.pcert1
-
-regex/regex-chartrans.pcert0 : no_pcert = 0
-regex/regex-chartrans.pcert0 : acl2x = 0
-regex/regex-chartrans.pcert0 : \
- regex/portcullis.pcert0 \
- regex/regex-chartrans.lisp \
- regex/cert.acl2
-regex/regex-chartrans.pcert1 : acl2x = 0
-regex/regex-chartrans.pcert1 : no_pcert = 0
-regex/regex-chartrans.pcert1 : regex/regex-chartrans.pcert0
-regex/regex-chartrans.cert : | regex/regex-chartrans.pcert1
-
-regex/regex-defs.pcert0 : no_pcert = 0
-regex/regex-defs.pcert0 : acl2x = 0
-regex/regex-defs.pcert0 : \
- tools/defsum.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- regex/portcullis.pcert0 \
- regex/regex-defs.lisp \
- regex/cert.acl2
-regex/regex-defs.pcert1 : acl2x = 0
-regex/regex-defs.pcert1 : no_pcert = 0
-regex/regex-defs.pcert1 : regex/regex-defs.pcert0
-regex/regex-defs.cert : | regex/regex-defs.pcert1
-
-regex/regex-exec.pcert0 : no_pcert = 0
-regex/regex-exec.pcert0 : acl2x = 0
-regex/regex-exec.pcert0 : \
- regex/regex-defs.pcert0 \
- regex/input-list.pcert0 \
- tools/flag.pcert0 \
- clause-processors/find-subterms.pcert0 \
- regex/portcullis.pcert0 \
- regex/regex-exec.lisp \
- regex/cert.acl2
-regex/regex-exec.pcert1 : acl2x = 0
-regex/regex-exec.pcert1 : no_pcert = 0
-regex/regex-exec.pcert1 : regex/regex-exec.pcert0
-regex/regex-exec.cert : | regex/regex-exec.pcert1
-
-regex/regex-fileio.pcert0 : no_pcert = 0
-regex/regex-fileio.pcert0 : acl2x = 0
-regex/regex-fileio.pcert0 : \
- regex/regex-exec.pcert0 \
- regex/regex-parse.pcert0 \
- regex/portcullis.pcert0 \
- regex/regex-fileio.lisp \
- regex/cert.acl2
-regex/regex-fileio.pcert1 : acl2x = 0
-regex/regex-fileio.pcert1 : no_pcert = 0
-regex/regex-fileio.pcert1 : regex/regex-fileio.pcert0
-regex/regex-fileio.cert : | regex/regex-fileio.pcert1
-
-regex/regex-parse-brace.pcert0 : no_pcert = 0
-regex/regex-parse-brace.pcert0 : acl2x = 0
-regex/regex-parse-brace.pcert0 : \
- regex/regex-defs.pcert0 \
- regex/input-list.pcert0 \
- regex/portcullis.pcert0 \
- regex/regex-parse-brace.lisp \
- regex/cert.acl2
-regex/regex-parse-brace.pcert1 : acl2x = 0
-regex/regex-parse-brace.pcert1 : no_pcert = 0
-regex/regex-parse-brace.pcert1 : regex/regex-parse-brace.pcert0
-regex/regex-parse-brace.cert : | regex/regex-parse-brace.pcert1
-
-regex/regex-parse-bracket.pcert0 : no_pcert = 0
-regex/regex-parse-bracket.pcert0 : acl2x = 0
-regex/regex-parse-bracket.pcert0 : \
- regex/regex-defs.pcert0 \
- regex/input-list.pcert0 \
- regex/portcullis.pcert0 \
- regex/regex-parse-bracket.lisp \
- regex/cert.acl2
-regex/regex-parse-bracket.pcert1 : acl2x = 0
-regex/regex-parse-bracket.pcert1 : no_pcert = 0
-regex/regex-parse-bracket.pcert1 : regex/regex-parse-bracket.pcert0
-regex/regex-parse-bracket.cert : | regex/regex-parse-bracket.pcert1
-
-regex/regex-parse.pcert0 : no_pcert = 0
-regex/regex-parse.pcert0 : acl2x = 0
-regex/regex-parse.pcert0 : \
- regex/regex-parse-bracket.pcert0 \
- regex/regex-parse-brace.pcert0 \
- regex/portcullis.pcert0 \
- regex/regex-parse.lisp \
- regex/cert.acl2
-regex/regex-parse.pcert1 : acl2x = 0
-regex/regex-parse.pcert1 : no_pcert = 0
-regex/regex-parse.pcert1 : regex/regex-parse.pcert0
-regex/regex-parse.cert : | regex/regex-parse.pcert1
-
-regex/regex-tests.pcert0 : no_pcert = 0
-regex/regex-tests.pcert0 : acl2x = 0
-regex/regex-tests.pcert0 : \
- regex/regex-parse.pcert0 \
- regex/regex-exec.pcert0 \
- regex/regex-chartrans.pcert0 \
- regex/portcullis.pcert0 \
- regex/regex-tests.lisp \
- regex/cert.acl2
-regex/regex-tests.pcert1 : acl2x = 0
-regex/regex-tests.pcert1 : no_pcert = 0
-regex/regex-tests.pcert1 : regex/regex-tests.pcert0
-regex/regex-tests.cert : | regex/regex-tests.pcert1
-
-regex/regex-ui.pcert0 : no_pcert = 0
-regex/regex-ui.pcert0 : acl2x = 0
-regex/regex-ui.pcert0 : \
- regex/regex-parse.pcert0 \
- regex/regex-exec.pcert0 \
- str/case-conversion.pcert0 \
- tools/mv-nth.pcert0 \
- misc/assert.pcert0 \
- regex/portcullis.pcert0 \
- regex/regex-ui.lisp \
- regex/cert.acl2
-regex/regex-ui.pcert1 : acl2x = 0
-regex/regex-ui.pcert1 : no_pcert = 0
-regex/regex-ui.pcert1 : regex/regex-ui.pcert0
-regex/regex-ui.cert : | regex/regex-ui.pcert1
-
-rtl/rel1/lib1/basic.pcert0 : no_pcert = 0
-rtl/rel1/lib1/basic.pcert0 : acl2x = 0
-rtl/rel1/lib1/basic.pcert0 : \
- rtl/rel1/support/proofs.pcert0 \
- rtl/rel1/lib1/basic.lisp
-rtl/rel1/lib1/basic.pcert1 : acl2x = 0
-rtl/rel1/lib1/basic.pcert1 : no_pcert = 0
-rtl/rel1/lib1/basic.pcert1 : rtl/rel1/lib1/basic.pcert0
-rtl/rel1/lib1/basic.cert : | rtl/rel1/lib1/basic.pcert1
-
-rtl/rel1/lib1/bits.pcert0 : no_pcert = 0
-rtl/rel1/lib1/bits.pcert0 : acl2x = 0
-rtl/rel1/lib1/bits.pcert0 : \
- rtl/rel1/support/proofs.pcert0 \
- rtl/rel1/lib1/bits.lisp
-rtl/rel1/lib1/bits.pcert1 : acl2x = 0
-rtl/rel1/lib1/bits.pcert1 : no_pcert = 0
-rtl/rel1/lib1/bits.pcert1 : rtl/rel1/lib1/bits.pcert0
-rtl/rel1/lib1/bits.cert : | rtl/rel1/lib1/bits.pcert1
-
-rtl/rel1/lib1/brat.pcert0 : no_pcert = 0
-rtl/rel1/lib1/brat.pcert0 : acl2x = 0
-rtl/rel1/lib1/brat.pcert0 : \
- rtl/rel1/support/fp.pcert0 \
- rtl/rel1/lib1/brat.lisp
-rtl/rel1/lib1/brat.pcert1 : acl2x = 0
-rtl/rel1/lib1/brat.pcert1 : no_pcert = 0
-rtl/rel1/lib1/brat.pcert1 : rtl/rel1/lib1/brat.pcert0
-rtl/rel1/lib1/brat.cert : | rtl/rel1/lib1/brat.pcert1
-
-rtl/rel1/lib1/float.pcert0 : no_pcert = 0
-rtl/rel1/lib1/float.pcert0 : acl2x = 0
-rtl/rel1/lib1/float.pcert0 : \
- rtl/rel1/support/proofs.pcert0 \
- rtl/rel1/lib1/float.lisp
-rtl/rel1/lib1/float.pcert1 : acl2x = 0
-rtl/rel1/lib1/float.pcert1 : no_pcert = 0
-rtl/rel1/lib1/float.pcert1 : rtl/rel1/lib1/float.pcert0
-rtl/rel1/lib1/float.cert : | rtl/rel1/lib1/float.pcert1
-
-rtl/rel1/lib1/reps.pcert0 : no_pcert = 0
-rtl/rel1/lib1/reps.pcert0 : acl2x = 0
-rtl/rel1/lib1/reps.pcert0 : \
- rtl/rel1/support/proofs.pcert0 \
- rtl/rel1/lib1/float.pcert0 \
- rtl/rel1/lib1/reps.lisp
-rtl/rel1/lib1/reps.pcert1 : acl2x = 0
-rtl/rel1/lib1/reps.pcert1 : no_pcert = 0
-rtl/rel1/lib1/reps.pcert1 : rtl/rel1/lib1/reps.pcert0
-rtl/rel1/lib1/reps.cert : | rtl/rel1/lib1/reps.pcert1
-
-rtl/rel1/lib1/round.pcert0 : no_pcert = 0
-rtl/rel1/lib1/round.pcert0 : acl2x = 0
-rtl/rel1/lib1/round.pcert0 : \
- rtl/rel1/support/proofs.pcert0 \
- rtl/rel1/lib1/float.pcert0 \
- rtl/rel1/lib1/round.lisp
-rtl/rel1/lib1/round.pcert1 : acl2x = 0
-rtl/rel1/lib1/round.pcert1 : no_pcert = 0
-rtl/rel1/lib1/round.pcert1 : rtl/rel1/lib1/round.pcert0
-rtl/rel1/lib1/round.cert : | rtl/rel1/lib1/round.pcert1
-
-rtl/rel1/lib1/top.pcert0 : no_pcert = 0
-rtl/rel1/lib1/top.pcert0 : acl2x = 0
-rtl/rel1/lib1/top.pcert0 : \
- rtl/rel1/lib1/basic.pcert0 \
- rtl/rel1/lib1/bits.pcert0 \
- rtl/rel1/lib1/float.pcert0 \
- rtl/rel1/lib1/round.pcert0 \
- rtl/rel1/lib1/reps.pcert0 \
- rtl/rel1/lib1/brat.pcert0 \
- rtl/rel1/lib1/top.lisp
-rtl/rel1/lib1/top.pcert1 : acl2x = 0
-rtl/rel1/lib1/top.pcert1 : no_pcert = 0
-rtl/rel1/lib1/top.pcert1 : rtl/rel1/lib1/top.pcert0
-rtl/rel1/lib1/top.cert : | rtl/rel1/lib1/top.pcert1
-
-rtl/rel1/lib3/basic.pcert0 : no_pcert = 0
-rtl/rel1/lib3/basic.pcert0 : acl2x = 0
-rtl/rel1/lib3/basic.pcert0 : \
- rtl/rel1/support/merge.pcert0 \
- rtl/rel1/support/rewrite-theory.pcert0 \
- rtl/rel1/lib3/basic.lisp
-rtl/rel1/lib3/basic.pcert1 : acl2x = 0
-rtl/rel1/lib3/basic.pcert1 : no_pcert = 0
-rtl/rel1/lib3/basic.pcert1 : rtl/rel1/lib3/basic.pcert0
-rtl/rel1/lib3/basic.cert : | rtl/rel1/lib3/basic.pcert1
-
-rtl/rel1/lib3/bits.pcert0 : no_pcert = 0
-rtl/rel1/lib3/bits.pcert0 : acl2x = 0
-rtl/rel1/lib3/bits.pcert0 : \
- rtl/rel1/support/merge.pcert0 \
- rtl/rel1/support/rewrite-theory.pcert0 \
- rtl/rel1/lib3/bits.lisp
-rtl/rel1/lib3/bits.pcert1 : acl2x = 0
-rtl/rel1/lib3/bits.pcert1 : no_pcert = 0
-rtl/rel1/lib3/bits.pcert1 : rtl/rel1/lib3/bits.pcert0
-rtl/rel1/lib3/bits.cert : | rtl/rel1/lib3/bits.pcert1
-
-rtl/rel1/lib3/brat.pcert0 : no_pcert = 0
-rtl/rel1/lib3/brat.pcert0 : acl2x = 0
-rtl/rel1/lib3/brat.pcert0 : \
- rtl/rel1/support/fp.pcert0 \
- rtl/rel1/lib3/brat.lisp
-rtl/rel1/lib3/brat.pcert1 : acl2x = 0
-rtl/rel1/lib3/brat.pcert1 : no_pcert = 0
-rtl/rel1/lib3/brat.pcert1 : rtl/rel1/lib3/brat.pcert0
-rtl/rel1/lib3/brat.cert : | rtl/rel1/lib3/brat.pcert1
-
-rtl/rel1/lib3/fadd.pcert0 : no_pcert = 0
-rtl/rel1/lib3/fadd.pcert0 : acl2x = 0
-rtl/rel1/lib3/fadd.pcert0 : \
- rtl/rel1/support/fadd/add3.pcert0 \
- rtl/rel1/lib3/float.pcert0 \
- rtl/rel1/lib3/bits.pcert0 \
- rtl/rel1/lib3/fadd.lisp
-rtl/rel1/lib3/fadd.pcert1 : acl2x = 0
-rtl/rel1/lib3/fadd.pcert1 : no_pcert = 0
-rtl/rel1/lib3/fadd.pcert1 : rtl/rel1/lib3/fadd.pcert0
-rtl/rel1/lib3/fadd.cert : | rtl/rel1/lib3/fadd.pcert1
-
-rtl/rel1/lib3/float.pcert0 : no_pcert = 0
-rtl/rel1/lib3/float.pcert0 : acl2x = 0
-rtl/rel1/lib3/float.pcert0 : \
- rtl/rel1/support/proofs.pcert0 \
- rtl/rel1/lib3/float.lisp
-rtl/rel1/lib3/float.pcert1 : acl2x = 0
-rtl/rel1/lib3/float.pcert1 : no_pcert = 0
-rtl/rel1/lib3/float.pcert1 : rtl/rel1/lib3/float.pcert0
-rtl/rel1/lib3/float.cert : | rtl/rel1/lib3/float.pcert1
-
-rtl/rel1/lib3/reps.pcert0 : no_pcert = 0
-rtl/rel1/lib3/reps.pcert0 : acl2x = 0
-rtl/rel1/lib3/reps.pcert0 : \
- rtl/rel1/support/proofs.pcert0 \
- rtl/rel1/lib3/float.pcert0 \
- rtl/rel1/lib3/reps.lisp
-rtl/rel1/lib3/reps.pcert1 : acl2x = 0
-rtl/rel1/lib3/reps.pcert1 : no_pcert = 0
-rtl/rel1/lib3/reps.pcert1 : rtl/rel1/lib3/reps.pcert0
-rtl/rel1/lib3/reps.cert : | rtl/rel1/lib3/reps.pcert1
-
-rtl/rel1/lib3/round.pcert0 : no_pcert = 0
-rtl/rel1/lib3/round.pcert0 : acl2x = 0
-rtl/rel1/lib3/round.pcert0 : \
- rtl/rel1/support/proofs.pcert0 \
- rtl/rel1/lib3/float.pcert0 \
- rtl/rel1/lib3/round.lisp
-rtl/rel1/lib3/round.pcert1 : acl2x = 0
-rtl/rel1/lib3/round.pcert1 : no_pcert = 0
-rtl/rel1/lib3/round.pcert1 : rtl/rel1/lib3/round.pcert0
-rtl/rel1/lib3/round.cert : | rtl/rel1/lib3/round.pcert1
-
-rtl/rel1/lib3/top.pcert0 : no_pcert = 0
-rtl/rel1/lib3/top.pcert0 : acl2x = 0
-rtl/rel1/lib3/top.pcert0 : \
- rtl/rel1/lib3/basic.pcert0 \
- rtl/rel1/lib3/bits.pcert0 \
- rtl/rel1/lib3/float.pcert0 \
- rtl/rel1/lib3/round.pcert0 \
- rtl/rel1/lib3/reps.pcert0 \
- rtl/rel1/lib3/fadd.pcert0 \
- rtl/rel1/support/fp.pcert0 \
- rtl/rel1/lib3/brat.pcert0 \
- rtl/rel1/lib3/top.lisp
-rtl/rel1/lib3/top.pcert1 : acl2x = 0
-rtl/rel1/lib3/top.pcert1 : no_pcert = 0
-rtl/rel1/lib3/top.pcert1 : rtl/rel1/lib3/top.pcert0
-rtl/rel1/lib3/top.cert : | rtl/rel1/lib3/top.pcert1
-
-rtl/rel1/support/add.pcert0 : no_pcert = 0
-rtl/rel1/support/add.pcert0 : acl2x = 0
-rtl/rel1/support/add.pcert0 : \
- rtl/rel1/support/divsqrt.pcert0 \
- rtl/rel1/support/logxor-lemmas.pcert0 \
- rtl/rel1/support/rnd.pcert0 \
- rtl/rel1/support/add.lisp
-rtl/rel1/support/add.pcert1 : acl2x = 0
-rtl/rel1/support/add.pcert1 : no_pcert = 0
-rtl/rel1/support/add.pcert1 : rtl/rel1/support/add.pcert0
-rtl/rel1/support/add.cert : | rtl/rel1/support/add.pcert1
-
-rtl/rel1/support/away.pcert0 : no_pcert = 0
-rtl/rel1/support/away.pcert0 : acl2x = 0
-rtl/rel1/support/away.pcert0 : \
- rtl/rel1/support/trunc.pcert0 \
- rtl/rel1/support/away.lisp
-rtl/rel1/support/away.pcert1 : acl2x = 0
-rtl/rel1/support/away.pcert1 : no_pcert = 0
-rtl/rel1/support/away.pcert1 : rtl/rel1/support/away.pcert0
-rtl/rel1/support/away.cert : | rtl/rel1/support/away.pcert1
-
-rtl/rel1/support/basic.pcert0 : no_pcert = 0
-rtl/rel1/support/basic.pcert0 : acl2x = 0
-rtl/rel1/support/basic.pcert0 : \
- rtl/rel1/support/fp.pcert0 \
- rtl/rel1/support/basic.lisp
-rtl/rel1/support/basic.pcert1 : acl2x = 0
-rtl/rel1/support/basic.pcert1 : no_pcert = 0
-rtl/rel1/support/basic.pcert1 : rtl/rel1/support/basic.pcert0
-rtl/rel1/support/basic.cert : | rtl/rel1/support/basic.pcert1
-
-rtl/rel1/support/divsqrt.pcert0 : no_pcert = 0
-rtl/rel1/support/divsqrt.pcert0 : acl2x = 0
-rtl/rel1/support/divsqrt.pcert0 : \
- rtl/rel1/support/odd.pcert0 \
- rtl/rel1/support/loglemmas.pcert0 \
- rtl/rel1/support/divsqrt.lisp
-rtl/rel1/support/divsqrt.pcert1 : acl2x = 0
-rtl/rel1/support/divsqrt.pcert1 : no_pcert = 0
-rtl/rel1/support/divsqrt.pcert1 : rtl/rel1/support/divsqrt.pcert0
-rtl/rel1/support/divsqrt.cert : | rtl/rel1/support/divsqrt.pcert1
-
-rtl/rel1/support/fadd/add3.pcert0 : no_pcert = 0
-rtl/rel1/support/fadd/add3.pcert0 : acl2x = 0
-rtl/rel1/support/fadd/add3.pcert0 : \
- rtl/rel1/support/fadd/stick.pcert0 \
- rtl/rel1/support/fadd/add3.lisp
-rtl/rel1/support/fadd/add3.pcert1 : acl2x = 0
-rtl/rel1/support/fadd/add3.pcert1 : no_pcert = 0
-rtl/rel1/support/fadd/add3.pcert1 : rtl/rel1/support/fadd/add3.pcert0
-rtl/rel1/support/fadd/add3.cert : | rtl/rel1/support/fadd/add3.pcert1
-
-rtl/rel1/support/fadd/lop1.pcert0 : no_pcert = 0
-rtl/rel1/support/fadd/lop1.pcert0 : acl2x = 0
-rtl/rel1/support/fadd/lop1.pcert0 : \
- rtl/rel1/lib1/top.pcert0 \
- rtl/rel1/support/fp.pcert0 \
- rtl/rel1/support/fadd/lop1.lisp
-rtl/rel1/support/fadd/lop1.pcert1 : acl2x = 0
-rtl/rel1/support/fadd/lop1.pcert1 : no_pcert = 0
-rtl/rel1/support/fadd/lop1.pcert1 : rtl/rel1/support/fadd/lop1.pcert0
-rtl/rel1/support/fadd/lop1.cert : | rtl/rel1/support/fadd/lop1.pcert1
-
-rtl/rel1/support/fadd/lop2.pcert0 : no_pcert = 0
-rtl/rel1/support/fadd/lop2.pcert0 : acl2x = 0
-rtl/rel1/support/fadd/lop2.pcert0 : \
- rtl/rel1/support/fadd/lop1.pcert0 \
- rtl/rel1/support/fadd/lop2.lisp
-rtl/rel1/support/fadd/lop2.pcert1 : acl2x = 0
-rtl/rel1/support/fadd/lop2.pcert1 : no_pcert = 0
-rtl/rel1/support/fadd/lop2.pcert1 : rtl/rel1/support/fadd/lop2.pcert0
-rtl/rel1/support/fadd/lop2.cert : | rtl/rel1/support/fadd/lop2.pcert1
-
-rtl/rel1/support/fadd/lop3.pcert0 : no_pcert = 0
-rtl/rel1/support/fadd/lop3.pcert0 : acl2x = 0
-rtl/rel1/support/fadd/lop3.pcert0 : \
- rtl/rel1/support/fadd/lop2.pcert0 \
- rtl/rel1/support/fadd/lop3.lisp
-rtl/rel1/support/fadd/lop3.pcert1 : acl2x = 0
-rtl/rel1/support/fadd/lop3.pcert1 : no_pcert = 0
-rtl/rel1/support/fadd/lop3.pcert1 : rtl/rel1/support/fadd/lop3.pcert0
-rtl/rel1/support/fadd/lop3.cert : | rtl/rel1/support/fadd/lop3.pcert1
-
-rtl/rel1/support/fadd/stick.pcert0 : no_pcert = 0
-rtl/rel1/support/fadd/stick.pcert0 : acl2x = 0
-rtl/rel1/support/fadd/stick.pcert0 : \
- rtl/rel1/support/fadd/lop3.pcert0 \
- rtl/rel1/support/fadd/stick.lisp
-rtl/rel1/support/fadd/stick.pcert1 : acl2x = 0
-rtl/rel1/support/fadd/stick.pcert1 : no_pcert = 0
-rtl/rel1/support/fadd/stick.pcert1 : rtl/rel1/support/fadd/stick.pcert0
-rtl/rel1/support/fadd/stick.cert : | rtl/rel1/support/fadd/stick.pcert1
-
-rtl/rel1/support/fadd/top.pcert0 : no_pcert = 0
-rtl/rel1/support/fadd/top.pcert0 : acl2x = 0
-rtl/rel1/support/fadd/top.pcert0 : \
- rtl/rel1/support/fadd/lop3.pcert0 \
- rtl/rel1/support/fadd/top.lisp
-rtl/rel1/support/fadd/top.pcert1 : acl2x = 0
-rtl/rel1/support/fadd/top.pcert1 : no_pcert = 0
-rtl/rel1/support/fadd/top.pcert1 : rtl/rel1/support/fadd/top.pcert0
-rtl/rel1/support/fadd/top.cert : | rtl/rel1/support/fadd/top.pcert1
-
-rtl/rel1/support/float.pcert0 : no_pcert = 0
-rtl/rel1/support/float.pcert0 : acl2x = 0
-rtl/rel1/support/float.pcert0 : \
- rtl/rel1/support/basic.pcert0 \
- rtl/rel1/support/x-2xx.pcert0 \
- rtl/rel1/support/float.lisp
-rtl/rel1/support/float.pcert1 : acl2x = 0
-rtl/rel1/support/float.pcert1 : no_pcert = 0
-rtl/rel1/support/float.pcert1 : rtl/rel1/support/float.pcert0
-rtl/rel1/support/float.cert : | rtl/rel1/support/float.pcert1
-
-rtl/rel1/support/floor.pcert0 : no_pcert = 0
-rtl/rel1/support/floor.pcert0 : acl2x = 0
-rtl/rel1/support/floor.pcert0 : \
- rtl/rel1/support/basic.pcert0 \
- rtl/rel1/support/floor.lisp
-rtl/rel1/support/floor.pcert1 : acl2x = 0
-rtl/rel1/support/floor.pcert1 : no_pcert = 0
-rtl/rel1/support/floor.pcert1 : rtl/rel1/support/floor.pcert0
-rtl/rel1/support/floor.cert : | rtl/rel1/support/floor.pcert1
-
-rtl/rel1/support/fp.pcert0 : no_pcert = 0
-rtl/rel1/support/fp.pcert0 : acl2x = 0
-rtl/rel1/support/fp.pcert0 : \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- rtl/rel1/support/fp.lisp
-rtl/rel1/support/fp.pcert1 : acl2x = 0
-rtl/rel1/support/fp.pcert1 : no_pcert = 0
-rtl/rel1/support/fp.pcert1 : rtl/rel1/support/fp.pcert0
-rtl/rel1/support/fp.cert : | rtl/rel1/support/fp.pcert1
-
-rtl/rel1/support/logdefs.pcert0 : no_pcert = 0
-rtl/rel1/support/logdefs.pcert0 : acl2x = 0
-rtl/rel1/support/logdefs.pcert0 : \
- rtl/rel1/support/floor.pcert0 \
- rtl/rel1/support/logdefs.lisp
-rtl/rel1/support/logdefs.pcert1 : acl2x = 0
-rtl/rel1/support/logdefs.pcert1 : no_pcert = 0
-rtl/rel1/support/logdefs.pcert1 : rtl/rel1/support/logdefs.pcert0
-rtl/rel1/support/logdefs.cert : | rtl/rel1/support/logdefs.pcert1
-
-rtl/rel1/support/loglemmas.pcert0 : no_pcert = 0
-rtl/rel1/support/loglemmas.pcert0 : acl2x = 0
-rtl/rel1/support/loglemmas.pcert0 : \
- rtl/rel1/support/logdefs.pcert0 \
- rtl/rel1/support/loglemmas.lisp
-rtl/rel1/support/loglemmas.pcert1 : acl2x = 0
-rtl/rel1/support/loglemmas.pcert1 : no_pcert = 0
-rtl/rel1/support/loglemmas.pcert1 : rtl/rel1/support/loglemmas.pcert0
-rtl/rel1/support/loglemmas.cert : | rtl/rel1/support/loglemmas.pcert1
-
-rtl/rel1/support/logxor-def.pcert0 : no_pcert = 0
-rtl/rel1/support/logxor-def.pcert0 : acl2x = 0
-rtl/rel1/support/logxor-def.pcert0 : \
- rtl/rel1/support/floor.pcert0 \
- rtl/rel1/support/logxor-def.lisp
-rtl/rel1/support/logxor-def.pcert1 : acl2x = 0
-rtl/rel1/support/logxor-def.pcert1 : no_pcert = 0
-rtl/rel1/support/logxor-def.pcert1 : rtl/rel1/support/logxor-def.pcert0
-rtl/rel1/support/logxor-def.cert : | rtl/rel1/support/logxor-def.pcert1
-
-rtl/rel1/support/logxor-lemmas.pcert0 : no_pcert = 0
-rtl/rel1/support/logxor-lemmas.pcert0 : acl2x = 0
-rtl/rel1/support/logxor-lemmas.pcert0 : \
- rtl/rel1/support/logxor-def.pcert0 \
- rtl/rel1/support/loglemmas.pcert0 \
- rtl/rel1/support/logxor-lemmas.lisp
-rtl/rel1/support/logxor-lemmas.pcert1 : acl2x = 0
-rtl/rel1/support/logxor-lemmas.pcert1 : no_pcert = 0
-rtl/rel1/support/logxor-lemmas.pcert1 : rtl/rel1/support/logxor-lemmas.pcert0
-rtl/rel1/support/logxor-lemmas.cert : | rtl/rel1/support/logxor-lemmas.pcert1
-
-rtl/rel1/support/merge.pcert0 : no_pcert = 0
-rtl/rel1/support/merge.pcert0 : acl2x = 0
-rtl/rel1/support/merge.pcert0 : \
- rtl/rel1/support/proofs.pcert0 \
- rtl/rel1/support/merge.lisp
-rtl/rel1/support/merge.pcert1 : acl2x = 0
-rtl/rel1/support/merge.pcert1 : no_pcert = 0
-rtl/rel1/support/merge.pcert1 : rtl/rel1/support/merge.pcert0
-rtl/rel1/support/merge.cert : | rtl/rel1/support/merge.pcert1
-
-rtl/rel1/support/near.pcert0 : no_pcert = 0
-rtl/rel1/support/near.pcert0 : acl2x = 0
-rtl/rel1/support/near.pcert0 : \
- rtl/rel1/support/away.pcert0 \
- rtl/rel1/support/near.lisp
-rtl/rel1/support/near.pcert1 : acl2x = 0
-rtl/rel1/support/near.pcert1 : no_pcert = 0
-rtl/rel1/support/near.pcert1 : rtl/rel1/support/near.pcert0
-rtl/rel1/support/near.cert : | rtl/rel1/support/near.pcert1
-
-rtl/rel1/support/odd.pcert0 : no_pcert = 0
-rtl/rel1/support/odd.pcert0 : acl2x = 0
-rtl/rel1/support/odd.pcert0 : \
- rtl/rel1/support/near.pcert0 \
- rtl/rel1/support/odd.lisp
-rtl/rel1/support/odd.pcert1 : acl2x = 0
-rtl/rel1/support/odd.pcert1 : no_pcert = 0
-rtl/rel1/support/odd.pcert1 : rtl/rel1/support/odd.pcert0
-rtl/rel1/support/odd.cert : | rtl/rel1/support/odd.pcert1
-
-rtl/rel1/support/proofs.pcert0 : no_pcert = 0
-rtl/rel1/support/proofs.pcert0 : acl2x = 0
-rtl/rel1/support/proofs.pcert0 : \
- rtl/rel1/support/basic.pcert0 \
- rtl/rel1/support/x-2xx.pcert0 \
- rtl/rel1/support/float.pcert0 \
- rtl/rel1/support/trunc.pcert0 \
- rtl/rel1/support/away.pcert0 \
- rtl/rel1/support/near.pcert0 \
- rtl/rel1/support/odd.pcert0 \
- rtl/rel1/support/floor.pcert0 \
- rtl/rel1/support/logdefs.pcert0 \
- rtl/rel1/support/loglemmas.pcert0 \
- rtl/rel1/support/divsqrt.pcert0 \
- rtl/rel1/support/logxor-def.pcert0 \
- rtl/rel1/support/logxor-lemmas.pcert0 \
- rtl/rel1/support/reps.pcert0 \
- rtl/rel1/support/sticky.pcert0 \
- rtl/rel1/support/rnd.pcert0 \
- rtl/rel1/support/add.pcert0 \
- rtl/rel1/support/proofs.lisp
-rtl/rel1/support/proofs.pcert1 : acl2x = 0
-rtl/rel1/support/proofs.pcert1 : no_pcert = 0
-rtl/rel1/support/proofs.pcert1 : rtl/rel1/support/proofs.pcert0
-rtl/rel1/support/proofs.cert : | rtl/rel1/support/proofs.pcert1
-
-rtl/rel1/support/reps.pcert0 : no_pcert = 0
-rtl/rel1/support/reps.pcert0 : acl2x = 0
-rtl/rel1/support/reps.pcert0 : \
- rtl/rel1/support/logdefs.pcert0 \
- rtl/rel1/support/float.pcert0 \
- rtl/rel1/support/reps.lisp
-rtl/rel1/support/reps.pcert1 : acl2x = 0
-rtl/rel1/support/reps.pcert1 : no_pcert = 0
-rtl/rel1/support/reps.pcert1 : rtl/rel1/support/reps.pcert0
-rtl/rel1/support/reps.cert : | rtl/rel1/support/reps.pcert1
-
-rtl/rel1/support/rewrite-theory.pcert0 : no_pcert = 0
-rtl/rel1/support/rewrite-theory.pcert0 : acl2x = 0
-rtl/rel1/support/rewrite-theory.pcert0 : \
- rtl/rel1/support/rewrite-theory.lisp
-rtl/rel1/support/rewrite-theory.pcert1 : acl2x = 0
-rtl/rel1/support/rewrite-theory.pcert1 : no_pcert = 0
-rtl/rel1/support/rewrite-theory.pcert1 : rtl/rel1/support/rewrite-theory.pcert0
-rtl/rel1/support/rewrite-theory.cert : | rtl/rel1/support/rewrite-theory.pcert1
-
-rtl/rel1/support/rnd.pcert0 : no_pcert = 0
-rtl/rel1/support/rnd.pcert0 : acl2x = 0
-rtl/rel1/support/rnd.pcert0 : \
- rtl/rel1/support/sticky.pcert0 \
- rtl/rel1/support/rnd.lisp
-rtl/rel1/support/rnd.pcert1 : acl2x = 0
-rtl/rel1/support/rnd.pcert1 : no_pcert = 0
-rtl/rel1/support/rnd.pcert1 : rtl/rel1/support/rnd.pcert0
-rtl/rel1/support/rnd.cert : | rtl/rel1/support/rnd.pcert1
-
-rtl/rel1/support/sticky.pcert0 : no_pcert = 0
-rtl/rel1/support/sticky.pcert0 : acl2x = 0
-rtl/rel1/support/sticky.pcert0 : \
- rtl/rel1/support/divsqrt.pcert0 \
- rtl/rel1/support/sticky.lisp
-rtl/rel1/support/sticky.pcert1 : acl2x = 0
-rtl/rel1/support/sticky.pcert1 : no_pcert = 0
-rtl/rel1/support/sticky.pcert1 : rtl/rel1/support/sticky.pcert0
-rtl/rel1/support/sticky.cert : | rtl/rel1/support/sticky.pcert1
-
-rtl/rel1/support/trunc.pcert0 : no_pcert = 0
-rtl/rel1/support/trunc.pcert0 : acl2x = 0
-rtl/rel1/support/trunc.pcert0 : \
- rtl/rel1/support/float.pcert0 \
- rtl/rel1/support/trunc.lisp
-rtl/rel1/support/trunc.pcert1 : acl2x = 0
-rtl/rel1/support/trunc.pcert1 : no_pcert = 0
-rtl/rel1/support/trunc.pcert1 : rtl/rel1/support/trunc.pcert0
-rtl/rel1/support/trunc.cert : | rtl/rel1/support/trunc.pcert1
-
-rtl/rel1/support/x-2xx.pcert0 : no_pcert = 0
-rtl/rel1/support/x-2xx.pcert0 : acl2x = 0
-rtl/rel1/support/x-2xx.pcert0 : \
- arithmetic/top.pcert0 \
- rtl/rel1/support/x-2xx.lisp
-rtl/rel1/support/x-2xx.pcert1 : acl2x = 0
-rtl/rel1/support/x-2xx.pcert1 : no_pcert = 0
-rtl/rel1/support/x-2xx.pcert1 : rtl/rel1/support/x-2xx.pcert0
-rtl/rel1/support/x-2xx.cert : | rtl/rel1/support/x-2xx.pcert1
-
-rtl/rel4/arithmetic/arith.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/arith.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/arith.pcert0 : \
- rtl/rel4/arithmetic/arith2.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- meta/meta-times-equal.pcert0 \
- rtl/rel4/arithmetic/arith.lisp
-rtl/rel4/arithmetic/arith.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/arith.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/arith.pcert1 : rtl/rel4/arithmetic/arith.pcert0
-rtl/rel4/arithmetic/arith.cert : | rtl/rel4/arithmetic/arith.pcert1
-
-rtl/rel4/arithmetic/arith2.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/arith2.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/arith2.pcert0 : \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/product.pcert0 \
- meta/meta-times-equal.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- meta/meta-times-equal.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel4/arithmetic/inverted-factor.pcert0 \
- rtl/rel4/arithmetic/arith2.lisp
-rtl/rel4/arithmetic/arith2.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/arith2.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/arith2.pcert1 : rtl/rel4/arithmetic/arith2.pcert0
-rtl/rel4/arithmetic/arith2.cert : | rtl/rel4/arithmetic/arith2.pcert1
-
-rtl/rel4/arithmetic/basic.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/basic.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/basic.pcert0 : \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/even-odd.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/expt.pcert0 \
- rtl/rel4/arithmetic/basic.lisp
-rtl/rel4/arithmetic/basic.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/basic.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/basic.pcert1 : rtl/rel4/arithmetic/basic.pcert0
-rtl/rel4/arithmetic/basic.cert : | rtl/rel4/arithmetic/basic.pcert1
-
-rtl/rel4/arithmetic/cg.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/cg.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/cg.pcert0 : \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- rtl/rel4/arithmetic/common-factor.pcert0 \
- rtl/rel4/arithmetic/cg.lisp
-rtl/rel4/arithmetic/cg.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/cg.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/cg.pcert1 : rtl/rel4/arithmetic/cg.pcert0
-rtl/rel4/arithmetic/cg.cert : | rtl/rel4/arithmetic/cg.pcert1
-
-rtl/rel4/arithmetic/common-factor-defuns.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/common-factor-defuns.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/common-factor-defuns.pcert0 : \
- rtl/rel4/arithmetic/inverted-factor.pcert0 \
- rtl/rel4/arithmetic/common-factor-defuns.lisp
-rtl/rel4/arithmetic/common-factor-defuns.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/common-factor-defuns.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/common-factor-defuns.pcert1 : rtl/rel4/arithmetic/common-factor-defuns.pcert0
-rtl/rel4/arithmetic/common-factor-defuns.cert : | rtl/rel4/arithmetic/common-factor-defuns.pcert1
-
-rtl/rel4/arithmetic/common-factor.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/common-factor.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/common-factor.pcert0 : \
- meta/meta-times-equal.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel4/arithmetic/common-factor-defuns.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/product.pcert0 \
- rtl/rel4/arithmetic/common-factor.lisp
-rtl/rel4/arithmetic/common-factor.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/common-factor.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/common-factor.pcert1 : rtl/rel4/arithmetic/common-factor.pcert0
-rtl/rel4/arithmetic/common-factor.cert : | rtl/rel4/arithmetic/common-factor.pcert1
-
-rtl/rel4/arithmetic/complex-rationalp.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/complex-rationalp.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/complex-rationalp.pcert0 : \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/complex-rationalp.lisp
-rtl/rel4/arithmetic/complex-rationalp.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/complex-rationalp.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/complex-rationalp.pcert1 : rtl/rel4/arithmetic/complex-rationalp.pcert0
-rtl/rel4/arithmetic/complex-rationalp.cert : | rtl/rel4/arithmetic/complex-rationalp.pcert1
-
-rtl/rel4/arithmetic/denominator.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/denominator.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/denominator.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- arithmetic/mod-gcd.pcert0 \
- rtl/rel4/arithmetic/denominator.lisp
-rtl/rel4/arithmetic/denominator.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/denominator.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/denominator.pcert1 : rtl/rel4/arithmetic/denominator.pcert0
-rtl/rel4/arithmetic/denominator.cert : | rtl/rel4/arithmetic/denominator.pcert1
-
-rtl/rel4/arithmetic/even-odd.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/even-odd.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/even-odd.pcert0 : \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/even-odd.lisp
-rtl/rel4/arithmetic/even-odd.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/even-odd.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/even-odd.pcert1 : rtl/rel4/arithmetic/even-odd.pcert0
-rtl/rel4/arithmetic/even-odd.cert : | rtl/rel4/arithmetic/even-odd.pcert1
-
-rtl/rel4/arithmetic/even-odd2-proofs.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/even-odd2-proofs.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/even-odd2-proofs.pcert0 : \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/arith.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/even-odd2-proofs.lisp
-rtl/rel4/arithmetic/even-odd2-proofs.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/even-odd2-proofs.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/even-odd2-proofs.pcert1 : rtl/rel4/arithmetic/even-odd2-proofs.pcert0
-rtl/rel4/arithmetic/even-odd2-proofs.cert : | rtl/rel4/arithmetic/even-odd2-proofs.pcert1
-
-rtl/rel4/arithmetic/even-odd2.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/even-odd2.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/even-odd2.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/even-odd2-proofs.pcert0 \
- rtl/rel4/arithmetic/even-odd2.lisp
-rtl/rel4/arithmetic/even-odd2.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/even-odd2.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/even-odd2.pcert1 : rtl/rel4/arithmetic/even-odd2.pcert0
-rtl/rel4/arithmetic/even-odd2.cert : | rtl/rel4/arithmetic/even-odd2.pcert1
-
-rtl/rel4/arithmetic/expo-proofs.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/expo-proofs.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/expo-proofs.pcert0 : \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/arithmetic/unary-divide.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/expt.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel4/arithmetic/common-factor-defuns.pcert0 \
- rtl/rel4/arithmetic/common-factor.pcert0 \
- rtl/rel4/arithmetic/expo-proofs.lisp
-rtl/rel4/arithmetic/expo-proofs.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/expo-proofs.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/expo-proofs.pcert1 : rtl/rel4/arithmetic/expo-proofs.pcert0
-rtl/rel4/arithmetic/expo-proofs.cert : | rtl/rel4/arithmetic/expo-proofs.pcert1
-
-rtl/rel4/arithmetic/expo.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/expo.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/expo.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/arithmetic/expo-proofs.pcert0 \
- rtl/rel4/arithmetic/common-factor-defuns.pcert0 \
- rtl/rel4/arithmetic/expo.lisp
-rtl/rel4/arithmetic/expo.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/expo.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/expo.pcert1 : rtl/rel4/arithmetic/expo.pcert0
-rtl/rel4/arithmetic/expo.cert : | rtl/rel4/arithmetic/expo.pcert1
-
-rtl/rel4/arithmetic/expt-proofs.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/expt-proofs.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/expt-proofs.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/numerator.pcert0 \
- rtl/rel4/arithmetic/denominator.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- arithmetic/top.pcert0 \
- rtl/rel4/arithmetic/even-odd.pcert0 \
- rtl/rel4/arithmetic/expt-proofs.lisp
-rtl/rel4/arithmetic/expt-proofs.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/expt-proofs.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/expt-proofs.pcert1 : rtl/rel4/arithmetic/expt-proofs.pcert0
-rtl/rel4/arithmetic/expt-proofs.cert : | rtl/rel4/arithmetic/expt-proofs.pcert1
-
-rtl/rel4/arithmetic/expt.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/expt.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/expt.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/expt-proofs.pcert0 \
- rtl/rel4/arithmetic/expt.lisp
-rtl/rel4/arithmetic/expt.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/expt.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/expt.pcert1 : rtl/rel4/arithmetic/expt.pcert0
-rtl/rel4/arithmetic/expt.cert : | rtl/rel4/arithmetic/expt.pcert1
-
-rtl/rel4/arithmetic/extra-rules.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/extra-rules.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/extra-rules.pcert0 : \
- rtl/rel4/arithmetic/basic.pcert0 \
- rtl/rel4/arithmetic/extra-rules.lisp
-rtl/rel4/arithmetic/extra-rules.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/extra-rules.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/extra-rules.pcert1 : rtl/rel4/arithmetic/extra-rules.pcert0
-rtl/rel4/arithmetic/extra-rules.cert : | rtl/rel4/arithmetic/extra-rules.pcert1
-
-rtl/rel4/arithmetic/fl-expt.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/fl-expt.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/fl-expt.pcert0 : \
- rtl/rel4/arithmetic/numerator.pcert0 \
- rtl/rel4/arithmetic/denominator.pcert0 \
- rtl/rel4/arithmetic/nniq.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/floor.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/rationalp.pcert0 \
- rtl/rel4/arithmetic/unary-divide.pcert0 \
- rtl/rel4/arithmetic/expt.pcert0 \
- rtl/rel4/arithmetic/expo.pcert0 \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/fl-expt.lisp
-rtl/rel4/arithmetic/fl-expt.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/fl-expt.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/fl-expt.pcert1 : rtl/rel4/arithmetic/fl-expt.pcert0
-rtl/rel4/arithmetic/fl-expt.cert : | rtl/rel4/arithmetic/fl-expt.pcert1
-
-rtl/rel4/arithmetic/fl-hacks.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/fl-hacks.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/fl-hacks.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/inverted-factor.pcert0 \
- rtl/rel4/arithmetic/nniq.pcert0 \
- rtl/rel4/arithmetic/numerator.pcert0 \
- rtl/rel4/arithmetic/denominator.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/product.pcert0 \
- rtl/rel4/arithmetic/unary-divide.pcert0 \
- rtl/rel4/arithmetic/rationalp.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/mod.pcert0 \
- rtl/rel4/arithmetic/even-odd.pcert0 \
- meta/meta-plus-equal.pcert0 \
- rtl/rel4/arithmetic/arith.pcert0 \
- rtl/rel4/arithmetic/fl-hacks.lisp
-rtl/rel4/arithmetic/fl-hacks.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/fl-hacks.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/fl-hacks.pcert1 : rtl/rel4/arithmetic/fl-hacks.pcert0
-rtl/rel4/arithmetic/fl-hacks.cert : | rtl/rel4/arithmetic/fl-hacks.pcert1
-
-rtl/rel4/arithmetic/fl-proofs.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/fl-proofs.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/fl-proofs.pcert0 : \
- rtl/rel4/arithmetic/numerator.pcert0 \
- rtl/rel4/arithmetic/denominator.pcert0 \
- rtl/rel4/arithmetic/nniq.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/floor.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/rationalp.pcert0 \
- rtl/rel4/arithmetic/unary-divide.pcert0 \
- rtl/rel4/arithmetic/common-factor.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/fl-proofs.lisp
-rtl/rel4/arithmetic/fl-proofs.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/fl-proofs.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/fl-proofs.pcert1 : rtl/rel4/arithmetic/fl-proofs.pcert0
-rtl/rel4/arithmetic/fl-proofs.cert : | rtl/rel4/arithmetic/fl-proofs.pcert1
-
-rtl/rel4/arithmetic/fl.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/fl.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/fl.pcert0 : \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/fl-proofs.pcert0 \
- rtl/rel4/arithmetic/fl.lisp
-rtl/rel4/arithmetic/fl.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/fl.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/fl.pcert1 : rtl/rel4/arithmetic/fl.pcert0
-rtl/rel4/arithmetic/fl.cert : | rtl/rel4/arithmetic/fl.pcert1
-
-rtl/rel4/arithmetic/floor-proofs.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/floor-proofs.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/floor-proofs.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/denominator.pcert0 \
- rtl/rel4/arithmetic/numerator.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/nniq.pcert0 \
- rtl/rel4/arithmetic/product.pcert0 \
- rtl/rel4/arithmetic/unary-divide.pcert0 \
- rtl/rel4/arithmetic/rationalp.pcert0 \
- rtl/rel4/arithmetic/inverted-factor.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel4/arithmetic/floor-proofs.lisp
-rtl/rel4/arithmetic/floor-proofs.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/floor-proofs.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/floor-proofs.pcert1 : rtl/rel4/arithmetic/floor-proofs.pcert0
-rtl/rel4/arithmetic/floor-proofs.cert : | rtl/rel4/arithmetic/floor-proofs.pcert1
-
-rtl/rel4/arithmetic/floor.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/floor.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/floor.pcert0 : \
- rtl/rel4/arithmetic/floor-proofs.pcert0 \
- rtl/rel4/arithmetic/floor.lisp
-rtl/rel4/arithmetic/floor.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/floor.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/floor.pcert1 : rtl/rel4/arithmetic/floor.pcert0
-rtl/rel4/arithmetic/floor.cert : | rtl/rel4/arithmetic/floor.pcert1
-
-rtl/rel4/arithmetic/fp.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/fp.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/fp.pcert0 : \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/fp.lisp
-rtl/rel4/arithmetic/fp.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/fp.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/fp.pcert1 : rtl/rel4/arithmetic/fp.pcert0
-rtl/rel4/arithmetic/fp.cert : | rtl/rel4/arithmetic/fp.pcert1
-
-rtl/rel4/arithmetic/fp2.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/fp2.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/fp2.pcert0 : \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- arithmetic-2/meta/non-linear.pcert0 \
- rtl/rel4/arithmetic/inverted-factor.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel4/arithmetic/fp2.lisp
-rtl/rel4/arithmetic/fp2.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/fp2.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/fp2.pcert1 : rtl/rel4/arithmetic/fp2.pcert0
-rtl/rel4/arithmetic/fp2.cert : | rtl/rel4/arithmetic/fp2.pcert1
-
-rtl/rel4/arithmetic/ground-zero.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/ground-zero.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/ground-zero.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.lisp
-rtl/rel4/arithmetic/ground-zero.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/ground-zero.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/ground-zero.pcert1 : rtl/rel4/arithmetic/ground-zero.pcert0
-rtl/rel4/arithmetic/ground-zero.cert : | rtl/rel4/arithmetic/ground-zero.pcert1
-
-rtl/rel4/arithmetic/hacks.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/hacks.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/hacks.pcert0 : \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/hacks.lisp
-rtl/rel4/arithmetic/hacks.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/hacks.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/hacks.pcert1 : rtl/rel4/arithmetic/hacks.pcert0
-rtl/rel4/arithmetic/hacks.cert : | rtl/rel4/arithmetic/hacks.pcert1
-
-rtl/rel4/arithmetic/induct.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/induct.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/induct.pcert0 : \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/induct.lisp
-rtl/rel4/arithmetic/induct.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/induct.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/induct.pcert1 : rtl/rel4/arithmetic/induct.pcert0
-rtl/rel4/arithmetic/induct.cert : | rtl/rel4/arithmetic/induct.pcert1
-
-rtl/rel4/arithmetic/integerp.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/integerp.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/integerp.pcert0 : \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/integerp.lisp
-rtl/rel4/arithmetic/integerp.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/integerp.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/integerp.pcert1 : rtl/rel4/arithmetic/integerp.pcert0
-rtl/rel4/arithmetic/integerp.cert : | rtl/rel4/arithmetic/integerp.pcert1
-
-rtl/rel4/arithmetic/inverted-factor.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/inverted-factor.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/inverted-factor.pcert0 : \
- rtl/rel4/arithmetic/inverted-factor.lisp
-rtl/rel4/arithmetic/inverted-factor.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/inverted-factor.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/inverted-factor.pcert1 : rtl/rel4/arithmetic/inverted-factor.pcert0
-rtl/rel4/arithmetic/inverted-factor.cert : | rtl/rel4/arithmetic/inverted-factor.pcert1
-
-rtl/rel4/arithmetic/mod-expt.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/mod-expt.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/mod-expt.pcert0 : \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/arithmetic/numerator.pcert0 \
- rtl/rel4/arithmetic/denominator.pcert0 \
- rtl/rel4/arithmetic/nniq.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/floor.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/rationalp.pcert0 \
- rtl/rel4/arithmetic/unary-divide.pcert0 \
- rtl/rel4/arithmetic/expt.pcert0 \
- rtl/rel4/arithmetic/expo.pcert0 \
- rtl/rel4/arithmetic/fl-expt.pcert0 \
- rtl/rel4/arithmetic/mod.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/mod-expt.lisp
-rtl/rel4/arithmetic/mod-expt.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/mod-expt.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/mod-expt.pcert1 : rtl/rel4/arithmetic/mod-expt.pcert0
-rtl/rel4/arithmetic/mod-expt.cert : | rtl/rel4/arithmetic/mod-expt.pcert1
-
-rtl/rel4/arithmetic/mod-proofs.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/mod-proofs.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/mod-proofs.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/floor.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/arith.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/product.pcert0 \
- rtl/rel4/arithmetic/complex-rationalp.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/rationalp.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/mod-proofs.lisp
-rtl/rel4/arithmetic/mod-proofs.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/mod-proofs.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/mod-proofs.pcert1 : rtl/rel4/arithmetic/mod-proofs.pcert0
-rtl/rel4/arithmetic/mod-proofs.cert : | rtl/rel4/arithmetic/mod-proofs.pcert1
-
-rtl/rel4/arithmetic/mod.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/mod.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/mod.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/mod-proofs.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/mod.lisp
-rtl/rel4/arithmetic/mod.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/mod.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/mod.pcert1 : rtl/rel4/arithmetic/mod.pcert0
-rtl/rel4/arithmetic/mod.cert : | rtl/rel4/arithmetic/mod.pcert1
-
-rtl/rel4/arithmetic/negative-syntaxp.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/negative-syntaxp.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/negative-syntaxp.pcert0 : \
- rtl/rel4/arithmetic/negative-syntaxp.lisp
-rtl/rel4/arithmetic/negative-syntaxp.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/negative-syntaxp.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/negative-syntaxp.pcert1 : rtl/rel4/arithmetic/negative-syntaxp.pcert0
-rtl/rel4/arithmetic/negative-syntaxp.cert : | rtl/rel4/arithmetic/negative-syntaxp.pcert1
-
-rtl/rel4/arithmetic/nniq.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/nniq.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/nniq.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/denominator.pcert0 \
- rtl/rel4/arithmetic/numerator.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/unary-divide.pcert0 \
- rtl/rel4/arithmetic/product.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/arith.pcert0 \
- arithmetic/rationals.pcert0 \
- arithmetic/idiv.pcert0 \
- arithmetic/idiv.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- rtl/rel4/arithmetic/nniq.lisp
-rtl/rel4/arithmetic/nniq.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/nniq.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/nniq.pcert1 : rtl/rel4/arithmetic/nniq.pcert0
-rtl/rel4/arithmetic/nniq.cert : | rtl/rel4/arithmetic/nniq.pcert1
-
-rtl/rel4/arithmetic/numerator.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/numerator.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/numerator.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/denominator.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/numerator.lisp
-rtl/rel4/arithmetic/numerator.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/numerator.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/numerator.pcert1 : rtl/rel4/arithmetic/numerator.pcert0
-rtl/rel4/arithmetic/numerator.cert : | rtl/rel4/arithmetic/numerator.pcert1
-
-rtl/rel4/arithmetic/power2p.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/power2p.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/power2p.pcert0 : \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/unary-divide.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel4/arithmetic/power2p.lisp
-rtl/rel4/arithmetic/power2p.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/power2p.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/power2p.pcert1 : rtl/rel4/arithmetic/power2p.pcert0
-rtl/rel4/arithmetic/power2p.cert : | rtl/rel4/arithmetic/power2p.pcert1
-
-rtl/rel4/arithmetic/predicate.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/predicate.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/predicate.pcert0 : \
- rtl/rel4/arithmetic/predicate.lisp
-rtl/rel4/arithmetic/predicate.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/predicate.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/predicate.pcert1 : rtl/rel4/arithmetic/predicate.pcert0
-rtl/rel4/arithmetic/predicate.cert : | rtl/rel4/arithmetic/predicate.pcert1
-
-rtl/rel4/arithmetic/product-proofs.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/product-proofs.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/product-proofs.pcert0 : \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/product-proofs.lisp
-rtl/rel4/arithmetic/product-proofs.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/product-proofs.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/product-proofs.pcert1 : rtl/rel4/arithmetic/product-proofs.pcert0
-rtl/rel4/arithmetic/product-proofs.cert : | rtl/rel4/arithmetic/product-proofs.pcert1
-
-rtl/rel4/arithmetic/product.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/product.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/product.pcert0 : \
- rtl/rel4/arithmetic/product-proofs.pcert0 \
- rtl/rel4/arithmetic/product.lisp
-rtl/rel4/arithmetic/product.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/product.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/product.pcert1 : rtl/rel4/arithmetic/product.pcert0
-rtl/rel4/arithmetic/product.cert : | rtl/rel4/arithmetic/product.pcert1
-
-rtl/rel4/arithmetic/rationalp.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/rationalp.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/rationalp.pcert0 : \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/rationalp.lisp
-rtl/rel4/arithmetic/rationalp.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/rationalp.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/rationalp.pcert1 : rtl/rel4/arithmetic/rationalp.pcert0
-rtl/rel4/arithmetic/rationalp.cert : | rtl/rel4/arithmetic/rationalp.pcert1
-
-rtl/rel4/arithmetic/top.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/top.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/top.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/arithmetic/induct.pcert0 \
- rtl/rel4/arithmetic/denominator.pcert0 \
- rtl/rel4/arithmetic/numerator.pcert0 \
- rtl/rel4/arithmetic/nniq.pcert0 \
- rtl/rel4/arithmetic/complex-rationalp.pcert0 \
- rtl/rel4/arithmetic/rationalp.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/arithmetic/arith.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/basic.pcert0 \
- rtl/rel4/arithmetic/unary-divide.pcert0 \
- rtl/rel4/arithmetic/product.pcert0 \
- rtl/rel4/arithmetic/inverted-factor.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/x-2xx.pcert0 \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/arithmetic/expt.pcert0 \
- rtl/rel4/arithmetic/expo.pcert0 \
- rtl/rel4/arithmetic/even-odd2.pcert0 \
- rtl/rel4/arithmetic/even-odd.pcert0 \
- rtl/rel4/arithmetic/floor.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/cg.pcert0 \
- rtl/rel4/arithmetic/mod.pcert0 \
- rtl/rel4/arithmetic/fl-expt.pcert0 \
- rtl/rel4/arithmetic/mod-expt.pcert0 \
- rtl/rel4/arithmetic/common-factor.pcert0 \
- rtl/rel4/arithmetic/top.lisp
-rtl/rel4/arithmetic/top.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/top.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/top.pcert1 : rtl/rel4/arithmetic/top.pcert0
-rtl/rel4/arithmetic/top.cert : | rtl/rel4/arithmetic/top.pcert1
-
-rtl/rel4/arithmetic/unary-divide.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/unary-divide.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/unary-divide.pcert0 : \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/inverted-factor.pcert0 \
- rtl/rel4/arithmetic/unary-divide.lisp
-rtl/rel4/arithmetic/unary-divide.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/unary-divide.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/unary-divide.pcert1 : rtl/rel4/arithmetic/unary-divide.pcert0
-rtl/rel4/arithmetic/unary-divide.cert : | rtl/rel4/arithmetic/unary-divide.pcert1
-
-rtl/rel4/arithmetic/x-2xx.pcert0 : no_pcert = 0
-rtl/rel4/arithmetic/x-2xx.pcert0 : acl2x = 0
-rtl/rel4/arithmetic/x-2xx.pcert0 : \
- arithmetic/top.pcert0 \
- rtl/rel4/arithmetic/x-2xx.lisp
-rtl/rel4/arithmetic/x-2xx.pcert1 : acl2x = 0
-rtl/rel4/arithmetic/x-2xx.pcert1 : no_pcert = 0
-rtl/rel4/arithmetic/x-2xx.pcert1 : rtl/rel4/arithmetic/x-2xx.pcert0
-rtl/rel4/arithmetic/x-2xx.cert : | rtl/rel4/arithmetic/x-2xx.pcert1
-
-rtl/rel4/lib/arith.pcert0 : no_pcert = 0
-rtl/rel4/lib/arith.pcert0 : acl2x = 0
-rtl/rel4/lib/arith.pcert0 : \
- rtl/rel4/arithmetic/fp.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/expt.pcert0 \
- rtl/rel4/arithmetic/expo.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel4/lib/arith.lisp
-rtl/rel4/lib/arith.pcert1 : acl2x = 0
-rtl/rel4/lib/arith.pcert1 : no_pcert = 0
-rtl/rel4/lib/arith.pcert1 : rtl/rel4/lib/arith.pcert0
-rtl/rel4/lib/arith.cert : | rtl/rel4/lib/arith.pcert1
-
-rtl/rel4/lib/basic.pcert0 : no_pcert = 0
-rtl/rel4/lib/basic.pcert0 : acl2x = 0
-rtl/rel4/lib/basic.pcert0 : \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/arithmetic/hacks.pcert0 \
- rtl/rel4/arithmetic/cg.pcert0 \
- rtl/rel4/support/ash.pcert0 \
- rtl/rel4/arithmetic/fl-hacks.pcert0 \
- rtl/rel4/arithmetic/mod.pcert0 \
- rtl/rel4/arithmetic/even-odd.pcert0 \
- rtl/rel4/arithmetic/extra-rules.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/lib/rtl.pcert0 \
- rtl/rel4/lib/rtlarr.pcert0 \
- rtl/rel4/lib/basic.lisp
-rtl/rel4/lib/basic.pcert1 : acl2x = 0
-rtl/rel4/lib/basic.pcert1 : no_pcert = 0
-rtl/rel4/lib/basic.pcert1 : rtl/rel4/lib/basic.pcert0
-rtl/rel4/lib/basic.cert : | rtl/rel4/lib/basic.pcert1
-
-rtl/rel4/lib/bits.pcert0 : no_pcert = 0
-rtl/rel4/lib/bits.pcert0 : acl2x = 0
-rtl/rel4/lib/bits.pcert0 : \
- rtl/rel4/lib/basic.pcert0 \
- rtl/rel4/support/top.pcert0 \
- rtl/rel4/lib/bits.lisp
-rtl/rel4/lib/bits.pcert1 : acl2x = 0
-rtl/rel4/lib/bits.pcert1 : no_pcert = 0
-rtl/rel4/lib/bits.pcert1 : rtl/rel4/lib/bits.pcert0
-rtl/rel4/lib/bits.cert : | rtl/rel4/lib/bits.pcert1
-
-rtl/rel4/lib/bvecp-helpers.pcert0 : no_pcert = 0
-rtl/rel4/lib/bvecp-helpers.pcert0 : acl2x = 0
-rtl/rel4/lib/bvecp-helpers.pcert0 : \
- rtl/rel4/lib/rtl.pcert0 \
- rtl/rel4/lib/rtlarr.pcert0 \
- rtl/rel4/support/bvecp-helpers.pcert0 \
- rtl/rel4/arithmetic/basic.pcert0 \
- rtl/rel4/lib/bvecp-helpers.lisp
-rtl/rel4/lib/bvecp-helpers.pcert1 : acl2x = 0
-rtl/rel4/lib/bvecp-helpers.pcert1 : no_pcert = 0
-rtl/rel4/lib/bvecp-helpers.pcert1 : rtl/rel4/lib/bvecp-helpers.pcert0
-rtl/rel4/lib/bvecp-helpers.cert : | rtl/rel4/lib/bvecp-helpers.pcert1
-
-rtl/rel4/lib/bvecp-raw-helpers.pcert0 : no_pcert = 0
-rtl/rel4/lib/bvecp-raw-helpers.pcert0 : acl2x = 0
-rtl/rel4/lib/bvecp-raw-helpers.pcert0 : \
- rtl/rel4/lib/rtl.pcert0 \
- rtl/rel4/lib/rtlarr.pcert0 \
- rtl/rel4/support/bvecp-helpers.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/setbits.pcert0 \
- rtl/rel4/support/setbitn.pcert0 \
- rtl/rel4/support/logs.pcert0 \
- rtl/rel4/support/lnot.pcert0 \
- rtl/rel4/support/shft.pcert0 \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/mulcat.pcert0 \
- rtl/rel4/support/encode.pcert0 \
- rtl/rel4/support/decode.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/lxor.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/arithmetic/expo.pcert0 \
- rtl/rel4/arithmetic/basic.pcert0 \
- rtl/rel4/lib/bvecp-raw-helpers.lisp
-rtl/rel4/lib/bvecp-raw-helpers.pcert1 : acl2x = 0
-rtl/rel4/lib/bvecp-raw-helpers.pcert1 : no_pcert = 0
-rtl/rel4/lib/bvecp-raw-helpers.pcert1 : rtl/rel4/lib/bvecp-raw-helpers.pcert0
-rtl/rel4/lib/bvecp-raw-helpers.cert : | rtl/rel4/lib/bvecp-raw-helpers.pcert1
-
-rtl/rel4/lib/clocks.pcert0 : no_pcert = 0
-rtl/rel4/lib/clocks.pcert0 : acl2x = 0
-rtl/rel4/lib/clocks.pcert0 : \
- rtl/rel4/support/clocks.pcert0 \
- rtl/rel4/lib/clocks.lisp
-rtl/rel4/lib/clocks.pcert1 : acl2x = 0
-rtl/rel4/lib/clocks.pcert1 : no_pcert = 0
-rtl/rel4/lib/clocks.pcert1 : rtl/rel4/lib/clocks.pcert0
-rtl/rel4/lib/clocks.cert : | rtl/rel4/lib/clocks.pcert1
-
-rtl/rel4/lib/fadd.pcert0 : no_pcert = 0
-rtl/rel4/lib/fadd.pcert0 : acl2x = 0
-rtl/rel4/lib/fadd.pcert0 : \
- rtl/rel4/support/fadd.pcert0 \
- rtl/rel4/support/bits-extra.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/lib/float.pcert0 \
- rtl/rel4/lib/fadd.lisp
-rtl/rel4/lib/fadd.pcert1 : acl2x = 0
-rtl/rel4/lib/fadd.pcert1 : no_pcert = 0
-rtl/rel4/lib/fadd.pcert1 : rtl/rel4/lib/fadd.pcert0
-rtl/rel4/lib/fadd.cert : | rtl/rel4/lib/fadd.pcert1
-
-rtl/rel4/lib/float.pcert0 : no_pcert = 0
-rtl/rel4/lib/float.pcert0 : acl2x = 0
-rtl/rel4/lib/float.pcert0 : \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/lib/bits.pcert0 \
- rtl/rel4/lib/float.lisp
-rtl/rel4/lib/float.pcert1 : acl2x = 0
-rtl/rel4/lib/float.pcert1 : no_pcert = 0
-rtl/rel4/lib/float.pcert1 : rtl/rel4/lib/float.pcert0
-rtl/rel4/lib/float.cert : | rtl/rel4/lib/float.pcert1
-
-rtl/rel4/lib/openers.pcert0 : no_pcert = 0
-rtl/rel4/lib/openers.pcert0 : acl2x = 0
-rtl/rel4/lib/openers.pcert0 : \
- rtl/rel4/support/openers.pcert0 \
- rtl/rel4/lib/openers.lisp
-rtl/rel4/lib/openers.pcert1 : acl2x = 0
-rtl/rel4/lib/openers.pcert1 : no_pcert = 0
-rtl/rel4/lib/openers.pcert1 : rtl/rel4/lib/openers.pcert0
-rtl/rel4/lib/openers.cert : | rtl/rel4/lib/openers.pcert1
-
-rtl/rel4/lib/package-defs.pcert0 : no_pcert = 0
-rtl/rel4/lib/package-defs.pcert0 : acl2x = 0
-rtl/rel4/lib/package-defs.pcert0 : \
- rtl/rel4/support/package-defs.pcert0 \
- rtl/rel4/lib/package-defs.lisp
-rtl/rel4/lib/package-defs.pcert1 : acl2x = 0
-rtl/rel4/lib/package-defs.pcert1 : no_pcert = 0
-rtl/rel4/lib/package-defs.pcert1 : rtl/rel4/lib/package-defs.pcert0
-rtl/rel4/lib/package-defs.cert : | rtl/rel4/lib/package-defs.pcert1
-
-rtl/rel4/lib/reps.pcert0 : no_pcert = 0
-rtl/rel4/lib/reps.pcert0 : acl2x = 0
-rtl/rel4/lib/reps.pcert0 : \
- rtl/rel4/support/ereps.pcert0 \
- rtl/rel4/support/ireps.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/lib/float.pcert0 \
- rtl/rel4/lib/reps.lisp
-rtl/rel4/lib/reps.pcert1 : acl2x = 0
-rtl/rel4/lib/reps.pcert1 : no_pcert = 0
-rtl/rel4/lib/reps.pcert1 : rtl/rel4/lib/reps.pcert0
-rtl/rel4/lib/reps.cert : | rtl/rel4/lib/reps.pcert1
-
-rtl/rel4/lib/rom-helpers.pcert0 : no_pcert = 0
-rtl/rel4/lib/rom-helpers.pcert0 : acl2x = 0
-rtl/rel4/lib/rom-helpers.pcert0 : \
- rtl/rel4/support/rom-helpers.pcert0 \
- rtl/rel4/lib/rom-helpers.lisp
-rtl/rel4/lib/rom-helpers.pcert1 : acl2x = 0
-rtl/rel4/lib/rom-helpers.pcert1 : no_pcert = 0
-rtl/rel4/lib/rom-helpers.pcert1 : rtl/rel4/lib/rom-helpers.pcert0
-rtl/rel4/lib/rom-helpers.cert : | rtl/rel4/lib/rom-helpers.pcert1
-
-rtl/rel4/lib/round.pcert0 : no_pcert = 0
-rtl/rel4/lib/round.pcert0 : acl2x = 0
-rtl/rel4/lib/round.pcert0 : \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/support/away.pcert0 \
- rtl/rel4/support/near.pcert0 \
- rtl/rel4/support/near+.pcert0 \
- rtl/rel4/support/oddr.pcert0 \
- rtl/rel4/support/rnd.pcert0 \
- rtl/rel4/support/drnd.pcert0 \
- rtl/rel4/support/bits-trunc.pcert0 \
- rtl/rel4/support/sticky.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/lib/reps.pcert0 \
- rtl/rel4/lib/round.lisp
-rtl/rel4/lib/round.pcert1 : acl2x = 0
-rtl/rel4/lib/round.pcert1 : no_pcert = 0
-rtl/rel4/lib/round.pcert1 : rtl/rel4/lib/round.pcert0
-rtl/rel4/lib/round.cert : | rtl/rel4/lib/round.pcert1
-
-rtl/rel4/lib/rtl.pcert0 : no_pcert = 0
-rtl/rel4/lib/rtl.pcert0 : acl2x = 0
-rtl/rel4/lib/rtl.pcert0 : \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/mulcat.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/lib/rtl.lisp
-rtl/rel4/lib/rtl.pcert1 : acl2x = 0
-rtl/rel4/lib/rtl.pcert1 : no_pcert = 0
-rtl/rel4/lib/rtl.pcert1 : rtl/rel4/lib/rtl.pcert0
-rtl/rel4/lib/rtl.cert : | rtl/rel4/lib/rtl.pcert1
-
-rtl/rel4/lib/rtlarr.pcert0 : no_pcert = 0
-rtl/rel4/lib/rtlarr.pcert0 : acl2x = 0
-rtl/rel4/lib/rtlarr.pcert0 : \
- rtl/rel4/support/rtlarr.pcert0 \
- rtl/rel4/support/bvecp-helpers.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- misc/total-order.pcert0 \
- rtl/rel4/lib/rtl.pcert0 \
- rtl/rel4/lib/rtlarr.lisp
-rtl/rel4/lib/rtlarr.pcert1 : acl2x = 0
-rtl/rel4/lib/rtlarr.pcert1 : no_pcert = 0
-rtl/rel4/lib/rtlarr.pcert1 : rtl/rel4/lib/rtlarr.pcert0
-rtl/rel4/lib/rtlarr.cert : | rtl/rel4/lib/rtlarr.pcert1
-
-rtl/rel4/lib/simple-loop-helpers.pcert0 : no_pcert = 0
-rtl/rel4/lib/simple-loop-helpers.pcert0 : acl2x = 0
-rtl/rel4/lib/simple-loop-helpers.pcert0 : \
- rtl/rel4/lib/rtl.pcert0 \
- rtl/rel4/lib/rtlarr.pcert0 \
- rtl/rel4/lib/arith.pcert0 \
- rtl/rel4/lib/bits.pcert0 \
- rtl/rel4/support/simple-loop-helpers.pcert0 \
- rtl/rel4/lib/simple-loop-helpers.lisp
-rtl/rel4/lib/simple-loop-helpers.pcert1 : acl2x = 0
-rtl/rel4/lib/simple-loop-helpers.pcert1 : no_pcert = 0
-rtl/rel4/lib/simple-loop-helpers.pcert1 : rtl/rel4/lib/simple-loop-helpers.pcert0
-rtl/rel4/lib/simple-loop-helpers.cert : | rtl/rel4/lib/simple-loop-helpers.pcert1
-
-rtl/rel4/lib/simplify-model-helpers.pcert0 : no_pcert = 0
-rtl/rel4/lib/simplify-model-helpers.pcert0 : acl2x = 0
-rtl/rel4/lib/simplify-model-helpers.pcert0 : \
- rtl/rel4/lib/rtl.pcert0 \
- rtl/rel4/lib/arith.pcert0 \
- rtl/rel4/lib/bits.pcert0 \
- rtl/rel4/support/simplify-model-helpers.pcert0 \
- rtl/rel4/lib/simplify-model-helpers.lisp
-rtl/rel4/lib/simplify-model-helpers.pcert1 : acl2x = 0
-rtl/rel4/lib/simplify-model-helpers.pcert1 : no_pcert = 0
-rtl/rel4/lib/simplify-model-helpers.pcert1 : rtl/rel4/lib/simplify-model-helpers.pcert0
-rtl/rel4/lib/simplify-model-helpers.cert : | rtl/rel4/lib/simplify-model-helpers.pcert1
-
-rtl/rel4/lib/top.pcert0 : no_pcert = 0
-rtl/rel4/lib/top.pcert0 : acl2x = 0
-rtl/rel4/lib/top.pcert0 : \
- rtl/rel4/lib/rtl.pcert0 \
- rtl/rel4/lib/rtlarr.pcert0 \
- rtl/rel4/lib/basic.pcert0 \
- rtl/rel4/lib/bits.pcert0 \
- rtl/rel4/lib/float.pcert0 \
- rtl/rel4/lib/reps.pcert0 \
- rtl/rel4/lib/round.pcert0 \
- rtl/rel4/lib/fadd.pcert0 \
- rtl/rel4/lib/arith.pcert0 \
- rtl/rel4/lib/util.pcert0 \
- rtl/rel4/lib/top.lisp
-rtl/rel4/lib/top.pcert1 : acl2x = 0
-rtl/rel4/lib/top.pcert1 : no_pcert = 0
-rtl/rel4/lib/top.pcert1 : rtl/rel4/lib/top.pcert0
-rtl/rel4/lib/top.cert : | rtl/rel4/lib/top.pcert1
-
-rtl/rel4/lib/util.pcert0 : no_pcert = 0
-rtl/rel4/lib/util.pcert0 : acl2x = 0
-rtl/rel4/lib/util.pcert0 : \
- rtl/rel4/support/util.pcert0 \
- rtl/rel4/lib/util.lisp
-rtl/rel4/lib/util.pcert1 : acl2x = 0
-rtl/rel4/lib/util.pcert1 : no_pcert = 0
-rtl/rel4/lib/util.pcert1 : rtl/rel4/lib/util.pcert0
-rtl/rel4/lib/util.cert : | rtl/rel4/lib/util.pcert1
-
-rtl/rel4/support/add3-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/add3-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/add3-proofs.pcert0 : \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/lxor.pcert0 \
- rtl/rel4/support/add3-proofs.lisp
-rtl/rel4/support/add3-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/add3-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/add3-proofs.pcert1 : rtl/rel4/support/add3-proofs.pcert0
-rtl/rel4/support/add3-proofs.cert : | rtl/rel4/support/add3-proofs.pcert1
-
-rtl/rel4/support/add3.pcert0 : no_pcert = 0
-rtl/rel4/support/add3.pcert0 : acl2x = 0
-rtl/rel4/support/add3.pcert0 : \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/add3-proofs.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/lxor.pcert0 \
- rtl/rel4/support/add3.lisp
-rtl/rel4/support/add3.pcert1 : acl2x = 0
-rtl/rel4/support/add3.pcert1 : no_pcert = 0
-rtl/rel4/support/add3.pcert1 : rtl/rel4/support/add3.pcert0
-rtl/rel4/support/add3.cert : | rtl/rel4/support/add3.pcert1
-
-rtl/rel4/support/all-ones.pcert0 : no_pcert = 0
-rtl/rel4/support/all-ones.pcert0 : acl2x = 0
-rtl/rel4/support/all-ones.pcert0 : \
- rtl/rel4/support/all-ones.lisp
-rtl/rel4/support/all-ones.pcert1 : acl2x = 0
-rtl/rel4/support/all-ones.pcert1 : no_pcert = 0
-rtl/rel4/support/all-ones.pcert1 : rtl/rel4/support/all-ones.pcert0
-rtl/rel4/support/all-ones.cert : | rtl/rel4/support/all-ones.pcert1
-
-rtl/rel4/support/ash.pcert0 : no_pcert = 0
-rtl/rel4/support/ash.pcert0 : acl2x = 0
-rtl/rel4/support/ash.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/expt.pcert0 \
- rtl/rel4/arithmetic/expo.pcert0 \
- rtl/rel4/support/ash.lisp
-rtl/rel4/support/ash.pcert1 : acl2x = 0
-rtl/rel4/support/ash.pcert1 : no_pcert = 0
-rtl/rel4/support/ash.pcert1 : rtl/rel4/support/ash.pcert0
-rtl/rel4/support/ash.cert : | rtl/rel4/support/ash.pcert1
-
-rtl/rel4/support/away-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/away-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/away-proofs.pcert0 : \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/away-proofs.lisp
-rtl/rel4/support/away-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/away-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/away-proofs.pcert1 : rtl/rel4/support/away-proofs.pcert0
-rtl/rel4/support/away-proofs.cert : | rtl/rel4/support/away-proofs.pcert1
-
-rtl/rel4/support/away.pcert0 : no_pcert = 0
-rtl/rel4/support/away.pcert0 : acl2x = 0
-rtl/rel4/support/away.pcert0 : \
- rtl/rel4/support/away-proofs.pcert0 \
- rtl/rel4/support/away.lisp
-rtl/rel4/support/away.pcert1 : acl2x = 0
-rtl/rel4/support/away.pcert1 : no_pcert = 0
-rtl/rel4/support/away.pcert1 : rtl/rel4/support/away.pcert0
-rtl/rel4/support/away.cert : | rtl/rel4/support/away.pcert1
-
-rtl/rel4/support/badguys.pcert0 : no_pcert = 0
-rtl/rel4/support/badguys.pcert0 : acl2x = 0
-rtl/rel4/support/badguys.pcert0 : \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/badguys.lisp
-rtl/rel4/support/badguys.pcert1 : acl2x = 0
-rtl/rel4/support/badguys.pcert1 : no_pcert = 0
-rtl/rel4/support/badguys.pcert1 : rtl/rel4/support/badguys.pcert0
-rtl/rel4/support/badguys.cert : | rtl/rel4/support/badguys.pcert1
-
-rtl/rel4/support/bias-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/bias-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/bias-proofs.pcert0 : \
- rtl/rel4/arithmetic/expt.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/support/bias-proofs.lisp
-rtl/rel4/support/bias-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/bias-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/bias-proofs.pcert1 : rtl/rel4/support/bias-proofs.pcert0
-rtl/rel4/support/bias-proofs.cert : | rtl/rel4/support/bias-proofs.pcert1
-
-rtl/rel4/support/bias.pcert0 : no_pcert = 0
-rtl/rel4/support/bias.pcert0 : acl2x = 0
-rtl/rel4/support/bias.pcert0 : \
- rtl/rel4/support/bias-proofs.pcert0 \
- rtl/rel4/support/bias.lisp
-rtl/rel4/support/bias.pcert1 : acl2x = 0
-rtl/rel4/support/bias.pcert1 : no_pcert = 0
-rtl/rel4/support/bias.pcert1 : rtl/rel4/support/bias.pcert0
-rtl/rel4/support/bias.cert : | rtl/rel4/support/bias.pcert1
-
-rtl/rel4/support/bitn-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/bitn-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/bitn-proofs.pcert0 : \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/bitn-proofs.lisp
-rtl/rel4/support/bitn-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/bitn-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/bitn-proofs.pcert1 : rtl/rel4/support/bitn-proofs.pcert0
-rtl/rel4/support/bitn-proofs.cert : | rtl/rel4/support/bitn-proofs.pcert1
-
-rtl/rel4/support/bitn.pcert0 : no_pcert = 0
-rtl/rel4/support/bitn.pcert0 : acl2x = 0
-rtl/rel4/support/bitn.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/support/bitn-proofs.pcert0 \
- rtl/rel4/support/bitn.lisp
-rtl/rel4/support/bitn.pcert1 : acl2x = 0
-rtl/rel4/support/bitn.pcert1 : no_pcert = 0
-rtl/rel4/support/bitn.pcert1 : rtl/rel4/support/bitn.pcert0
-rtl/rel4/support/bitn.cert : | rtl/rel4/support/bitn.pcert1
-
-rtl/rel4/support/bits-extra.pcert0 : no_pcert = 0
-rtl/rel4/support/bits-extra.pcert0 : acl2x = 0
-rtl/rel4/support/bits-extra.pcert0 : \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/fadd.pcert0 \
- rtl/rel4/support/top1.pcert0 \
- rtl/rel4/support/bits-extra.lisp
-rtl/rel4/support/bits-extra.pcert1 : acl2x = 0
-rtl/rel4/support/bits-extra.pcert1 : no_pcert = 0
-rtl/rel4/support/bits-extra.pcert1 : rtl/rel4/support/bits-extra.pcert0
-rtl/rel4/support/bits-extra.cert : | rtl/rel4/support/bits-extra.pcert1
-
-rtl/rel4/support/bits-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/bits-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/bits-proofs.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/bits-proofs.lisp
-rtl/rel4/support/bits-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/bits-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/bits-proofs.pcert1 : rtl/rel4/support/bits-proofs.pcert0
-rtl/rel4/support/bits-proofs.cert : | rtl/rel4/support/bits-proofs.pcert1
-
-rtl/rel4/support/bits-trunc-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/bits-trunc-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/bits-trunc-proofs.pcert0 : \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/support/log.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/bits-trunc-proofs.lisp
-rtl/rel4/support/bits-trunc-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/bits-trunc-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/bits-trunc-proofs.pcert1 : rtl/rel4/support/bits-trunc-proofs.pcert0
-rtl/rel4/support/bits-trunc-proofs.cert : | rtl/rel4/support/bits-trunc-proofs.pcert1
-
-rtl/rel4/support/bits-trunc.pcert0 : no_pcert = 0
-rtl/rel4/support/bits-trunc.pcert0 : acl2x = 0
-rtl/rel4/support/bits-trunc.pcert0 : \
- rtl/rel4/support/log.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/bits-trunc-proofs.pcert0 \
- rtl/rel4/support/bits-trunc.lisp
-rtl/rel4/support/bits-trunc.pcert1 : acl2x = 0
-rtl/rel4/support/bits-trunc.pcert1 : no_pcert = 0
-rtl/rel4/support/bits-trunc.pcert1 : rtl/rel4/support/bits-trunc.pcert0
-rtl/rel4/support/bits-trunc.cert : | rtl/rel4/support/bits-trunc.pcert1
-
-rtl/rel4/support/bits.pcert0 : no_pcert = 0
-rtl/rel4/support/bits.pcert0 : acl2x = 0
-rtl/rel4/support/bits.pcert0 : \
- rtl/rel4/support/bits-proofs.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/support/bits.lisp
-rtl/rel4/support/bits.pcert1 : acl2x = 0
-rtl/rel4/support/bits.pcert1 : no_pcert = 0
-rtl/rel4/support/bits.pcert1 : rtl/rel4/support/bits.pcert0
-rtl/rel4/support/bits.cert : | rtl/rel4/support/bits.pcert1
-
-rtl/rel4/support/bvecp-helpers.pcert0 : no_pcert = 0
-rtl/rel4/support/bvecp-helpers.pcert0 : acl2x = 0
-rtl/rel4/support/bvecp-helpers.pcert0 : \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/bvecp-lemmas.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bvecp-helpers.lisp
-rtl/rel4/support/bvecp-helpers.pcert1 : acl2x = 0
-rtl/rel4/support/bvecp-helpers.pcert1 : no_pcert = 0
-rtl/rel4/support/bvecp-helpers.pcert1 : rtl/rel4/support/bvecp-helpers.pcert0
-rtl/rel4/support/bvecp-helpers.cert : | rtl/rel4/support/bvecp-helpers.pcert1
-
-rtl/rel4/support/bvecp-lemmas.pcert0 : no_pcert = 0
-rtl/rel4/support/bvecp-lemmas.pcert0 : acl2x = 0
-rtl/rel4/support/bvecp-lemmas.pcert0 : \
- rtl/rel4/arithmetic/expo.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/setbits.pcert0 \
- rtl/rel4/support/setbitn.pcert0 \
- rtl/rel4/support/encode.pcert0 \
- rtl/rel4/support/decode.pcert0 \
- rtl/rel4/support/logs.pcert0 \
- rtl/rel4/support/lnot.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/shft.pcert0 \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/mulcat.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/lxor.pcert0 \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/bvecp-lemmas.lisp
-rtl/rel4/support/bvecp-lemmas.pcert1 : acl2x = 0
-rtl/rel4/support/bvecp-lemmas.pcert1 : no_pcert = 0
-rtl/rel4/support/bvecp-lemmas.pcert1 : rtl/rel4/support/bvecp-lemmas.pcert0
-rtl/rel4/support/bvecp-lemmas.cert : | rtl/rel4/support/bvecp-lemmas.pcert1
-
-rtl/rel4/support/bvecp-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/bvecp-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/bvecp-proofs.pcert0 : \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bvecp-proofs.lisp
-rtl/rel4/support/bvecp-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/bvecp-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/bvecp-proofs.pcert1 : rtl/rel4/support/bvecp-proofs.pcert0
-rtl/rel4/support/bvecp-proofs.cert : | rtl/rel4/support/bvecp-proofs.pcert1
-
-rtl/rel4/support/bvecp.pcert0 : no_pcert = 0
-rtl/rel4/support/bvecp.pcert0 : acl2x = 0
-rtl/rel4/support/bvecp.pcert0 : \
- rtl/rel4/support/bvecp-proofs.pcert0 \
- rtl/rel4/support/bvecp.lisp
-rtl/rel4/support/bvecp.pcert1 : acl2x = 0
-rtl/rel4/support/bvecp.pcert1 : no_pcert = 0
-rtl/rel4/support/bvecp.pcert1 : rtl/rel4/support/bvecp.pcert0
-rtl/rel4/support/bvecp.cert : | rtl/rel4/support/bvecp.pcert1
-
-rtl/rel4/support/cat-def.pcert0 : no_pcert = 0
-rtl/rel4/support/cat-def.pcert0 : acl2x = 0
-rtl/rel4/support/cat-def.pcert0 : \
- rtl/rel4/support/cat-def.lisp
-rtl/rel4/support/cat-def.pcert1 : acl2x = 0
-rtl/rel4/support/cat-def.pcert1 : no_pcert = 0
-rtl/rel4/support/cat-def.pcert1 : rtl/rel4/support/cat-def.pcert0
-rtl/rel4/support/cat-def.cert : | rtl/rel4/support/cat-def.pcert1
-
-rtl/rel4/support/cat-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/cat-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/cat-proofs.pcert0 : \
- rtl/rel4/support/cat-def.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/cat-proofs.lisp
-rtl/rel4/support/cat-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/cat-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/cat-proofs.pcert1 : rtl/rel4/support/cat-proofs.pcert0
-rtl/rel4/support/cat-proofs.cert : | rtl/rel4/support/cat-proofs.pcert1
-
-rtl/rel4/support/cat.pcert0 : no_pcert = 0
-rtl/rel4/support/cat.pcert0 : acl2x = 0
-rtl/rel4/support/cat.pcert0 : \
- rtl/rel4/support/cat-def.pcert0 \
- rtl/rel4/support/cat-proofs.pcert0 \
- rtl/rel4/support/cat.lisp
-rtl/rel4/support/cat.pcert1 : acl2x = 0
-rtl/rel4/support/cat.pcert1 : no_pcert = 0
-rtl/rel4/support/cat.pcert1 : rtl/rel4/support/cat.pcert0
-rtl/rel4/support/cat.cert : | rtl/rel4/support/cat.pcert1
-
-rtl/rel4/support/clocks.pcert0 : no_pcert = 0
-rtl/rel4/support/clocks.pcert0 : acl2x = 0
-rtl/rel4/support/clocks.pcert0 : \
- rtl/rel4/support/mod4.pcert0 \
- rtl/rel4/arithmetic/even-odd2.pcert0 \
- rtl/rel4/support/clocks.lisp
-rtl/rel4/support/clocks.pcert1 : acl2x = 0
-rtl/rel4/support/clocks.pcert1 : no_pcert = 0
-rtl/rel4/support/clocks.pcert1 : rtl/rel4/support/clocks.pcert0
-rtl/rel4/support/clocks.cert : | rtl/rel4/support/clocks.pcert1
-
-rtl/rel4/support/decode-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/decode-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/decode-proofs.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/support/ash.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/decode-proofs.lisp
-rtl/rel4/support/decode-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/decode-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/decode-proofs.pcert1 : rtl/rel4/support/decode-proofs.pcert0
-rtl/rel4/support/decode-proofs.cert : | rtl/rel4/support/decode-proofs.pcert1
-
-rtl/rel4/support/decode.pcert0 : no_pcert = 0
-rtl/rel4/support/decode.pcert0 : acl2x = 0
-rtl/rel4/support/decode.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/decode-proofs.pcert0 \
- rtl/rel4/support/decode.lisp
-rtl/rel4/support/decode.pcert1 : acl2x = 0
-rtl/rel4/support/decode.pcert1 : no_pcert = 0
-rtl/rel4/support/decode.pcert1 : rtl/rel4/support/decode.pcert0
-rtl/rel4/support/decode.cert : | rtl/rel4/support/decode.pcert1
-
-rtl/rel4/support/drnd.pcert0 : no_pcert = 0
-rtl/rel4/support/drnd.pcert0 : acl2x = 0
-rtl/rel4/support/drnd.pcert0 : \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/ireps.pcert0 \
- rtl/rel4/support/rnd.pcert0 \
- rtl/rel4/support/bias.pcert0 \
- rtl/rel4/support/sgn.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/support/away.pcert0 \
- rtl/rel4/support/near.pcert0 \
- rtl/rel4/support/near+.pcert0 \
- rtl/rel4/support/sticky.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/drnd.lisp
-rtl/rel4/support/drnd.pcert1 : acl2x = 0
-rtl/rel4/support/drnd.pcert1 : no_pcert = 0
-rtl/rel4/support/drnd.pcert1 : rtl/rel4/support/drnd.pcert0
-rtl/rel4/support/drnd.cert : | rtl/rel4/support/drnd.pcert1
-
-rtl/rel4/support/encode.pcert0 : no_pcert = 0
-rtl/rel4/support/encode.pcert0 : acl2x = 0
-rtl/rel4/support/encode.pcert0 : \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/ash.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/encode.lisp
-rtl/rel4/support/encode.pcert1 : acl2x = 0
-rtl/rel4/support/encode.pcert1 : no_pcert = 0
-rtl/rel4/support/encode.pcert1 : rtl/rel4/support/encode.pcert0
-rtl/rel4/support/encode.cert : | rtl/rel4/support/encode.pcert1
-
-rtl/rel4/support/ereps-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/ereps-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/ereps-proofs.pcert0 : \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/bias.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/mulcat.pcert0 \
- rtl/rel4/support/ereps-proofs.lisp
-rtl/rel4/support/ereps-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/ereps-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/ereps-proofs.pcert1 : rtl/rel4/support/ereps-proofs.pcert0
-rtl/rel4/support/ereps-proofs.cert : | rtl/rel4/support/ereps-proofs.pcert1
-
-rtl/rel4/support/ereps.pcert0 : no_pcert = 0
-rtl/rel4/support/ereps.pcert0 : acl2x = 0
-rtl/rel4/support/ereps.pcert0 : \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/ereps-proofs.pcert0 \
- rtl/rel4/support/ereps.lisp
-rtl/rel4/support/ereps.pcert1 : acl2x = 0
-rtl/rel4/support/ereps.pcert1 : no_pcert = 0
-rtl/rel4/support/ereps.pcert1 : rtl/rel4/support/ereps.pcert0
-rtl/rel4/support/ereps.cert : | rtl/rel4/support/ereps.pcert1
-
-rtl/rel4/support/fadd.pcert0 : no_pcert = 0
-rtl/rel4/support/fadd.pcert0 : acl2x = 0
-rtl/rel4/support/fadd.pcert0 : \
- rtl/rel4/support/stick.pcert0 \
- rtl/rel4/support/lop3.pcert0 \
- rtl/rel4/support/add3.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/lextra.pcert0 \
- rtl/rel4/support/fadd.lisp
-rtl/rel4/support/fadd.pcert1 : acl2x = 0
-rtl/rel4/support/fadd.pcert1 : no_pcert = 0
-rtl/rel4/support/fadd.pcert1 : rtl/rel4/support/fadd.pcert0
-rtl/rel4/support/fadd.cert : | rtl/rel4/support/fadd.pcert1
-
-rtl/rel4/support/fast-and.pcert0 : no_pcert = 0
-rtl/rel4/support/fast-and.pcert0 : acl2x = 0
-rtl/rel4/support/fast-and.pcert0 : \
- rtl/rel4/support/fast-and.lisp
-rtl/rel4/support/fast-and.pcert1 : acl2x = 0
-rtl/rel4/support/fast-and.pcert1 : no_pcert = 0
-rtl/rel4/support/fast-and.pcert1 : rtl/rel4/support/fast-and.pcert0
-rtl/rel4/support/fast-and.cert : | rtl/rel4/support/fast-and.pcert1
-
-rtl/rel4/support/float.pcert0 : no_pcert = 0
-rtl/rel4/support/float.pcert0 : acl2x = 0
-rtl/rel4/support/float.pcert0 : \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/basic.pcert0 \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/cg.pcert0 \
- rtl/rel4/support/float.lisp
-rtl/rel4/support/float.pcert1 : acl2x = 0
-rtl/rel4/support/float.pcert1 : no_pcert = 0
-rtl/rel4/support/float.pcert1 : rtl/rel4/support/float.pcert0
-rtl/rel4/support/float.cert : | rtl/rel4/support/float.pcert1
-
-rtl/rel4/support/ground-zero.pcert0 : no_pcert = 0
-rtl/rel4/support/ground-zero.pcert0 : acl2x = 0
-rtl/rel4/support/ground-zero.pcert0 : \
- rtl/rel4/arithmetic/ground-zero.pcert0 \
- rtl/rel4/support/util.pcert0 \
- rtl/rel4/support/ground-zero.lisp
-rtl/rel4/support/ground-zero.pcert1 : acl2x = 0
-rtl/rel4/support/ground-zero.pcert1 : no_pcert = 0
-rtl/rel4/support/ground-zero.pcert1 : rtl/rel4/support/ground-zero.pcert0
-rtl/rel4/support/ground-zero.cert : | rtl/rel4/support/ground-zero.pcert1
-
-rtl/rel4/support/guards.pcert0 : no_pcert = 0
-rtl/rel4/support/guards.pcert0 : acl2x = 0
-rtl/rel4/support/guards.pcert0 : \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/top1.pcert0 \
- rtl/rel4/support/guards.lisp
-rtl/rel4/support/guards.pcert1 : acl2x = 0
-rtl/rel4/support/guards.pcert1 : no_pcert = 0
-rtl/rel4/support/guards.pcert1 : rtl/rel4/support/guards.pcert0
-rtl/rel4/support/guards.cert : | rtl/rel4/support/guards.pcert1
-
-rtl/rel4/support/ireps.pcert0 : no_pcert = 0
-rtl/rel4/support/ireps.pcert0 : acl2x = 0
-rtl/rel4/support/ireps.pcert0 : \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/bias.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/ireps.lisp
-rtl/rel4/support/ireps.pcert1 : acl2x = 0
-rtl/rel4/support/ireps.pcert1 : no_pcert = 0
-rtl/rel4/support/ireps.pcert1 : rtl/rel4/support/ireps.pcert0
-rtl/rel4/support/ireps.cert : | rtl/rel4/support/ireps.pcert1
-
-rtl/rel4/support/land-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/land-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/land-proofs.pcert0 : \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/all-ones.pcert0 \
- rtl/rel4/support/log.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/land-proofs.lisp
-rtl/rel4/support/land-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/land-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/land-proofs.pcert1 : rtl/rel4/support/land-proofs.pcert0
-rtl/rel4/support/land-proofs.cert : | rtl/rel4/support/land-proofs.pcert1
-
-rtl/rel4/support/land.pcert0 : no_pcert = 0
-rtl/rel4/support/land.pcert0 : acl2x = 0
-rtl/rel4/support/land.pcert0 : \
- rtl/rel4/support/land-proofs.pcert0 \
- rtl/rel4/support/land.lisp
-rtl/rel4/support/land.pcert1 : acl2x = 0
-rtl/rel4/support/land.pcert1 : no_pcert = 0
-rtl/rel4/support/land.pcert1 : rtl/rel4/support/land.pcert0
-rtl/rel4/support/land.cert : | rtl/rel4/support/land.pcert1
-
-rtl/rel4/support/lextra-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/lextra-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/lextra-proofs.pcert0 : \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/lxor.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- rtl/rel4/support/logior.pcert0 \
- rtl/rel4/support/logxor.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/lextra-proofs.lisp
-rtl/rel4/support/lextra-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/lextra-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/lextra-proofs.pcert1 : rtl/rel4/support/lextra-proofs.pcert0
-rtl/rel4/support/lextra-proofs.cert : | rtl/rel4/support/lextra-proofs.pcert1
-
-rtl/rel4/support/lextra.pcert0 : no_pcert = 0
-rtl/rel4/support/lextra.pcert0 : acl2x = 0
-rtl/rel4/support/lextra.pcert0 : \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/lxor.pcert0 \
- rtl/rel4/support/lextra-proofs.pcert0 \
- rtl/rel4/support/lextra.lisp
-rtl/rel4/support/lextra.pcert1 : acl2x = 0
-rtl/rel4/support/lextra.pcert1 : no_pcert = 0
-rtl/rel4/support/lextra.pcert1 : rtl/rel4/support/lextra.pcert0
-rtl/rel4/support/lextra.cert : | rtl/rel4/support/lextra.pcert1
-
-rtl/rel4/support/lior-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/lior-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/lior-proofs.pcert0 : \
- rtl/rel4/support/all-ones.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/logior.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/lior-proofs.lisp
-rtl/rel4/support/lior-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/lior-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/lior-proofs.pcert1 : rtl/rel4/support/lior-proofs.pcert0
-rtl/rel4/support/lior-proofs.cert : | rtl/rel4/support/lior-proofs.pcert1
-
-rtl/rel4/support/lior.pcert0 : no_pcert = 0
-rtl/rel4/support/lior.pcert0 : acl2x = 0
-rtl/rel4/support/lior.pcert0 : \
- rtl/rel4/support/lior-proofs.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/lior.lisp
-rtl/rel4/support/lior.pcert1 : acl2x = 0
-rtl/rel4/support/lior.pcert1 : no_pcert = 0
-rtl/rel4/support/lior.pcert1 : rtl/rel4/support/lior.pcert0
-rtl/rel4/support/lior.cert : | rtl/rel4/support/lior.pcert1
-
-rtl/rel4/support/lnot-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/lnot-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/lnot-proofs.pcert0 : \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/arithmetic/expt.pcert0 \
- rtl/rel4/arithmetic/mod.pcert0 \
- rtl/rel4/arithmetic/mod.pcert0 \
- rtl/rel4/arithmetic/arith.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/lnot-proofs.lisp
-rtl/rel4/support/lnot-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/lnot-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/lnot-proofs.pcert1 : rtl/rel4/support/lnot-proofs.pcert0
-rtl/rel4/support/lnot-proofs.cert : | rtl/rel4/support/lnot-proofs.pcert1
-
-rtl/rel4/support/lnot.pcert0 : no_pcert = 0
-rtl/rel4/support/lnot.pcert0 : acl2x = 0
-rtl/rel4/support/lnot.pcert0 : \
- rtl/rel4/support/lnot-proofs.pcert0 \
- rtl/rel4/support/lnot.lisp
-rtl/rel4/support/lnot.pcert1 : acl2x = 0
-rtl/rel4/support/lnot.pcert1 : no_pcert = 0
-rtl/rel4/support/lnot.pcert1 : rtl/rel4/support/lnot.pcert0
-rtl/rel4/support/lnot.cert : | rtl/rel4/support/lnot.pcert1
-
-rtl/rel4/support/log-equal.pcert0 : no_pcert = 0
-rtl/rel4/support/log-equal.pcert0 : acl2x = 0
-rtl/rel4/support/log-equal.pcert0 : \
- rtl/rel4/support/log-equal.lisp
-rtl/rel4/support/log-equal.pcert1 : acl2x = 0
-rtl/rel4/support/log-equal.pcert1 : no_pcert = 0
-rtl/rel4/support/log-equal.pcert1 : rtl/rel4/support/log-equal.pcert0
-rtl/rel4/support/log-equal.cert : | rtl/rel4/support/log-equal.pcert1
-
-rtl/rel4/support/log-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/log-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/log-proofs.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/lognot.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/lnot.pcert0 \
- rtl/rel4/support/logior.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- rtl/rel4/support/logxor.pcert0 \
- rtl/rel4/support/log-proofs.lisp
-rtl/rel4/support/log-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/log-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/log-proofs.pcert1 : rtl/rel4/support/log-proofs.pcert0
-rtl/rel4/support/log-proofs.cert : | rtl/rel4/support/log-proofs.pcert1
-
-rtl/rel4/support/log.pcert0 : no_pcert = 0
-rtl/rel4/support/log.pcert0 : acl2x = 0
-rtl/rel4/support/log.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/log-proofs.pcert0 \
- rtl/rel4/support/lnot.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- rtl/rel4/support/logior.pcert0 \
- rtl/rel4/support/logxor.pcert0 \
- rtl/rel4/support/log.lisp
-rtl/rel4/support/log.pcert1 : acl2x = 0
-rtl/rel4/support/log.pcert1 : no_pcert = 0
-rtl/rel4/support/log.pcert1 : rtl/rel4/support/log.pcert0
-rtl/rel4/support/log.cert : | rtl/rel4/support/log.pcert1
-
-rtl/rel4/support/logand-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/logand-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/logand-proofs.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/arithmetic/induct.pcert0 \
- rtl/rel4/support/lognot.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/logand-proofs.lisp
-rtl/rel4/support/logand-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/logand-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/logand-proofs.pcert1 : rtl/rel4/support/logand-proofs.pcert0
-rtl/rel4/support/logand-proofs.cert : | rtl/rel4/support/logand-proofs.pcert1
-
-rtl/rel4/support/logand.pcert0 : no_pcert = 0
-rtl/rel4/support/logand.pcert0 : acl2x = 0
-rtl/rel4/support/logand.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/logand-proofs.pcert0 \
- rtl/rel4/support/logand.lisp
-rtl/rel4/support/logand.pcert1 : acl2x = 0
-rtl/rel4/support/logand.pcert1 : no_pcert = 0
-rtl/rel4/support/logand.pcert1 : rtl/rel4/support/logand.pcert0
-rtl/rel4/support/logand.cert : | rtl/rel4/support/logand.pcert1
-
-rtl/rel4/support/logeqv.pcert0 : no_pcert = 0
-rtl/rel4/support/logeqv.pcert0 : acl2x = 0
-rtl/rel4/support/logeqv.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/logior.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- rtl/rel4/support/logorc1.pcert0 \
- rtl/rel4/support/lognot.pcert0 \
- rtl/rel4/support/logeqv.lisp
-rtl/rel4/support/logeqv.pcert1 : acl2x = 0
-rtl/rel4/support/logeqv.pcert1 : no_pcert = 0
-rtl/rel4/support/logeqv.pcert1 : rtl/rel4/support/logeqv.pcert0
-rtl/rel4/support/logeqv.cert : | rtl/rel4/support/logeqv.pcert1
-
-rtl/rel4/support/logior-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/logior-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/logior-proofs.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- rtl/rel4/support/lognot.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/logior-proofs.lisp
-rtl/rel4/support/logior-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/logior-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/logior-proofs.pcert1 : rtl/rel4/support/logior-proofs.pcert0
-rtl/rel4/support/logior-proofs.cert : | rtl/rel4/support/logior-proofs.pcert1
-
-rtl/rel4/support/logior.pcert0 : no_pcert = 0
-rtl/rel4/support/logior.pcert0 : acl2x = 0
-rtl/rel4/support/logior.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/logior-proofs.pcert0 \
- rtl/rel4/support/logior.lisp
-rtl/rel4/support/logior.pcert1 : acl2x = 0
-rtl/rel4/support/logior.pcert1 : no_pcert = 0
-rtl/rel4/support/logior.pcert1 : rtl/rel4/support/logior.pcert0
-rtl/rel4/support/logior.cert : | rtl/rel4/support/logior.pcert1
-
-rtl/rel4/support/logior1-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/logior1-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/logior1-proofs.pcert0 : \
- rtl/rel4/support/logior1-proofs.lisp
-rtl/rel4/support/logior1-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/logior1-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/logior1-proofs.pcert1 : rtl/rel4/support/logior1-proofs.pcert0
-rtl/rel4/support/logior1-proofs.cert : | rtl/rel4/support/logior1-proofs.pcert1
-
-rtl/rel4/support/logior1.pcert0 : no_pcert = 0
-rtl/rel4/support/logior1.pcert0 : acl2x = 0
-rtl/rel4/support/logior1.pcert0 : \
- rtl/rel4/support/logior1-proofs.pcert0 \
- rtl/rel4/support/logior1.lisp
-rtl/rel4/support/logior1.pcert1 : acl2x = 0
-rtl/rel4/support/logior1.pcert1 : no_pcert = 0
-rtl/rel4/support/logior1.pcert1 : rtl/rel4/support/logior1.pcert0
-rtl/rel4/support/logior1.cert : | rtl/rel4/support/logior1.pcert1
-
-rtl/rel4/support/lognot.pcert0 : no_pcert = 0
-rtl/rel4/support/lognot.pcert0 : acl2x = 0
-rtl/rel4/support/lognot.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/lognot.lisp
-rtl/rel4/support/lognot.pcert1 : acl2x = 0
-rtl/rel4/support/lognot.pcert1 : no_pcert = 0
-rtl/rel4/support/lognot.pcert1 : rtl/rel4/support/lognot.pcert0
-rtl/rel4/support/lognot.cert : | rtl/rel4/support/lognot.pcert1
-
-rtl/rel4/support/logorc1.pcert0 : no_pcert = 0
-rtl/rel4/support/logorc1.pcert0 : acl2x = 0
-rtl/rel4/support/logorc1.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/logior.pcert0 \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/support/lognot.pcert0 \
- rtl/rel4/support/logorc1.lisp
-rtl/rel4/support/logorc1.pcert1 : acl2x = 0
-rtl/rel4/support/logorc1.pcert1 : no_pcert = 0
-rtl/rel4/support/logorc1.pcert1 : rtl/rel4/support/logorc1.pcert0
-rtl/rel4/support/logorc1.cert : | rtl/rel4/support/logorc1.pcert1
-
-rtl/rel4/support/logs.pcert0 : no_pcert = 0
-rtl/rel4/support/logs.pcert0 : acl2x = 0
-rtl/rel4/support/logs.pcert0 : \
- rtl/rel4/support/logs.lisp
-rtl/rel4/support/logs.pcert1 : acl2x = 0
-rtl/rel4/support/logs.pcert1 : no_pcert = 0
-rtl/rel4/support/logs.pcert1 : rtl/rel4/support/logs.pcert0
-rtl/rel4/support/logs.cert : | rtl/rel4/support/logs.pcert1
-
-rtl/rel4/support/logxor.pcert0 : no_pcert = 0
-rtl/rel4/support/logxor.pcert0 : acl2x = 0
-rtl/rel4/support/logxor.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/logeqv.pcert0 \
- rtl/rel4/support/logorc1.pcert0 \
- rtl/rel4/support/lognot.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/logxor.lisp
-rtl/rel4/support/logxor.pcert1 : acl2x = 0
-rtl/rel4/support/logxor.pcert1 : no_pcert = 0
-rtl/rel4/support/logxor.pcert1 : rtl/rel4/support/logxor.pcert0
-rtl/rel4/support/logxor.cert : | rtl/rel4/support/logxor.pcert1
-
-rtl/rel4/support/lop1-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/lop1-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/lop1-proofs.pcert0 : \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/lop1-proofs.lisp
-rtl/rel4/support/lop1-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/lop1-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/lop1-proofs.pcert1 : rtl/rel4/support/lop1-proofs.pcert0
-rtl/rel4/support/lop1-proofs.cert : | rtl/rel4/support/lop1-proofs.pcert1
-
-rtl/rel4/support/lop1.pcert0 : no_pcert = 0
-rtl/rel4/support/lop1.pcert0 : acl2x = 0
-rtl/rel4/support/lop1.pcert0 : \
- rtl/rel4/support/lop1-proofs.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/lop1.lisp
-rtl/rel4/support/lop1.pcert1 : acl2x = 0
-rtl/rel4/support/lop1.pcert1 : no_pcert = 0
-rtl/rel4/support/lop1.pcert1 : rtl/rel4/support/lop1.pcert0
-rtl/rel4/support/lop1.cert : | rtl/rel4/support/lop1.pcert1
-
-rtl/rel4/support/lop2-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/lop2-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/lop2-proofs.pcert0 : \
- rtl/rel4/support/lop1.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/logior.pcert0 \
- rtl/rel4/support/lop2-proofs.lisp
-rtl/rel4/support/lop2-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/lop2-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/lop2-proofs.pcert1 : rtl/rel4/support/lop2-proofs.pcert0
-rtl/rel4/support/lop2-proofs.cert : | rtl/rel4/support/lop2-proofs.pcert1
-
-rtl/rel4/support/lop2.pcert0 : no_pcert = 0
-rtl/rel4/support/lop2.pcert0 : acl2x = 0
-rtl/rel4/support/lop2.pcert0 : \
- rtl/rel4/support/lop1.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/lop2-proofs.pcert0 \
- rtl/rel4/support/lop2.lisp
-rtl/rel4/support/lop2.pcert1 : acl2x = 0
-rtl/rel4/support/lop2.pcert1 : no_pcert = 0
-rtl/rel4/support/lop2.pcert1 : rtl/rel4/support/lop2.pcert0
-rtl/rel4/support/lop2.cert : | rtl/rel4/support/lop2.pcert1
-
-rtl/rel4/support/lop3-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/lop3-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/lop3-proofs.pcert0 : \
- rtl/rel4/support/lop2.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/lxor.pcert0 \
- rtl/rel4/support/lop3-proofs.lisp
-rtl/rel4/support/lop3-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/lop3-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/lop3-proofs.pcert1 : rtl/rel4/support/lop3-proofs.pcert0
-rtl/rel4/support/lop3-proofs.cert : | rtl/rel4/support/lop3-proofs.pcert1
-
-rtl/rel4/support/lop3.pcert0 : no_pcert = 0
-rtl/rel4/support/lop3.pcert0 : acl2x = 0
-rtl/rel4/support/lop3.pcert0 : \
- rtl/rel4/support/lop2.pcert0 \
- rtl/rel4/support/lop3-proofs.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/lxor.pcert0 \
- rtl/rel4/support/lop3.lisp
-rtl/rel4/support/lop3.pcert1 : acl2x = 0
-rtl/rel4/support/lop3.pcert1 : no_pcert = 0
-rtl/rel4/support/lop3.pcert1 : rtl/rel4/support/lop3.pcert0
-rtl/rel4/support/lop3.cert : | rtl/rel4/support/lop3.pcert1
-
-rtl/rel4/support/lxor-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/lxor-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/lxor-proofs.pcert0 : \
- rtl/rel4/support/all-ones.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/lxor-proofs.lisp
-rtl/rel4/support/lxor-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/lxor-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/lxor-proofs.pcert1 : rtl/rel4/support/lxor-proofs.pcert0
-rtl/rel4/support/lxor-proofs.cert : | rtl/rel4/support/lxor-proofs.pcert1
-
-rtl/rel4/support/lxor.pcert0 : no_pcert = 0
-rtl/rel4/support/lxor.pcert0 : acl2x = 0
-rtl/rel4/support/lxor.pcert0 : \
- rtl/rel4/support/lxor-proofs.pcert0 \
- rtl/rel4/support/lxor.lisp
-rtl/rel4/support/lxor.pcert1 : acl2x = 0
-rtl/rel4/support/lxor.pcert1 : no_pcert = 0
-rtl/rel4/support/lxor.pcert1 : rtl/rel4/support/lxor.pcert0
-rtl/rel4/support/lxor.cert : | rtl/rel4/support/lxor.pcert1
-
-rtl/rel4/support/merge.pcert0 : no_pcert = 0
-rtl/rel4/support/merge.pcert0 : acl2x = 0
-rtl/rel4/support/merge.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/log.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/lnot.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/logior.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- rtl/rel4/support/logxor.pcert0 \
- rtl/rel4/support/ocat.pcert0 \
- rtl/rel4/support/sumbits.pcert0 \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/merge.lisp
-rtl/rel4/support/merge.pcert1 : acl2x = 0
-rtl/rel4/support/merge.pcert1 : no_pcert = 0
-rtl/rel4/support/merge.pcert1 : rtl/rel4/support/merge.pcert0
-rtl/rel4/support/merge.cert : | rtl/rel4/support/merge.pcert1
-
-rtl/rel4/support/merge2.pcert0 : no_pcert = 0
-rtl/rel4/support/merge2.pcert0 : acl2x = 0
-rtl/rel4/support/merge2.pcert0 : \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/logs.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/merge2.lisp
-rtl/rel4/support/merge2.pcert1 : acl2x = 0
-rtl/rel4/support/merge2.pcert1 : no_pcert = 0
-rtl/rel4/support/merge2.pcert1 : rtl/rel4/support/merge2.pcert0
-rtl/rel4/support/merge2.cert : | rtl/rel4/support/merge2.pcert1
-
-rtl/rel4/support/mod4.pcert0 : no_pcert = 0
-rtl/rel4/support/mod4.pcert0 : acl2x = 0
-rtl/rel4/support/mod4.pcert0 : \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/mod4.lisp
-rtl/rel4/support/mod4.pcert1 : acl2x = 0
-rtl/rel4/support/mod4.pcert1 : no_pcert = 0
-rtl/rel4/support/mod4.pcert1 : rtl/rel4/support/mod4.pcert0
-rtl/rel4/support/mod4.cert : | rtl/rel4/support/mod4.pcert1
-
-rtl/rel4/support/model-helpers.pcert0 : no_pcert = 0
-rtl/rel4/support/model-helpers.pcert0 : acl2x = 0
-rtl/rel4/support/model-helpers.pcert0 : \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/model-helpers.lisp
-rtl/rel4/support/model-helpers.pcert1 : acl2x = 0
-rtl/rel4/support/model-helpers.pcert1 : no_pcert = 0
-rtl/rel4/support/model-helpers.pcert1 : rtl/rel4/support/model-helpers.pcert0
-rtl/rel4/support/model-helpers.cert : | rtl/rel4/support/model-helpers.pcert1
-
-rtl/rel4/support/mulcat-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/mulcat-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/mulcat-proofs.pcert0 : \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/cat-def.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/mulcat-proofs.lisp
-rtl/rel4/support/mulcat-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/mulcat-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/mulcat-proofs.pcert1 : rtl/rel4/support/mulcat-proofs.pcert0
-rtl/rel4/support/mulcat-proofs.cert : | rtl/rel4/support/mulcat-proofs.pcert1
-
-rtl/rel4/support/mulcat.pcert0 : no_pcert = 0
-rtl/rel4/support/mulcat.pcert0 : acl2x = 0
-rtl/rel4/support/mulcat.pcert0 : \
- rtl/rel4/support/cat-def.pcert0 \
- rtl/rel4/support/mulcat-proofs.pcert0 \
- rtl/rel4/support/mulcat.lisp
-rtl/rel4/support/mulcat.pcert1 : acl2x = 0
-rtl/rel4/support/mulcat.pcert1 : no_pcert = 0
-rtl/rel4/support/mulcat.pcert1 : rtl/rel4/support/mulcat.pcert0
-rtl/rel4/support/mulcat.cert : | rtl/rel4/support/mulcat.pcert1
-
-rtl/rel4/support/near+-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/near+-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/near+-proofs.pcert0 : \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/support/away.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/arithmetic/predicate.pcert0 \
- rtl/rel4/arithmetic/cg.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/near+-proofs.lisp
-rtl/rel4/support/near+-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/near+-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/near+-proofs.pcert1 : rtl/rel4/support/near+-proofs.pcert0
-rtl/rel4/support/near+-proofs.cert : | rtl/rel4/support/near+-proofs.pcert1
-
-rtl/rel4/support/near+.pcert0 : no_pcert = 0
-rtl/rel4/support/near+.pcert0 : acl2x = 0
-rtl/rel4/support/near+.pcert0 : \
- rtl/rel4/support/near+-proofs.pcert0 \
- rtl/rel4/support/near+.lisp
-rtl/rel4/support/near+.pcert1 : acl2x = 0
-rtl/rel4/support/near+.pcert1 : no_pcert = 0
-rtl/rel4/support/near+.pcert1 : rtl/rel4/support/near+.pcert0
-rtl/rel4/support/near+.cert : | rtl/rel4/support/near+.pcert1
-
-rtl/rel4/support/near-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/near-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/near-proofs.pcert0 : \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/away.pcert0 \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/support/near-proofs.lisp
-rtl/rel4/support/near-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/near-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/near-proofs.pcert1 : rtl/rel4/support/near-proofs.pcert0
-rtl/rel4/support/near-proofs.cert : | rtl/rel4/support/near-proofs.pcert1
-
-rtl/rel4/support/near.pcert0 : no_pcert = 0
-rtl/rel4/support/near.pcert0 : acl2x = 0
-rtl/rel4/support/near.pcert0 : \
- rtl/rel4/support/near-proofs.pcert0 \
- rtl/rel4/support/near.lisp
-rtl/rel4/support/near.pcert1 : acl2x = 0
-rtl/rel4/support/near.pcert1 : no_pcert = 0
-rtl/rel4/support/near.pcert1 : rtl/rel4/support/near.pcert0
-rtl/rel4/support/near.cert : | rtl/rel4/support/near.pcert1
-
-rtl/rel4/support/ocat.pcert0 : no_pcert = 0
-rtl/rel4/support/ocat.pcert0 : acl2x = 0
-rtl/rel4/support/ocat.pcert0 : \
- rtl/rel4/arithmetic/expt.pcert0 \
- rtl/rel4/arithmetic/expo.pcert0 \
- rtl/rel4/arithmetic/arith2.pcert0 \
- rtl/rel4/arithmetic/fp2.pcert0 \
- rtl/rel4/arithmetic/integerp.pcert0 \
- rtl/rel4/support/ocat.lisp
-rtl/rel4/support/ocat.pcert1 : acl2x = 0
-rtl/rel4/support/ocat.pcert1 : no_pcert = 0
-rtl/rel4/support/ocat.pcert1 : rtl/rel4/support/ocat.pcert0
-rtl/rel4/support/ocat.cert : | rtl/rel4/support/ocat.pcert1
-
-rtl/rel4/support/oddr-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/oddr-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/oddr-proofs.pcert0 : \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/support/away.pcert0 \
- rtl/rel4/support/near.pcert0 \
- rtl/rel4/support/oddr-proofs.lisp
-rtl/rel4/support/oddr-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/oddr-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/oddr-proofs.pcert1 : rtl/rel4/support/oddr-proofs.pcert0
-rtl/rel4/support/oddr-proofs.cert : | rtl/rel4/support/oddr-proofs.pcert1
-
-rtl/rel4/support/oddr.pcert0 : no_pcert = 0
-rtl/rel4/support/oddr.pcert0 : acl2x = 0
-rtl/rel4/support/oddr.pcert0 : \
- rtl/rel4/support/oddr-proofs.pcert0 \
- rtl/rel4/support/oddr.lisp
-rtl/rel4/support/oddr.pcert1 : acl2x = 0
-rtl/rel4/support/oddr.pcert1 : no_pcert = 0
-rtl/rel4/support/oddr.pcert1 : rtl/rel4/support/oddr.pcert0
-rtl/rel4/support/oddr.cert : | rtl/rel4/support/oddr.pcert1
-
-rtl/rel4/support/openers.pcert0 : no_pcert = 0
-rtl/rel4/support/openers.pcert0 : acl2x = 0
-rtl/rel4/support/openers.pcert0 : \
- rtl/rel4/support/openers.lisp
-rtl/rel4/support/openers.pcert1 : acl2x = 0
-rtl/rel4/support/openers.pcert1 : no_pcert = 0
-rtl/rel4/support/openers.pcert1 : rtl/rel4/support/openers.pcert0
-rtl/rel4/support/openers.cert : | rtl/rel4/support/openers.pcert1
-
-rtl/rel4/support/package-defs.pcert0 : no_pcert = 0
-rtl/rel4/support/package-defs.pcert0 : acl2x = 0
-rtl/rel4/support/package-defs.pcert0 : \
- rtl/rel4/support/package-defs.lisp
-rtl/rel4/support/package-defs.pcert1 : acl2x = 0
-rtl/rel4/support/package-defs.pcert1 : no_pcert = 0
-rtl/rel4/support/package-defs.pcert1 : rtl/rel4/support/package-defs.pcert0
-rtl/rel4/support/package-defs.cert : | rtl/rel4/support/package-defs.pcert1
-
-rtl/rel4/support/rewrite-theory.pcert0 : no_pcert = 0
-rtl/rel4/support/rewrite-theory.pcert0 : acl2x = 0
-rtl/rel4/support/rewrite-theory.pcert0 : \
- rtl/rel4/support/rewrite-theory.lisp
-rtl/rel4/support/rewrite-theory.pcert1 : acl2x = 0
-rtl/rel4/support/rewrite-theory.pcert1 : no_pcert = 0
-rtl/rel4/support/rewrite-theory.pcert1 : rtl/rel4/support/rewrite-theory.pcert0
-rtl/rel4/support/rewrite-theory.cert : | rtl/rel4/support/rewrite-theory.pcert1
-
-rtl/rel4/support/rnd.pcert0 : no_pcert = 0
-rtl/rel4/support/rnd.pcert0 : acl2x = 0
-rtl/rel4/support/rnd.pcert0 : \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/support/away.pcert0 \
- rtl/rel4/support/near.pcert0 \
- rtl/rel4/support/near+.pcert0 \
- rtl/rel4/support/sticky.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/bits-trunc.pcert0 \
- rtl/rel4/support/rnd.lisp
-rtl/rel4/support/rnd.pcert1 : acl2x = 0
-rtl/rel4/support/rnd.pcert1 : no_pcert = 0
-rtl/rel4/support/rnd.pcert1 : rtl/rel4/support/rnd.pcert0
-rtl/rel4/support/rnd.cert : | rtl/rel4/support/rnd.pcert1
-
-rtl/rel4/support/rom-helpers.pcert0 : no_pcert = 0
-rtl/rel4/support/rom-helpers.pcert0 : acl2x = 0
-rtl/rel4/support/rom-helpers.pcert0 : \
- rtl/rel4/support/rom-helpers.lisp
-rtl/rel4/support/rom-helpers.pcert1 : acl2x = 0
-rtl/rel4/support/rom-helpers.pcert1 : no_pcert = 0
-rtl/rel4/support/rom-helpers.pcert1 : rtl/rel4/support/rom-helpers.pcert0
-rtl/rel4/support/rom-helpers.cert : | rtl/rel4/support/rom-helpers.pcert1
-
-rtl/rel4/support/rtl.pcert0 : no_pcert = 0
-rtl/rel4/support/rtl.pcert0 : acl2x = 0
-rtl/rel4/support/rtl.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/rtlarr.pcert0 \
- rtl/rel4/support/cat-def.pcert0 \
- rtl/rel4/support/rtl.lisp
-rtl/rel4/support/rtl.pcert1 : acl2x = 0
-rtl/rel4/support/rtl.pcert1 : no_pcert = 0
-rtl/rel4/support/rtl.pcert1 : rtl/rel4/support/rtl.pcert0
-rtl/rel4/support/rtl.cert : | rtl/rel4/support/rtl.pcert1
-
-rtl/rel4/support/rtlarr.pcert0 : no_pcert = 0
-rtl/rel4/support/rtlarr.pcert0 : acl2x = 0
-rtl/rel4/support/rtlarr.pcert0 : \
- misc/total-order.pcert0 \
- rtl/rel4/support/rtlarr.lisp
-rtl/rel4/support/rtlarr.pcert1 : acl2x = 0
-rtl/rel4/support/rtlarr.pcert1 : no_pcert = 0
-rtl/rel4/support/rtlarr.pcert1 : rtl/rel4/support/rtlarr.pcert0
-rtl/rel4/support/rtlarr.cert : | rtl/rel4/support/rtlarr.pcert1
-
-rtl/rel4/support/setbitn-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/setbitn-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/setbitn-proofs.pcert0 : \
- rtl/rel4/support/cat-def.pcert0 \
- rtl/rel4/support/setbits.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/setbitn-proofs.lisp
-rtl/rel4/support/setbitn-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/setbitn-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/setbitn-proofs.pcert1 : rtl/rel4/support/setbitn-proofs.pcert0
-rtl/rel4/support/setbitn-proofs.cert : | rtl/rel4/support/setbitn-proofs.pcert1
-
-rtl/rel4/support/setbitn.pcert0 : no_pcert = 0
-rtl/rel4/support/setbitn.pcert0 : acl2x = 0
-rtl/rel4/support/setbitn.pcert0 : \
- rtl/rel4/support/cat-def.pcert0 \
- rtl/rel4/support/setbitn-proofs.pcert0 \
- rtl/rel4/support/setbitn.lisp
-rtl/rel4/support/setbitn.pcert1 : acl2x = 0
-rtl/rel4/support/setbitn.pcert1 : no_pcert = 0
-rtl/rel4/support/setbitn.pcert1 : rtl/rel4/support/setbitn.pcert0
-rtl/rel4/support/setbitn.cert : | rtl/rel4/support/setbitn.pcert1
-
-rtl/rel4/support/setbits-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/setbits-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/setbits-proofs.pcert0 : \
- rtl/rel4/support/cat-def.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/setbits-proofs.lisp
-rtl/rel4/support/setbits-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/setbits-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/setbits-proofs.pcert1 : rtl/rel4/support/setbits-proofs.pcert0
-rtl/rel4/support/setbits-proofs.cert : | rtl/rel4/support/setbits-proofs.pcert1
-
-rtl/rel4/support/setbits.pcert0 : no_pcert = 0
-rtl/rel4/support/setbits.pcert0 : acl2x = 0
-rtl/rel4/support/setbits.pcert0 : \
- rtl/rel4/support/cat-def.pcert0 \
- rtl/rel4/support/setbits-proofs.pcert0 \
- rtl/rel4/support/setbits.lisp
-rtl/rel4/support/setbits.pcert1 : acl2x = 0
-rtl/rel4/support/setbits.pcert1 : no_pcert = 0
-rtl/rel4/support/setbits.pcert1 : rtl/rel4/support/setbits.pcert0
-rtl/rel4/support/setbits.cert : | rtl/rel4/support/setbits.pcert1
-
-rtl/rel4/support/sgn.pcert0 : no_pcert = 0
-rtl/rel4/support/sgn.pcert0 : acl2x = 0
-rtl/rel4/support/sgn.pcert0 : \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/sgn.lisp
-rtl/rel4/support/sgn.pcert1 : acl2x = 0
-rtl/rel4/support/sgn.pcert1 : no_pcert = 0
-rtl/rel4/support/sgn.pcert1 : rtl/rel4/support/sgn.pcert0
-rtl/rel4/support/sgn.cert : | rtl/rel4/support/sgn.pcert1
-
-rtl/rel4/support/shft.pcert0 : no_pcert = 0
-rtl/rel4/support/shft.pcert0 : acl2x = 0
-rtl/rel4/support/shft.pcert0 : \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/shft.lisp
-rtl/rel4/support/shft.pcert1 : acl2x = 0
-rtl/rel4/support/shft.pcert1 : no_pcert = 0
-rtl/rel4/support/shft.pcert1 : rtl/rel4/support/shft.pcert0
-rtl/rel4/support/shft.cert : | rtl/rel4/support/shft.pcert1
-
-rtl/rel4/support/simple-loop-helpers.pcert0 : no_pcert = 0
-rtl/rel4/support/simple-loop-helpers.pcert0 : acl2x = 0
-rtl/rel4/support/simple-loop-helpers.pcert0 : \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/setbitn.pcert0 \
- rtl/rel4/support/simple-loop-helpers.lisp
-rtl/rel4/support/simple-loop-helpers.pcert1 : acl2x = 0
-rtl/rel4/support/simple-loop-helpers.pcert1 : no_pcert = 0
-rtl/rel4/support/simple-loop-helpers.pcert1 : rtl/rel4/support/simple-loop-helpers.pcert0
-rtl/rel4/support/simple-loop-helpers.cert : | rtl/rel4/support/simple-loop-helpers.pcert1
-
-rtl/rel4/support/simplify-model-helpers.pcert0 : no_pcert = 0
-rtl/rel4/support/simplify-model-helpers.pcert0 : acl2x = 0
-rtl/rel4/support/simplify-model-helpers.pcert0 : \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/simplify-model-helpers.lisp
-rtl/rel4/support/simplify-model-helpers.pcert1 : acl2x = 0
-rtl/rel4/support/simplify-model-helpers.pcert1 : no_pcert = 0
-rtl/rel4/support/simplify-model-helpers.pcert1 : rtl/rel4/support/simplify-model-helpers.pcert0
-rtl/rel4/support/simplify-model-helpers.cert : | rtl/rel4/support/simplify-model-helpers.pcert1
-
-rtl/rel4/support/stick-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/stick-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/stick-proofs.pcert0 : \
- rtl/rel4/support/merge.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/lxor.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/lnot.pcert0 \
- rtl/rel4/support/stick-proofs.lisp
-rtl/rel4/support/stick-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/stick-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/stick-proofs.pcert1 : rtl/rel4/support/stick-proofs.pcert0
-rtl/rel4/support/stick-proofs.cert : | rtl/rel4/support/stick-proofs.pcert1
-
-rtl/rel4/support/stick.pcert0 : no_pcert = 0
-rtl/rel4/support/stick.pcert0 : acl2x = 0
-rtl/rel4/support/stick.pcert0 : \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/stick-proofs.pcert0 \
- rtl/rel4/support/stick.lisp
-rtl/rel4/support/stick.pcert1 : acl2x = 0
-rtl/rel4/support/stick.pcert1 : no_pcert = 0
-rtl/rel4/support/stick.pcert1 : rtl/rel4/support/stick.pcert0
-rtl/rel4/support/stick.cert : | rtl/rel4/support/stick.pcert1
-
-rtl/rel4/support/sticky-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/sticky-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/sticky-proofs.pcert0 : \
- rtl/rel4/arithmetic/arith.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/support/away.pcert0 \
- rtl/rel4/support/near.pcert0 \
- rtl/rel4/support/near+.pcert0 \
- rtl/rel4/support/sticky-proofs.lisp
-rtl/rel4/support/sticky-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/sticky-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/sticky-proofs.pcert1 : rtl/rel4/support/sticky-proofs.pcert0
-rtl/rel4/support/sticky-proofs.cert : | rtl/rel4/support/sticky-proofs.pcert1
-
-rtl/rel4/support/sticky.pcert0 : no_pcert = 0
-rtl/rel4/support/sticky.pcert0 : acl2x = 0
-rtl/rel4/support/sticky.pcert0 : \
- rtl/rel4/support/sticky-proofs.pcert0 \
- rtl/rel4/support/sticky.lisp
-rtl/rel4/support/sticky.pcert1 : acl2x = 0
-rtl/rel4/support/sticky.pcert1 : no_pcert = 0
-rtl/rel4/support/sticky.pcert1 : rtl/rel4/support/sticky.pcert0
-rtl/rel4/support/sticky.cert : | rtl/rel4/support/sticky.pcert1
-
-rtl/rel4/support/sumbits.pcert0 : no_pcert = 0
-rtl/rel4/support/sumbits.pcert0 : acl2x = 0
-rtl/rel4/support/sumbits.pcert0 : \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/sumbits.lisp
-rtl/rel4/support/sumbits.pcert1 : acl2x = 0
-rtl/rel4/support/sumbits.pcert1 : no_pcert = 0
-rtl/rel4/support/sumbits.pcert1 : rtl/rel4/support/sumbits.pcert0
-rtl/rel4/support/sumbits.cert : | rtl/rel4/support/sumbits.pcert1
-
-rtl/rel4/support/top.pcert0 : no_pcert = 0
-rtl/rel4/support/top.pcert0 : acl2x = 0
-rtl/rel4/support/top.pcert0 : \
- rtl/rel4/support/top1.pcert0 \
- rtl/rel4/support/bits-extra.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/support/top.lisp
-rtl/rel4/support/top.pcert1 : acl2x = 0
-rtl/rel4/support/top.pcert1 : no_pcert = 0
-rtl/rel4/support/top.pcert1 : rtl/rel4/support/top.pcert0
-rtl/rel4/support/top.cert : | rtl/rel4/support/top.pcert1
-
-rtl/rel4/support/top1.pcert0 : no_pcert = 0
-rtl/rel4/support/top1.pcert0 : acl2x = 0
-rtl/rel4/support/top1.pcert0 : \
- rtl/rel4/support/util.pcert0 \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/rewrite-theory.pcert0 \
- rtl/rel4/support/rtl.pcert0 \
- rtl/rel4/support/rtlarr.pcert0 \
- rtl/rel4/support/bvecp-lemmas.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/ocat.pcert0 \
- rtl/rel4/support/cat-def.pcert0 \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/support/ash.pcert0 \
- rtl/rel4/support/decode.pcert0 \
- rtl/rel4/support/encode.pcert0 \
- rtl/rel4/support/mulcat.pcert0 \
- rtl/rel4/support/shft.pcert0 \
- rtl/rel4/support/all-ones.pcert0 \
- rtl/rel4/support/merge2.pcert0 \
- rtl/rel4/support/logior1.pcert0 \
- rtl/rel4/support/setbits.pcert0 \
- rtl/rel4/support/setbitn.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/support/bias.pcert0 \
- rtl/rel4/support/ereps.pcert0 \
- rtl/rel4/support/ireps.pcert0 \
- rtl/rel4/support/logeqv.pcert0 \
- rtl/rel4/support/logorc1.pcert0 \
- rtl/rel4/support/lognot.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- rtl/rel4/support/logior.pcert0 \
- rtl/rel4/support/logxor.pcert0 \
- rtl/rel4/support/log.pcert0 \
- rtl/rel4/support/lnot.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/lxor.pcert0 \
- rtl/rel4/support/lextra.pcert0 \
- rtl/rel4/support/logs.pcert0 \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/support/away.pcert0 \
- rtl/rel4/support/near.pcert0 \
- rtl/rel4/support/near+.pcert0 \
- rtl/rel4/support/oddr.pcert0 \
- rtl/rel4/support/sticky.pcert0 \
- rtl/rel4/support/rnd.pcert0 \
- rtl/rel4/support/drnd.pcert0 \
- rtl/rel4/support/bits-trunc.pcert0 \
- rtl/rel4/support/add3.pcert0 \
- rtl/rel4/support/lop1.pcert0 \
- rtl/rel4/support/lop2.pcert0 \
- rtl/rel4/support/lop3.pcert0 \
- rtl/rel4/support/stick.pcert0 \
- rtl/rel4/support/bvecp-helpers.pcert0 \
- rtl/rel4/support/model-helpers.pcert0 \
- rtl/rel4/support/rom-helpers.pcert0 \
- rtl/rel4/support/simple-loop-helpers.pcert0 \
- rtl/rel4/support/clocks.pcert0 \
- rtl/rel4/support/openers.pcert0 \
- rtl/rel4/support/package-defs.pcert0 \
- rtl/rel4/support/simplify-model-helpers.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/arithmetic/fp.pcert0 \
- rtl/rel4/support/fadd.pcert0 \
- rtl/rel4/support/top1.lisp
-rtl/rel4/support/top1.pcert1 : acl2x = 0
-rtl/rel4/support/top1.pcert1 : no_pcert = 0
-rtl/rel4/support/top1.pcert1 : rtl/rel4/support/top1.pcert0
-rtl/rel4/support/top1.cert : | rtl/rel4/support/top1.pcert1
-
-rtl/rel4/support/trunc-proofs.pcert0 : no_pcert = 0
-rtl/rel4/support/trunc-proofs.pcert0 : acl2x = 0
-rtl/rel4/support/trunc-proofs.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/float.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- rtl/rel4/support/trunc-proofs.lisp
-rtl/rel4/support/trunc-proofs.pcert1 : acl2x = 0
-rtl/rel4/support/trunc-proofs.pcert1 : no_pcert = 0
-rtl/rel4/support/trunc-proofs.pcert1 : rtl/rel4/support/trunc-proofs.pcert0
-rtl/rel4/support/trunc-proofs.cert : | rtl/rel4/support/trunc-proofs.pcert1
-
-rtl/rel4/support/trunc.pcert0 : no_pcert = 0
-rtl/rel4/support/trunc.pcert0 : acl2x = 0
-rtl/rel4/support/trunc.pcert0 : \
- rtl/rel4/support/ground-zero.pcert0 \
- rtl/rel4/support/trunc-proofs.pcert0 \
- rtl/rel4/support/trunc.lisp
-rtl/rel4/support/trunc.pcert1 : acl2x = 0
-rtl/rel4/support/trunc.pcert1 : no_pcert = 0
-rtl/rel4/support/trunc.pcert1 : rtl/rel4/support/trunc.pcert0
-rtl/rel4/support/trunc.cert : | rtl/rel4/support/trunc.pcert1
-
-rtl/rel4/support/util.pcert0 : no_pcert = 0
-rtl/rel4/support/util.pcert0 : acl2x = 0
-rtl/rel4/support/util.pcert0 : \
- rtl/rel4/support/util.lisp
-rtl/rel4/support/util.pcert1 : acl2x = 0
-rtl/rel4/support/util.pcert1 : no_pcert = 0
-rtl/rel4/support/util.pcert1 : rtl/rel4/support/util.pcert0
-rtl/rel4/support/util.cert : | rtl/rel4/support/util.pcert1
-
-rtl/rel4/user/away.pcert0 : no_pcert = 0
-rtl/rel4/user/away.pcert0 : acl2x = 0
-rtl/rel4/user/away.pcert0 : \
- rtl/rel4/user/trunc.pcert0 \
- rtl/rel4/support/away.pcert0 \
- rtl/rel4/user/away.lisp
-rtl/rel4/user/away.pcert1 : acl2x = 0
-rtl/rel4/user/away.pcert1 : no_pcert = 0
-rtl/rel4/user/away.pcert1 : rtl/rel4/user/away.pcert0
-rtl/rel4/user/away.cert : | rtl/rel4/user/away.pcert1
-
-rtl/rel4/user/bias.pcert0 : no_pcert = 0
-rtl/rel4/user/bias.pcert0 : acl2x = 0
-rtl/rel4/user/bias.pcert0 : \
- rtl/rel4/support/bias.pcert0 \
- rtl/rel4/user/bias.lisp
-rtl/rel4/user/bias.pcert1 : acl2x = 0
-rtl/rel4/user/bias.pcert1 : no_pcert = 0
-rtl/rel4/user/bias.pcert1 : rtl/rel4/user/bias.pcert0
-rtl/rel4/user/bias.cert : | rtl/rel4/user/bias.pcert1
-
-rtl/rel4/user/bitn.pcert0 : no_pcert = 0
-rtl/rel4/user/bitn.pcert0 : acl2x = 0
-rtl/rel4/user/bitn.pcert0 : \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/support/bitn.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/user/bitn.lisp
-rtl/rel4/user/bitn.pcert1 : acl2x = 0
-rtl/rel4/user/bitn.pcert1 : no_pcert = 0
-rtl/rel4/user/bitn.pcert1 : rtl/rel4/user/bitn.pcert0
-rtl/rel4/user/bitn.cert : | rtl/rel4/user/bitn.pcert1
-
-rtl/rel4/user/bits-trunc.pcert0 : no_pcert = 0
-rtl/rel4/user/bits-trunc.pcert0 : acl2x = 0
-rtl/rel4/user/bits-trunc.pcert0 : \
- rtl/rel4/user/land.pcert0 \
- rtl/rel4/support/bits-trunc.pcert0 \
- rtl/rel4/user/bits-trunc.lisp
-rtl/rel4/user/bits-trunc.pcert1 : acl2x = 0
-rtl/rel4/user/bits-trunc.pcert1 : no_pcert = 0
-rtl/rel4/user/bits-trunc.pcert1 : rtl/rel4/user/bits-trunc.pcert0
-rtl/rel4/user/bits-trunc.cert : | rtl/rel4/user/bits-trunc.pcert1
-
-rtl/rel4/user/bits.pcert0 : no_pcert = 0
-rtl/rel4/user/bits.pcert0 : acl2x = 0
-rtl/rel4/user/bits.pcert0 : \
- rtl/rel4/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel4/arithmetic/power2p.pcert0 \
- rtl/rel4/support/bits.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/user/bits.lisp
-rtl/rel4/user/bits.pcert1 : acl2x = 0
-rtl/rel4/user/bits.pcert1 : no_pcert = 0
-rtl/rel4/user/bits.pcert1 : rtl/rel4/user/bits.pcert0
-rtl/rel4/user/bits.cert : | rtl/rel4/user/bits.pcert1
-
-rtl/rel4/user/brat.pcert0 : no_pcert = 0
-rtl/rel4/user/brat.pcert0 : acl2x = 0
-rtl/rel4/user/brat.pcert0 : \
- rtl/rel4/arithmetic/fl.pcert0 \
- rtl/rel4/user/brat.lisp
-rtl/rel4/user/brat.pcert1 : acl2x = 0
-rtl/rel4/user/brat.pcert1 : no_pcert = 0
-rtl/rel4/user/brat.pcert1 : rtl/rel4/user/brat.pcert0
-rtl/rel4/user/brat.cert : | rtl/rel4/user/brat.pcert1
-
-rtl/rel4/user/bvecp.pcert0 : no_pcert = 0
-rtl/rel4/user/bvecp.pcert0 : acl2x = 0
-rtl/rel4/user/bvecp.pcert0 : \
- rtl/rel4/support/bvecp.pcert0 \
- rtl/rel4/user/bvecp.lisp
-rtl/rel4/user/bvecp.pcert1 : acl2x = 0
-rtl/rel4/user/bvecp.pcert1 : no_pcert = 0
-rtl/rel4/user/bvecp.pcert1 : rtl/rel4/user/bvecp.pcert0
-rtl/rel4/user/bvecp.cert : | rtl/rel4/user/bvecp.pcert1
-
-rtl/rel4/user/cat.pcert0 : no_pcert = 0
-rtl/rel4/user/cat.pcert0 : acl2x = 0
-rtl/rel4/user/cat.pcert0 : \
- rtl/rel4/support/cat.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/user/cat.lisp
-rtl/rel4/user/cat.pcert1 : acl2x = 0
-rtl/rel4/user/cat.pcert1 : no_pcert = 0
-rtl/rel4/user/cat.pcert1 : rtl/rel4/user/cat.pcert0
-rtl/rel4/user/cat.cert : | rtl/rel4/user/cat.pcert1
-
-rtl/rel4/user/decode.pcert0 : no_pcert = 0
-rtl/rel4/user/decode.pcert0 : acl2x = 0
-rtl/rel4/user/decode.pcert0 : \
- rtl/rel4/support/decode.pcert0 \
- rtl/rel4/user/decode.lisp
-rtl/rel4/user/decode.pcert1 : acl2x = 0
-rtl/rel4/user/decode.pcert1 : no_pcert = 0
-rtl/rel4/user/decode.pcert1 : rtl/rel4/user/decode.pcert0
-rtl/rel4/user/decode.cert : | rtl/rel4/user/decode.pcert1
-
-rtl/rel4/user/ereps.pcert0 : no_pcert = 0
-rtl/rel4/user/ereps.pcert0 : acl2x = 0
-rtl/rel4/user/ereps.pcert0 : \
- rtl/rel4/support/ereps.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/user/ereps.lisp
-rtl/rel4/user/ereps.pcert1 : acl2x = 0
-rtl/rel4/user/ereps.pcert1 : no_pcert = 0
-rtl/rel4/user/ereps.pcert1 : rtl/rel4/user/ereps.pcert0
-rtl/rel4/user/ereps.cert : | rtl/rel4/user/ereps.pcert1
-
-rtl/rel4/user/land.pcert0 : no_pcert = 0
-rtl/rel4/user/land.pcert0 : acl2x = 0
-rtl/rel4/user/land.pcert0 : \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/support/land.pcert0 \
- rtl/rel4/user/land.lisp
-rtl/rel4/user/land.pcert1 : acl2x = 0
-rtl/rel4/user/land.pcert1 : no_pcert = 0
-rtl/rel4/user/land.pcert1 : rtl/rel4/user/land.pcert0
-rtl/rel4/user/land.cert : | rtl/rel4/user/land.pcert1
-
-rtl/rel4/user/lextra.pcert0 : no_pcert = 0
-rtl/rel4/user/lextra.pcert0 : acl2x = 0
-rtl/rel4/user/lextra.pcert0 : \
- rtl/rel4/user/land.pcert0 \
- rtl/rel4/user/lior.pcert0 \
- rtl/rel4/user/lxor.pcert0 \
- rtl/rel4/support/lextra.pcert0 \
- rtl/rel4/user/lextra.lisp
-rtl/rel4/user/lextra.pcert1 : acl2x = 0
-rtl/rel4/user/lextra.pcert1 : no_pcert = 0
-rtl/rel4/user/lextra.pcert1 : rtl/rel4/user/lextra.pcert0
-rtl/rel4/user/lextra.cert : | rtl/rel4/user/lextra.pcert1
-
-rtl/rel4/user/lior.pcert0 : no_pcert = 0
-rtl/rel4/user/lior.pcert0 : acl2x = 0
-rtl/rel4/user/lior.pcert0 : \
- rtl/rel4/support/lior.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/user/lior.lisp
-rtl/rel4/user/lior.pcert1 : acl2x = 0
-rtl/rel4/user/lior.pcert1 : no_pcert = 0
-rtl/rel4/user/lior.pcert1 : rtl/rel4/user/lior.pcert0
-rtl/rel4/user/lior.cert : | rtl/rel4/user/lior.pcert1
-
-rtl/rel4/user/lnot.pcert0 : no_pcert = 0
-rtl/rel4/user/lnot.pcert0 : acl2x = 0
-rtl/rel4/user/lnot.pcert0 : \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/support/lnot.pcert0 \
- rtl/rel4/user/lnot.lisp
-rtl/rel4/user/lnot.pcert1 : acl2x = 0
-rtl/rel4/user/lnot.pcert1 : no_pcert = 0
-rtl/rel4/user/lnot.pcert1 : rtl/rel4/user/lnot.pcert0
-rtl/rel4/user/lnot.cert : | rtl/rel4/user/lnot.pcert1
-
-rtl/rel4/user/logior1.pcert0 : no_pcert = 0
-rtl/rel4/user/logior1.pcert0 : acl2x = 0
-rtl/rel4/user/logior1.pcert0 : \
- rtl/rel4/support/logior1.pcert0 \
- rtl/rel4/user/logior1.lisp
-rtl/rel4/user/logior1.pcert1 : acl2x = 0
-rtl/rel4/user/logior1.pcert1 : no_pcert = 0
-rtl/rel4/user/logior1.pcert1 : rtl/rel4/user/logior1.pcert0
-rtl/rel4/user/logior1.cert : | rtl/rel4/user/logior1.pcert1
-
-rtl/rel4/user/lxor.pcert0 : no_pcert = 0
-rtl/rel4/user/lxor.pcert0 : acl2x = 0
-rtl/rel4/user/lxor.pcert0 : \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/support/lxor.pcert0 \
- rtl/rel4/user/lxor.lisp
-rtl/rel4/user/lxor.pcert1 : acl2x = 0
-rtl/rel4/user/lxor.pcert1 : no_pcert = 0
-rtl/rel4/user/lxor.pcert1 : rtl/rel4/user/lxor.pcert0
-rtl/rel4/user/lxor.cert : | rtl/rel4/user/lxor.pcert1
-
-rtl/rel4/user/mulcat.pcert0 : no_pcert = 0
-rtl/rel4/user/mulcat.pcert0 : acl2x = 0
-rtl/rel4/user/mulcat.pcert0 : \
- rtl/rel4/support/mulcat.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/user/mulcat.lisp
-rtl/rel4/user/mulcat.pcert1 : acl2x = 0
-rtl/rel4/user/mulcat.pcert1 : no_pcert = 0
-rtl/rel4/user/mulcat.pcert1 : rtl/rel4/user/mulcat.pcert0
-rtl/rel4/user/mulcat.cert : | rtl/rel4/user/mulcat.pcert1
-
-rtl/rel4/user/near.pcert0 : no_pcert = 0
-rtl/rel4/user/near.pcert0 : acl2x = 0
-rtl/rel4/user/near.pcert0 : \
- rtl/rel4/support/near.pcert0 \
- rtl/rel4/user/near.lisp
-rtl/rel4/user/near.pcert1 : acl2x = 0
-rtl/rel4/user/near.pcert1 : no_pcert = 0
-rtl/rel4/user/near.pcert1 : rtl/rel4/user/near.pcert0
-rtl/rel4/user/near.cert : | rtl/rel4/user/near.pcert1
-
-rtl/rel4/user/setbitn.pcert0 : no_pcert = 0
-rtl/rel4/user/setbitn.pcert0 : acl2x = 0
-rtl/rel4/user/setbitn.pcert0 : \
- rtl/rel4/support/setbitn.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/user/setbitn.lisp
-rtl/rel4/user/setbitn.pcert1 : acl2x = 0
-rtl/rel4/user/setbitn.pcert1 : no_pcert = 0
-rtl/rel4/user/setbitn.pcert1 : rtl/rel4/user/setbitn.pcert0
-rtl/rel4/user/setbitn.cert : | rtl/rel4/user/setbitn.pcert1
-
-rtl/rel4/user/setbits.pcert0 : no_pcert = 0
-rtl/rel4/user/setbits.pcert0 : acl2x = 0
-rtl/rel4/user/setbits.pcert0 : \
- rtl/rel4/support/setbits.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/user/setbits.lisp
-rtl/rel4/user/setbits.pcert1 : acl2x = 0
-rtl/rel4/user/setbits.pcert1 : no_pcert = 0
-rtl/rel4/user/setbits.pcert1 : rtl/rel4/user/setbits.pcert0
-rtl/rel4/user/setbits.cert : | rtl/rel4/user/setbits.pcert1
-
-rtl/rel4/user/stick.pcert0 : no_pcert = 0
-rtl/rel4/user/stick.pcert0 : acl2x = 0
-rtl/rel4/user/stick.pcert0 : \
- rtl/rel4/user/land.pcert0 \
- rtl/rel4/user/lior.pcert0 \
- rtl/rel4/user/lxor.pcert0 \
- rtl/rel4/user/lnot.pcert0 \
- rtl/rel4/support/stick.pcert0 \
- rtl/rel4/user/stick.lisp
-rtl/rel4/user/stick.pcert1 : acl2x = 0
-rtl/rel4/user/stick.pcert1 : no_pcert = 0
-rtl/rel4/user/stick.pcert1 : rtl/rel4/user/stick.pcert0
-rtl/rel4/user/stick.cert : | rtl/rel4/user/stick.pcert1
-
-rtl/rel4/user/sumbits.pcert0 : no_pcert = 0
-rtl/rel4/user/sumbits.pcert0 : acl2x = 0
-rtl/rel4/user/sumbits.pcert0 : \
- rtl/rel4/support/sumbits.pcert0 \
- rtl/rel4/support/guards.pcert0 \
- rtl/rel4/user/sumbits.lisp
-rtl/rel4/user/sumbits.pcert1 : acl2x = 0
-rtl/rel4/user/sumbits.pcert1 : no_pcert = 0
-rtl/rel4/user/sumbits.pcert1 : rtl/rel4/user/sumbits.pcert0
-rtl/rel4/user/sumbits.cert : | rtl/rel4/user/sumbits.pcert1
-
-rtl/rel4/user/top.pcert0 : no_pcert = 0
-rtl/rel4/user/top.pcert0 : acl2x = 0
-rtl/rel4/user/top.pcert0 : \
- rtl/rel4/user/bits.pcert0 \
- rtl/rel4/user/bitn.pcert0 \
- rtl/rel4/user/cat.pcert0 \
- rtl/rel4/user/bvecp.pcert0 \
- rtl/rel4/user/mulcat.pcert0 \
- rtl/rel4/user/logior1.pcert0 \
- rtl/rel4/user/setbits.pcert0 \
- rtl/rel4/user/setbitn.pcert0 \
- rtl/rel4/user/bias.pcert0 \
- rtl/rel4/user/ereps.pcert0 \
- rtl/rel4/user/lnot.pcert0 \
- rtl/rel4/user/land.pcert0 \
- rtl/rel4/user/lior.pcert0 \
- rtl/rel4/user/lxor.pcert0 \
- rtl/rel4/user/lextra.pcert0 \
- rtl/rel4/user/trunc.pcert0 \
- rtl/rel4/user/away.pcert0 \
- rtl/rel4/user/near.pcert0 \
- rtl/rel4/user/bits-trunc.pcert0 \
- rtl/rel4/user/stick.pcert0 \
- rtl/rel4/user/sumbits.pcert0 \
- rtl/rel4/user/top.lisp
-rtl/rel4/user/top.pcert1 : acl2x = 0
-rtl/rel4/user/top.pcert1 : no_pcert = 0
-rtl/rel4/user/top.pcert1 : rtl/rel4/user/top.pcert0
-rtl/rel4/user/top.cert : | rtl/rel4/user/top.pcert1
-
-rtl/rel4/user/trunc.pcert0 : no_pcert = 0
-rtl/rel4/user/trunc.pcert0 : acl2x = 0
-rtl/rel4/user/trunc.pcert0 : \
- rtl/rel4/support/trunc.pcert0 \
- rtl/rel4/user/trunc.lisp
-rtl/rel4/user/trunc.pcert1 : acl2x = 0
-rtl/rel4/user/trunc.pcert1 : no_pcert = 0
-rtl/rel4/user/trunc.pcert1 : rtl/rel4/user/trunc.pcert0
-rtl/rel4/user/trunc.cert : | rtl/rel4/user/trunc.pcert1
-
-rtl/rel5/arithmetic/arith.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/arith.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/arith.pcert0 : \
- rtl/rel5/arithmetic/arith2.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- meta/meta-times-equal.pcert0 \
- rtl/rel5/arithmetic/arith.lisp
-rtl/rel5/arithmetic/arith.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/arith.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/arith.pcert1 : rtl/rel5/arithmetic/arith.pcert0
-rtl/rel5/arithmetic/arith.cert : | rtl/rel5/arithmetic/arith.pcert1
-
-rtl/rel5/arithmetic/arith2.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/arith2.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/arith2.pcert0 : \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/product.pcert0 \
- meta/meta-times-equal.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel5/arithmetic/inverted-factor.pcert0 \
- rtl/rel5/arithmetic/arith2.lisp
-rtl/rel5/arithmetic/arith2.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/arith2.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/arith2.pcert1 : rtl/rel5/arithmetic/arith2.pcert0
-rtl/rel5/arithmetic/arith2.cert : | rtl/rel5/arithmetic/arith2.pcert1
-
-rtl/rel5/arithmetic/basic.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/basic.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/basic.pcert0 : \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/even-odd.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/expt.pcert0 \
- rtl/rel5/arithmetic/basic.lisp
-rtl/rel5/arithmetic/basic.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/basic.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/basic.pcert1 : rtl/rel5/arithmetic/basic.pcert0
-rtl/rel5/arithmetic/basic.cert : | rtl/rel5/arithmetic/basic.pcert1
-
-rtl/rel5/arithmetic/cg.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/cg.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/cg.pcert0 : \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- rtl/rel5/arithmetic/common-factor.pcert0 \
- rtl/rel5/arithmetic/cg.lisp
-rtl/rel5/arithmetic/cg.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/cg.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/cg.pcert1 : rtl/rel5/arithmetic/cg.pcert0
-rtl/rel5/arithmetic/cg.cert : | rtl/rel5/arithmetic/cg.pcert1
-
-rtl/rel5/arithmetic/common-factor-defuns.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/common-factor-defuns.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/common-factor-defuns.pcert0 : \
- rtl/rel5/arithmetic/inverted-factor.pcert0 \
- rtl/rel5/arithmetic/common-factor-defuns.lisp
-rtl/rel5/arithmetic/common-factor-defuns.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/common-factor-defuns.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/common-factor-defuns.pcert1 : rtl/rel5/arithmetic/common-factor-defuns.pcert0
-rtl/rel5/arithmetic/common-factor-defuns.cert : | rtl/rel5/arithmetic/common-factor-defuns.pcert1
-
-rtl/rel5/arithmetic/common-factor.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/common-factor.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/common-factor.pcert0 : \
- meta/meta-times-equal.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel5/arithmetic/common-factor-defuns.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/product.pcert0 \
- rtl/rel5/arithmetic/common-factor.lisp
-rtl/rel5/arithmetic/common-factor.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/common-factor.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/common-factor.pcert1 : rtl/rel5/arithmetic/common-factor.pcert0
-rtl/rel5/arithmetic/common-factor.cert : | rtl/rel5/arithmetic/common-factor.pcert1
-
-rtl/rel5/arithmetic/complex-rationalp.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/complex-rationalp.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/complex-rationalp.pcert0 : \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/complex-rationalp.lisp
-rtl/rel5/arithmetic/complex-rationalp.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/complex-rationalp.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/complex-rationalp.pcert1 : rtl/rel5/arithmetic/complex-rationalp.pcert0
-rtl/rel5/arithmetic/complex-rationalp.cert : | rtl/rel5/arithmetic/complex-rationalp.pcert1
-
-rtl/rel5/arithmetic/denominator.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/denominator.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/denominator.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- arithmetic/mod-gcd.pcert0 \
- rtl/rel5/arithmetic/denominator.lisp
-rtl/rel5/arithmetic/denominator.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/denominator.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/denominator.pcert1 : rtl/rel5/arithmetic/denominator.pcert0
-rtl/rel5/arithmetic/denominator.cert : | rtl/rel5/arithmetic/denominator.pcert1
-
-rtl/rel5/arithmetic/even-odd.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/even-odd.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/even-odd.pcert0 : \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/even-odd.lisp
-rtl/rel5/arithmetic/even-odd.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/even-odd.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/even-odd.pcert1 : rtl/rel5/arithmetic/even-odd.pcert0
-rtl/rel5/arithmetic/even-odd.cert : | rtl/rel5/arithmetic/even-odd.pcert1
-
-rtl/rel5/arithmetic/even-odd2-proofs.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/even-odd2-proofs.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/even-odd2-proofs.pcert0 : \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/arith.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/even-odd2-proofs.lisp
-rtl/rel5/arithmetic/even-odd2-proofs.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/even-odd2-proofs.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/even-odd2-proofs.pcert1 : rtl/rel5/arithmetic/even-odd2-proofs.pcert0
-rtl/rel5/arithmetic/even-odd2-proofs.cert : | rtl/rel5/arithmetic/even-odd2-proofs.pcert1
-
-rtl/rel5/arithmetic/even-odd2.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/even-odd2.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/even-odd2.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/even-odd2-proofs.pcert0 \
- rtl/rel5/arithmetic/even-odd2.lisp
-rtl/rel5/arithmetic/even-odd2.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/even-odd2.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/even-odd2.pcert1 : rtl/rel5/arithmetic/even-odd2.pcert0
-rtl/rel5/arithmetic/even-odd2.cert : | rtl/rel5/arithmetic/even-odd2.pcert1
-
-rtl/rel5/arithmetic/expo-proofs.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/expo-proofs.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/expo-proofs.pcert0 : \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/arithmetic/unary-divide.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/expt.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel5/arithmetic/common-factor-defuns.pcert0 \
- rtl/rel5/arithmetic/common-factor.pcert0 \
- rtl/rel5/arithmetic/expo-proofs.lisp
-rtl/rel5/arithmetic/expo-proofs.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/expo-proofs.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/expo-proofs.pcert1 : rtl/rel5/arithmetic/expo-proofs.pcert0
-rtl/rel5/arithmetic/expo-proofs.cert : | rtl/rel5/arithmetic/expo-proofs.pcert1
-
-rtl/rel5/arithmetic/expo.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/expo.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/expo.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/arithmetic/expo-proofs.pcert0 \
- rtl/rel5/arithmetic/common-factor-defuns.pcert0 \
- rtl/rel5/arithmetic/expo.lisp
-rtl/rel5/arithmetic/expo.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/expo.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/expo.pcert1 : rtl/rel5/arithmetic/expo.pcert0
-rtl/rel5/arithmetic/expo.cert : | rtl/rel5/arithmetic/expo.pcert1
-
-rtl/rel5/arithmetic/expt-proofs.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/expt-proofs.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/expt-proofs.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/numerator.pcert0 \
- rtl/rel5/arithmetic/denominator.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- arithmetic/top.pcert0 \
- rtl/rel5/arithmetic/even-odd.pcert0 \
- rtl/rel5/arithmetic/expt-proofs.lisp
-rtl/rel5/arithmetic/expt-proofs.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/expt-proofs.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/expt-proofs.pcert1 : rtl/rel5/arithmetic/expt-proofs.pcert0
-rtl/rel5/arithmetic/expt-proofs.cert : | rtl/rel5/arithmetic/expt-proofs.pcert1
-
-rtl/rel5/arithmetic/expt.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/expt.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/expt.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/expt-proofs.pcert0 \
- rtl/rel5/arithmetic/expt.lisp
-rtl/rel5/arithmetic/expt.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/expt.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/expt.pcert1 : rtl/rel5/arithmetic/expt.pcert0
-rtl/rel5/arithmetic/expt.cert : | rtl/rel5/arithmetic/expt.pcert1
-
-rtl/rel5/arithmetic/extra-rules.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/extra-rules.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/extra-rules.pcert0 : \
- rtl/rel5/arithmetic/basic.pcert0 \
- rtl/rel5/arithmetic/extra-rules.lisp
-rtl/rel5/arithmetic/extra-rules.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/extra-rules.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/extra-rules.pcert1 : rtl/rel5/arithmetic/extra-rules.pcert0
-rtl/rel5/arithmetic/extra-rules.cert : | rtl/rel5/arithmetic/extra-rules.pcert1
-
-rtl/rel5/arithmetic/fl-expt.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/fl-expt.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/fl-expt.pcert0 : \
- rtl/rel5/arithmetic/numerator.pcert0 \
- rtl/rel5/arithmetic/denominator.pcert0 \
- rtl/rel5/arithmetic/nniq.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/floor.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/rationalp.pcert0 \
- rtl/rel5/arithmetic/unary-divide.pcert0 \
- rtl/rel5/arithmetic/expt.pcert0 \
- rtl/rel5/arithmetic/expo.pcert0 \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/fl-expt.lisp
-rtl/rel5/arithmetic/fl-expt.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/fl-expt.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/fl-expt.pcert1 : rtl/rel5/arithmetic/fl-expt.pcert0
-rtl/rel5/arithmetic/fl-expt.cert : | rtl/rel5/arithmetic/fl-expt.pcert1
-
-rtl/rel5/arithmetic/fl-hacks.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/fl-hacks.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/fl-hacks.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/inverted-factor.pcert0 \
- rtl/rel5/arithmetic/nniq.pcert0 \
- rtl/rel5/arithmetic/numerator.pcert0 \
- rtl/rel5/arithmetic/denominator.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/product.pcert0 \
- rtl/rel5/arithmetic/unary-divide.pcert0 \
- rtl/rel5/arithmetic/rationalp.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/mod.pcert0 \
- rtl/rel5/arithmetic/even-odd.pcert0 \
- meta/meta-plus-equal.pcert0 \
- rtl/rel5/arithmetic/arith.pcert0 \
- rtl/rel5/arithmetic/fl-hacks.lisp
-rtl/rel5/arithmetic/fl-hacks.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/fl-hacks.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/fl-hacks.pcert1 : rtl/rel5/arithmetic/fl-hacks.pcert0
-rtl/rel5/arithmetic/fl-hacks.cert : | rtl/rel5/arithmetic/fl-hacks.pcert1
-
-rtl/rel5/arithmetic/fl-proofs.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/fl-proofs.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/fl-proofs.pcert0 : \
- rtl/rel5/arithmetic/numerator.pcert0 \
- rtl/rel5/arithmetic/denominator.pcert0 \
- rtl/rel5/arithmetic/nniq.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/floor.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/rationalp.pcert0 \
- rtl/rel5/arithmetic/unary-divide.pcert0 \
- rtl/rel5/arithmetic/common-factor.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/fl-proofs.lisp
-rtl/rel5/arithmetic/fl-proofs.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/fl-proofs.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/fl-proofs.pcert1 : rtl/rel5/arithmetic/fl-proofs.pcert0
-rtl/rel5/arithmetic/fl-proofs.cert : | rtl/rel5/arithmetic/fl-proofs.pcert1
-
-rtl/rel5/arithmetic/fl.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/fl.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/fl.pcert0 : \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/fl-proofs.pcert0 \
- rtl/rel5/arithmetic/fl.lisp
-rtl/rel5/arithmetic/fl.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/fl.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/fl.pcert1 : rtl/rel5/arithmetic/fl.pcert0
-rtl/rel5/arithmetic/fl.cert : | rtl/rel5/arithmetic/fl.pcert1
-
-rtl/rel5/arithmetic/floor-proofs.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/floor-proofs.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/floor-proofs.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/denominator.pcert0 \
- rtl/rel5/arithmetic/numerator.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/nniq.pcert0 \
- rtl/rel5/arithmetic/product.pcert0 \
- rtl/rel5/arithmetic/unary-divide.pcert0 \
- rtl/rel5/arithmetic/rationalp.pcert0 \
- rtl/rel5/arithmetic/inverted-factor.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel5/arithmetic/floor-proofs.lisp
-rtl/rel5/arithmetic/floor-proofs.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/floor-proofs.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/floor-proofs.pcert1 : rtl/rel5/arithmetic/floor-proofs.pcert0
-rtl/rel5/arithmetic/floor-proofs.cert : | rtl/rel5/arithmetic/floor-proofs.pcert1
-
-rtl/rel5/arithmetic/floor.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/floor.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/floor.pcert0 : \
- rtl/rel5/arithmetic/floor-proofs.pcert0 \
- rtl/rel5/arithmetic/floor.lisp
-rtl/rel5/arithmetic/floor.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/floor.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/floor.pcert1 : rtl/rel5/arithmetic/floor.pcert0
-rtl/rel5/arithmetic/floor.cert : | rtl/rel5/arithmetic/floor.pcert1
-
-rtl/rel5/arithmetic/fp.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/fp.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/fp.pcert0 : \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/fp.lisp
-rtl/rel5/arithmetic/fp.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/fp.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/fp.pcert1 : rtl/rel5/arithmetic/fp.pcert0
-rtl/rel5/arithmetic/fp.cert : | rtl/rel5/arithmetic/fp.pcert1
-
-rtl/rel5/arithmetic/fp2.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/fp2.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/fp2.pcert0 : \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- arithmetic-2/meta/non-linear.pcert0 \
- rtl/rel5/arithmetic/inverted-factor.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel5/arithmetic/fp2.lisp
-rtl/rel5/arithmetic/fp2.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/fp2.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/fp2.pcert1 : rtl/rel5/arithmetic/fp2.pcert0
-rtl/rel5/arithmetic/fp2.cert : | rtl/rel5/arithmetic/fp2.pcert1
-
-rtl/rel5/arithmetic/ground-zero.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/ground-zero.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/ground-zero.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.lisp
-rtl/rel5/arithmetic/ground-zero.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/ground-zero.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/ground-zero.pcert1 : rtl/rel5/arithmetic/ground-zero.pcert0
-rtl/rel5/arithmetic/ground-zero.cert : | rtl/rel5/arithmetic/ground-zero.pcert1
-
-rtl/rel5/arithmetic/hacks.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/hacks.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/hacks.pcert0 : \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/hacks.lisp
-rtl/rel5/arithmetic/hacks.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/hacks.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/hacks.pcert1 : rtl/rel5/arithmetic/hacks.pcert0
-rtl/rel5/arithmetic/hacks.cert : | rtl/rel5/arithmetic/hacks.pcert1
-
-rtl/rel5/arithmetic/induct.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/induct.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/induct.pcert0 : \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/induct.lisp
-rtl/rel5/arithmetic/induct.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/induct.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/induct.pcert1 : rtl/rel5/arithmetic/induct.pcert0
-rtl/rel5/arithmetic/induct.cert : | rtl/rel5/arithmetic/induct.pcert1
-
-rtl/rel5/arithmetic/integerp.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/integerp.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/integerp.pcert0 : \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/integerp.lisp
-rtl/rel5/arithmetic/integerp.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/integerp.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/integerp.pcert1 : rtl/rel5/arithmetic/integerp.pcert0
-rtl/rel5/arithmetic/integerp.cert : | rtl/rel5/arithmetic/integerp.pcert1
-
-rtl/rel5/arithmetic/inverted-factor.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/inverted-factor.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/inverted-factor.pcert0 : \
- rtl/rel5/arithmetic/inverted-factor.lisp
-rtl/rel5/arithmetic/inverted-factor.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/inverted-factor.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/inverted-factor.pcert1 : rtl/rel5/arithmetic/inverted-factor.pcert0
-rtl/rel5/arithmetic/inverted-factor.cert : | rtl/rel5/arithmetic/inverted-factor.pcert1
-
-rtl/rel5/arithmetic/mod-expt.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/mod-expt.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/mod-expt.pcert0 : \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/arithmetic/numerator.pcert0 \
- rtl/rel5/arithmetic/denominator.pcert0 \
- rtl/rel5/arithmetic/nniq.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/floor.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/rationalp.pcert0 \
- rtl/rel5/arithmetic/unary-divide.pcert0 \
- rtl/rel5/arithmetic/expt.pcert0 \
- rtl/rel5/arithmetic/expo.pcert0 \
- rtl/rel5/arithmetic/fl-expt.pcert0 \
- rtl/rel5/arithmetic/mod.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/mod-expt.lisp
-rtl/rel5/arithmetic/mod-expt.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/mod-expt.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/mod-expt.pcert1 : rtl/rel5/arithmetic/mod-expt.pcert0
-rtl/rel5/arithmetic/mod-expt.cert : | rtl/rel5/arithmetic/mod-expt.pcert1
-
-rtl/rel5/arithmetic/mod-proofs.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/mod-proofs.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/mod-proofs.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/floor.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/arith.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/product.pcert0 \
- rtl/rel5/arithmetic/complex-rationalp.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/rationalp.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/mod-proofs.lisp
-rtl/rel5/arithmetic/mod-proofs.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/mod-proofs.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/mod-proofs.pcert1 : rtl/rel5/arithmetic/mod-proofs.pcert0
-rtl/rel5/arithmetic/mod-proofs.cert : | rtl/rel5/arithmetic/mod-proofs.pcert1
-
-rtl/rel5/arithmetic/mod.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/mod.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/mod.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/mod-proofs.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/mod.lisp
-rtl/rel5/arithmetic/mod.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/mod.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/mod.pcert1 : rtl/rel5/arithmetic/mod.pcert0
-rtl/rel5/arithmetic/mod.cert : | rtl/rel5/arithmetic/mod.pcert1
-
-rtl/rel5/arithmetic/negative-syntaxp.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/negative-syntaxp.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/negative-syntaxp.pcert0 : \
- rtl/rel5/arithmetic/negative-syntaxp.lisp
-rtl/rel5/arithmetic/negative-syntaxp.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/negative-syntaxp.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/negative-syntaxp.pcert1 : rtl/rel5/arithmetic/negative-syntaxp.pcert0
-rtl/rel5/arithmetic/negative-syntaxp.cert : | rtl/rel5/arithmetic/negative-syntaxp.pcert1
-
-rtl/rel5/arithmetic/nniq.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/nniq.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/nniq.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/denominator.pcert0 \
- rtl/rel5/arithmetic/numerator.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/unary-divide.pcert0 \
- rtl/rel5/arithmetic/product.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/arith.pcert0 \
- arithmetic/rationals.pcert0 \
- arithmetic/idiv.pcert0 \
- arithmetic/idiv.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- rtl/rel5/arithmetic/nniq.lisp
-rtl/rel5/arithmetic/nniq.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/nniq.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/nniq.pcert1 : rtl/rel5/arithmetic/nniq.pcert0
-rtl/rel5/arithmetic/nniq.cert : | rtl/rel5/arithmetic/nniq.pcert1
-
-rtl/rel5/arithmetic/numerator.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/numerator.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/numerator.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/denominator.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/numerator.lisp
-rtl/rel5/arithmetic/numerator.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/numerator.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/numerator.pcert1 : rtl/rel5/arithmetic/numerator.pcert0
-rtl/rel5/arithmetic/numerator.cert : | rtl/rel5/arithmetic/numerator.pcert1
-
-rtl/rel5/arithmetic/power2p.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/power2p.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/power2p.pcert0 : \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/unary-divide.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel5/arithmetic/power2p.lisp
-rtl/rel5/arithmetic/power2p.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/power2p.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/power2p.pcert1 : rtl/rel5/arithmetic/power2p.pcert0
-rtl/rel5/arithmetic/power2p.cert : | rtl/rel5/arithmetic/power2p.pcert1
-
-rtl/rel5/arithmetic/predicate.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/predicate.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/predicate.pcert0 : \
- rtl/rel5/arithmetic/predicate.lisp
-rtl/rel5/arithmetic/predicate.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/predicate.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/predicate.pcert1 : rtl/rel5/arithmetic/predicate.pcert0
-rtl/rel5/arithmetic/predicate.cert : | rtl/rel5/arithmetic/predicate.pcert1
-
-rtl/rel5/arithmetic/product-proofs.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/product-proofs.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/product-proofs.pcert0 : \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/product-proofs.lisp
-rtl/rel5/arithmetic/product-proofs.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/product-proofs.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/product-proofs.pcert1 : rtl/rel5/arithmetic/product-proofs.pcert0
-rtl/rel5/arithmetic/product-proofs.cert : | rtl/rel5/arithmetic/product-proofs.pcert1
-
-rtl/rel5/arithmetic/product.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/product.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/product.pcert0 : \
- rtl/rel5/arithmetic/product-proofs.pcert0 \
- rtl/rel5/arithmetic/product.lisp
-rtl/rel5/arithmetic/product.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/product.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/product.pcert1 : rtl/rel5/arithmetic/product.pcert0
-rtl/rel5/arithmetic/product.cert : | rtl/rel5/arithmetic/product.pcert1
-
-rtl/rel5/arithmetic/rationalp.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/rationalp.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/rationalp.pcert0 : \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/rationalp.lisp
-rtl/rel5/arithmetic/rationalp.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/rationalp.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/rationalp.pcert1 : rtl/rel5/arithmetic/rationalp.pcert0
-rtl/rel5/arithmetic/rationalp.cert : | rtl/rel5/arithmetic/rationalp.pcert1
-
-rtl/rel5/arithmetic/top.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/top.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/top.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/arithmetic/induct.pcert0 \
- rtl/rel5/arithmetic/denominator.pcert0 \
- rtl/rel5/arithmetic/numerator.pcert0 \
- rtl/rel5/arithmetic/nniq.pcert0 \
- rtl/rel5/arithmetic/complex-rationalp.pcert0 \
- rtl/rel5/arithmetic/rationalp.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/arithmetic/arith.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/basic.pcert0 \
- rtl/rel5/arithmetic/unary-divide.pcert0 \
- rtl/rel5/arithmetic/product.pcert0 \
- rtl/rel5/arithmetic/inverted-factor.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/x-2xx.pcert0 \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/arithmetic/expt.pcert0 \
- rtl/rel5/arithmetic/expo.pcert0 \
- rtl/rel5/arithmetic/fl-hacks.pcert0 \
- rtl/rel5/arithmetic/even-odd2.pcert0 \
- rtl/rel5/arithmetic/even-odd.pcert0 \
- rtl/rel5/arithmetic/floor.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/cg.pcert0 \
- rtl/rel5/arithmetic/mod.pcert0 \
- rtl/rel5/arithmetic/fl-expt.pcert0 \
- rtl/rel5/arithmetic/mod-expt.pcert0 \
- rtl/rel5/arithmetic/common-factor.pcert0 \
- rtl/rel5/arithmetic/top.lisp
-rtl/rel5/arithmetic/top.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/top.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/top.pcert1 : rtl/rel5/arithmetic/top.pcert0
-rtl/rel5/arithmetic/top.cert : | rtl/rel5/arithmetic/top.pcert1
-
-rtl/rel5/arithmetic/unary-divide.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/unary-divide.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/unary-divide.pcert0 : \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/inverted-factor.pcert0 \
- rtl/rel5/arithmetic/unary-divide.lisp
-rtl/rel5/arithmetic/unary-divide.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/unary-divide.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/unary-divide.pcert1 : rtl/rel5/arithmetic/unary-divide.pcert0
-rtl/rel5/arithmetic/unary-divide.cert : | rtl/rel5/arithmetic/unary-divide.pcert1
-
-rtl/rel5/arithmetic/x-2xx.pcert0 : no_pcert = 0
-rtl/rel5/arithmetic/x-2xx.pcert0 : acl2x = 0
-rtl/rel5/arithmetic/x-2xx.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/mod-gcd.pcert0 \
- rtl/rel5/arithmetic/x-2xx.lisp
-rtl/rel5/arithmetic/x-2xx.pcert1 : acl2x = 0
-rtl/rel5/arithmetic/x-2xx.pcert1 : no_pcert = 0
-rtl/rel5/arithmetic/x-2xx.pcert1 : rtl/rel5/arithmetic/x-2xx.pcert0
-rtl/rel5/arithmetic/x-2xx.cert : | rtl/rel5/arithmetic/x-2xx.pcert1
-
-rtl/rel5/lib/add.pcert0 : no_pcert = 0
-rtl/rel5/lib/add.pcert0 : acl2x = 0
-rtl/rel5/lib/add.pcert0 : \
- rtl/rel5/support/top.pcert0 \
- rtl/rel5/lib/round.pcert0 \
- rtl/rel5/lib/add.lisp
-rtl/rel5/lib/add.pcert1 : acl2x = 0
-rtl/rel5/lib/add.pcert1 : no_pcert = 0
-rtl/rel5/lib/add.pcert1 : rtl/rel5/lib/add.pcert0
-rtl/rel5/lib/add.cert : | rtl/rel5/lib/add.pcert1
-
-rtl/rel5/lib/arith.pcert0 : no_pcert = 0
-rtl/rel5/lib/arith.pcert0 : acl2x = 0
-rtl/rel5/lib/arith.pcert0 : \
- rtl/rel5/arithmetic/fp.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/expt.pcert0 \
- rtl/rel5/arithmetic/expo.pcert0 \
- rtl/rel5/arithmetic/extra-rules.pcert0 \
- rtl/rel5/support/ash.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel5/lib/arith.lisp
-rtl/rel5/lib/arith.pcert1 : acl2x = 0
-rtl/rel5/lib/arith.pcert1 : no_pcert = 0
-rtl/rel5/lib/arith.pcert1 : rtl/rel5/lib/arith.pcert0
-rtl/rel5/lib/arith.cert : | rtl/rel5/lib/arith.pcert1
-
-rtl/rel5/lib/basic.pcert0 : no_pcert = 0
-rtl/rel5/lib/basic.pcert0 : acl2x = 0
-rtl/rel5/lib/basic.pcert0 : \
- rtl/rel5/support/top.pcert0 \
- rtl/rel5/lib/basic.lisp
-rtl/rel5/lib/basic.pcert1 : acl2x = 0
-rtl/rel5/lib/basic.pcert1 : no_pcert = 0
-rtl/rel5/lib/basic.pcert1 : rtl/rel5/lib/basic.pcert0
-rtl/rel5/lib/basic.cert : | rtl/rel5/lib/basic.pcert1
-
-rtl/rel5/lib/bits.pcert0 : no_pcert = 0
-rtl/rel5/lib/bits.pcert0 : acl2x = 0
-rtl/rel5/lib/bits.pcert0 : \
- rtl/rel5/lib/basic.pcert0 \
- rtl/rel5/support/top.pcert0 \
- rtl/rel5/lib/bits.lisp
-rtl/rel5/lib/bits.pcert1 : acl2x = 0
-rtl/rel5/lib/bits.pcert1 : no_pcert = 0
-rtl/rel5/lib/bits.pcert1 : rtl/rel5/lib/bits.pcert0
-rtl/rel5/lib/bits.cert : | rtl/rel5/lib/bits.pcert1
-
-rtl/rel5/lib/bvecp-helpers.pcert0 : no_pcert = 0
-rtl/rel5/lib/bvecp-helpers.pcert0 : acl2x = 0
-rtl/rel5/lib/bvecp-helpers.pcert0 : \
- rtl/rel5/lib/rtl.pcert0 \
- rtl/rel5/lib/rtlarr.pcert0 \
- rtl/rel5/support/bvecp-helpers.pcert0 \
- rtl/rel5/arithmetic/basic.pcert0 \
- rtl/rel5/lib/bvecp-helpers.lisp
-rtl/rel5/lib/bvecp-helpers.pcert1 : acl2x = 0
-rtl/rel5/lib/bvecp-helpers.pcert1 : no_pcert = 0
-rtl/rel5/lib/bvecp-helpers.pcert1 : rtl/rel5/lib/bvecp-helpers.pcert0
-rtl/rel5/lib/bvecp-helpers.cert : | rtl/rel5/lib/bvecp-helpers.pcert1
-
-rtl/rel5/lib/bvecp-raw-helpers.pcert0 : no_pcert = 0
-rtl/rel5/lib/bvecp-raw-helpers.pcert0 : acl2x = 0
-rtl/rel5/lib/bvecp-raw-helpers.pcert0 : \
- rtl/rel5/lib/rtl.pcert0 \
- rtl/rel5/lib/rtlarr.pcert0 \
- rtl/rel5/support/bvecp-helpers.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/setbits.pcert0 \
- rtl/rel5/support/setbitn.pcert0 \
- rtl/rel5/support/logs.pcert0 \
- rtl/rel5/support/lnot.pcert0 \
- rtl/rel5/support/shft.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/mulcat.pcert0 \
- rtl/rel5/support/encode.pcert0 \
- rtl/rel5/support/decode.pcert0 \
- rtl/rel5/support/land.pcert0 \
- rtl/rel5/support/lior.pcert0 \
- rtl/rel5/support/lxor.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/arithmetic/expo.pcert0 \
- rtl/rel5/arithmetic/basic.pcert0 \
- rtl/rel5/lib/bvecp-raw-helpers.lisp
-rtl/rel5/lib/bvecp-raw-helpers.pcert1 : acl2x = 0
-rtl/rel5/lib/bvecp-raw-helpers.pcert1 : no_pcert = 0
-rtl/rel5/lib/bvecp-raw-helpers.pcert1 : rtl/rel5/lib/bvecp-raw-helpers.pcert0
-rtl/rel5/lib/bvecp-raw-helpers.cert : | rtl/rel5/lib/bvecp-raw-helpers.pcert1
-
-rtl/rel5/lib/clocks.pcert0 : no_pcert = 0
-rtl/rel5/lib/clocks.pcert0 : acl2x = 0
-rtl/rel5/lib/clocks.pcert0 : \
- rtl/rel5/support/clocks.pcert0 \
- rtl/rel5/lib/clocks.lisp
-rtl/rel5/lib/clocks.pcert1 : acl2x = 0
-rtl/rel5/lib/clocks.pcert1 : no_pcert = 0
-rtl/rel5/lib/clocks.pcert1 : rtl/rel5/lib/clocks.pcert0
-rtl/rel5/lib/clocks.cert : | rtl/rel5/lib/clocks.pcert1
-
-rtl/rel5/lib/float.pcert0 : no_pcert = 0
-rtl/rel5/lib/float.pcert0 : acl2x = 0
-rtl/rel5/lib/float.pcert0 : \
- rtl/rel5/support/top.pcert0 \
- rtl/rel5/lib/log.pcert0 \
- rtl/rel5/lib/float.lisp
-rtl/rel5/lib/float.pcert1 : acl2x = 0
-rtl/rel5/lib/float.pcert1 : no_pcert = 0
-rtl/rel5/lib/float.pcert1 : rtl/rel5/lib/float.pcert0
-rtl/rel5/lib/float.cert : | rtl/rel5/lib/float.pcert1
-
-rtl/rel5/lib/log.pcert0 : no_pcert = 0
-rtl/rel5/lib/log.pcert0 : acl2x = 0
-rtl/rel5/lib/log.pcert0 : \
- rtl/rel5/lib/bits.pcert0 \
- rtl/rel5/support/top.pcert0 \
- rtl/rel5/lib/log.lisp
-rtl/rel5/lib/log.pcert1 : acl2x = 0
-rtl/rel5/lib/log.pcert1 : no_pcert = 0
-rtl/rel5/lib/log.pcert1 : rtl/rel5/lib/log.pcert0
-rtl/rel5/lib/log.cert : | rtl/rel5/lib/log.pcert1
-
-rtl/rel5/lib/openers.pcert0 : no_pcert = 0
-rtl/rel5/lib/openers.pcert0 : acl2x = 0
-rtl/rel5/lib/openers.pcert0 : \
- rtl/rel5/support/openers.pcert0 \
- rtl/rel5/lib/openers.lisp
-rtl/rel5/lib/openers.pcert1 : acl2x = 0
-rtl/rel5/lib/openers.pcert1 : no_pcert = 0
-rtl/rel5/lib/openers.pcert1 : rtl/rel5/lib/openers.pcert0
-rtl/rel5/lib/openers.cert : | rtl/rel5/lib/openers.pcert1
-
-rtl/rel5/lib/package-defs.pcert0 : no_pcert = 0
-rtl/rel5/lib/package-defs.pcert0 : acl2x = 0
-rtl/rel5/lib/package-defs.pcert0 : \
- rtl/rel5/support/package-defs.pcert0 \
- rtl/rel5/lib/package-defs.lisp
-rtl/rel5/lib/package-defs.pcert1 : acl2x = 0
-rtl/rel5/lib/package-defs.pcert1 : no_pcert = 0
-rtl/rel5/lib/package-defs.pcert1 : rtl/rel5/lib/package-defs.pcert0
-rtl/rel5/lib/package-defs.cert : | rtl/rel5/lib/package-defs.pcert1
-
-rtl/rel5/lib/reps.pcert0 : no_pcert = 0
-rtl/rel5/lib/reps.pcert0 : acl2x = 0
-rtl/rel5/lib/reps.pcert0 : \
- rtl/rel5/support/ereps.pcert0 \
- rtl/rel5/support/ireps.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/lib/log.pcert0 \
- rtl/rel5/lib/float.pcert0 \
- rtl/rel5/lib/reps.lisp
-rtl/rel5/lib/reps.pcert1 : acl2x = 0
-rtl/rel5/lib/reps.pcert1 : no_pcert = 0
-rtl/rel5/lib/reps.pcert1 : rtl/rel5/lib/reps.pcert0
-rtl/rel5/lib/reps.cert : | rtl/rel5/lib/reps.pcert1
-
-rtl/rel5/lib/rom-helpers.pcert0 : no_pcert = 0
-rtl/rel5/lib/rom-helpers.pcert0 : acl2x = 0
-rtl/rel5/lib/rom-helpers.pcert0 : \
- rtl/rel5/support/rom-helpers.pcert0 \
- rtl/rel5/lib/rom-helpers.lisp
-rtl/rel5/lib/rom-helpers.pcert1 : acl2x = 0
-rtl/rel5/lib/rom-helpers.pcert1 : no_pcert = 0
-rtl/rel5/lib/rom-helpers.pcert1 : rtl/rel5/lib/rom-helpers.pcert0
-rtl/rel5/lib/rom-helpers.cert : | rtl/rel5/lib/rom-helpers.pcert1
-
-rtl/rel5/lib/round.pcert0 : no_pcert = 0
-rtl/rel5/lib/round.pcert0 : acl2x = 0
-rtl/rel5/lib/round.pcert0 : \
- rtl/rel5/support/top.pcert0 \
- rtl/rel5/lib/reps.pcert0 \
- rtl/rel5/lib/round.lisp
-rtl/rel5/lib/round.pcert1 : acl2x = 0
-rtl/rel5/lib/round.pcert1 : no_pcert = 0
-rtl/rel5/lib/round.pcert1 : rtl/rel5/lib/round.pcert0
-rtl/rel5/lib/round.cert : | rtl/rel5/lib/round.pcert1
-
-rtl/rel5/lib/rtl.pcert0 : no_pcert = 0
-rtl/rel5/lib/rtl.pcert0 : acl2x = 0
-rtl/rel5/lib/rtl.pcert0 : \
- rtl/rel5/support/top.pcert0 \
- rtl/rel5/lib/rtl.lisp
-rtl/rel5/lib/rtl.pcert1 : acl2x = 0
-rtl/rel5/lib/rtl.pcert1 : no_pcert = 0
-rtl/rel5/lib/rtl.pcert1 : rtl/rel5/lib/rtl.pcert0
-rtl/rel5/lib/rtl.cert : | rtl/rel5/lib/rtl.pcert1
-
-rtl/rel5/lib/rtlarr.pcert0 : no_pcert = 0
-rtl/rel5/lib/rtlarr.pcert0 : acl2x = 0
-rtl/rel5/lib/rtlarr.pcert0 : \
- rtl/rel5/support/rtlarr.pcert0 \
- rtl/rel5/support/bvecp-helpers.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- misc/total-order.pcert0 \
- rtl/rel5/lib/rtl.pcert0 \
- rtl/rel5/lib/rtlarr.lisp
-rtl/rel5/lib/rtlarr.pcert1 : acl2x = 0
-rtl/rel5/lib/rtlarr.pcert1 : no_pcert = 0
-rtl/rel5/lib/rtlarr.pcert1 : rtl/rel5/lib/rtlarr.pcert0
-rtl/rel5/lib/rtlarr.cert : | rtl/rel5/lib/rtlarr.pcert1
-
-rtl/rel5/lib/simple-loop-helpers.pcert0 : no_pcert = 0
-rtl/rel5/lib/simple-loop-helpers.pcert0 : acl2x = 0
-rtl/rel5/lib/simple-loop-helpers.pcert0 : \
- rtl/rel5/lib/rtl.pcert0 \
- rtl/rel5/lib/rtlarr.pcert0 \
- rtl/rel5/lib/arith.pcert0 \
- rtl/rel5/lib/log.pcert0 \
- rtl/rel5/support/simple-loop-helpers.pcert0 \
- rtl/rel5/lib/simple-loop-helpers.lisp
-rtl/rel5/lib/simple-loop-helpers.pcert1 : acl2x = 0
-rtl/rel5/lib/simple-loop-helpers.pcert1 : no_pcert = 0
-rtl/rel5/lib/simple-loop-helpers.pcert1 : rtl/rel5/lib/simple-loop-helpers.pcert0
-rtl/rel5/lib/simple-loop-helpers.cert : | rtl/rel5/lib/simple-loop-helpers.pcert1
-
-rtl/rel5/lib/simplify-model-helpers.pcert0 : no_pcert = 0
-rtl/rel5/lib/simplify-model-helpers.pcert0 : acl2x = 0
-rtl/rel5/lib/simplify-model-helpers.pcert0 : \
- rtl/rel5/lib/rtl.pcert0 \
- rtl/rel5/lib/arith.pcert0 \
- rtl/rel5/lib/bits.pcert0 \
- rtl/rel5/support/simplify-model-helpers.pcert0 \
- rtl/rel5/lib/simplify-model-helpers.lisp
-rtl/rel5/lib/simplify-model-helpers.pcert1 : acl2x = 0
-rtl/rel5/lib/simplify-model-helpers.pcert1 : no_pcert = 0
-rtl/rel5/lib/simplify-model-helpers.pcert1 : rtl/rel5/lib/simplify-model-helpers.pcert0
-rtl/rel5/lib/simplify-model-helpers.cert : | rtl/rel5/lib/simplify-model-helpers.pcert1
-
-rtl/rel5/lib/top.pcert0 : no_pcert = 0
-rtl/rel5/lib/top.pcert0 : acl2x = 0
-rtl/rel5/lib/top.pcert0 : \
- rtl/rel5/lib/rtl.pcert0 \
- rtl/rel5/lib/rtlarr.pcert0 \
- rtl/rel5/lib/basic.pcert0 \
- rtl/rel5/lib/bits.pcert0 \
- rtl/rel5/lib/log.pcert0 \
- rtl/rel5/lib/float.pcert0 \
- rtl/rel5/lib/reps.pcert0 \
- rtl/rel5/lib/round.pcert0 \
- rtl/rel5/lib/add.pcert0 \
- rtl/rel5/lib/arith.pcert0 \
- rtl/rel5/lib/util.pcert0 \
- rtl/rel5/lib/top.lisp
-rtl/rel5/lib/top.pcert1 : acl2x = 0
-rtl/rel5/lib/top.pcert1 : no_pcert = 0
-rtl/rel5/lib/top.pcert1 : rtl/rel5/lib/top.pcert0
-rtl/rel5/lib/top.cert : | rtl/rel5/lib/top.pcert1
-
-rtl/rel5/lib/util.pcert0 : no_pcert = 0
-rtl/rel5/lib/util.pcert0 : acl2x = 0
-rtl/rel5/lib/util.pcert0 : \
- rtl/rel5/support/util.pcert0 \
- rtl/rel5/lib/util.lisp
-rtl/rel5/lib/util.pcert1 : acl2x = 0
-rtl/rel5/lib/util.pcert1 : no_pcert = 0
-rtl/rel5/lib/util.pcert1 : rtl/rel5/lib/util.pcert0
-rtl/rel5/lib/util.cert : | rtl/rel5/lib/util.pcert1
-
-rtl/rel5/support/add3-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/add3-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/add3-proofs.pcert0 : \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/support/add3-proofs.lisp
-rtl/rel5/support/add3-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/add3-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/add3-proofs.pcert1 : rtl/rel5/support/add3-proofs.pcert0
-rtl/rel5/support/add3-proofs.cert : | rtl/rel5/support/add3-proofs.pcert1
-
-rtl/rel5/support/add3.pcert0 : no_pcert = 0
-rtl/rel5/support/add3.pcert0 : acl2x = 0
-rtl/rel5/support/add3.pcert0 : \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/add3-proofs.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/support/add3.lisp
-rtl/rel5/support/add3.pcert1 : acl2x = 0
-rtl/rel5/support/add3.pcert1 : no_pcert = 0
-rtl/rel5/support/add3.pcert1 : rtl/rel5/support/add3.pcert0
-rtl/rel5/support/add3.cert : | rtl/rel5/support/add3.pcert1
-
-rtl/rel5/support/all-ones.pcert0 : no_pcert = 0
-rtl/rel5/support/all-ones.pcert0 : acl2x = 0
-rtl/rel5/support/all-ones.pcert0 : \
- rtl/rel5/support/all-ones.lisp
-rtl/rel5/support/all-ones.pcert1 : acl2x = 0
-rtl/rel5/support/all-ones.pcert1 : no_pcert = 0
-rtl/rel5/support/all-ones.pcert1 : rtl/rel5/support/all-ones.pcert0
-rtl/rel5/support/all-ones.cert : | rtl/rel5/support/all-ones.pcert1
-
-rtl/rel5/support/ash.pcert0 : no_pcert = 0
-rtl/rel5/support/ash.pcert0 : acl2x = 0
-rtl/rel5/support/ash.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/expt.pcert0 \
- rtl/rel5/arithmetic/expo.pcert0 \
- rtl/rel5/support/ash.lisp
-rtl/rel5/support/ash.pcert1 : acl2x = 0
-rtl/rel5/support/ash.pcert1 : no_pcert = 0
-rtl/rel5/support/ash.pcert1 : rtl/rel5/support/ash.pcert0
-rtl/rel5/support/ash.cert : | rtl/rel5/support/ash.pcert1
-
-rtl/rel5/support/away-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/away-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/away-proofs.pcert0 : \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/away-proofs.lisp
-rtl/rel5/support/away-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/away-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/away-proofs.pcert1 : rtl/rel5/support/away-proofs.pcert0
-rtl/rel5/support/away-proofs.cert : | rtl/rel5/support/away-proofs.pcert1
-
-rtl/rel5/support/away.pcert0 : no_pcert = 0
-rtl/rel5/support/away.pcert0 : acl2x = 0
-rtl/rel5/support/away.pcert0 : \
- rtl/rel5/support/away-proofs.pcert0 \
- rtl/rel5/support/away.lisp
-rtl/rel5/support/away.pcert1 : acl2x = 0
-rtl/rel5/support/away.pcert1 : no_pcert = 0
-rtl/rel5/support/away.pcert1 : rtl/rel5/support/away.pcert0
-rtl/rel5/support/away.cert : | rtl/rel5/support/away.pcert1
-
-rtl/rel5/support/badguys.pcert0 : no_pcert = 0
-rtl/rel5/support/badguys.pcert0 : acl2x = 0
-rtl/rel5/support/badguys.pcert0 : \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/badguys.lisp
-rtl/rel5/support/badguys.pcert1 : acl2x = 0
-rtl/rel5/support/badguys.pcert1 : no_pcert = 0
-rtl/rel5/support/badguys.pcert1 : rtl/rel5/support/badguys.pcert0
-rtl/rel5/support/badguys.cert : | rtl/rel5/support/badguys.pcert1
-
-rtl/rel5/support/bias-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/bias-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/bias-proofs.pcert0 : \
- rtl/rel5/arithmetic/expt.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/support/bias-proofs.lisp
-rtl/rel5/support/bias-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/bias-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/bias-proofs.pcert1 : rtl/rel5/support/bias-proofs.pcert0
-rtl/rel5/support/bias-proofs.cert : | rtl/rel5/support/bias-proofs.pcert1
-
-rtl/rel5/support/bias.pcert0 : no_pcert = 0
-rtl/rel5/support/bias.pcert0 : acl2x = 0
-rtl/rel5/support/bias.pcert0 : \
- rtl/rel5/support/bias-proofs.pcert0 \
- rtl/rel5/support/bias.lisp
-rtl/rel5/support/bias.pcert1 : acl2x = 0
-rtl/rel5/support/bias.pcert1 : no_pcert = 0
-rtl/rel5/support/bias.pcert1 : rtl/rel5/support/bias.pcert0
-rtl/rel5/support/bias.cert : | rtl/rel5/support/bias.pcert1
-
-rtl/rel5/support/bitn-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/bitn-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/bitn-proofs.pcert0 : \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/bitn-proofs.lisp
-rtl/rel5/support/bitn-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/bitn-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/bitn-proofs.pcert1 : rtl/rel5/support/bitn-proofs.pcert0
-rtl/rel5/support/bitn-proofs.cert : | rtl/rel5/support/bitn-proofs.pcert1
-
-rtl/rel5/support/bitn.pcert0 : no_pcert = 0
-rtl/rel5/support/bitn.pcert0 : acl2x = 0
-rtl/rel5/support/bitn.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/support/bitn-proofs.pcert0 \
- rtl/rel5/support/bitn.lisp
-rtl/rel5/support/bitn.pcert1 : acl2x = 0
-rtl/rel5/support/bitn.pcert1 : no_pcert = 0
-rtl/rel5/support/bitn.pcert1 : rtl/rel5/support/bitn.pcert0
-rtl/rel5/support/bitn.cert : | rtl/rel5/support/bitn.pcert1
-
-rtl/rel5/support/bits-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/bits-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/bits-proofs.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/bits-proofs.lisp
-rtl/rel5/support/bits-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/bits-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/bits-proofs.pcert1 : rtl/rel5/support/bits-proofs.pcert0
-rtl/rel5/support/bits-proofs.cert : | rtl/rel5/support/bits-proofs.pcert1
-
-rtl/rel5/support/bits-trunc-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/bits-trunc-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/bits-trunc-proofs.pcert0 : \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/support/log.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/bits-trunc-proofs.lisp
-rtl/rel5/support/bits-trunc-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/bits-trunc-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/bits-trunc-proofs.pcert1 : rtl/rel5/support/bits-trunc-proofs.pcert0
-rtl/rel5/support/bits-trunc-proofs.cert : | rtl/rel5/support/bits-trunc-proofs.pcert1
-
-rtl/rel5/support/bits-trunc.pcert0 : no_pcert = 0
-rtl/rel5/support/bits-trunc.pcert0 : acl2x = 0
-rtl/rel5/support/bits-trunc.pcert0 : \
- rtl/rel5/support/log.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/bits-trunc-proofs.pcert0 \
- rtl/rel5/support/bits-trunc.lisp
-rtl/rel5/support/bits-trunc.pcert1 : acl2x = 0
-rtl/rel5/support/bits-trunc.pcert1 : no_pcert = 0
-rtl/rel5/support/bits-trunc.pcert1 : rtl/rel5/support/bits-trunc.pcert0
-rtl/rel5/support/bits-trunc.cert : | rtl/rel5/support/bits-trunc.pcert1
-
-rtl/rel5/support/bits.pcert0 : no_pcert = 0
-rtl/rel5/support/bits.pcert0 : acl2x = 0
-rtl/rel5/support/bits.pcert0 : \
- rtl/rel5/support/bits-proofs.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/support/bits.lisp
-rtl/rel5/support/bits.pcert1 : acl2x = 0
-rtl/rel5/support/bits.pcert1 : no_pcert = 0
-rtl/rel5/support/bits.pcert1 : rtl/rel5/support/bits.pcert0
-rtl/rel5/support/bits.cert : | rtl/rel5/support/bits.pcert1
-
-rtl/rel5/support/bvecp-helpers.pcert0 : no_pcert = 0
-rtl/rel5/support/bvecp-helpers.pcert0 : acl2x = 0
-rtl/rel5/support/bvecp-helpers.pcert0 : \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/bvecp-lemmas.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bvecp-helpers.lisp
-rtl/rel5/support/bvecp-helpers.pcert1 : acl2x = 0
-rtl/rel5/support/bvecp-helpers.pcert1 : no_pcert = 0
-rtl/rel5/support/bvecp-helpers.pcert1 : rtl/rel5/support/bvecp-helpers.pcert0
-rtl/rel5/support/bvecp-helpers.cert : | rtl/rel5/support/bvecp-helpers.pcert1
-
-rtl/rel5/support/bvecp-lemmas.pcert0 : no_pcert = 0
-rtl/rel5/support/bvecp-lemmas.pcert0 : acl2x = 0
-rtl/rel5/support/bvecp-lemmas.pcert0 : \
- rtl/rel5/arithmetic/expo.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/setbits.pcert0 \
- rtl/rel5/support/setbitn.pcert0 \
- rtl/rel5/support/encode.pcert0 \
- rtl/rel5/support/decode.pcert0 \
- rtl/rel5/support/logs.pcert0 \
- rtl/rel5/support/lnot.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/shft.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/logand.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/mulcat.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/bvecp-lemmas.lisp
-rtl/rel5/support/bvecp-lemmas.pcert1 : acl2x = 0
-rtl/rel5/support/bvecp-lemmas.pcert1 : no_pcert = 0
-rtl/rel5/support/bvecp-lemmas.pcert1 : rtl/rel5/support/bvecp-lemmas.pcert0
-rtl/rel5/support/bvecp-lemmas.cert : | rtl/rel5/support/bvecp-lemmas.pcert1
-
-rtl/rel5/support/bvecp-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/bvecp-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/bvecp-proofs.pcert0 : \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bvecp-proofs.lisp
-rtl/rel5/support/bvecp-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/bvecp-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/bvecp-proofs.pcert1 : rtl/rel5/support/bvecp-proofs.pcert0
-rtl/rel5/support/bvecp-proofs.cert : | rtl/rel5/support/bvecp-proofs.pcert1
-
-rtl/rel5/support/bvecp.pcert0 : no_pcert = 0
-rtl/rel5/support/bvecp.pcert0 : acl2x = 0
-rtl/rel5/support/bvecp.pcert0 : \
- rtl/rel5/support/bvecp-proofs.pcert0 \
- rtl/rel5/support/bvecp.lisp
-rtl/rel5/support/bvecp.pcert1 : acl2x = 0
-rtl/rel5/support/bvecp.pcert1 : no_pcert = 0
-rtl/rel5/support/bvecp.pcert1 : rtl/rel5/support/bvecp.pcert0
-rtl/rel5/support/bvecp.cert : | rtl/rel5/support/bvecp.pcert1
-
-rtl/rel5/support/cat-def.pcert0 : no_pcert = 0
-rtl/rel5/support/cat-def.pcert0 : acl2x = 0
-rtl/rel5/support/cat-def.pcert0 : \
- rtl/rel5/support/cat-def.lisp
-rtl/rel5/support/cat-def.pcert1 : acl2x = 0
-rtl/rel5/support/cat-def.pcert1 : no_pcert = 0
-rtl/rel5/support/cat-def.pcert1 : rtl/rel5/support/cat-def.pcert0
-rtl/rel5/support/cat-def.cert : | rtl/rel5/support/cat-def.pcert1
-
-rtl/rel5/support/cat-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/cat-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/cat-proofs.pcert0 : \
- rtl/rel5/support/cat-def.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/cat-proofs.lisp
-rtl/rel5/support/cat-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/cat-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/cat-proofs.pcert1 : rtl/rel5/support/cat-proofs.pcert0
-rtl/rel5/support/cat-proofs.cert : | rtl/rel5/support/cat-proofs.pcert1
-
-rtl/rel5/support/cat.pcert0 : no_pcert = 0
-rtl/rel5/support/cat.pcert0 : acl2x = 0
-rtl/rel5/support/cat.pcert0 : \
- rtl/rel5/support/cat-def.pcert0 \
- rtl/rel5/support/cat-proofs.pcert0 \
- rtl/rel5/support/cat.lisp
-rtl/rel5/support/cat.pcert1 : acl2x = 0
-rtl/rel5/support/cat.pcert1 : no_pcert = 0
-rtl/rel5/support/cat.pcert1 : rtl/rel5/support/cat.pcert0
-rtl/rel5/support/cat.cert : | rtl/rel5/support/cat.pcert1
-
-rtl/rel5/support/clocks.pcert0 : no_pcert = 0
-rtl/rel5/support/clocks.pcert0 : acl2x = 0
-rtl/rel5/support/clocks.pcert0 : \
- rtl/rel5/support/mod4.pcert0 \
- rtl/rel5/arithmetic/even-odd2.pcert0 \
- rtl/rel5/support/clocks.lisp
-rtl/rel5/support/clocks.pcert1 : acl2x = 0
-rtl/rel5/support/clocks.pcert1 : no_pcert = 0
-rtl/rel5/support/clocks.pcert1 : rtl/rel5/support/clocks.pcert0
-rtl/rel5/support/clocks.cert : | rtl/rel5/support/clocks.pcert1
-
-rtl/rel5/support/decode-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/decode-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/decode-proofs.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/support/ash.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/decode-proofs.lisp
-rtl/rel5/support/decode-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/decode-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/decode-proofs.pcert1 : rtl/rel5/support/decode-proofs.pcert0
-rtl/rel5/support/decode-proofs.cert : | rtl/rel5/support/decode-proofs.pcert1
-
-rtl/rel5/support/decode.pcert0 : no_pcert = 0
-rtl/rel5/support/decode.pcert0 : acl2x = 0
-rtl/rel5/support/decode.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/decode-proofs.pcert0 \
- rtl/rel5/support/decode.lisp
-rtl/rel5/support/decode.pcert1 : acl2x = 0
-rtl/rel5/support/decode.pcert1 : no_pcert = 0
-rtl/rel5/support/decode.pcert1 : rtl/rel5/support/decode.pcert0
-rtl/rel5/support/decode.cert : | rtl/rel5/support/decode.pcert1
-
-rtl/rel5/support/drnd.pcert0 : no_pcert = 0
-rtl/rel5/support/drnd.pcert0 : acl2x = 0
-rtl/rel5/support/drnd.pcert0 : \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/ireps.pcert0 \
- rtl/rel5/support/rnd.pcert0 \
- rtl/rel5/support/bias.pcert0 \
- rtl/rel5/support/sgn.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/support/away.pcert0 \
- rtl/rel5/support/near.pcert0 \
- rtl/rel5/support/near+.pcert0 \
- rtl/rel5/support/sticky.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/drnd.lisp
-rtl/rel5/support/drnd.pcert1 : acl2x = 0
-rtl/rel5/support/drnd.pcert1 : no_pcert = 0
-rtl/rel5/support/drnd.pcert1 : rtl/rel5/support/drnd.pcert0
-rtl/rel5/support/drnd.cert : | rtl/rel5/support/drnd.pcert1
-
-rtl/rel5/support/encode.pcert0 : no_pcert = 0
-rtl/rel5/support/encode.pcert0 : acl2x = 0
-rtl/rel5/support/encode.pcert0 : \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/ash.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/encode.lisp
-rtl/rel5/support/encode.pcert1 : acl2x = 0
-rtl/rel5/support/encode.pcert1 : no_pcert = 0
-rtl/rel5/support/encode.pcert1 : rtl/rel5/support/encode.pcert0
-rtl/rel5/support/encode.cert : | rtl/rel5/support/encode.pcert1
-
-rtl/rel5/support/ereps-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/ereps-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/ereps-proofs.pcert0 : \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/bias.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/mulcat.pcert0 \
- rtl/rel5/support/ereps-proofs.lisp
-rtl/rel5/support/ereps-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/ereps-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/ereps-proofs.pcert1 : rtl/rel5/support/ereps-proofs.pcert0
-rtl/rel5/support/ereps-proofs.cert : | rtl/rel5/support/ereps-proofs.pcert1
-
-rtl/rel5/support/ereps.pcert0 : no_pcert = 0
-rtl/rel5/support/ereps.pcert0 : acl2x = 0
-rtl/rel5/support/ereps.pcert0 : \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/ereps-proofs.pcert0 \
- rtl/rel5/support/ereps.lisp
-rtl/rel5/support/ereps.pcert1 : acl2x = 0
-rtl/rel5/support/ereps.pcert1 : no_pcert = 0
-rtl/rel5/support/ereps.pcert1 : rtl/rel5/support/ereps.pcert0
-rtl/rel5/support/ereps.cert : | rtl/rel5/support/ereps.pcert1
-
-rtl/rel5/support/fadd-extra.pcert0 : no_pcert = 0
-rtl/rel5/support/fadd-extra.pcert0 : acl2x = 0
-rtl/rel5/support/fadd-extra.pcert0 : \
- rtl/rel5/support/fadd-extra0.pcert0 \
- rtl/rel5/support/land.pcert0 \
- rtl/rel5/support/lior.pcert0 \
- rtl/rel5/support/lxor.pcert0 \
- rtl/rel5/support/top1.pcert0 \
- rtl/rel5/support/fadd-extra.lisp
-rtl/rel5/support/fadd-extra.pcert1 : acl2x = 0
-rtl/rel5/support/fadd-extra.pcert1 : no_pcert = 0
-rtl/rel5/support/fadd-extra.pcert1 : rtl/rel5/support/fadd-extra.pcert0
-rtl/rel5/support/fadd-extra.cert : | rtl/rel5/support/fadd-extra.pcert1
-
-rtl/rel5/support/fadd-extra0.pcert0 : no_pcert = 0
-rtl/rel5/support/fadd-extra0.pcert0 : acl2x = 0
-rtl/rel5/support/fadd-extra0.pcert0 : \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/fadd.pcert0 \
- rtl/rel5/support/top1.pcert0 \
- rtl/rel5/support/fadd-extra0.lisp
-rtl/rel5/support/fadd-extra0.pcert1 : acl2x = 0
-rtl/rel5/support/fadd-extra0.pcert1 : no_pcert = 0
-rtl/rel5/support/fadd-extra0.pcert1 : rtl/rel5/support/fadd-extra0.pcert0
-rtl/rel5/support/fadd-extra0.cert : | rtl/rel5/support/fadd-extra0.pcert1
-
-rtl/rel5/support/fadd.pcert0 : no_pcert = 0
-rtl/rel5/support/fadd.pcert0 : acl2x = 0
-rtl/rel5/support/fadd.pcert0 : \
- rtl/rel5/support/stick.pcert0 \
- rtl/rel5/support/lop3.pcert0 \
- rtl/rel5/support/add3.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/lextra0.pcert0 \
- rtl/rel5/support/fadd.lisp
-rtl/rel5/support/fadd.pcert1 : acl2x = 0
-rtl/rel5/support/fadd.pcert1 : no_pcert = 0
-rtl/rel5/support/fadd.pcert1 : rtl/rel5/support/fadd.pcert0
-rtl/rel5/support/fadd.cert : | rtl/rel5/support/fadd.pcert1
-
-rtl/rel5/support/fast-and.pcert0 : no_pcert = 0
-rtl/rel5/support/fast-and.pcert0 : acl2x = 0
-rtl/rel5/support/fast-and.pcert0 : \
- rtl/rel5/support/fast-and.lisp
-rtl/rel5/support/fast-and.pcert1 : acl2x = 0
-rtl/rel5/support/fast-and.pcert1 : no_pcert = 0
-rtl/rel5/support/fast-and.pcert1 : rtl/rel5/support/fast-and.pcert0
-rtl/rel5/support/fast-and.cert : | rtl/rel5/support/fast-and.pcert1
-
-rtl/rel5/support/float-extra.pcert0 : no_pcert = 0
-rtl/rel5/support/float-extra.pcert0 : acl2x = 0
-rtl/rel5/support/float-extra.pcert0 : \
- arithmetic/inequalities.pcert0 \
- rtl/rel5/support/sticky.pcert0 \
- rtl/rel5/support/util.pcert0 \
- rtl/rel5/support/top1.pcert0 \
- rtl/rel5/support/float-extra.lisp
-rtl/rel5/support/float-extra.pcert1 : acl2x = 0
-rtl/rel5/support/float-extra.pcert1 : no_pcert = 0
-rtl/rel5/support/float-extra.pcert1 : rtl/rel5/support/float-extra.pcert0
-rtl/rel5/support/float-extra.cert : | rtl/rel5/support/float-extra.pcert1
-
-rtl/rel5/support/float.pcert0 : no_pcert = 0
-rtl/rel5/support/float.pcert0 : acl2x = 0
-rtl/rel5/support/float.pcert0 : \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/basic.pcert0 \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/cg.pcert0 \
- rtl/rel5/support/float.lisp
-rtl/rel5/support/float.pcert1 : acl2x = 0
-rtl/rel5/support/float.pcert1 : no_pcert = 0
-rtl/rel5/support/float.pcert1 : rtl/rel5/support/float.pcert0
-rtl/rel5/support/float.cert : | rtl/rel5/support/float.pcert1
-
-rtl/rel5/support/ground-zero.pcert0 : no_pcert = 0
-rtl/rel5/support/ground-zero.pcert0 : acl2x = 0
-rtl/rel5/support/ground-zero.pcert0 : \
- rtl/rel5/arithmetic/ground-zero.pcert0 \
- rtl/rel5/support/util.pcert0 \
- rtl/rel5/support/ground-zero.lisp
-rtl/rel5/support/ground-zero.pcert1 : acl2x = 0
-rtl/rel5/support/ground-zero.pcert1 : no_pcert = 0
-rtl/rel5/support/ground-zero.pcert1 : rtl/rel5/support/ground-zero.pcert0
-rtl/rel5/support/ground-zero.cert : | rtl/rel5/support/ground-zero.pcert1
-
-rtl/rel5/support/guards.pcert0 : no_pcert = 0
-rtl/rel5/support/guards.pcert0 : acl2x = 0
-rtl/rel5/support/guards.pcert0 : \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/top1.pcert0 \
- rtl/rel5/support/land.pcert0 \
- rtl/rel5/support/lior.pcert0 \
- rtl/rel5/support/lxor.pcert0 \
- rtl/rel5/support/guards.lisp
-rtl/rel5/support/guards.pcert1 : acl2x = 0
-rtl/rel5/support/guards.pcert1 : no_pcert = 0
-rtl/rel5/support/guards.pcert1 : rtl/rel5/support/guards.pcert0
-rtl/rel5/support/guards.cert : | rtl/rel5/support/guards.pcert1
-
-rtl/rel5/support/ireps.pcert0 : no_pcert = 0
-rtl/rel5/support/ireps.pcert0 : acl2x = 0
-rtl/rel5/support/ireps.pcert0 : \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/bias.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/ireps.lisp
-rtl/rel5/support/ireps.pcert1 : acl2x = 0
-rtl/rel5/support/ireps.pcert1 : no_pcert = 0
-rtl/rel5/support/ireps.pcert1 : rtl/rel5/support/ireps.pcert0
-rtl/rel5/support/ireps.cert : | rtl/rel5/support/ireps.pcert1
-
-rtl/rel5/support/land.pcert0 : no_pcert = 0
-rtl/rel5/support/land.pcert0 : acl2x = 0
-rtl/rel5/support/land.pcert0 : \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/top1.pcert0 \
- rtl/rel5/support/land.lisp
-rtl/rel5/support/land.pcert1 : acl2x = 0
-rtl/rel5/support/land.pcert1 : no_pcert = 0
-rtl/rel5/support/land.pcert1 : rtl/rel5/support/land.pcert0
-rtl/rel5/support/land.cert : | rtl/rel5/support/land.pcert1
-
-rtl/rel5/support/land0-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/land0-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/land0-proofs.pcert0 : \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/all-ones.pcert0 \
- rtl/rel5/support/log.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/logand.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/arithmetic/fl-hacks.pcert0 \
- rtl/rel5/support/land0-proofs.lisp
-rtl/rel5/support/land0-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/land0-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/land0-proofs.pcert1 : rtl/rel5/support/land0-proofs.pcert0
-rtl/rel5/support/land0-proofs.cert : | rtl/rel5/support/land0-proofs.pcert1
-
-rtl/rel5/support/land0.pcert0 : no_pcert = 0
-rtl/rel5/support/land0.pcert0 : acl2x = 0
-rtl/rel5/support/land0.pcert0 : \
- rtl/rel5/support/land0-proofs.pcert0 \
- rtl/rel5/support/land0.lisp
-rtl/rel5/support/land0.pcert1 : acl2x = 0
-rtl/rel5/support/land0.pcert1 : no_pcert = 0
-rtl/rel5/support/land0.pcert1 : rtl/rel5/support/land0.pcert0
-rtl/rel5/support/land0.cert : | rtl/rel5/support/land0.pcert1
-
-rtl/rel5/support/lextra-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/lextra-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/lextra-proofs.pcert0 : \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/logand.pcert0 \
- rtl/rel5/support/logior.pcert0 \
- rtl/rel5/support/logxor.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/lextra-proofs.lisp
-rtl/rel5/support/lextra-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/lextra-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/lextra-proofs.pcert1 : rtl/rel5/support/lextra-proofs.pcert0
-rtl/rel5/support/lextra-proofs.cert : | rtl/rel5/support/lextra-proofs.pcert1
-
-rtl/rel5/support/lextra.pcert0 : no_pcert = 0
-rtl/rel5/support/lextra.pcert0 : acl2x = 0
-rtl/rel5/support/lextra.pcert0 : \
- rtl/rel5/support/land.pcert0 \
- rtl/rel5/support/lior.pcert0 \
- rtl/rel5/support/lxor.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/lextra0.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/support/merge2.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bits-trunc.pcert0 \
- rtl/rel5/support/fadd.pcert0 \
- rtl/rel5/support/lextra.lisp
-rtl/rel5/support/lextra.pcert1 : acl2x = 0
-rtl/rel5/support/lextra.pcert1 : no_pcert = 0
-rtl/rel5/support/lextra.pcert1 : rtl/rel5/support/lextra.pcert0
-rtl/rel5/support/lextra.cert : | rtl/rel5/support/lextra.pcert1
-
-rtl/rel5/support/lextra0.pcert0 : no_pcert = 0
-rtl/rel5/support/lextra0.pcert0 : acl2x = 0
-rtl/rel5/support/lextra0.pcert0 : \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/support/lextra-proofs.pcert0 \
- rtl/rel5/support/lextra0.lisp
-rtl/rel5/support/lextra0.pcert1 : acl2x = 0
-rtl/rel5/support/lextra0.pcert1 : no_pcert = 0
-rtl/rel5/support/lextra0.pcert1 : rtl/rel5/support/lextra0.pcert0
-rtl/rel5/support/lextra0.cert : | rtl/rel5/support/lextra0.pcert1
-
-rtl/rel5/support/lior.pcert0 : no_pcert = 0
-rtl/rel5/support/lior.pcert0 : acl2x = 0
-rtl/rel5/support/lior.pcert0 : \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/top1.pcert0 \
- rtl/rel5/support/lior.lisp
-rtl/rel5/support/lior.pcert1 : acl2x = 0
-rtl/rel5/support/lior.pcert1 : no_pcert = 0
-rtl/rel5/support/lior.pcert1 : rtl/rel5/support/lior.pcert0
-rtl/rel5/support/lior.cert : | rtl/rel5/support/lior.pcert1
-
-rtl/rel5/support/lior0-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/lior0-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/lior0-proofs.pcert0 : \
- rtl/rel5/support/all-ones.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/logior.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/lior0-proofs.lisp
-rtl/rel5/support/lior0-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/lior0-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/lior0-proofs.pcert1 : rtl/rel5/support/lior0-proofs.pcert0
-rtl/rel5/support/lior0-proofs.cert : | rtl/rel5/support/lior0-proofs.pcert1
-
-rtl/rel5/support/lior0.pcert0 : no_pcert = 0
-rtl/rel5/support/lior0.pcert0 : acl2x = 0
-rtl/rel5/support/lior0.pcert0 : \
- rtl/rel5/support/lior0-proofs.pcert0 \
- rtl/rel5/support/lior0.lisp
-rtl/rel5/support/lior0.pcert1 : acl2x = 0
-rtl/rel5/support/lior0.pcert1 : no_pcert = 0
-rtl/rel5/support/lior0.pcert1 : rtl/rel5/support/lior0.pcert0
-rtl/rel5/support/lior0.cert : | rtl/rel5/support/lior0.pcert1
-
-rtl/rel5/support/lnot-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/lnot-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/lnot-proofs.pcert0 : \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/arithmetic/expt.pcert0 \
- rtl/rel5/arithmetic/mod.pcert0 \
- rtl/rel5/arithmetic/mod.pcert0 \
- rtl/rel5/arithmetic/arith.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/lnot-proofs.lisp
-rtl/rel5/support/lnot-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/lnot-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/lnot-proofs.pcert1 : rtl/rel5/support/lnot-proofs.pcert0
-rtl/rel5/support/lnot-proofs.cert : | rtl/rel5/support/lnot-proofs.pcert1
-
-rtl/rel5/support/lnot.pcert0 : no_pcert = 0
-rtl/rel5/support/lnot.pcert0 : acl2x = 0
-rtl/rel5/support/lnot.pcert0 : \
- rtl/rel5/support/lnot-proofs.pcert0 \
- rtl/rel5/support/lnot.lisp
-rtl/rel5/support/lnot.pcert1 : acl2x = 0
-rtl/rel5/support/lnot.pcert1 : no_pcert = 0
-rtl/rel5/support/lnot.pcert1 : rtl/rel5/support/lnot.pcert0
-rtl/rel5/support/lnot.cert : | rtl/rel5/support/lnot.pcert1
-
-rtl/rel5/support/log-equal.pcert0 : no_pcert = 0
-rtl/rel5/support/log-equal.pcert0 : acl2x = 0
-rtl/rel5/support/log-equal.pcert0 : \
- rtl/rel5/support/log-equal.lisp
-rtl/rel5/support/log-equal.pcert1 : acl2x = 0
-rtl/rel5/support/log-equal.pcert1 : no_pcert = 0
-rtl/rel5/support/log-equal.pcert1 : rtl/rel5/support/log-equal.pcert0
-rtl/rel5/support/log-equal.cert : | rtl/rel5/support/log-equal.pcert1
-
-rtl/rel5/support/log-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/log-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/log-proofs.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/lognot.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/lnot.pcert0 \
- rtl/rel5/support/logior.pcert0 \
- rtl/rel5/support/logand.pcert0 \
- rtl/rel5/support/logxor.pcert0 \
- rtl/rel5/support/log-proofs.lisp
-rtl/rel5/support/log-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/log-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/log-proofs.pcert1 : rtl/rel5/support/log-proofs.pcert0
-rtl/rel5/support/log-proofs.cert : | rtl/rel5/support/log-proofs.pcert1
-
-rtl/rel5/support/log.pcert0 : no_pcert = 0
-rtl/rel5/support/log.pcert0 : acl2x = 0
-rtl/rel5/support/log.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/log-proofs.pcert0 \
- rtl/rel5/support/lnot.pcert0 \
- rtl/rel5/support/logand.pcert0 \
- rtl/rel5/support/logior.pcert0 \
- rtl/rel5/support/logxor.pcert0 \
- rtl/rel5/support/log.lisp
-rtl/rel5/support/log.pcert1 : acl2x = 0
-rtl/rel5/support/log.pcert1 : no_pcert = 0
-rtl/rel5/support/log.pcert1 : rtl/rel5/support/log.pcert0
-rtl/rel5/support/log.cert : | rtl/rel5/support/log.pcert1
-
-rtl/rel5/support/logand-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/logand-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/logand-proofs.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/arithmetic/induct.pcert0 \
- rtl/rel5/support/lognot.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/logand-proofs.lisp
-rtl/rel5/support/logand-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/logand-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/logand-proofs.pcert1 : rtl/rel5/support/logand-proofs.pcert0
-rtl/rel5/support/logand-proofs.cert : | rtl/rel5/support/logand-proofs.pcert1
-
-rtl/rel5/support/logand.pcert0 : no_pcert = 0
-rtl/rel5/support/logand.pcert0 : acl2x = 0
-rtl/rel5/support/logand.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/logand-proofs.pcert0 \
- rtl/rel5/support/logand.lisp
-rtl/rel5/support/logand.pcert1 : acl2x = 0
-rtl/rel5/support/logand.pcert1 : no_pcert = 0
-rtl/rel5/support/logand.pcert1 : rtl/rel5/support/logand.pcert0
-rtl/rel5/support/logand.cert : | rtl/rel5/support/logand.pcert1
-
-rtl/rel5/support/logeqv.pcert0 : no_pcert = 0
-rtl/rel5/support/logeqv.pcert0 : acl2x = 0
-rtl/rel5/support/logeqv.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/logior.pcert0 \
- rtl/rel5/support/logand.pcert0 \
- rtl/rel5/support/logorc1.pcert0 \
- rtl/rel5/support/lognot.pcert0 \
- rtl/rel5/support/logeqv.lisp
-rtl/rel5/support/logeqv.pcert1 : acl2x = 0
-rtl/rel5/support/logeqv.pcert1 : no_pcert = 0
-rtl/rel5/support/logeqv.pcert1 : rtl/rel5/support/logeqv.pcert0
-rtl/rel5/support/logeqv.cert : | rtl/rel5/support/logeqv.pcert1
-
-rtl/rel5/support/logior-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/logior-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/logior-proofs.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/logand.pcert0 \
- rtl/rel5/support/lognot.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/logior-proofs.lisp
-rtl/rel5/support/logior-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/logior-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/logior-proofs.pcert1 : rtl/rel5/support/logior-proofs.pcert0
-rtl/rel5/support/logior-proofs.cert : | rtl/rel5/support/logior-proofs.pcert1
-
-rtl/rel5/support/logior.pcert0 : no_pcert = 0
-rtl/rel5/support/logior.pcert0 : acl2x = 0
-rtl/rel5/support/logior.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/logior-proofs.pcert0 \
- rtl/rel5/support/logior.lisp
-rtl/rel5/support/logior.pcert1 : acl2x = 0
-rtl/rel5/support/logior.pcert1 : no_pcert = 0
-rtl/rel5/support/logior.pcert1 : rtl/rel5/support/logior.pcert0
-rtl/rel5/support/logior.cert : | rtl/rel5/support/logior.pcert1
-
-rtl/rel5/support/logior1-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/logior1-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/logior1-proofs.pcert0 : \
- rtl/rel5/support/logior1-proofs.lisp
-rtl/rel5/support/logior1-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/logior1-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/logior1-proofs.pcert1 : rtl/rel5/support/logior1-proofs.pcert0
-rtl/rel5/support/logior1-proofs.cert : | rtl/rel5/support/logior1-proofs.pcert1
-
-rtl/rel5/support/logior1.pcert0 : no_pcert = 0
-rtl/rel5/support/logior1.pcert0 : acl2x = 0
-rtl/rel5/support/logior1.pcert0 : \
- rtl/rel5/support/logior1-proofs.pcert0 \
- rtl/rel5/support/logior1.lisp
-rtl/rel5/support/logior1.pcert1 : acl2x = 0
-rtl/rel5/support/logior1.pcert1 : no_pcert = 0
-rtl/rel5/support/logior1.pcert1 : rtl/rel5/support/logior1.pcert0
-rtl/rel5/support/logior1.cert : | rtl/rel5/support/logior1.pcert1
-
-rtl/rel5/support/lognot.pcert0 : no_pcert = 0
-rtl/rel5/support/lognot.pcert0 : acl2x = 0
-rtl/rel5/support/lognot.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/lognot.lisp
-rtl/rel5/support/lognot.pcert1 : acl2x = 0
-rtl/rel5/support/lognot.pcert1 : no_pcert = 0
-rtl/rel5/support/lognot.pcert1 : rtl/rel5/support/lognot.pcert0
-rtl/rel5/support/lognot.cert : | rtl/rel5/support/lognot.pcert1
-
-rtl/rel5/support/logorc1.pcert0 : no_pcert = 0
-rtl/rel5/support/logorc1.pcert0 : acl2x = 0
-rtl/rel5/support/logorc1.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/logior.pcert0 \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/support/lognot.pcert0 \
- rtl/rel5/support/logorc1.lisp
-rtl/rel5/support/logorc1.pcert1 : acl2x = 0
-rtl/rel5/support/logorc1.pcert1 : no_pcert = 0
-rtl/rel5/support/logorc1.pcert1 : rtl/rel5/support/logorc1.pcert0
-rtl/rel5/support/logorc1.cert : | rtl/rel5/support/logorc1.pcert1
-
-rtl/rel5/support/logs.pcert0 : no_pcert = 0
-rtl/rel5/support/logs.pcert0 : acl2x = 0
-rtl/rel5/support/logs.pcert0 : \
- rtl/rel5/support/logs.lisp
-rtl/rel5/support/logs.pcert1 : acl2x = 0
-rtl/rel5/support/logs.pcert1 : no_pcert = 0
-rtl/rel5/support/logs.pcert1 : rtl/rel5/support/logs.pcert0
-rtl/rel5/support/logs.cert : | rtl/rel5/support/logs.pcert1
-
-rtl/rel5/support/logxor.pcert0 : no_pcert = 0
-rtl/rel5/support/logxor.pcert0 : acl2x = 0
-rtl/rel5/support/logxor.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/logeqv.pcert0 \
- rtl/rel5/support/logorc1.pcert0 \
- rtl/rel5/support/lognot.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/logxor.lisp
-rtl/rel5/support/logxor.pcert1 : acl2x = 0
-rtl/rel5/support/logxor.pcert1 : no_pcert = 0
-rtl/rel5/support/logxor.pcert1 : rtl/rel5/support/logxor.pcert0
-rtl/rel5/support/logxor.cert : | rtl/rel5/support/logxor.pcert1
-
-rtl/rel5/support/lop1-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/lop1-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/lop1-proofs.pcert0 : \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/lop1-proofs.lisp
-rtl/rel5/support/lop1-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/lop1-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/lop1-proofs.pcert1 : rtl/rel5/support/lop1-proofs.pcert0
-rtl/rel5/support/lop1-proofs.cert : | rtl/rel5/support/lop1-proofs.pcert1
-
-rtl/rel5/support/lop1.pcert0 : no_pcert = 0
-rtl/rel5/support/lop1.pcert0 : acl2x = 0
-rtl/rel5/support/lop1.pcert0 : \
- rtl/rel5/support/lop1-proofs.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/lop1.lisp
-rtl/rel5/support/lop1.pcert1 : acl2x = 0
-rtl/rel5/support/lop1.pcert1 : no_pcert = 0
-rtl/rel5/support/lop1.pcert1 : rtl/rel5/support/lop1.pcert0
-rtl/rel5/support/lop1.cert : | rtl/rel5/support/lop1.pcert1
-
-rtl/rel5/support/lop2-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/lop2-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/lop2-proofs.pcert0 : \
- rtl/rel5/support/lop1.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/logior.pcert0 \
- rtl/rel5/support/lop2-proofs.lisp
-rtl/rel5/support/lop2-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/lop2-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/lop2-proofs.pcert1 : rtl/rel5/support/lop2-proofs.pcert0
-rtl/rel5/support/lop2-proofs.cert : | rtl/rel5/support/lop2-proofs.pcert1
-
-rtl/rel5/support/lop2.pcert0 : no_pcert = 0
-rtl/rel5/support/lop2.pcert0 : acl2x = 0
-rtl/rel5/support/lop2.pcert0 : \
- rtl/rel5/support/lop1.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/lop2-proofs.pcert0 \
- rtl/rel5/support/lop2.lisp
-rtl/rel5/support/lop2.pcert1 : acl2x = 0
-rtl/rel5/support/lop2.pcert1 : no_pcert = 0
-rtl/rel5/support/lop2.pcert1 : rtl/rel5/support/lop2.pcert0
-rtl/rel5/support/lop2.cert : | rtl/rel5/support/lop2.pcert1
-
-rtl/rel5/support/lop3-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/lop3-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/lop3-proofs.pcert0 : \
- rtl/rel5/support/lop2.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/support/lop3-proofs.lisp
-rtl/rel5/support/lop3-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/lop3-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/lop3-proofs.pcert1 : rtl/rel5/support/lop3-proofs.pcert0
-rtl/rel5/support/lop3-proofs.cert : | rtl/rel5/support/lop3-proofs.pcert1
-
-rtl/rel5/support/lop3.pcert0 : no_pcert = 0
-rtl/rel5/support/lop3.pcert0 : acl2x = 0
-rtl/rel5/support/lop3.pcert0 : \
- rtl/rel5/support/lop2.pcert0 \
- rtl/rel5/support/lop3-proofs.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/support/lop3.lisp
-rtl/rel5/support/lop3.pcert1 : acl2x = 0
-rtl/rel5/support/lop3.pcert1 : no_pcert = 0
-rtl/rel5/support/lop3.pcert1 : rtl/rel5/support/lop3.pcert0
-rtl/rel5/support/lop3.cert : | rtl/rel5/support/lop3.pcert1
-
-rtl/rel5/support/lxor.pcert0 : no_pcert = 0
-rtl/rel5/support/lxor.pcert0 : acl2x = 0
-rtl/rel5/support/lxor.pcert0 : \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/support/top1.pcert0 \
- rtl/rel5/support/lxor.lisp
-rtl/rel5/support/lxor.pcert1 : acl2x = 0
-rtl/rel5/support/lxor.pcert1 : no_pcert = 0
-rtl/rel5/support/lxor.pcert1 : rtl/rel5/support/lxor.pcert0
-rtl/rel5/support/lxor.cert : | rtl/rel5/support/lxor.pcert1
-
-rtl/rel5/support/lxor0-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/lxor0-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/lxor0-proofs.pcert0 : \
- rtl/rel5/support/all-ones.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/logand.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/lxor0-proofs.lisp
-rtl/rel5/support/lxor0-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/lxor0-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/lxor0-proofs.pcert1 : rtl/rel5/support/lxor0-proofs.pcert0
-rtl/rel5/support/lxor0-proofs.cert : | rtl/rel5/support/lxor0-proofs.pcert1
-
-rtl/rel5/support/lxor0.pcert0 : no_pcert = 0
-rtl/rel5/support/lxor0.pcert0 : acl2x = 0
-rtl/rel5/support/lxor0.pcert0 : \
- rtl/rel5/support/lxor0-proofs.pcert0 \
- rtl/rel5/support/lxor0.lisp
-rtl/rel5/support/lxor0.pcert1 : acl2x = 0
-rtl/rel5/support/lxor0.pcert1 : no_pcert = 0
-rtl/rel5/support/lxor0.pcert1 : rtl/rel5/support/lxor0.pcert0
-rtl/rel5/support/lxor0.cert : | rtl/rel5/support/lxor0.pcert1
-
-rtl/rel5/support/merge.pcert0 : no_pcert = 0
-rtl/rel5/support/merge.pcert0 : acl2x = 0
-rtl/rel5/support/merge.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/log.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/lnot.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/logior.pcert0 \
- rtl/rel5/support/logand.pcert0 \
- rtl/rel5/support/logxor.pcert0 \
- rtl/rel5/support/ocat.pcert0 \
- rtl/rel5/support/sumbits.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/merge.lisp
-rtl/rel5/support/merge.pcert1 : acl2x = 0
-rtl/rel5/support/merge.pcert1 : no_pcert = 0
-rtl/rel5/support/merge.pcert1 : rtl/rel5/support/merge.pcert0
-rtl/rel5/support/merge.cert : | rtl/rel5/support/merge.pcert1
-
-rtl/rel5/support/merge2.pcert0 : no_pcert = 0
-rtl/rel5/support/merge2.pcert0 : acl2x = 0
-rtl/rel5/support/merge2.pcert0 : \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/support/logs.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/merge2.lisp
-rtl/rel5/support/merge2.pcert1 : acl2x = 0
-rtl/rel5/support/merge2.pcert1 : no_pcert = 0
-rtl/rel5/support/merge2.pcert1 : rtl/rel5/support/merge2.pcert0
-rtl/rel5/support/merge2.cert : | rtl/rel5/support/merge2.pcert1
-
-rtl/rel5/support/mod4.pcert0 : no_pcert = 0
-rtl/rel5/support/mod4.pcert0 : acl2x = 0
-rtl/rel5/support/mod4.pcert0 : \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/mod4.lisp
-rtl/rel5/support/mod4.pcert1 : acl2x = 0
-rtl/rel5/support/mod4.pcert1 : no_pcert = 0
-rtl/rel5/support/mod4.pcert1 : rtl/rel5/support/mod4.pcert0
-rtl/rel5/support/mod4.cert : | rtl/rel5/support/mod4.pcert1
-
-rtl/rel5/support/model-helpers.pcert0 : no_pcert = 0
-rtl/rel5/support/model-helpers.pcert0 : acl2x = 0
-rtl/rel5/support/model-helpers.pcert0 : \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/model-helpers.lisp
-rtl/rel5/support/model-helpers.pcert1 : acl2x = 0
-rtl/rel5/support/model-helpers.pcert1 : no_pcert = 0
-rtl/rel5/support/model-helpers.pcert1 : rtl/rel5/support/model-helpers.pcert0
-rtl/rel5/support/model-helpers.cert : | rtl/rel5/support/model-helpers.pcert1
-
-rtl/rel5/support/mulcat-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/mulcat-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/mulcat-proofs.pcert0 : \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/cat-def.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/mulcat-proofs.lisp
-rtl/rel5/support/mulcat-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/mulcat-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/mulcat-proofs.pcert1 : rtl/rel5/support/mulcat-proofs.pcert0
-rtl/rel5/support/mulcat-proofs.cert : | rtl/rel5/support/mulcat-proofs.pcert1
-
-rtl/rel5/support/mulcat.pcert0 : no_pcert = 0
-rtl/rel5/support/mulcat.pcert0 : acl2x = 0
-rtl/rel5/support/mulcat.pcert0 : \
- rtl/rel5/support/cat-def.pcert0 \
- rtl/rel5/support/mulcat-proofs.pcert0 \
- rtl/rel5/support/mulcat.lisp
-rtl/rel5/support/mulcat.pcert1 : acl2x = 0
-rtl/rel5/support/mulcat.pcert1 : no_pcert = 0
-rtl/rel5/support/mulcat.pcert1 : rtl/rel5/support/mulcat.pcert0
-rtl/rel5/support/mulcat.cert : | rtl/rel5/support/mulcat.pcert1
-
-rtl/rel5/support/near+-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/near+-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/near+-proofs.pcert0 : \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/support/away.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/arithmetic/predicate.pcert0 \
- rtl/rel5/arithmetic/cg.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/near+-proofs.lisp
-rtl/rel5/support/near+-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/near+-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/near+-proofs.pcert1 : rtl/rel5/support/near+-proofs.pcert0
-rtl/rel5/support/near+-proofs.cert : | rtl/rel5/support/near+-proofs.pcert1
-
-rtl/rel5/support/near+.pcert0 : no_pcert = 0
-rtl/rel5/support/near+.pcert0 : acl2x = 0
-rtl/rel5/support/near+.pcert0 : \
- rtl/rel5/support/near+-proofs.pcert0 \
- rtl/rel5/support/near+.lisp
-rtl/rel5/support/near+.pcert1 : acl2x = 0
-rtl/rel5/support/near+.pcert1 : no_pcert = 0
-rtl/rel5/support/near+.pcert1 : rtl/rel5/support/near+.pcert0
-rtl/rel5/support/near+.cert : | rtl/rel5/support/near+.pcert1
-
-rtl/rel5/support/near-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/near-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/near-proofs.pcert0 : \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/away.pcert0 \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/support/near-proofs.lisp
-rtl/rel5/support/near-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/near-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/near-proofs.pcert1 : rtl/rel5/support/near-proofs.pcert0
-rtl/rel5/support/near-proofs.cert : | rtl/rel5/support/near-proofs.pcert1
-
-rtl/rel5/support/near.pcert0 : no_pcert = 0
-rtl/rel5/support/near.pcert0 : acl2x = 0
-rtl/rel5/support/near.pcert0 : \
- rtl/rel5/support/near-proofs.pcert0 \
- rtl/rel5/support/near.lisp
-rtl/rel5/support/near.pcert1 : acl2x = 0
-rtl/rel5/support/near.pcert1 : no_pcert = 0
-rtl/rel5/support/near.pcert1 : rtl/rel5/support/near.pcert0
-rtl/rel5/support/near.cert : | rtl/rel5/support/near.pcert1
-
-rtl/rel5/support/ocat.pcert0 : no_pcert = 0
-rtl/rel5/support/ocat.pcert0 : acl2x = 0
-rtl/rel5/support/ocat.pcert0 : \
- rtl/rel5/arithmetic/expt.pcert0 \
- rtl/rel5/arithmetic/expo.pcert0 \
- rtl/rel5/arithmetic/arith2.pcert0 \
- rtl/rel5/arithmetic/fp2.pcert0 \
- rtl/rel5/arithmetic/integerp.pcert0 \
- rtl/rel5/support/ocat.lisp
-rtl/rel5/support/ocat.pcert1 : acl2x = 0
-rtl/rel5/support/ocat.pcert1 : no_pcert = 0
-rtl/rel5/support/ocat.pcert1 : rtl/rel5/support/ocat.pcert0
-rtl/rel5/support/ocat.cert : | rtl/rel5/support/ocat.pcert1
-
-rtl/rel5/support/oddr-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/oddr-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/oddr-proofs.pcert0 : \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/support/away.pcert0 \
- rtl/rel5/support/near.pcert0 \
- rtl/rel5/support/oddr-proofs.lisp
-rtl/rel5/support/oddr-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/oddr-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/oddr-proofs.pcert1 : rtl/rel5/support/oddr-proofs.pcert0
-rtl/rel5/support/oddr-proofs.cert : | rtl/rel5/support/oddr-proofs.pcert1
-
-rtl/rel5/support/oddr.pcert0 : no_pcert = 0
-rtl/rel5/support/oddr.pcert0 : acl2x = 0
-rtl/rel5/support/oddr.pcert0 : \
- rtl/rel5/support/oddr-proofs.pcert0 \
- rtl/rel5/support/oddr.lisp
-rtl/rel5/support/oddr.pcert1 : acl2x = 0
-rtl/rel5/support/oddr.pcert1 : no_pcert = 0
-rtl/rel5/support/oddr.pcert1 : rtl/rel5/support/oddr.pcert0
-rtl/rel5/support/oddr.cert : | rtl/rel5/support/oddr.pcert1
-
-rtl/rel5/support/openers.pcert0 : no_pcert = 0
-rtl/rel5/support/openers.pcert0 : acl2x = 0
-rtl/rel5/support/openers.pcert0 : \
- rtl/rel5/support/openers.lisp
-rtl/rel5/support/openers.pcert1 : acl2x = 0
-rtl/rel5/support/openers.pcert1 : no_pcert = 0
-rtl/rel5/support/openers.pcert1 : rtl/rel5/support/openers.pcert0
-rtl/rel5/support/openers.cert : | rtl/rel5/support/openers.pcert1
-
-rtl/rel5/support/package-defs.pcert0 : no_pcert = 0
-rtl/rel5/support/package-defs.pcert0 : acl2x = 0
-rtl/rel5/support/package-defs.pcert0 : \
- rtl/rel5/support/package-defs.lisp
-rtl/rel5/support/package-defs.pcert1 : acl2x = 0
-rtl/rel5/support/package-defs.pcert1 : no_pcert = 0
-rtl/rel5/support/package-defs.pcert1 : rtl/rel5/support/package-defs.pcert0
-rtl/rel5/support/package-defs.cert : | rtl/rel5/support/package-defs.pcert1
-
-rtl/rel5/support/rewrite-theory.pcert0 : no_pcert = 0
-rtl/rel5/support/rewrite-theory.pcert0 : acl2x = 0
-rtl/rel5/support/rewrite-theory.pcert0 : \
- rtl/rel5/support/rewrite-theory.lisp
-rtl/rel5/support/rewrite-theory.pcert1 : acl2x = 0
-rtl/rel5/support/rewrite-theory.pcert1 : no_pcert = 0
-rtl/rel5/support/rewrite-theory.pcert1 : rtl/rel5/support/rewrite-theory.pcert0
-rtl/rel5/support/rewrite-theory.cert : | rtl/rel5/support/rewrite-theory.pcert1
-
-rtl/rel5/support/rnd.pcert0 : no_pcert = 0
-rtl/rel5/support/rnd.pcert0 : acl2x = 0
-rtl/rel5/support/rnd.pcert0 : \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/support/away.pcert0 \
- rtl/rel5/support/near.pcert0 \
- rtl/rel5/support/near+.pcert0 \
- rtl/rel5/support/sticky.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/bits-trunc.pcert0 \
- rtl/rel5/support/rnd.lisp
-rtl/rel5/support/rnd.pcert1 : acl2x = 0
-rtl/rel5/support/rnd.pcert1 : no_pcert = 0
-rtl/rel5/support/rnd.pcert1 : rtl/rel5/support/rnd.pcert0
-rtl/rel5/support/rnd.cert : | rtl/rel5/support/rnd.pcert1
-
-rtl/rel5/support/rom-helpers.pcert0 : no_pcert = 0
-rtl/rel5/support/rom-helpers.pcert0 : acl2x = 0
-rtl/rel5/support/rom-helpers.pcert0 : \
- rtl/rel5/support/rom-helpers.lisp
-rtl/rel5/support/rom-helpers.pcert1 : acl2x = 0
-rtl/rel5/support/rom-helpers.pcert1 : no_pcert = 0
-rtl/rel5/support/rom-helpers.pcert1 : rtl/rel5/support/rom-helpers.pcert0
-rtl/rel5/support/rom-helpers.cert : | rtl/rel5/support/rom-helpers.pcert1
-
-rtl/rel5/support/round-extra.pcert0 : no_pcert = 0
-rtl/rel5/support/round-extra.pcert0 : acl2x = 0
-rtl/rel5/support/round-extra.pcert0 : \
- rtl/rel5/support/sticky.pcert0 \
- rtl/rel5/support/util.pcert0 \
- rtl/rel5/support/top1.pcert0 \
- rtl/rel5/support/round-extra.lisp
-rtl/rel5/support/round-extra.pcert1 : acl2x = 0
-rtl/rel5/support/round-extra.pcert1 : no_pcert = 0
-rtl/rel5/support/round-extra.pcert1 : rtl/rel5/support/round-extra.pcert0
-rtl/rel5/support/round-extra.cert : | rtl/rel5/support/round-extra.pcert1
-
-rtl/rel5/support/rtl.pcert0 : no_pcert = 0
-rtl/rel5/support/rtl.pcert0 : acl2x = 0
-rtl/rel5/support/rtl.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/rtlarr.pcert0 \
- rtl/rel5/support/cat-def.pcert0 \
- rtl/rel5/support/rtl.lisp
-rtl/rel5/support/rtl.pcert1 : acl2x = 0
-rtl/rel5/support/rtl.pcert1 : no_pcert = 0
-rtl/rel5/support/rtl.pcert1 : rtl/rel5/support/rtl.pcert0
-rtl/rel5/support/rtl.cert : | rtl/rel5/support/rtl.pcert1
-
-rtl/rel5/support/rtlarr.pcert0 : no_pcert = 0
-rtl/rel5/support/rtlarr.pcert0 : acl2x = 0
-rtl/rel5/support/rtlarr.pcert0 : \
- misc/total-order.pcert0 \
- rtl/rel5/support/rtlarr.lisp
-rtl/rel5/support/rtlarr.pcert1 : acl2x = 0
-rtl/rel5/support/rtlarr.pcert1 : no_pcert = 0
-rtl/rel5/support/rtlarr.pcert1 : rtl/rel5/support/rtlarr.pcert0
-rtl/rel5/support/rtlarr.cert : | rtl/rel5/support/rtlarr.pcert1
-
-rtl/rel5/support/setbitn-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/setbitn-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/setbitn-proofs.pcert0 : \
- rtl/rel5/support/cat-def.pcert0 \
- rtl/rel5/support/setbits.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/setbitn-proofs.lisp
-rtl/rel5/support/setbitn-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/setbitn-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/setbitn-proofs.pcert1 : rtl/rel5/support/setbitn-proofs.pcert0
-rtl/rel5/support/setbitn-proofs.cert : | rtl/rel5/support/setbitn-proofs.pcert1
-
-rtl/rel5/support/setbitn.pcert0 : no_pcert = 0
-rtl/rel5/support/setbitn.pcert0 : acl2x = 0
-rtl/rel5/support/setbitn.pcert0 : \
- rtl/rel5/support/cat-def.pcert0 \
- rtl/rel5/support/setbitn-proofs.pcert0 \
- rtl/rel5/support/setbitn.lisp
-rtl/rel5/support/setbitn.pcert1 : acl2x = 0
-rtl/rel5/support/setbitn.pcert1 : no_pcert = 0
-rtl/rel5/support/setbitn.pcert1 : rtl/rel5/support/setbitn.pcert0
-rtl/rel5/support/setbitn.cert : | rtl/rel5/support/setbitn.pcert1
-
-rtl/rel5/support/setbits-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/setbits-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/setbits-proofs.pcert0 : \
- rtl/rel5/support/cat-def.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/setbits-proofs.lisp
-rtl/rel5/support/setbits-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/setbits-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/setbits-proofs.pcert1 : rtl/rel5/support/setbits-proofs.pcert0
-rtl/rel5/support/setbits-proofs.cert : | rtl/rel5/support/setbits-proofs.pcert1
-
-rtl/rel5/support/setbits.pcert0 : no_pcert = 0
-rtl/rel5/support/setbits.pcert0 : acl2x = 0
-rtl/rel5/support/setbits.pcert0 : \
- rtl/rel5/support/cat-def.pcert0 \
- rtl/rel5/support/setbits-proofs.pcert0 \
- rtl/rel5/support/setbits.lisp
-rtl/rel5/support/setbits.pcert1 : acl2x = 0
-rtl/rel5/support/setbits.pcert1 : no_pcert = 0
-rtl/rel5/support/setbits.pcert1 : rtl/rel5/support/setbits.pcert0
-rtl/rel5/support/setbits.cert : | rtl/rel5/support/setbits.pcert1
-
-rtl/rel5/support/sgn.pcert0 : no_pcert = 0
-rtl/rel5/support/sgn.pcert0 : acl2x = 0
-rtl/rel5/support/sgn.pcert0 : \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/sgn.lisp
-rtl/rel5/support/sgn.pcert1 : acl2x = 0
-rtl/rel5/support/sgn.pcert1 : no_pcert = 0
-rtl/rel5/support/sgn.pcert1 : rtl/rel5/support/sgn.pcert0
-rtl/rel5/support/sgn.cert : | rtl/rel5/support/sgn.pcert1
-
-rtl/rel5/support/shft.pcert0 : no_pcert = 0
-rtl/rel5/support/shft.pcert0 : acl2x = 0
-rtl/rel5/support/shft.pcert0 : \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/shft.lisp
-rtl/rel5/support/shft.pcert1 : acl2x = 0
-rtl/rel5/support/shft.pcert1 : no_pcert = 0
-rtl/rel5/support/shft.pcert1 : rtl/rel5/support/shft.pcert0
-rtl/rel5/support/shft.cert : | rtl/rel5/support/shft.pcert1
-
-rtl/rel5/support/simple-loop-helpers.pcert0 : no_pcert = 0
-rtl/rel5/support/simple-loop-helpers.pcert0 : acl2x = 0
-rtl/rel5/support/simple-loop-helpers.pcert0 : \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/setbitn.pcert0 \
- rtl/rel5/support/simple-loop-helpers.lisp
-rtl/rel5/support/simple-loop-helpers.pcert1 : acl2x = 0
-rtl/rel5/support/simple-loop-helpers.pcert1 : no_pcert = 0
-rtl/rel5/support/simple-loop-helpers.pcert1 : rtl/rel5/support/simple-loop-helpers.pcert0
-rtl/rel5/support/simple-loop-helpers.cert : | rtl/rel5/support/simple-loop-helpers.pcert1
-
-rtl/rel5/support/simplify-model-helpers.pcert0 : no_pcert = 0
-rtl/rel5/support/simplify-model-helpers.pcert0 : acl2x = 0
-rtl/rel5/support/simplify-model-helpers.pcert0 : \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/simplify-model-helpers.lisp
-rtl/rel5/support/simplify-model-helpers.pcert1 : acl2x = 0
-rtl/rel5/support/simplify-model-helpers.pcert1 : no_pcert = 0
-rtl/rel5/support/simplify-model-helpers.pcert1 : rtl/rel5/support/simplify-model-helpers.pcert0
-rtl/rel5/support/simplify-model-helpers.cert : | rtl/rel5/support/simplify-model-helpers.pcert1
-
-rtl/rel5/support/stick-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/stick-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/stick-proofs.pcert0 : \
- rtl/rel5/support/merge.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/lnot.pcert0 \
- rtl/rel5/support/stick-proofs.lisp
-rtl/rel5/support/stick-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/stick-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/stick-proofs.pcert1 : rtl/rel5/support/stick-proofs.pcert0
-rtl/rel5/support/stick-proofs.cert : | rtl/rel5/support/stick-proofs.pcert1
-
-rtl/rel5/support/stick.pcert0 : no_pcert = 0
-rtl/rel5/support/stick.pcert0 : acl2x = 0
-rtl/rel5/support/stick.pcert0 : \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/stick-proofs.pcert0 \
- rtl/rel5/support/stick.lisp
-rtl/rel5/support/stick.pcert1 : acl2x = 0
-rtl/rel5/support/stick.pcert1 : no_pcert = 0
-rtl/rel5/support/stick.pcert1 : rtl/rel5/support/stick.pcert0
-rtl/rel5/support/stick.cert : | rtl/rel5/support/stick.pcert1
-
-rtl/rel5/support/sticky-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/sticky-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/sticky-proofs.pcert0 : \
- rtl/rel5/arithmetic/arith.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/support/away.pcert0 \
- rtl/rel5/support/near.pcert0 \
- rtl/rel5/support/near+.pcert0 \
- rtl/rel5/support/sticky-proofs.lisp
-rtl/rel5/support/sticky-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/sticky-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/sticky-proofs.pcert1 : rtl/rel5/support/sticky-proofs.pcert0
-rtl/rel5/support/sticky-proofs.cert : | rtl/rel5/support/sticky-proofs.pcert1
-
-rtl/rel5/support/sticky.pcert0 : no_pcert = 0
-rtl/rel5/support/sticky.pcert0 : acl2x = 0
-rtl/rel5/support/sticky.pcert0 : \
- rtl/rel5/support/sticky-proofs.pcert0 \
- rtl/rel5/support/sticky.lisp
-rtl/rel5/support/sticky.pcert1 : acl2x = 0
-rtl/rel5/support/sticky.pcert1 : no_pcert = 0
-rtl/rel5/support/sticky.pcert1 : rtl/rel5/support/sticky.pcert0
-rtl/rel5/support/sticky.cert : | rtl/rel5/support/sticky.pcert1
-
-rtl/rel5/support/sumbits.pcert0 : no_pcert = 0
-rtl/rel5/support/sumbits.pcert0 : acl2x = 0
-rtl/rel5/support/sumbits.pcert0 : \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/sumbits.lisp
-rtl/rel5/support/sumbits.pcert1 : acl2x = 0
-rtl/rel5/support/sumbits.pcert1 : no_pcert = 0
-rtl/rel5/support/sumbits.pcert1 : rtl/rel5/support/sumbits.pcert0
-rtl/rel5/support/sumbits.cert : | rtl/rel5/support/sumbits.pcert1
-
-rtl/rel5/support/top.pcert0 : no_pcert = 0
-rtl/rel5/support/top.pcert0 : acl2x = 0
-rtl/rel5/support/top.pcert0 : \
- rtl/rel5/support/top1.pcert0 \
- rtl/rel5/support/lextra.pcert0 \
- rtl/rel5/support/fadd-extra.pcert0 \
- rtl/rel5/support/float-extra.pcert0 \
- rtl/rel5/support/round-extra.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/support/badguys.pcert0 \
- rtl/rel5/support/top.lisp
-rtl/rel5/support/top.pcert1 : acl2x = 0
-rtl/rel5/support/top.pcert1 : no_pcert = 0
-rtl/rel5/support/top.pcert1 : rtl/rel5/support/top.pcert0
-rtl/rel5/support/top.cert : | rtl/rel5/support/top.pcert1
-
-rtl/rel5/support/top1.pcert0 : no_pcert = 0
-rtl/rel5/support/top1.pcert0 : acl2x = 0
-rtl/rel5/support/top1.pcert0 : \
- rtl/rel5/support/util.pcert0 \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/rewrite-theory.pcert0 \
- rtl/rel5/support/rtl.pcert0 \
- rtl/rel5/support/rtlarr.pcert0 \
- rtl/rel5/support/bvecp-lemmas.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/ocat.pcert0 \
- rtl/rel5/support/cat-def.pcert0 \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/support/ash.pcert0 \
- rtl/rel5/support/decode.pcert0 \
- rtl/rel5/support/encode.pcert0 \
- rtl/rel5/support/mulcat.pcert0 \
- rtl/rel5/support/shft.pcert0 \
- rtl/rel5/support/all-ones.pcert0 \
- rtl/rel5/support/merge2.pcert0 \
- rtl/rel5/support/logior1.pcert0 \
- rtl/rel5/support/setbits.pcert0 \
- rtl/rel5/support/setbitn.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/support/bias.pcert0 \
- rtl/rel5/support/ereps.pcert0 \
- rtl/rel5/support/ireps.pcert0 \
- rtl/rel5/support/logeqv.pcert0 \
- rtl/rel5/support/logorc1.pcert0 \
- rtl/rel5/support/lognot.pcert0 \
- rtl/rel5/support/logand.pcert0 \
- rtl/rel5/support/logior.pcert0 \
- rtl/rel5/support/logxor.pcert0 \
- rtl/rel5/support/log.pcert0 \
- rtl/rel5/support/lnot.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/support/lextra0.pcert0 \
- rtl/rel5/support/logs.pcert0 \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/support/away.pcert0 \
- rtl/rel5/support/near.pcert0 \
- rtl/rel5/support/near+.pcert0 \
- rtl/rel5/support/oddr.pcert0 \
- rtl/rel5/support/sticky.pcert0 \
- rtl/rel5/support/rnd.pcert0 \
- rtl/rel5/support/drnd.pcert0 \
- rtl/rel5/support/bits-trunc.pcert0 \
- rtl/rel5/support/add3.pcert0 \
- rtl/rel5/support/lop1.pcert0 \
- rtl/rel5/support/lop2.pcert0 \
- rtl/rel5/support/lop3.pcert0 \
- rtl/rel5/support/stick.pcert0 \
- rtl/rel5/support/bvecp-helpers.pcert0 \
- rtl/rel5/support/model-helpers.pcert0 \
- rtl/rel5/support/rom-helpers.pcert0 \
- rtl/rel5/support/simple-loop-helpers.pcert0 \
- rtl/rel5/support/clocks.pcert0 \
- rtl/rel5/support/openers.pcert0 \
- rtl/rel5/support/package-defs.pcert0 \
- rtl/rel5/support/simplify-model-helpers.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/arithmetic/fp.pcert0 \
- rtl/rel5/support/fadd.pcert0 \
- rtl/rel5/support/top1.lisp
-rtl/rel5/support/top1.pcert1 : acl2x = 0
-rtl/rel5/support/top1.pcert1 : no_pcert = 0
-rtl/rel5/support/top1.pcert1 : rtl/rel5/support/top1.pcert0
-rtl/rel5/support/top1.cert : | rtl/rel5/support/top1.pcert1
-
-rtl/rel5/support/trunc-proofs.pcert0 : no_pcert = 0
-rtl/rel5/support/trunc-proofs.pcert0 : acl2x = 0
-rtl/rel5/support/trunc-proofs.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/float.pcert0 \
- rtl/rel5/arithmetic/top.pcert0 \
- rtl/rel5/support/trunc-proofs.lisp
-rtl/rel5/support/trunc-proofs.pcert1 : acl2x = 0
-rtl/rel5/support/trunc-proofs.pcert1 : no_pcert = 0
-rtl/rel5/support/trunc-proofs.pcert1 : rtl/rel5/support/trunc-proofs.pcert0
-rtl/rel5/support/trunc-proofs.cert : | rtl/rel5/support/trunc-proofs.pcert1
-
-rtl/rel5/support/trunc.pcert0 : no_pcert = 0
-rtl/rel5/support/trunc.pcert0 : acl2x = 0
-rtl/rel5/support/trunc.pcert0 : \
- rtl/rel5/support/ground-zero.pcert0 \
- rtl/rel5/support/trunc-proofs.pcert0 \
- rtl/rel5/support/trunc.lisp
-rtl/rel5/support/trunc.pcert1 : acl2x = 0
-rtl/rel5/support/trunc.pcert1 : no_pcert = 0
-rtl/rel5/support/trunc.pcert1 : rtl/rel5/support/trunc.pcert0
-rtl/rel5/support/trunc.cert : | rtl/rel5/support/trunc.pcert1
-
-rtl/rel5/support/util.pcert0 : no_pcert = 0
-rtl/rel5/support/util.pcert0 : acl2x = 0
-rtl/rel5/support/util.pcert0 : \
- rtl/rel5/support/util.lisp
-rtl/rel5/support/util.pcert1 : acl2x = 0
-rtl/rel5/support/util.pcert1 : no_pcert = 0
-rtl/rel5/support/util.pcert1 : rtl/rel5/support/util.pcert0
-rtl/rel5/support/util.cert : | rtl/rel5/support/util.pcert1
-
-rtl/rel5/user/away.pcert0 : no_pcert = 0
-rtl/rel5/user/away.pcert0 : acl2x = 0
-rtl/rel5/user/away.pcert0 : \
- rtl/rel5/user/trunc.pcert0 \
- rtl/rel5/support/away.pcert0 \
- rtl/rel5/user/away.lisp
-rtl/rel5/user/away.pcert1 : acl2x = 0
-rtl/rel5/user/away.pcert1 : no_pcert = 0
-rtl/rel5/user/away.pcert1 : rtl/rel5/user/away.pcert0
-rtl/rel5/user/away.cert : | rtl/rel5/user/away.pcert1
-
-rtl/rel5/user/bias.pcert0 : no_pcert = 0
-rtl/rel5/user/bias.pcert0 : acl2x = 0
-rtl/rel5/user/bias.pcert0 : \
- rtl/rel5/support/bias.pcert0 \
- rtl/rel5/user/bias.lisp
-rtl/rel5/user/bias.pcert1 : acl2x = 0
-rtl/rel5/user/bias.pcert1 : no_pcert = 0
-rtl/rel5/user/bias.pcert1 : rtl/rel5/user/bias.pcert0
-rtl/rel5/user/bias.cert : | rtl/rel5/user/bias.pcert1
-
-rtl/rel5/user/bitn.pcert0 : no_pcert = 0
-rtl/rel5/user/bitn.pcert0 : acl2x = 0
-rtl/rel5/user/bitn.pcert0 : \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/support/bitn.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/user/bitn.lisp
-rtl/rel5/user/bitn.pcert1 : acl2x = 0
-rtl/rel5/user/bitn.pcert1 : no_pcert = 0
-rtl/rel5/user/bitn.pcert1 : rtl/rel5/user/bitn.pcert0
-rtl/rel5/user/bitn.cert : | rtl/rel5/user/bitn.pcert1
-
-rtl/rel5/user/bits-trunc.pcert0 : no_pcert = 0
-rtl/rel5/user/bits-trunc.pcert0 : acl2x = 0
-rtl/rel5/user/bits-trunc.pcert0 : \
- rtl/rel5/user/land.pcert0 \
- rtl/rel5/support/bits-trunc.pcert0 \
- rtl/rel5/user/bits-trunc.lisp
-rtl/rel5/user/bits-trunc.pcert1 : acl2x = 0
-rtl/rel5/user/bits-trunc.pcert1 : no_pcert = 0
-rtl/rel5/user/bits-trunc.pcert1 : rtl/rel5/user/bits-trunc.pcert0
-rtl/rel5/user/bits-trunc.cert : | rtl/rel5/user/bits-trunc.pcert1
-
-rtl/rel5/user/bits.pcert0 : no_pcert = 0
-rtl/rel5/user/bits.pcert0 : acl2x = 0
-rtl/rel5/user/bits.pcert0 : \
- rtl/rel5/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel5/arithmetic/power2p.pcert0 \
- rtl/rel5/support/bits.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/user/bits.lisp
-rtl/rel5/user/bits.pcert1 : acl2x = 0
-rtl/rel5/user/bits.pcert1 : no_pcert = 0
-rtl/rel5/user/bits.pcert1 : rtl/rel5/user/bits.pcert0
-rtl/rel5/user/bits.cert : | rtl/rel5/user/bits.pcert1
-
-rtl/rel5/user/brat.pcert0 : no_pcert = 0
-rtl/rel5/user/brat.pcert0 : acl2x = 0
-rtl/rel5/user/brat.pcert0 : \
- rtl/rel5/arithmetic/fl.pcert0 \
- rtl/rel5/user/brat.lisp
-rtl/rel5/user/brat.pcert1 : acl2x = 0
-rtl/rel5/user/brat.pcert1 : no_pcert = 0
-rtl/rel5/user/brat.pcert1 : rtl/rel5/user/brat.pcert0
-rtl/rel5/user/brat.cert : | rtl/rel5/user/brat.pcert1
-
-rtl/rel5/user/bvecp.pcert0 : no_pcert = 0
-rtl/rel5/user/bvecp.pcert0 : acl2x = 0
-rtl/rel5/user/bvecp.pcert0 : \
- rtl/rel5/support/bvecp.pcert0 \
- rtl/rel5/user/bvecp.lisp
-rtl/rel5/user/bvecp.pcert1 : acl2x = 0
-rtl/rel5/user/bvecp.pcert1 : no_pcert = 0
-rtl/rel5/user/bvecp.pcert1 : rtl/rel5/user/bvecp.pcert0
-rtl/rel5/user/bvecp.cert : | rtl/rel5/user/bvecp.pcert1
-
-rtl/rel5/user/cat.pcert0 : no_pcert = 0
-rtl/rel5/user/cat.pcert0 : acl2x = 0
-rtl/rel5/user/cat.pcert0 : \
- rtl/rel5/support/cat.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/user/cat.lisp
-rtl/rel5/user/cat.pcert1 : acl2x = 0
-rtl/rel5/user/cat.pcert1 : no_pcert = 0
-rtl/rel5/user/cat.pcert1 : rtl/rel5/user/cat.pcert0
-rtl/rel5/user/cat.cert : | rtl/rel5/user/cat.pcert1
-
-rtl/rel5/user/decode.pcert0 : no_pcert = 0
-rtl/rel5/user/decode.pcert0 : acl2x = 0
-rtl/rel5/user/decode.pcert0 : \
- rtl/rel5/support/decode.pcert0 \
- rtl/rel5/user/decode.lisp
-rtl/rel5/user/decode.pcert1 : acl2x = 0
-rtl/rel5/user/decode.pcert1 : no_pcert = 0
-rtl/rel5/user/decode.pcert1 : rtl/rel5/user/decode.pcert0
-rtl/rel5/user/decode.cert : | rtl/rel5/user/decode.pcert1
-
-rtl/rel5/user/ereps.pcert0 : no_pcert = 0
-rtl/rel5/user/ereps.pcert0 : acl2x = 0
-rtl/rel5/user/ereps.pcert0 : \
- rtl/rel5/support/ereps.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/user/ereps.lisp
-rtl/rel5/user/ereps.pcert1 : acl2x = 0
-rtl/rel5/user/ereps.pcert1 : no_pcert = 0
-rtl/rel5/user/ereps.pcert1 : rtl/rel5/user/ereps.pcert0
-rtl/rel5/user/ereps.cert : | rtl/rel5/user/ereps.pcert1
-
-rtl/rel5/user/land.pcert0 : no_pcert = 0
-rtl/rel5/user/land.pcert0 : acl2x = 0
-rtl/rel5/user/land.pcert0 : \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/support/land0.pcert0 \
- rtl/rel5/user/land.lisp
-rtl/rel5/user/land.pcert1 : acl2x = 0
-rtl/rel5/user/land.pcert1 : no_pcert = 0
-rtl/rel5/user/land.pcert1 : rtl/rel5/user/land.pcert0
-rtl/rel5/user/land.cert : | rtl/rel5/user/land.pcert1
-
-rtl/rel5/user/lextra.pcert0 : no_pcert = 0
-rtl/rel5/user/lextra.pcert0 : acl2x = 0
-rtl/rel5/user/lextra.pcert0 : \
- rtl/rel5/user/land.pcert0 \
- rtl/rel5/user/lior.pcert0 \
- rtl/rel5/user/lxor.pcert0 \
- rtl/rel5/support/lextra0.pcert0 \
- rtl/rel5/user/lextra.lisp
-rtl/rel5/user/lextra.pcert1 : acl2x = 0
-rtl/rel5/user/lextra.pcert1 : no_pcert = 0
-rtl/rel5/user/lextra.pcert1 : rtl/rel5/user/lextra.pcert0
-rtl/rel5/user/lextra.cert : | rtl/rel5/user/lextra.pcert1
-
-rtl/rel5/user/lior.pcert0 : no_pcert = 0
-rtl/rel5/user/lior.pcert0 : acl2x = 0
-rtl/rel5/user/lior.pcert0 : \
- rtl/rel5/support/lior0.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/user/lior.lisp
-rtl/rel5/user/lior.pcert1 : acl2x = 0
-rtl/rel5/user/lior.pcert1 : no_pcert = 0
-rtl/rel5/user/lior.pcert1 : rtl/rel5/user/lior.pcert0
-rtl/rel5/user/lior.cert : | rtl/rel5/user/lior.pcert1
-
-rtl/rel5/user/lnot.pcert0 : no_pcert = 0
-rtl/rel5/user/lnot.pcert0 : acl2x = 0
-rtl/rel5/user/lnot.pcert0 : \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/support/lnot.pcert0 \
- rtl/rel5/user/lnot.lisp
-rtl/rel5/user/lnot.pcert1 : acl2x = 0
-rtl/rel5/user/lnot.pcert1 : no_pcert = 0
-rtl/rel5/user/lnot.pcert1 : rtl/rel5/user/lnot.pcert0
-rtl/rel5/user/lnot.cert : | rtl/rel5/user/lnot.pcert1
-
-rtl/rel5/user/logior1.pcert0 : no_pcert = 0
-rtl/rel5/user/logior1.pcert0 : acl2x = 0
-rtl/rel5/user/logior1.pcert0 : \
- rtl/rel5/support/logior1.pcert0 \
- rtl/rel5/user/logior1.lisp
-rtl/rel5/user/logior1.pcert1 : acl2x = 0
-rtl/rel5/user/logior1.pcert1 : no_pcert = 0
-rtl/rel5/user/logior1.pcert1 : rtl/rel5/user/logior1.pcert0
-rtl/rel5/user/logior1.cert : | rtl/rel5/user/logior1.pcert1
-
-rtl/rel5/user/lxor.pcert0 : no_pcert = 0
-rtl/rel5/user/lxor.pcert0 : acl2x = 0
-rtl/rel5/user/lxor.pcert0 : \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/support/lxor0.pcert0 \
- rtl/rel5/user/lxor.lisp
-rtl/rel5/user/lxor.pcert1 : acl2x = 0
-rtl/rel5/user/lxor.pcert1 : no_pcert = 0
-rtl/rel5/user/lxor.pcert1 : rtl/rel5/user/lxor.pcert0
-rtl/rel5/user/lxor.cert : | rtl/rel5/user/lxor.pcert1
-
-rtl/rel5/user/mulcat.pcert0 : no_pcert = 0
-rtl/rel5/user/mulcat.pcert0 : acl2x = 0
-rtl/rel5/user/mulcat.pcert0 : \
- rtl/rel5/support/mulcat.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/user/mulcat.lisp
-rtl/rel5/user/mulcat.pcert1 : acl2x = 0
-rtl/rel5/user/mulcat.pcert1 : no_pcert = 0
-rtl/rel5/user/mulcat.pcert1 : rtl/rel5/user/mulcat.pcert0
-rtl/rel5/user/mulcat.cert : | rtl/rel5/user/mulcat.pcert1
-
-rtl/rel5/user/near.pcert0 : no_pcert = 0
-rtl/rel5/user/near.pcert0 : acl2x = 0
-rtl/rel5/user/near.pcert0 : \
- rtl/rel5/support/near.pcert0 \
- rtl/rel5/user/near.lisp
-rtl/rel5/user/near.pcert1 : acl2x = 0
-rtl/rel5/user/near.pcert1 : no_pcert = 0
-rtl/rel5/user/near.pcert1 : rtl/rel5/user/near.pcert0
-rtl/rel5/user/near.cert : | rtl/rel5/user/near.pcert1
-
-rtl/rel5/user/setbitn.pcert0 : no_pcert = 0
-rtl/rel5/user/setbitn.pcert0 : acl2x = 0
-rtl/rel5/user/setbitn.pcert0 : \
- rtl/rel5/support/setbitn.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/user/setbitn.lisp
-rtl/rel5/user/setbitn.pcert1 : acl2x = 0
-rtl/rel5/user/setbitn.pcert1 : no_pcert = 0
-rtl/rel5/user/setbitn.pcert1 : rtl/rel5/user/setbitn.pcert0
-rtl/rel5/user/setbitn.cert : | rtl/rel5/user/setbitn.pcert1
-
-rtl/rel5/user/setbits.pcert0 : no_pcert = 0
-rtl/rel5/user/setbits.pcert0 : acl2x = 0
-rtl/rel5/user/setbits.pcert0 : \
- rtl/rel5/support/setbits.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/user/setbits.lisp
-rtl/rel5/user/setbits.pcert1 : acl2x = 0
-rtl/rel5/user/setbits.pcert1 : no_pcert = 0
-rtl/rel5/user/setbits.pcert1 : rtl/rel5/user/setbits.pcert0
-rtl/rel5/user/setbits.cert : | rtl/rel5/user/setbits.pcert1
-
-rtl/rel5/user/stick.pcert0 : no_pcert = 0
-rtl/rel5/user/stick.pcert0 : acl2x = 0
-rtl/rel5/user/stick.pcert0 : \
- rtl/rel5/user/land.pcert0 \
- rtl/rel5/user/lior.pcert0 \
- rtl/rel5/user/lxor.pcert0 \
- rtl/rel5/user/lnot.pcert0 \
- rtl/rel5/support/stick.pcert0 \
- rtl/rel5/user/stick.lisp
-rtl/rel5/user/stick.pcert1 : acl2x = 0
-rtl/rel5/user/stick.pcert1 : no_pcert = 0
-rtl/rel5/user/stick.pcert1 : rtl/rel5/user/stick.pcert0
-rtl/rel5/user/stick.cert : | rtl/rel5/user/stick.pcert1
-
-rtl/rel5/user/sumbits.pcert0 : no_pcert = 0
-rtl/rel5/user/sumbits.pcert0 : acl2x = 0
-rtl/rel5/user/sumbits.pcert0 : \
- rtl/rel5/support/sumbits.pcert0 \
- rtl/rel5/support/guards.pcert0 \
- rtl/rel5/user/sumbits.lisp
-rtl/rel5/user/sumbits.pcert1 : acl2x = 0
-rtl/rel5/user/sumbits.pcert1 : no_pcert = 0
-rtl/rel5/user/sumbits.pcert1 : rtl/rel5/user/sumbits.pcert0
-rtl/rel5/user/sumbits.cert : | rtl/rel5/user/sumbits.pcert1
-
-rtl/rel5/user/top.pcert0 : no_pcert = 0
-rtl/rel5/user/top.pcert0 : acl2x = 0
-rtl/rel5/user/top.pcert0 : \
- rtl/rel5/user/bits.pcert0 \
- rtl/rel5/user/bitn.pcert0 \
- rtl/rel5/user/cat.pcert0 \
- rtl/rel5/user/bvecp.pcert0 \
- rtl/rel5/user/mulcat.pcert0 \
- rtl/rel5/user/logior1.pcert0 \
- rtl/rel5/user/setbits.pcert0 \
- rtl/rel5/user/setbitn.pcert0 \
- rtl/rel5/user/bias.pcert0 \
- rtl/rel5/user/ereps.pcert0 \
- rtl/rel5/user/lnot.pcert0 \
- rtl/rel5/user/land.pcert0 \
- rtl/rel5/user/lior.pcert0 \
- rtl/rel5/user/lxor.pcert0 \
- rtl/rel5/user/lextra.pcert0 \
- rtl/rel5/user/trunc.pcert0 \
- rtl/rel5/user/away.pcert0 \
- rtl/rel5/user/near.pcert0 \
- rtl/rel5/user/bits-trunc.pcert0 \
- rtl/rel5/user/stick.pcert0 \
- rtl/rel5/user/sumbits.pcert0 \
- rtl/rel5/user/top.lisp
-rtl/rel5/user/top.pcert1 : acl2x = 0
-rtl/rel5/user/top.pcert1 : no_pcert = 0
-rtl/rel5/user/top.pcert1 : rtl/rel5/user/top.pcert0
-rtl/rel5/user/top.cert : | rtl/rel5/user/top.pcert1
-
-rtl/rel5/user/trunc.pcert0 : no_pcert = 0
-rtl/rel5/user/trunc.pcert0 : acl2x = 0
-rtl/rel5/user/trunc.pcert0 : \
- rtl/rel5/support/trunc.pcert0 \
- rtl/rel5/user/trunc.lisp
-rtl/rel5/user/trunc.pcert1 : acl2x = 0
-rtl/rel5/user/trunc.pcert1 : no_pcert = 0
-rtl/rel5/user/trunc.pcert1 : rtl/rel5/user/trunc.pcert0
-rtl/rel5/user/trunc.cert : | rtl/rel5/user/trunc.pcert1
-
-rtl/rel8/arithmetic/arith.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/arith.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/arith.pcert0 : \
- rtl/rel8/arithmetic/arith2.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- meta/meta-times-equal.pcert0 \
- rtl/rel8/arithmetic/arith.lisp
-rtl/rel8/arithmetic/arith.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/arith.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/arith.pcert1 : rtl/rel8/arithmetic/arith.pcert0
-rtl/rel8/arithmetic/arith.cert : | rtl/rel8/arithmetic/arith.pcert1
-
-rtl/rel8/arithmetic/arith2.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/arith2.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/arith2.pcert0 : \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/product.pcert0 \
- meta/meta-times-equal.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- meta/meta-times-equal.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel8/arithmetic/inverted-factor.pcert0 \
- rtl/rel8/arithmetic/arith2.lisp
-rtl/rel8/arithmetic/arith2.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/arith2.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/arith2.pcert1 : rtl/rel8/arithmetic/arith2.pcert0
-rtl/rel8/arithmetic/arith2.cert : | rtl/rel8/arithmetic/arith2.pcert1
-
-rtl/rel8/arithmetic/basic.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/basic.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/basic.pcert0 : \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/even-odd.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/expt.pcert0 \
- rtl/rel8/arithmetic/basic.lisp
-rtl/rel8/arithmetic/basic.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/basic.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/basic.pcert1 : rtl/rel8/arithmetic/basic.pcert0
-rtl/rel8/arithmetic/basic.cert : | rtl/rel8/arithmetic/basic.pcert1
-
-rtl/rel8/arithmetic/cg.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/cg.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/cg.pcert0 : \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- rtl/rel8/arithmetic/common-factor.pcert0 \
- rtl/rel8/arithmetic/cg.lisp
-rtl/rel8/arithmetic/cg.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/cg.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/cg.pcert1 : rtl/rel8/arithmetic/cg.pcert0
-rtl/rel8/arithmetic/cg.cert : | rtl/rel8/arithmetic/cg.pcert1
-
-rtl/rel8/arithmetic/common-factor-defuns.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/common-factor-defuns.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/common-factor-defuns.pcert0 : \
- rtl/rel8/arithmetic/inverted-factor.pcert0 \
- rtl/rel8/arithmetic/common-factor-defuns.lisp
-rtl/rel8/arithmetic/common-factor-defuns.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/common-factor-defuns.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/common-factor-defuns.pcert1 : rtl/rel8/arithmetic/common-factor-defuns.pcert0
-rtl/rel8/arithmetic/common-factor-defuns.cert : | rtl/rel8/arithmetic/common-factor-defuns.pcert1
-
-rtl/rel8/arithmetic/common-factor.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/common-factor.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/common-factor.pcert0 : \
- meta/meta-times-equal.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel8/arithmetic/common-factor-defuns.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/product.pcert0 \
- rtl/rel8/arithmetic/common-factor.lisp
-rtl/rel8/arithmetic/common-factor.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/common-factor.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/common-factor.pcert1 : rtl/rel8/arithmetic/common-factor.pcert0
-rtl/rel8/arithmetic/common-factor.cert : | rtl/rel8/arithmetic/common-factor.pcert1
-
-rtl/rel8/arithmetic/complex-rationalp.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/complex-rationalp.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/complex-rationalp.pcert0 : \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/complex-rationalp.lisp
-rtl/rel8/arithmetic/complex-rationalp.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/complex-rationalp.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/complex-rationalp.pcert1 : rtl/rel8/arithmetic/complex-rationalp.pcert0
-rtl/rel8/arithmetic/complex-rationalp.cert : | rtl/rel8/arithmetic/complex-rationalp.pcert1
-
-rtl/rel8/arithmetic/denominator.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/denominator.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/denominator.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- arithmetic/mod-gcd.pcert0 \
- rtl/rel8/arithmetic/denominator.lisp
-rtl/rel8/arithmetic/denominator.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/denominator.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/denominator.pcert1 : rtl/rel8/arithmetic/denominator.pcert0
-rtl/rel8/arithmetic/denominator.cert : | rtl/rel8/arithmetic/denominator.pcert1
-
-rtl/rel8/arithmetic/even-odd.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/even-odd.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/even-odd.pcert0 : \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/even-odd.lisp
-rtl/rel8/arithmetic/even-odd.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/even-odd.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/even-odd.pcert1 : rtl/rel8/arithmetic/even-odd.pcert0
-rtl/rel8/arithmetic/even-odd.cert : | rtl/rel8/arithmetic/even-odd.pcert1
-
-rtl/rel8/arithmetic/even-odd2-proofs.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/even-odd2-proofs.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/even-odd2-proofs.pcert0 : \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/arith.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/even-odd2-proofs.lisp
-rtl/rel8/arithmetic/even-odd2-proofs.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/even-odd2-proofs.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/even-odd2-proofs.pcert1 : rtl/rel8/arithmetic/even-odd2-proofs.pcert0
-rtl/rel8/arithmetic/even-odd2-proofs.cert : | rtl/rel8/arithmetic/even-odd2-proofs.pcert1
-
-rtl/rel8/arithmetic/even-odd2.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/even-odd2.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/even-odd2.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/even-odd2-proofs.pcert0 \
- rtl/rel8/arithmetic/even-odd2.lisp
-rtl/rel8/arithmetic/even-odd2.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/even-odd2.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/even-odd2.pcert1 : rtl/rel8/arithmetic/even-odd2.pcert0
-rtl/rel8/arithmetic/even-odd2.cert : | rtl/rel8/arithmetic/even-odd2.pcert1
-
-rtl/rel8/arithmetic/expo-proofs.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/expo-proofs.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/expo-proofs.pcert0 : \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/power2p.pcert0 \
- rtl/rel8/arithmetic/unary-divide.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/expt.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel8/arithmetic/common-factor-defuns.pcert0 \
- rtl/rel8/arithmetic/common-factor.pcert0 \
- rtl/rel8/arithmetic/expo-proofs.lisp
-rtl/rel8/arithmetic/expo-proofs.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/expo-proofs.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/expo-proofs.pcert1 : rtl/rel8/arithmetic/expo-proofs.pcert0
-rtl/rel8/arithmetic/expo-proofs.cert : | rtl/rel8/arithmetic/expo-proofs.pcert1
-
-rtl/rel8/arithmetic/expo.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/expo.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/expo.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/power2p.pcert0 \
- rtl/rel8/arithmetic/expo-proofs.pcert0 \
- rtl/rel8/arithmetic/common-factor-defuns.pcert0 \
- rtl/rel8/arithmetic/expo.lisp
-rtl/rel8/arithmetic/expo.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/expo.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/expo.pcert1 : rtl/rel8/arithmetic/expo.pcert0
-rtl/rel8/arithmetic/expo.cert : | rtl/rel8/arithmetic/expo.pcert1
-
-rtl/rel8/arithmetic/expt-proofs.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/expt-proofs.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/expt-proofs.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/numerator.pcert0 \
- rtl/rel8/arithmetic/denominator.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- arithmetic/top.pcert0 \
- rtl/rel8/arithmetic/even-odd.pcert0 \
- rtl/rel8/arithmetic/expt-proofs.lisp
-rtl/rel8/arithmetic/expt-proofs.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/expt-proofs.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/expt-proofs.pcert1 : rtl/rel8/arithmetic/expt-proofs.pcert0
-rtl/rel8/arithmetic/expt-proofs.cert : | rtl/rel8/arithmetic/expt-proofs.pcert1
-
-rtl/rel8/arithmetic/expt.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/expt.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/expt.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/expt-proofs.pcert0 \
- rtl/rel8/arithmetic/expt.lisp
-rtl/rel8/arithmetic/expt.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/expt.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/expt.pcert1 : rtl/rel8/arithmetic/expt.pcert0
-rtl/rel8/arithmetic/expt.cert : | rtl/rel8/arithmetic/expt.pcert1
-
-rtl/rel8/arithmetic/extra-rules.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/extra-rules.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/extra-rules.pcert0 : \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/arithmetic/extra-rules.lisp
-rtl/rel8/arithmetic/extra-rules.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/extra-rules.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/extra-rules.pcert1 : rtl/rel8/arithmetic/extra-rules.pcert0
-rtl/rel8/arithmetic/extra-rules.cert : | rtl/rel8/arithmetic/extra-rules.pcert1
-
-rtl/rel8/arithmetic/fl-expt.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/fl-expt.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/fl-expt.pcert0 : \
- rtl/rel8/arithmetic/numerator.pcert0 \
- rtl/rel8/arithmetic/denominator.pcert0 \
- rtl/rel8/arithmetic/nniq.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/floor.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/rationalp.pcert0 \
- rtl/rel8/arithmetic/unary-divide.pcert0 \
- rtl/rel8/arithmetic/expt.pcert0 \
- rtl/rel8/arithmetic/expo.pcert0 \
- rtl/rel8/arithmetic/power2p.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/fl-expt.lisp
-rtl/rel8/arithmetic/fl-expt.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/fl-expt.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/fl-expt.pcert1 : rtl/rel8/arithmetic/fl-expt.pcert0
-rtl/rel8/arithmetic/fl-expt.cert : | rtl/rel8/arithmetic/fl-expt.pcert1
-
-rtl/rel8/arithmetic/fl-hacks.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/fl-hacks.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/fl-hacks.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/inverted-factor.pcert0 \
- rtl/rel8/arithmetic/nniq.pcert0 \
- rtl/rel8/arithmetic/numerator.pcert0 \
- rtl/rel8/arithmetic/denominator.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/product.pcert0 \
- rtl/rel8/arithmetic/unary-divide.pcert0 \
- rtl/rel8/arithmetic/rationalp.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/mod.pcert0 \
- rtl/rel8/arithmetic/even-odd.pcert0 \
- meta/meta-plus-equal.pcert0 \
- rtl/rel8/arithmetic/arith.pcert0 \
- rtl/rel8/arithmetic/fl-hacks.lisp
-rtl/rel8/arithmetic/fl-hacks.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/fl-hacks.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/fl-hacks.pcert1 : rtl/rel8/arithmetic/fl-hacks.pcert0
-rtl/rel8/arithmetic/fl-hacks.cert : | rtl/rel8/arithmetic/fl-hacks.pcert1
-
-rtl/rel8/arithmetic/fl-proofs.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/fl-proofs.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/fl-proofs.pcert0 : \
- rtl/rel8/arithmetic/numerator.pcert0 \
- rtl/rel8/arithmetic/denominator.pcert0 \
- rtl/rel8/arithmetic/nniq.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/floor.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/rationalp.pcert0 \
- rtl/rel8/arithmetic/unary-divide.pcert0 \
- rtl/rel8/arithmetic/common-factor.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/fl-proofs.lisp
-rtl/rel8/arithmetic/fl-proofs.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/fl-proofs.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/fl-proofs.pcert1 : rtl/rel8/arithmetic/fl-proofs.pcert0
-rtl/rel8/arithmetic/fl-proofs.cert : | rtl/rel8/arithmetic/fl-proofs.pcert1
-
-rtl/rel8/arithmetic/fl.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/fl.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/fl.pcert0 : \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/fl-proofs.pcert0 \
- rtl/rel8/arithmetic/fl.lisp
-rtl/rel8/arithmetic/fl.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/fl.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/fl.pcert1 : rtl/rel8/arithmetic/fl.pcert0
-rtl/rel8/arithmetic/fl.cert : | rtl/rel8/arithmetic/fl.pcert1
-
-rtl/rel8/arithmetic/floor-proofs.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/floor-proofs.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/floor-proofs.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/denominator.pcert0 \
- rtl/rel8/arithmetic/numerator.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/nniq.pcert0 \
- rtl/rel8/arithmetic/product.pcert0 \
- rtl/rel8/arithmetic/unary-divide.pcert0 \
- rtl/rel8/arithmetic/rationalp.pcert0 \
- rtl/rel8/arithmetic/inverted-factor.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel8/arithmetic/floor-proofs.lisp
-rtl/rel8/arithmetic/floor-proofs.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/floor-proofs.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/floor-proofs.pcert1 : rtl/rel8/arithmetic/floor-proofs.pcert0
-rtl/rel8/arithmetic/floor-proofs.cert : | rtl/rel8/arithmetic/floor-proofs.pcert1
-
-rtl/rel8/arithmetic/floor.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/floor.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/floor.pcert0 : \
- rtl/rel8/arithmetic/floor-proofs.pcert0 \
- rtl/rel8/arithmetic/floor.lisp
-rtl/rel8/arithmetic/floor.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/floor.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/floor.pcert1 : rtl/rel8/arithmetic/floor.pcert0
-rtl/rel8/arithmetic/floor.cert : | rtl/rel8/arithmetic/floor.pcert1
-
-rtl/rel8/arithmetic/fp.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/fp.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/fp.pcert0 : \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/fp.lisp
-rtl/rel8/arithmetic/fp.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/fp.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/fp.pcert1 : rtl/rel8/arithmetic/fp.pcert0
-rtl/rel8/arithmetic/fp.cert : | rtl/rel8/arithmetic/fp.pcert1
-
-rtl/rel8/arithmetic/fp2.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/fp2.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/fp2.pcert0 : \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- arithmetic-2/meta/non-linear.pcert0 \
- rtl/rel8/arithmetic/inverted-factor.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel8/arithmetic/fp2.lisp
-rtl/rel8/arithmetic/fp2.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/fp2.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/fp2.pcert1 : rtl/rel8/arithmetic/fp2.pcert0
-rtl/rel8/arithmetic/fp2.cert : | rtl/rel8/arithmetic/fp2.pcert1
-
-rtl/rel8/arithmetic/ground-zero.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/ground-zero.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/ground-zero.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.lisp
-rtl/rel8/arithmetic/ground-zero.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/ground-zero.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/ground-zero.pcert1 : rtl/rel8/arithmetic/ground-zero.pcert0
-rtl/rel8/arithmetic/ground-zero.cert : | rtl/rel8/arithmetic/ground-zero.pcert1
-
-rtl/rel8/arithmetic/hacks.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/hacks.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/hacks.pcert0 : \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/hacks.lisp
-rtl/rel8/arithmetic/hacks.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/hacks.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/hacks.pcert1 : rtl/rel8/arithmetic/hacks.pcert0
-rtl/rel8/arithmetic/hacks.cert : | rtl/rel8/arithmetic/hacks.pcert1
-
-rtl/rel8/arithmetic/induct.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/induct.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/induct.pcert0 : \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/induct.lisp
-rtl/rel8/arithmetic/induct.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/induct.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/induct.pcert1 : rtl/rel8/arithmetic/induct.pcert0
-rtl/rel8/arithmetic/induct.cert : | rtl/rel8/arithmetic/induct.pcert1
-
-rtl/rel8/arithmetic/integerp.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/integerp.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/integerp.pcert0 : \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/integerp.lisp
-rtl/rel8/arithmetic/integerp.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/integerp.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/integerp.pcert1 : rtl/rel8/arithmetic/integerp.pcert0
-rtl/rel8/arithmetic/integerp.cert : | rtl/rel8/arithmetic/integerp.pcert1
-
-rtl/rel8/arithmetic/inverted-factor.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/inverted-factor.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/inverted-factor.pcert0 : \
- rtl/rel8/arithmetic/inverted-factor.lisp
-rtl/rel8/arithmetic/inverted-factor.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/inverted-factor.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/inverted-factor.pcert1 : rtl/rel8/arithmetic/inverted-factor.pcert0
-rtl/rel8/arithmetic/inverted-factor.cert : | rtl/rel8/arithmetic/inverted-factor.pcert1
-
-rtl/rel8/arithmetic/mod-expt.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/mod-expt.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/mod-expt.pcert0 : \
- rtl/rel8/arithmetic/power2p.pcert0 \
- rtl/rel8/arithmetic/numerator.pcert0 \
- rtl/rel8/arithmetic/denominator.pcert0 \
- rtl/rel8/arithmetic/nniq.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/floor.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/rationalp.pcert0 \
- rtl/rel8/arithmetic/unary-divide.pcert0 \
- rtl/rel8/arithmetic/expt.pcert0 \
- rtl/rel8/arithmetic/expo.pcert0 \
- rtl/rel8/arithmetic/fl-expt.pcert0 \
- rtl/rel8/arithmetic/mod.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/mod-expt.lisp
-rtl/rel8/arithmetic/mod-expt.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/mod-expt.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/mod-expt.pcert1 : rtl/rel8/arithmetic/mod-expt.pcert0
-rtl/rel8/arithmetic/mod-expt.cert : | rtl/rel8/arithmetic/mod-expt.pcert1
-
-rtl/rel8/arithmetic/mod-proofs.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/mod-proofs.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/mod-proofs.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/floor.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- rtl/rel8/arithmetic/power2p.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/arith.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/product.pcert0 \
- rtl/rel8/arithmetic/complex-rationalp.pcert0 \
- meta/meta-plus-equal.pcert0 \
- meta/meta-plus-lessp.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/rationalp.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/mod-proofs.lisp
-rtl/rel8/arithmetic/mod-proofs.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/mod-proofs.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/mod-proofs.pcert1 : rtl/rel8/arithmetic/mod-proofs.pcert0
-rtl/rel8/arithmetic/mod-proofs.cert : | rtl/rel8/arithmetic/mod-proofs.pcert1
-
-rtl/rel8/arithmetic/mod.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/mod.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/mod.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/mod-proofs.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/mod.lisp
-rtl/rel8/arithmetic/mod.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/mod.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/mod.pcert1 : rtl/rel8/arithmetic/mod.pcert0
-rtl/rel8/arithmetic/mod.cert : | rtl/rel8/arithmetic/mod.pcert1
-
-rtl/rel8/arithmetic/negative-syntaxp.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/negative-syntaxp.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/negative-syntaxp.pcert0 : \
- rtl/rel8/arithmetic/negative-syntaxp.lisp
-rtl/rel8/arithmetic/negative-syntaxp.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/negative-syntaxp.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/negative-syntaxp.pcert1 : rtl/rel8/arithmetic/negative-syntaxp.pcert0
-rtl/rel8/arithmetic/negative-syntaxp.cert : | rtl/rel8/arithmetic/negative-syntaxp.pcert1
-
-rtl/rel8/arithmetic/nniq.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/nniq.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/nniq.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/denominator.pcert0 \
- rtl/rel8/arithmetic/numerator.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/unary-divide.pcert0 \
- rtl/rel8/arithmetic/product.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/arith.pcert0 \
- arithmetic/rationals.pcert0 \
- arithmetic/idiv.pcert0 \
- arithmetic/idiv.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- rtl/rel8/arithmetic/nniq.lisp
-rtl/rel8/arithmetic/nniq.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/nniq.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/nniq.pcert1 : rtl/rel8/arithmetic/nniq.pcert0
-rtl/rel8/arithmetic/nniq.cert : | rtl/rel8/arithmetic/nniq.pcert1
-
-rtl/rel8/arithmetic/numerator.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/numerator.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/numerator.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/denominator.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/numerator.lisp
-rtl/rel8/arithmetic/numerator.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/numerator.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/numerator.pcert1 : rtl/rel8/arithmetic/numerator.pcert0
-rtl/rel8/arithmetic/numerator.cert : | rtl/rel8/arithmetic/numerator.pcert1
-
-rtl/rel8/arithmetic/power2p.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/power2p.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/power2p.pcert0 : \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/unary-divide.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel8/arithmetic/power2p.lisp
-rtl/rel8/arithmetic/power2p.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/power2p.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/power2p.pcert1 : rtl/rel8/arithmetic/power2p.pcert0
-rtl/rel8/arithmetic/power2p.cert : | rtl/rel8/arithmetic/power2p.pcert1
-
-rtl/rel8/arithmetic/predicate.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/predicate.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/predicate.pcert0 : \
- rtl/rel8/arithmetic/predicate.lisp
-rtl/rel8/arithmetic/predicate.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/predicate.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/predicate.pcert1 : rtl/rel8/arithmetic/predicate.pcert0
-rtl/rel8/arithmetic/predicate.cert : | rtl/rel8/arithmetic/predicate.pcert1
-
-rtl/rel8/arithmetic/product-proofs.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/product-proofs.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/product-proofs.pcert0 : \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/product-proofs.lisp
-rtl/rel8/arithmetic/product-proofs.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/product-proofs.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/product-proofs.pcert1 : rtl/rel8/arithmetic/product-proofs.pcert0
-rtl/rel8/arithmetic/product-proofs.cert : | rtl/rel8/arithmetic/product-proofs.pcert1
-
-rtl/rel8/arithmetic/product.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/product.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/product.pcert0 : \
- rtl/rel8/arithmetic/product-proofs.pcert0 \
- rtl/rel8/arithmetic/product.lisp
-rtl/rel8/arithmetic/product.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/product.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/product.pcert1 : rtl/rel8/arithmetic/product.pcert0
-rtl/rel8/arithmetic/product.cert : | rtl/rel8/arithmetic/product.pcert1
-
-rtl/rel8/arithmetic/rationalp.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/rationalp.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/rationalp.pcert0 : \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/rationalp.lisp
-rtl/rel8/arithmetic/rationalp.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/rationalp.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/rationalp.pcert1 : rtl/rel8/arithmetic/rationalp.pcert0
-rtl/rel8/arithmetic/rationalp.cert : | rtl/rel8/arithmetic/rationalp.pcert1
-
-rtl/rel8/arithmetic/top.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/top.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/top.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/arithmetic/induct.pcert0 \
- rtl/rel8/arithmetic/denominator.pcert0 \
- rtl/rel8/arithmetic/numerator.pcert0 \
- rtl/rel8/arithmetic/nniq.pcert0 \
- rtl/rel8/arithmetic/complex-rationalp.pcert0 \
- rtl/rel8/arithmetic/rationalp.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/arith.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/arithmetic/unary-divide.pcert0 \
- rtl/rel8/arithmetic/product.pcert0 \
- rtl/rel8/arithmetic/inverted-factor.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/x-2xx.pcert0 \
- rtl/rel8/arithmetic/power2p.pcert0 \
- rtl/rel8/arithmetic/expt.pcert0 \
- rtl/rel8/arithmetic/expo.pcert0 \
- rtl/rel8/arithmetic/fl-hacks.pcert0 \
- rtl/rel8/arithmetic/even-odd2.pcert0 \
- rtl/rel8/arithmetic/even-odd.pcert0 \
- rtl/rel8/arithmetic/floor.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/cg.pcert0 \
- rtl/rel8/arithmetic/mod.pcert0 \
- rtl/rel8/arithmetic/fl-expt.pcert0 \
- rtl/rel8/arithmetic/mod-expt.pcert0 \
- rtl/rel8/arithmetic/common-factor.pcert0 \
- rtl/rel8/arithmetic/top.lisp
-rtl/rel8/arithmetic/top.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/top.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/top.pcert1 : rtl/rel8/arithmetic/top.pcert0
-rtl/rel8/arithmetic/top.cert : | rtl/rel8/arithmetic/top.pcert1
-
-rtl/rel8/arithmetic/unary-divide.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/unary-divide.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/unary-divide.pcert0 : \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/inverted-factor.pcert0 \
- rtl/rel8/arithmetic/unary-divide.lisp
-rtl/rel8/arithmetic/unary-divide.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/unary-divide.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/unary-divide.pcert1 : rtl/rel8/arithmetic/unary-divide.pcert0
-rtl/rel8/arithmetic/unary-divide.cert : | rtl/rel8/arithmetic/unary-divide.pcert1
-
-rtl/rel8/arithmetic/x-2xx.pcert0 : no_pcert = 0
-rtl/rel8/arithmetic/x-2xx.pcert0 : acl2x = 0
-rtl/rel8/arithmetic/x-2xx.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/mod-gcd.pcert0 \
- rtl/rel8/arithmetic/x-2xx.lisp
-rtl/rel8/arithmetic/x-2xx.pcert1 : acl2x = 0
-rtl/rel8/arithmetic/x-2xx.pcert1 : no_pcert = 0
-rtl/rel8/arithmetic/x-2xx.pcert1 : rtl/rel8/arithmetic/x-2xx.pcert0
-rtl/rel8/arithmetic/x-2xx.cert : | rtl/rel8/arithmetic/x-2xx.pcert1
-
-rtl/rel8/lib/add.pcert0 : no_pcert = 0
-rtl/rel8/lib/add.pcert0 : acl2x = 0
-rtl/rel8/lib/add.pcert0 : \
- rtl/rel8/lib/round.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/add.lisp
-rtl/rel8/lib/add.pcert1 : acl2x = 0
-rtl/rel8/lib/add.pcert1 : no_pcert = 0
-rtl/rel8/lib/add.pcert1 : rtl/rel8/lib/add.pcert0
-rtl/rel8/lib/add.cert : | rtl/rel8/lib/add.pcert1
-
-rtl/rel8/lib/arith.pcert0 : no_pcert = 0
-rtl/rel8/lib/arith.pcert0 : acl2x = 0
-rtl/rel8/lib/arith.pcert0 : \
- rtl/rel8/support/top/top.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel8/lib/arith.lisp
-rtl/rel8/lib/arith.pcert1 : acl2x = 0
-rtl/rel8/lib/arith.pcert1 : no_pcert = 0
-rtl/rel8/lib/arith.pcert1 : rtl/rel8/lib/arith.pcert0
-rtl/rel8/lib/arith.cert : | rtl/rel8/lib/arith.pcert1
-
-rtl/rel8/lib/basic.pcert0 : no_pcert = 0
-rtl/rel8/lib/basic.pcert0 : acl2x = 0
-rtl/rel8/lib/basic.pcert0 : \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/basic.lisp
-rtl/rel8/lib/basic.pcert1 : acl2x = 0
-rtl/rel8/lib/basic.pcert1 : no_pcert = 0
-rtl/rel8/lib/basic.pcert1 : rtl/rel8/lib/basic.pcert0
-rtl/rel8/lib/basic.cert : | rtl/rel8/lib/basic.pcert1
-
-rtl/rel8/lib/bits.pcert0 : no_pcert = 0
-rtl/rel8/lib/bits.pcert0 : acl2x = 0
-rtl/rel8/lib/bits.pcert0 : \
- rtl/rel8/lib/basic.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/bits.lisp
-rtl/rel8/lib/bits.pcert1 : acl2x = 0
-rtl/rel8/lib/bits.pcert1 : no_pcert = 0
-rtl/rel8/lib/bits.pcert1 : rtl/rel8/lib/bits.pcert0
-rtl/rel8/lib/bits.cert : | rtl/rel8/lib/bits.pcert1
-
-rtl/rel8/lib/bvecp-helpers.pcert0 : no_pcert = 0
-rtl/rel8/lib/bvecp-helpers.pcert0 : acl2x = 0
-rtl/rel8/lib/bvecp-helpers.pcert0 : \
- rtl/rel8/lib/rtl.pcert0 \
- rtl/rel8/lib/rtlarr.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/bvecp-helpers.lisp
-rtl/rel8/lib/bvecp-helpers.pcert1 : acl2x = 0
-rtl/rel8/lib/bvecp-helpers.pcert1 : no_pcert = 0
-rtl/rel8/lib/bvecp-helpers.pcert1 : rtl/rel8/lib/bvecp-helpers.pcert0
-rtl/rel8/lib/bvecp-helpers.cert : | rtl/rel8/lib/bvecp-helpers.pcert1
-
-rtl/rel8/lib/bvecp-raw-helpers.pcert0 : no_pcert = 0
-rtl/rel8/lib/bvecp-raw-helpers.pcert0 : acl2x = 0
-rtl/rel8/lib/bvecp-raw-helpers.pcert0 : \
- rtl/rel8/lib/rtl.pcert0 \
- rtl/rel8/lib/rtlarr.pcert0 \
- rtl/rel8/lib/bits.pcert0 \
- rtl/rel8/lib/float.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/bvecp-raw-helpers.lisp
-rtl/rel8/lib/bvecp-raw-helpers.pcert1 : acl2x = 0
-rtl/rel8/lib/bvecp-raw-helpers.pcert1 : no_pcert = 0
-rtl/rel8/lib/bvecp-raw-helpers.pcert1 : rtl/rel8/lib/bvecp-raw-helpers.pcert0
-rtl/rel8/lib/bvecp-raw-helpers.cert : | rtl/rel8/lib/bvecp-raw-helpers.pcert1
-
-rtl/rel8/lib/clocks.pcert0 : no_pcert = 0
-rtl/rel8/lib/clocks.pcert0 : acl2x = 0
-rtl/rel8/lib/clocks.pcert0 : \
- rtl/rel8/support/support/clocks.pcert0 \
- rtl/rel8/lib/clocks.lisp
-rtl/rel8/lib/clocks.pcert1 : acl2x = 0
-rtl/rel8/lib/clocks.pcert1 : no_pcert = 0
-rtl/rel8/lib/clocks.pcert1 : rtl/rel8/lib/clocks.pcert0
-rtl/rel8/lib/clocks.cert : | rtl/rel8/lib/clocks.pcert1
-
-rtl/rel8/lib/float.pcert0 : no_pcert = 0
-rtl/rel8/lib/float.pcert0 : acl2x = 0
-rtl/rel8/lib/float.pcert0 : \
- rtl/rel8/lib/log.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/float.lisp
-rtl/rel8/lib/float.pcert1 : acl2x = 0
-rtl/rel8/lib/float.pcert1 : no_pcert = 0
-rtl/rel8/lib/float.pcert1 : rtl/rel8/lib/float.pcert0
-rtl/rel8/lib/float.cert : | rtl/rel8/lib/float.pcert1
-
-rtl/rel8/lib/log.pcert0 : no_pcert = 0
-rtl/rel8/lib/log.pcert0 : acl2x = 0
-rtl/rel8/lib/log.pcert0 : \
- rtl/rel8/lib/basic.pcert0 \
- rtl/rel8/lib/bits.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/log.lisp
-rtl/rel8/lib/log.pcert1 : acl2x = 0
-rtl/rel8/lib/log.pcert1 : no_pcert = 0
-rtl/rel8/lib/log.pcert1 : rtl/rel8/lib/log.pcert0
-rtl/rel8/lib/log.cert : | rtl/rel8/lib/log.pcert1
-
-rtl/rel8/lib/logn.pcert0 : no_pcert = 0
-rtl/rel8/lib/logn.pcert0 : acl2x = 0
-rtl/rel8/lib/logn.pcert0 : \
- rtl/rel8/lib/bits.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/logn.lisp
-rtl/rel8/lib/logn.pcert1 : acl2x = 0
-rtl/rel8/lib/logn.pcert1 : no_pcert = 0
-rtl/rel8/lib/logn.pcert1 : rtl/rel8/lib/logn.pcert0
-rtl/rel8/lib/logn.cert : | rtl/rel8/lib/logn.pcert1
-
-rtl/rel8/lib/logn2log.pcert0 : no_pcert = 0
-rtl/rel8/lib/logn2log.pcert0 : acl2x = 0
-rtl/rel8/lib/logn2log.pcert0 : \
- rtl/rel8/lib/log.pcert0 \
- rtl/rel8/lib/logn.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/logn2log.lisp
-rtl/rel8/lib/logn2log.pcert1 : acl2x = 0
-rtl/rel8/lib/logn2log.pcert1 : no_pcert = 0
-rtl/rel8/lib/logn2log.pcert1 : rtl/rel8/lib/logn2log.pcert0
-rtl/rel8/lib/logn2log.cert : | rtl/rel8/lib/logn2log.pcert1
-
-rtl/rel8/lib/mult.pcert0 : no_pcert = 0
-rtl/rel8/lib/mult.pcert0 : acl2x = 0
-rtl/rel8/lib/mult.pcert0 : \
- rtl/rel8/lib/add.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/mult.lisp
-rtl/rel8/lib/mult.pcert1 : acl2x = 0
-rtl/rel8/lib/mult.pcert1 : no_pcert = 0
-rtl/rel8/lib/mult.pcert1 : rtl/rel8/lib/mult.pcert0
-rtl/rel8/lib/mult.cert : | rtl/rel8/lib/mult.pcert1
-
-rtl/rel8/lib/openers.pcert0 : no_pcert = 0
-rtl/rel8/lib/openers.pcert0 : acl2x = 0
-rtl/rel8/lib/openers.pcert0 : \
- rtl/rel8/support/support/openers.pcert0 \
- rtl/rel8/lib/openers.lisp
-rtl/rel8/lib/openers.pcert1 : acl2x = 0
-rtl/rel8/lib/openers.pcert1 : no_pcert = 0
-rtl/rel8/lib/openers.pcert1 : rtl/rel8/lib/openers.pcert0
-rtl/rel8/lib/openers.cert : | rtl/rel8/lib/openers.pcert1
-
-rtl/rel8/lib/package-defs.pcert0 : no_pcert = 0
-rtl/rel8/lib/package-defs.pcert0 : acl2x = 0
-rtl/rel8/lib/package-defs.pcert0 : \
- rtl/rel8/support/support/package-defs.pcert0 \
- rtl/rel8/lib/package-defs.lisp
-rtl/rel8/lib/package-defs.pcert1 : acl2x = 0
-rtl/rel8/lib/package-defs.pcert1 : no_pcert = 0
-rtl/rel8/lib/package-defs.pcert1 : rtl/rel8/lib/package-defs.pcert0
-rtl/rel8/lib/package-defs.cert : | rtl/rel8/lib/package-defs.pcert1
-
-rtl/rel8/lib/reps.pcert0 : no_pcert = 0
-rtl/rel8/lib/reps.pcert0 : acl2x = 0
-rtl/rel8/lib/reps.pcert0 : \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/log.pcert0 \
- rtl/rel8/lib/float.pcert0 \
- rtl/rel8/lib/reps.lisp
-rtl/rel8/lib/reps.pcert1 : acl2x = 0
-rtl/rel8/lib/reps.pcert1 : no_pcert = 0
-rtl/rel8/lib/reps.pcert1 : rtl/rel8/lib/reps.pcert0
-rtl/rel8/lib/reps.cert : | rtl/rel8/lib/reps.pcert1
-
-rtl/rel8/lib/rom-helpers.pcert0 : no_pcert = 0
-rtl/rel8/lib/rom-helpers.pcert0 : acl2x = 0
-rtl/rel8/lib/rom-helpers.pcert0 : \
- rtl/rel8/support/support/rom-helpers.pcert0 \
- rtl/rel8/lib/rom-helpers.lisp
-rtl/rel8/lib/rom-helpers.pcert1 : acl2x = 0
-rtl/rel8/lib/rom-helpers.pcert1 : no_pcert = 0
-rtl/rel8/lib/rom-helpers.pcert1 : rtl/rel8/lib/rom-helpers.pcert0
-rtl/rel8/lib/rom-helpers.cert : | rtl/rel8/lib/rom-helpers.pcert1
-
-rtl/rel8/lib/round.pcert0 : no_pcert = 0
-rtl/rel8/lib/round.pcert0 : acl2x = 0
-rtl/rel8/lib/round.pcert0 : \
- rtl/rel8/lib/float.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/round.lisp
-rtl/rel8/lib/round.pcert1 : acl2x = 0
-rtl/rel8/lib/round.pcert1 : no_pcert = 0
-rtl/rel8/lib/round.pcert1 : rtl/rel8/lib/round.pcert0
-rtl/rel8/lib/round.cert : | rtl/rel8/lib/round.pcert1
-
-rtl/rel8/lib/rtl.pcert0 : no_pcert = 0
-rtl/rel8/lib/rtl.pcert0 : acl2x = 0
-rtl/rel8/lib/rtl.pcert0 : \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/rtl.lisp
-rtl/rel8/lib/rtl.pcert1 : acl2x = 0
-rtl/rel8/lib/rtl.pcert1 : no_pcert = 0
-rtl/rel8/lib/rtl.pcert1 : rtl/rel8/lib/rtl.pcert0
-rtl/rel8/lib/rtl.cert : | rtl/rel8/lib/rtl.pcert1
-
-rtl/rel8/lib/rtlarr.pcert0 : no_pcert = 0
-rtl/rel8/lib/rtlarr.pcert0 : acl2x = 0
-rtl/rel8/lib/rtlarr.pcert0 : \
- rtl/rel8/support/top/top.pcert0 \
- misc/total-order.pcert0 \
- rtl/rel8/lib/rtl.pcert0 \
- rtl/rel8/lib/rtlarr.lisp
-rtl/rel8/lib/rtlarr.pcert1 : acl2x = 0
-rtl/rel8/lib/rtlarr.pcert1 : no_pcert = 0
-rtl/rel8/lib/rtlarr.pcert1 : rtl/rel8/lib/rtlarr.pcert0
-rtl/rel8/lib/rtlarr.cert : | rtl/rel8/lib/rtlarr.pcert1
-
-rtl/rel8/lib/simple-loop-helpers.pcert0 : no_pcert = 0
-rtl/rel8/lib/simple-loop-helpers.pcert0 : acl2x = 0
-rtl/rel8/lib/simple-loop-helpers.pcert0 : \
- rtl/rel8/lib/rtl.pcert0 \
- rtl/rel8/lib/rtlarr.pcert0 \
- rtl/rel8/lib/log.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/simple-loop-helpers.lisp
-rtl/rel8/lib/simple-loop-helpers.pcert1 : acl2x = 0
-rtl/rel8/lib/simple-loop-helpers.pcert1 : no_pcert = 0
-rtl/rel8/lib/simple-loop-helpers.pcert1 : rtl/rel8/lib/simple-loop-helpers.pcert0
-rtl/rel8/lib/simple-loop-helpers.cert : | rtl/rel8/lib/simple-loop-helpers.pcert1
-
-rtl/rel8/lib/simplify-model-helpers.pcert0 : no_pcert = 0
-rtl/rel8/lib/simplify-model-helpers.pcert0 : acl2x = 0
-rtl/rel8/lib/simplify-model-helpers.pcert0 : \
- rtl/rel8/lib/rtl.pcert0 \
- rtl/rel8/lib/arith.pcert0 \
- rtl/rel8/lib/bits.pcert0 \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/simplify-model-helpers.lisp
-rtl/rel8/lib/simplify-model-helpers.pcert1 : acl2x = 0
-rtl/rel8/lib/simplify-model-helpers.pcert1 : no_pcert = 0
-rtl/rel8/lib/simplify-model-helpers.pcert1 : rtl/rel8/lib/simplify-model-helpers.pcert0
-rtl/rel8/lib/simplify-model-helpers.cert : | rtl/rel8/lib/simplify-model-helpers.pcert1
-
-rtl/rel8/lib/top.pcert0 : no_pcert = 0
-rtl/rel8/lib/top.pcert0 : acl2x = 0
-rtl/rel8/lib/top.pcert0 : \
- rtl/rel8/lib/rtl.pcert0 \
- rtl/rel8/lib/rtlarr.pcert0 \
- rtl/rel8/lib/basic.pcert0 \
- rtl/rel8/lib/bits.pcert0 \
- rtl/rel8/lib/log.pcert0 \
- rtl/rel8/lib/float.pcert0 \
- rtl/rel8/lib/reps.pcert0 \
- rtl/rel8/lib/round.pcert0 \
- rtl/rel8/lib/add.pcert0 \
- rtl/rel8/lib/mult.pcert0 \
- rtl/rel8/lib/arith.pcert0 \
- rtl/rel8/lib/util.pcert0 \
- rtl/rel8/lib/top.lisp
-rtl/rel8/lib/top.pcert1 : acl2x = 0
-rtl/rel8/lib/top.pcert1 : no_pcert = 0
-rtl/rel8/lib/top.pcert1 : rtl/rel8/lib/top.pcert0
-rtl/rel8/lib/top.cert : | rtl/rel8/lib/top.pcert1
-
-rtl/rel8/lib/util.pcert0 : no_pcert = 0
-rtl/rel8/lib/util.pcert0 : acl2x = 0
-rtl/rel8/lib/util.pcert0 : \
- rtl/rel8/support/top/top.pcert0 \
- rtl/rel8/lib/util.lisp
-rtl/rel8/lib/util.pcert1 : acl2x = 0
-rtl/rel8/lib/util.pcert1 : no_pcert = 0
-rtl/rel8/lib/util.pcert1 : rtl/rel8/lib/util.pcert0
-rtl/rel8/lib/util.cert : | rtl/rel8/lib/util.pcert1
-
-rtl/rel8/support/lib1.delta1/arith-extra.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/arith-extra.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/arith-extra.pcert0 : \
- rtl/rel8/support/lib1/arith.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib1.delta1/arith-extra.lisp
-rtl/rel8/support/lib1.delta1/arith-extra.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/arith-extra.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/arith-extra.pcert1 : rtl/rel8/support/lib1.delta1/arith-extra.pcert0
-rtl/rel8/support/lib1.delta1/arith-extra.cert : | rtl/rel8/support/lib1.delta1/arith-extra.pcert1
-
-rtl/rel8/support/lib1.delta1/arith.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/arith.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/arith.pcert0 : \
- rtl/rel8/support/lib1/arith.pcert0 \
- rtl/rel8/support/lib1.delta1/arith-extra.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel8/support/lib1.delta1/arith.lisp
-rtl/rel8/support/lib1.delta1/arith.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/arith.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/arith.pcert1 : rtl/rel8/support/lib1.delta1/arith.pcert0
-rtl/rel8/support/lib1.delta1/arith.cert : | rtl/rel8/support/lib1.delta1/arith.pcert1
-
-rtl/rel8/support/lib1.delta1/basic-extra.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/basic-extra.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/basic-extra.pcert0 : \
- rtl/rel8/support/lib1/basic.pcert0 \
- rtl/rel8/arithmetic/floor.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib1.delta1/basic-extra.lisp
-rtl/rel8/support/lib1.delta1/basic-extra.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/basic-extra.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/basic-extra.pcert1 : rtl/rel8/support/lib1.delta1/basic-extra.pcert0
-rtl/rel8/support/lib1.delta1/basic-extra.cert : | rtl/rel8/support/lib1.delta1/basic-extra.pcert1
-
-rtl/rel8/support/lib1.delta1/basic.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/basic.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/basic.pcert0 : \
- rtl/rel8/support/lib1/basic.pcert0 \
- rtl/rel8/support/lib1.delta1/basic-extra.pcert0 \
- rtl/rel8/support/lib1.delta1/basic.lisp
-rtl/rel8/support/lib1.delta1/basic.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/basic.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/basic.pcert1 : rtl/rel8/support/lib1.delta1/basic.pcert0
-rtl/rel8/support/lib1.delta1/basic.cert : | rtl/rel8/support/lib1.delta1/basic.pcert1
-
-rtl/rel8/support/lib1.delta1/bits-extra.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/bits-extra.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/bits-extra.pcert0 : \
- rtl/rel8/support/lib1/top.pcert0 \
- rtl/rel8/support/lib1.delta1/bits-extra.lisp
-rtl/rel8/support/lib1.delta1/bits-extra.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/bits-extra.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/bits-extra.pcert1 : rtl/rel8/support/lib1.delta1/bits-extra.pcert0
-rtl/rel8/support/lib1.delta1/bits-extra.cert : | rtl/rel8/support/lib1.delta1/bits-extra.pcert1
-
-rtl/rel8/support/lib1.delta1/bits.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/bits.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/bits.pcert0 : \
- rtl/rel8/support/lib1/bits.pcert0 \
- rtl/rel8/support/lib1.delta1/bits-extra.pcert0 \
- rtl/rel8/support/lib1.delta1/bits.lisp
-rtl/rel8/support/lib1.delta1/bits.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/bits.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/bits.pcert1 : rtl/rel8/support/lib1.delta1/bits.pcert0
-rtl/rel8/support/lib1.delta1/bits.cert : | rtl/rel8/support/lib1.delta1/bits.pcert1
-
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.pcert0 : \
- rtl/rel8/support/lib1/rtl.pcert0 \
- rtl/rel8/support/lib1/bits.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.lisp
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.pcert1 : rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.pcert0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.cert : | rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.pcert1
-
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.pcert0 : \
- rtl/rel8/support/lib1/rtl.pcert0 \
- rtl/rel8/support/lib1/rtlarr.pcert0 \
- rtl/rel8/support/lib1/bvecp-raw-helpers.pcert0 \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers-extra.pcert0 \
- rtl/rel8/arithmetic/expo.pcert0 \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.lisp
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.pcert1 : rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.pcert0
-rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.cert : | rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.pcert1
-
-rtl/rel8/support/lib1.delta1/float-extra2.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/float-extra2.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/float-extra2.pcert0 : \
- rtl/rel8/support/lib1/top.pcert0 \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/support/lib1.delta1/float-extra2.lisp
-rtl/rel8/support/lib1.delta1/float-extra2.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/float-extra2.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/float-extra2.pcert1 : rtl/rel8/support/lib1.delta1/float-extra2.pcert0
-rtl/rel8/support/lib1.delta1/float-extra2.cert : | rtl/rel8/support/lib1.delta1/float-extra2.pcert1
-
-rtl/rel8/support/lib1.delta1/float.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/float.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/float.pcert0 : \
- rtl/rel8/support/lib1/log.pcert0 \
- rtl/rel8/support/lib1/float.pcert0 \
- rtl/rel8/support/lib1.delta1/float-extra2.pcert0 \
- rtl/rel8/support/lib1.delta1/float.lisp
-rtl/rel8/support/lib1.delta1/float.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/float.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/float.pcert1 : rtl/rel8/support/lib1.delta1/float.pcert0
-rtl/rel8/support/lib1.delta1/float.cert : | rtl/rel8/support/lib1.delta1/float.pcert1
-
-rtl/rel8/support/lib1.delta1/mult-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/mult-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/mult-proofs.pcert0 : \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/sumbits.pcert0 \
- rtl/rel8/support/support/util.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/lior.pcert0 \
- rtl/rel8/support/support/land.pcert0 \
- rtl/rel8/support/support/lxor.pcert0 \
- rtl/rel8/support/lib1.delta1/mult-proofs.lisp \
- rtl/rel8/support/lib1.delta1/mult-proofs.acl2
-rtl/rel8/support/lib1.delta1/mult-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/mult-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/mult-proofs.pcert1 : rtl/rel8/support/lib1.delta1/mult-proofs.pcert0
-rtl/rel8/support/lib1.delta1/mult-proofs.cert : | rtl/rel8/support/lib1.delta1/mult-proofs.pcert1
-
-rtl/rel8/support/lib1.delta1/mult.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/mult.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/mult.pcert0 : \
- rtl/rel8/support/lib1/add.pcert0 \
- rtl/rel8/support/lib1.delta1/mult-proofs.pcert0 \
- rtl/rel8/support/lib1.delta1/mult.lisp
-rtl/rel8/support/lib1.delta1/mult.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/mult.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/mult.pcert1 : rtl/rel8/support/lib1.delta1/mult.pcert0
-rtl/rel8/support/lib1.delta1/mult.cert : | rtl/rel8/support/lib1.delta1/mult.pcert1
-
-rtl/rel8/support/lib1.delta1/round-extra2.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/round-extra2.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/round-extra2.pcert0 : \
- rtl/rel8/support/lib1/top.pcert0 \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/arithmetic/even-odd.pcert0 \
- rtl/rel8/support/support/away.pcert0 \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/arithmetic/expt.pcert0 \
- rtl/rel8/arithmetic/expt.pcert0 \
- rtl/rel8/support/lib1.delta1/float-extra2.pcert0 \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/support/lib1.delta1/round-extra2.lisp
-rtl/rel8/support/lib1.delta1/round-extra2.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/round-extra2.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/round-extra2.pcert1 : rtl/rel8/support/lib1.delta1/round-extra2.pcert0
-rtl/rel8/support/lib1.delta1/round-extra2.cert : | rtl/rel8/support/lib1.delta1/round-extra2.pcert1
-
-rtl/rel8/support/lib1.delta1/round.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/round.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/round.pcert0 : \
- rtl/rel8/support/lib1.delta1/float.pcert0 \
- rtl/rel8/support/lib1/round.pcert0 \
- rtl/rel8/support/lib1.delta1/round-extra2.pcert0 \
- rtl/rel8/support/lib1.delta1/round.lisp
-rtl/rel8/support/lib1.delta1/round.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/round.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/round.pcert1 : rtl/rel8/support/lib1.delta1/round.pcert0
-rtl/rel8/support/lib1.delta1/round.cert : | rtl/rel8/support/lib1.delta1/round.pcert1
-
-rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.pcert0 : \
- rtl/rel8/support/lib1/rtl.pcert0 \
- rtl/rel8/support/lib1/rtlarr.pcert0 \
- rtl/rel8/support/lib1/bits.pcert0 \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.lisp
-rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.pcert1 : rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.pcert0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.cert : | rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.pcert1
-
-rtl/rel8/support/lib1.delta1/simple-loop-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers.pcert0 : \
- rtl/rel8/support/lib1/rtl.pcert0 \
- rtl/rel8/support/lib1/rtlarr.pcert0 \
- rtl/rel8/support/lib1.delta1/arith.pcert0 \
- rtl/rel8/support/lib1/log.pcert0 \
- rtl/rel8/support/lib1/simple-loop-helpers.pcert0 \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers-extra.pcert0 \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers.lisp
-rtl/rel8/support/lib1.delta1/simple-loop-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers.pcert1 : rtl/rel8/support/lib1.delta1/simple-loop-helpers.pcert0
-rtl/rel8/support/lib1.delta1/simple-loop-helpers.cert : | rtl/rel8/support/lib1.delta1/simple-loop-helpers.pcert1
-
-rtl/rel8/support/lib1.delta2/float-extra.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta2/float-extra.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta2/float-extra.pcert0 : \
- rtl/rel8/support/lib1/top.pcert0 \
- rtl/rel8/support/lib1.delta2/float-extra.lisp
-rtl/rel8/support/lib1.delta2/float-extra.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta2/float-extra.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta2/float-extra.pcert1 : rtl/rel8/support/lib1.delta2/float-extra.pcert0
-rtl/rel8/support/lib1.delta2/float-extra.cert : | rtl/rel8/support/lib1.delta2/float-extra.pcert1
-
-rtl/rel8/support/lib1.delta2/float.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1.delta2/float.pcert0 : acl2x = 0
-rtl/rel8/support/lib1.delta2/float.pcert0 : \
- rtl/rel8/support/lib1/log.pcert0 \
- rtl/rel8/support/lib1.delta1/float.pcert0 \
- rtl/rel8/support/lib1.delta2/float-extra.pcert0 \
- rtl/rel8/support/lib1.delta2/float.lisp
-rtl/rel8/support/lib1.delta2/float.pcert1 : acl2x = 0
-rtl/rel8/support/lib1.delta2/float.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1.delta2/float.pcert1 : rtl/rel8/support/lib1.delta2/float.pcert0
-rtl/rel8/support/lib1.delta2/float.cert : | rtl/rel8/support/lib1.delta2/float.pcert1
-
-rtl/rel8/support/lib1/add.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/add.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/add.pcert0 : \
- rtl/rel8/support/lib1/round.pcert0 \
- rtl/rel8/support/support/top.pcert0 \
- rtl/rel8/support/lib1/add.lisp
-rtl/rel8/support/lib1/add.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/add.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/add.pcert1 : rtl/rel8/support/lib1/add.pcert0
-rtl/rel8/support/lib1/add.cert : | rtl/rel8/support/lib1/add.pcert1
-
-rtl/rel8/support/lib1/arith.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/arith.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/arith.pcert0 : \
- rtl/rel8/arithmetic/fp.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/expt.pcert0 \
- rtl/rel8/arithmetic/expo.pcert0 \
- rtl/rel8/arithmetic/extra-rules.pcert0 \
- rtl/rel8/support/support/ash.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel8/support/lib1/arith.lisp
-rtl/rel8/support/lib1/arith.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/arith.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/arith.pcert1 : rtl/rel8/support/lib1/arith.pcert0
-rtl/rel8/support/lib1/arith.cert : | rtl/rel8/support/lib1/arith.pcert1
-
-rtl/rel8/support/lib1/basic.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/basic.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/basic.pcert0 : \
- rtl/rel8/support/support/top.pcert0 \
- rtl/rel8/support/lib1/basic.lisp
-rtl/rel8/support/lib1/basic.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/basic.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/basic.pcert1 : rtl/rel8/support/lib1/basic.pcert0
-rtl/rel8/support/lib1/basic.cert : | rtl/rel8/support/lib1/basic.pcert1
-
-rtl/rel8/support/lib1/bits.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/bits.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/bits.pcert0 : \
- rtl/rel8/support/lib1/basic.pcert0 \
- rtl/rel8/support/support/top.pcert0 \
- rtl/rel8/support/lib1/bits.lisp
-rtl/rel8/support/lib1/bits.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/bits.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/bits.pcert1 : rtl/rel8/support/lib1/bits.pcert0
-rtl/rel8/support/lib1/bits.cert : | rtl/rel8/support/lib1/bits.pcert1
-
-rtl/rel8/support/lib1/bvecp-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/bvecp-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/bvecp-helpers.pcert0 : \
- rtl/rel8/support/lib1/rtl.pcert0 \
- rtl/rel8/support/lib1/rtlarr.pcert0 \
- rtl/rel8/support/support/bvecp-helpers.pcert0 \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/support/lib1/bvecp-helpers.lisp
-rtl/rel8/support/lib1/bvecp-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/bvecp-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/bvecp-helpers.pcert1 : rtl/rel8/support/lib1/bvecp-helpers.pcert0
-rtl/rel8/support/lib1/bvecp-helpers.cert : | rtl/rel8/support/lib1/bvecp-helpers.pcert1
-
-rtl/rel8/support/lib1/bvecp-raw-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/bvecp-raw-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/bvecp-raw-helpers.pcert0 : \
- rtl/rel8/support/lib1/rtl.pcert0 \
- rtl/rel8/support/lib1/rtlarr.pcert0 \
- rtl/rel8/support/support/bvecp-helpers.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/setbits.pcert0 \
- rtl/rel8/support/support/setbitn.pcert0 \
- rtl/rel8/support/support/logs.pcert0 \
- rtl/rel8/support/support/lnot.pcert0 \
- rtl/rel8/support/support/shft.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/mulcat.pcert0 \
- rtl/rel8/support/support/encode.pcert0 \
- rtl/rel8/support/support/decode.pcert0 \
- rtl/rel8/support/support/land.pcert0 \
- rtl/rel8/support/support/lior.pcert0 \
- rtl/rel8/support/support/lxor.pcert0 \
- rtl/rel8/support/support/guards.pcert0 \
- rtl/rel8/arithmetic/expo.pcert0 \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/support/lib1/bvecp-raw-helpers.lisp
-rtl/rel8/support/lib1/bvecp-raw-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/bvecp-raw-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/bvecp-raw-helpers.pcert1 : rtl/rel8/support/lib1/bvecp-raw-helpers.pcert0
-rtl/rel8/support/lib1/bvecp-raw-helpers.cert : | rtl/rel8/support/lib1/bvecp-raw-helpers.pcert1
-
-rtl/rel8/support/lib1/clocks.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/clocks.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/clocks.pcert0 : \
- rtl/rel8/support/support/clocks.pcert0 \
- rtl/rel8/support/lib1/clocks.lisp
-rtl/rel8/support/lib1/clocks.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/clocks.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/clocks.pcert1 : rtl/rel8/support/lib1/clocks.pcert0
-rtl/rel8/support/lib1/clocks.cert : | rtl/rel8/support/lib1/clocks.pcert1
-
-rtl/rel8/support/lib1/float.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/float.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/float.pcert0 : \
- rtl/rel8/support/lib1/log.pcert0 \
- rtl/rel8/support/support/top.pcert0 \
- rtl/rel8/support/lib1/float.lisp
-rtl/rel8/support/lib1/float.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/float.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/float.pcert1 : rtl/rel8/support/lib1/float.pcert0
-rtl/rel8/support/lib1/float.cert : | rtl/rel8/support/lib1/float.pcert1
-
-rtl/rel8/support/lib1/log.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/log.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/log.pcert0 : \
- rtl/rel8/support/lib1/bits.pcert0 \
- rtl/rel8/support/support/top.pcert0 \
- rtl/rel8/support/lib1/log.lisp
-rtl/rel8/support/lib1/log.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/log.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/log.pcert1 : rtl/rel8/support/lib1/log.pcert0
-rtl/rel8/support/lib1/log.cert : | rtl/rel8/support/lib1/log.pcert1
-
-rtl/rel8/support/lib1/openers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/openers.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/openers.pcert0 : \
- rtl/rel8/support/support/openers.pcert0 \
- rtl/rel8/support/lib1/openers.lisp
-rtl/rel8/support/lib1/openers.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/openers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/openers.pcert1 : rtl/rel8/support/lib1/openers.pcert0
-rtl/rel8/support/lib1/openers.cert : | rtl/rel8/support/lib1/openers.pcert1
-
-rtl/rel8/support/lib1/package-defs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/package-defs.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/package-defs.pcert0 : \
- rtl/rel8/support/support/package-defs.pcert0 \
- rtl/rel8/support/lib1/package-defs.lisp
-rtl/rel8/support/lib1/package-defs.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/package-defs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/package-defs.pcert1 : rtl/rel8/support/lib1/package-defs.pcert0
-rtl/rel8/support/lib1/package-defs.cert : | rtl/rel8/support/lib1/package-defs.pcert1
-
-rtl/rel8/support/lib1/reps.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/reps.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/reps.pcert0 : \
- rtl/rel8/support/support/ereps.pcert0 \
- rtl/rel8/support/support/ireps.pcert0 \
- rtl/rel8/support/support/guards.pcert0 \
- rtl/rel8/support/lib1/log.pcert0 \
- rtl/rel8/support/lib1/float.pcert0 \
- rtl/rel8/support/lib1/reps.lisp
-rtl/rel8/support/lib1/reps.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/reps.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/reps.pcert1 : rtl/rel8/support/lib1/reps.pcert0
-rtl/rel8/support/lib1/reps.cert : | rtl/rel8/support/lib1/reps.pcert1
-
-rtl/rel8/support/lib1/rom-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/rom-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/rom-helpers.pcert0 : \
- rtl/rel8/support/support/rom-helpers.pcert0 \
- rtl/rel8/support/lib1/rom-helpers.lisp
-rtl/rel8/support/lib1/rom-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/rom-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/rom-helpers.pcert1 : rtl/rel8/support/lib1/rom-helpers.pcert0
-rtl/rel8/support/lib1/rom-helpers.cert : | rtl/rel8/support/lib1/rom-helpers.pcert1
-
-rtl/rel8/support/lib1/round.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/round.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/round.pcert0 : \
- rtl/rel8/support/support/top.pcert0 \
- rtl/rel8/support/lib1/reps.pcert0 \
- rtl/rel8/support/lib1/round.lisp
-rtl/rel8/support/lib1/round.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/round.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/round.pcert1 : rtl/rel8/support/lib1/round.pcert0
-rtl/rel8/support/lib1/round.cert : | rtl/rel8/support/lib1/round.pcert1
-
-rtl/rel8/support/lib1/rtl.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/rtl.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/rtl.pcert0 : \
- rtl/rel8/support/support/top.pcert0 \
- rtl/rel8/support/lib1/rtl.lisp
-rtl/rel8/support/lib1/rtl.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/rtl.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/rtl.pcert1 : rtl/rel8/support/lib1/rtl.pcert0
-rtl/rel8/support/lib1/rtl.cert : | rtl/rel8/support/lib1/rtl.pcert1
-
-rtl/rel8/support/lib1/rtlarr.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/rtlarr.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/rtlarr.pcert0 : \
- rtl/rel8/support/support/rtlarr.pcert0 \
- rtl/rel8/support/support/bvecp-helpers.pcert0 \
- rtl/rel8/support/support/guards.pcert0 \
- misc/total-order.pcert0 \
- rtl/rel8/support/lib1/rtl.pcert0 \
- rtl/rel8/support/lib1/rtlarr.lisp
-rtl/rel8/support/lib1/rtlarr.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/rtlarr.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/rtlarr.pcert1 : rtl/rel8/support/lib1/rtlarr.pcert0
-rtl/rel8/support/lib1/rtlarr.cert : | rtl/rel8/support/lib1/rtlarr.pcert1
-
-rtl/rel8/support/lib1/simple-loop-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/simple-loop-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/simple-loop-helpers.pcert0 : \
- rtl/rel8/support/lib1/rtl.pcert0 \
- rtl/rel8/support/lib1/rtlarr.pcert0 \
- rtl/rel8/support/lib1/arith.pcert0 \
- rtl/rel8/support/lib1/log.pcert0 \
- rtl/rel8/support/support/simple-loop-helpers.pcert0 \
- rtl/rel8/support/lib1/simple-loop-helpers.lisp
-rtl/rel8/support/lib1/simple-loop-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/simple-loop-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/simple-loop-helpers.pcert1 : rtl/rel8/support/lib1/simple-loop-helpers.pcert0
-rtl/rel8/support/lib1/simple-loop-helpers.cert : | rtl/rel8/support/lib1/simple-loop-helpers.pcert1
-
-rtl/rel8/support/lib1/simplify-model-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/simplify-model-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/simplify-model-helpers.pcert0 : \
- rtl/rel8/support/lib1/rtl.pcert0 \
- rtl/rel8/support/lib1/arith.pcert0 \
- rtl/rel8/support/lib1/bits.pcert0 \
- rtl/rel8/support/support/simplify-model-helpers.pcert0 \
- rtl/rel8/support/lib1/simplify-model-helpers.lisp
-rtl/rel8/support/lib1/simplify-model-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/simplify-model-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/simplify-model-helpers.pcert1 : rtl/rel8/support/lib1/simplify-model-helpers.pcert0
-rtl/rel8/support/lib1/simplify-model-helpers.cert : | rtl/rel8/support/lib1/simplify-model-helpers.pcert1
-
-rtl/rel8/support/lib1/top.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/top.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/top.pcert0 : \
- rtl/rel8/support/lib1/rtl.pcert0 \
- rtl/rel8/support/lib1/rtlarr.pcert0 \
- rtl/rel8/support/lib1/basic.pcert0 \
- rtl/rel8/support/lib1/bits.pcert0 \
- rtl/rel8/support/lib1/log.pcert0 \
- rtl/rel8/support/lib1/float.pcert0 \
- rtl/rel8/support/lib1/reps.pcert0 \
- rtl/rel8/support/lib1/round.pcert0 \
- rtl/rel8/support/lib1/add.pcert0 \
- rtl/rel8/support/lib1/arith.pcert0 \
- rtl/rel8/support/lib1/util.pcert0 \
- rtl/rel8/support/lib1/top.lisp
-rtl/rel8/support/lib1/top.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/top.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/top.pcert1 : rtl/rel8/support/lib1/top.pcert0
-rtl/rel8/support/lib1/top.cert : | rtl/rel8/support/lib1/top.pcert1
-
-rtl/rel8/support/lib1/util.pcert0 : no_pcert = 0
-rtl/rel8/support/lib1/util.pcert0 : acl2x = 0
-rtl/rel8/support/lib1/util.pcert0 : \
- rtl/rel8/support/support/util.pcert0 \
- rtl/rel8/support/lib1/util.lisp
-rtl/rel8/support/lib1/util.pcert1 : acl2x = 0
-rtl/rel8/support/lib1/util.pcert1 : no_pcert = 0
-rtl/rel8/support/lib1/util.pcert1 : rtl/rel8/support/lib1/util.pcert0
-rtl/rel8/support/lib1/util.cert : | rtl/rel8/support/lib1/util.pcert1
-
-rtl/rel8/support/lib2.delta1/add-new-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/add-new-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/add-new-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/round-new.pcert0 \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/add-new-proofs.lisp
-rtl/rel8/support/lib2.delta1/add-new-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/add-new-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/add-new-proofs.pcert1 : rtl/rel8/support/lib2.delta1/add-new-proofs.pcert0
-rtl/rel8/support/lib2.delta1/add-new-proofs.cert : | rtl/rel8/support/lib2.delta1/add-new-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/add-new.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/add-new.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/add-new.pcert0 : \
- rtl/rel8/support/lib2.delta1/round-new.pcert0 \
- rtl/rel8/support/lib2.delta1/add-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/add-new.lisp
-rtl/rel8/support/lib2.delta1/add-new.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/add-new.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/add-new.pcert1 : rtl/rel8/support/lib2.delta1/add-new.pcert0
-rtl/rel8/support/lib2.delta1/add-new.cert : | rtl/rel8/support/lib2.delta1/add-new.pcert1
-
-rtl/rel8/support/lib2.delta1/add-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/add-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/add-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/round.pcert0 \
- rtl/rel8/support/lib2.delta1/add-new.pcert0 \
- rtl/rel8/support/lib2.delta1/add-proofs.lisp
-rtl/rel8/support/lib2.delta1/add-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/add-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/add-proofs.pcert1 : rtl/rel8/support/lib2.delta1/add-proofs.pcert0
-rtl/rel8/support/lib2.delta1/add-proofs.cert : | rtl/rel8/support/lib2.delta1/add-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/add.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/add.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/add.pcert0 : \
- rtl/rel8/support/lib2.delta1/round.pcert0 \
- rtl/rel8/support/lib2.delta1/add-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/add.lisp
-rtl/rel8/support/lib2.delta1/add.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/add.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/add.pcert1 : rtl/rel8/support/lib2.delta1/add.pcert0
-rtl/rel8/support/lib2.delta1/add.cert : | rtl/rel8/support/lib2.delta1/add.pcert1
-
-rtl/rel8/support/lib2.delta1/arith.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/arith.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/arith.pcert0 : \
- rtl/rel8/support/lib2/top.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel8/support/lib2.delta1/arith.lisp
-rtl/rel8/support/lib2.delta1/arith.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/arith.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/arith.pcert1 : rtl/rel8/support/lib2.delta1/arith.pcert0
-rtl/rel8/support/lib2.delta1/arith.cert : | rtl/rel8/support/lib2.delta1/arith.pcert1
-
-rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 : \
- rtl/rel8/support/lib2/bits.pcert0 \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/log.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/badguys.pcert0 \
- rtl/rel8/support/lib2/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.lisp
-rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert1 : rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0
-rtl/rel8/support/lib2.delta1/bits-new-proofs.cert : | rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/bits-new.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bits-new.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits-new.pcert0 : \
- rtl/rel8/support/lib2/basic.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new.lisp
-rtl/rel8/support/lib2.delta1/bits-new.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits-new.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bits-new.pcert1 : rtl/rel8/support/lib2.delta1/bits-new.pcert0
-rtl/rel8/support/lib2.delta1/bits-new.cert : | rtl/rel8/support/lib2.delta1/bits-new.pcert1
-
-rtl/rel8/support/lib2.delta1/bits-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bits-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits-proofs.pcert0 : \
- rtl/rel8/support/lib2/basic.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-proofs.lisp
-rtl/rel8/support/lib2.delta1/bits-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bits-proofs.pcert1 : rtl/rel8/support/lib2.delta1/bits-proofs.pcert0
-rtl/rel8/support/lib2.delta1/bits-proofs.cert : | rtl/rel8/support/lib2.delta1/bits-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/bits.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bits.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits.pcert0 : \
- rtl/rel8/support/lib2/basic.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/bits.lisp
-rtl/rel8/support/lib2.delta1/bits.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bits.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bits.pcert1 : rtl/rel8/support/lib2.delta1/bits.pcert0
-rtl/rel8/support/lib2.delta1/bits.cert : | rtl/rel8/support/lib2.delta1/bits.pcert1
-
-rtl/rel8/support/lib2.delta1/bvecp-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bvecp-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bvecp-helpers.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/rtlarr.pcert0 \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert0 \
- rtl/rel8/support/lib2.delta1/bvecp-helpers.lisp
-rtl/rel8/support/lib2.delta1/bvecp-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bvecp-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bvecp-helpers.pcert1 : rtl/rel8/support/lib2.delta1/bvecp-helpers.pcert0
-rtl/rel8/support/lib2.delta1/bvecp-helpers.cert : | rtl/rel8/support/lib2.delta1/bvecp-helpers.pcert1
-
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/rtlarr.pcert0 \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/float.pcert0 \
- rtl/rel8/support/lib2.delta1/logn.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/support/encode.pcert0 \
- rtl/rel8/support/support/decode.pcert0 \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.lisp
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.pcert1 : rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.pcert0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.cert : | rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/rtlarr.pcert0 \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/float.pcert0 \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.lisp
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert1 : rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert0
-rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.cert : | rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert1
-
-rtl/rel8/support/lib2.delta1/float-new-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/float-new-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/float-new-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/float-new-proofs.lisp
-rtl/rel8/support/lib2.delta1/float-new-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/float-new-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/float-new-proofs.pcert1 : rtl/rel8/support/lib2.delta1/float-new-proofs.pcert0
-rtl/rel8/support/lib2.delta1/float-new-proofs.cert : | rtl/rel8/support/lib2.delta1/float-new-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/float-new.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/float-new.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/float-new.pcert0 : \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2.delta1/float-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/float-new.lisp
-rtl/rel8/support/lib2.delta1/float-new.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/float-new.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/float-new.pcert1 : rtl/rel8/support/lib2.delta1/float-new.pcert0
-rtl/rel8/support/lib2.delta1/float-new.cert : | rtl/rel8/support/lib2.delta1/float-new.pcert1
-
-rtl/rel8/support/lib2.delta1/float-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/float-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/float-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/log.pcert0 \
- rtl/rel8/support/lib2.delta1/float-new.pcert0 \
- rtl/rel8/support/lib2.delta1/float-proofs.lisp
-rtl/rel8/support/lib2.delta1/float-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/float-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/float-proofs.pcert1 : rtl/rel8/support/lib2.delta1/float-proofs.pcert0
-rtl/rel8/support/lib2.delta1/float-proofs.cert : | rtl/rel8/support/lib2.delta1/float-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/float.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/float.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/float.pcert0 : \
- rtl/rel8/support/lib2.delta1/log.pcert0 \
- rtl/rel8/support/lib2.delta1/float-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/float.lisp
-rtl/rel8/support/lib2.delta1/float.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/float.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/float.pcert1 : rtl/rel8/support/lib2.delta1/float.pcert0
-rtl/rel8/support/lib2.delta1/float.cert : | rtl/rel8/support/lib2.delta1/float.pcert1
-
-rtl/rel8/support/lib2.delta1/log-new-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log-new-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-new-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/bits-new.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/support/logxor.pcert0 \
- rtl/rel8/support/support/log.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/lognot.pcert0 \
- rtl/rel8/support/support/lognot.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new-proofs.lisp
-rtl/rel8/support/lib2.delta1/log-new-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-new-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log-new-proofs.pcert1 : rtl/rel8/support/lib2.delta1/log-new-proofs.pcert0
-rtl/rel8/support/lib2.delta1/log-new-proofs.cert : | rtl/rel8/support/lib2.delta1/log-new-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/log-new.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log-new.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-new.pcert0 : \
- rtl/rel8/support/lib2.delta1/bits-new.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.lisp
-rtl/rel8/support/lib2.delta1/log-new.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-new.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log-new.pcert1 : rtl/rel8/support/lib2.delta1/log-new.pcert0
-rtl/rel8/support/lib2.delta1/log-new.cert : | rtl/rel8/support/lib2.delta1/log-new.pcert1
-
-rtl/rel8/support/lib2.delta1/log-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-proofs.pcert0 : \
- rtl/rel8/support/lib2/basic.pcert0 \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2.delta1/log-proofs.lisp
-rtl/rel8/support/lib2.delta1/log-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log-proofs.pcert1 : rtl/rel8/support/lib2.delta1/log-proofs.pcert0
-rtl/rel8/support/lib2.delta1/log-proofs.cert : | rtl/rel8/support/lib2.delta1/log-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/log-support-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log-support-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-support-proofs.pcert0 : \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2.delta1/log-support-proofs.lisp
-rtl/rel8/support/lib2.delta1/log-support-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-support-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log-support-proofs.pcert1 : rtl/rel8/support/lib2.delta1/log-support-proofs.pcert0
-rtl/rel8/support/lib2.delta1/log-support-proofs.cert : | rtl/rel8/support/lib2.delta1/log-support-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/log-support.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log-support.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-support.pcert0 : \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/support/lib2.delta1/log-support-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log-support.lisp
-rtl/rel8/support/lib2.delta1/log-support.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log-support.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log-support.pcert1 : rtl/rel8/support/lib2.delta1/log-support.pcert0
-rtl/rel8/support/lib2.delta1/log-support.cert : | rtl/rel8/support/lib2.delta1/log-support.pcert1
-
-rtl/rel8/support/lib2.delta1/log.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log.pcert0 : \
- rtl/rel8/support/lib2/basic.pcert0 \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/log-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log.lisp
-rtl/rel8/support/lib2.delta1/log.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/log.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/log.pcert1 : rtl/rel8/support/lib2.delta1/log.pcert0
-rtl/rel8/support/lib2.delta1/log.cert : | rtl/rel8/support/lib2.delta1/log.pcert1
-
-rtl/rel8/support/lib2.delta1/logn-new-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn-new-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn-new-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/bits-new.pcert0 \
- rtl/rel8/support/lib2.delta1/rtl-new.pcert0 \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2.delta1/logn-new-proofs.lisp
-rtl/rel8/support/lib2.delta1/logn-new-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn-new-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn-new-proofs.pcert1 : rtl/rel8/support/lib2.delta1/logn-new-proofs.pcert0
-rtl/rel8/support/lib2.delta1/logn-new-proofs.cert : | rtl/rel8/support/lib2.delta1/logn-new-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/logn-new.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn-new.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn-new.pcert0 : \
- rtl/rel8/support/lib2.delta1/bits-new.pcert0 \
- rtl/rel8/support/lib2.delta1/rtl-new.pcert0 \
- rtl/rel8/support/lib2.delta1/logn-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/logn-new.lisp
-rtl/rel8/support/lib2.delta1/logn-new.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn-new.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn-new.pcert1 : rtl/rel8/support/lib2.delta1/logn-new.pcert0
-rtl/rel8/support/lib2.delta1/logn-new.cert : | rtl/rel8/support/lib2.delta1/logn-new.pcert1
-
-rtl/rel8/support/lib2.delta1/logn-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/logn-new.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2.delta1/logn-proofs.lisp
-rtl/rel8/support/lib2.delta1/logn-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn-proofs.pcert1 : rtl/rel8/support/lib2.delta1/logn-proofs.pcert0
-rtl/rel8/support/lib2.delta1/logn-proofs.cert : | rtl/rel8/support/lib2.delta1/logn-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/logn.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn.pcert0 : \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/logn-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/logn.lisp
-rtl/rel8/support/lib2.delta1/logn.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn.pcert1 : rtl/rel8/support/lib2.delta1/logn.pcert0
-rtl/rel8/support/lib2.delta1/logn.cert : | rtl/rel8/support/lib2.delta1/logn.pcert1
-
-rtl/rel8/support/lib2.delta1/logn2log-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn2log-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn2log-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/log.pcert0 \
- rtl/rel8/support/lib2.delta1/logn.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib2.delta1/log.pcert0 \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert0 \
- rtl/rel8/support/lib2.delta1/logn2log-proofs.lisp
-rtl/rel8/support/lib2.delta1/logn2log-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn2log-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn2log-proofs.pcert1 : rtl/rel8/support/lib2.delta1/logn2log-proofs.pcert0
-rtl/rel8/support/lib2.delta1/logn2log-proofs.cert : | rtl/rel8/support/lib2.delta1/logn2log-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/logn2log.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn2log.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn2log.pcert0 : \
- rtl/rel8/support/lib2.delta1/log.pcert0 \
- rtl/rel8/support/lib2.delta1/logn.pcert0 \
- rtl/rel8/support/lib2.delta1/logn2log-proofs.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib2.delta1/logn2log.lisp
-rtl/rel8/support/lib2.delta1/logn2log.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/logn2log.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/logn2log.pcert1 : rtl/rel8/support/lib2.delta1/logn2log.pcert0
-rtl/rel8/support/lib2.delta1/logn2log.cert : | rtl/rel8/support/lib2.delta1/logn2log.pcert1
-
-rtl/rel8/support/lib2.delta1/mult-new-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/mult-new-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult-new-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/add-new.pcert0 \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib2.delta1/log-support.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/mult-new-proofs.lisp
-rtl/rel8/support/lib2.delta1/mult-new-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult-new-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/mult-new-proofs.pcert1 : rtl/rel8/support/lib2.delta1/mult-new-proofs.pcert0
-rtl/rel8/support/lib2.delta1/mult-new-proofs.cert : | rtl/rel8/support/lib2.delta1/mult-new-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/mult-new.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/mult-new.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult-new.pcert0 : \
- rtl/rel8/support/lib2.delta1/add-new.pcert0 \
- rtl/rel8/support/lib2.delta1/mult-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/mult-new.lisp
-rtl/rel8/support/lib2.delta1/mult-new.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult-new.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/mult-new.pcert1 : rtl/rel8/support/lib2.delta1/mult-new.pcert0
-rtl/rel8/support/lib2.delta1/mult-new.cert : | rtl/rel8/support/lib2.delta1/mult-new.pcert1
-
-rtl/rel8/support/lib2.delta1/mult-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/mult-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/add.pcert0 \
- rtl/rel8/support/lib2.delta1/mult-new.pcert0 \
- rtl/rel8/support/lib2.delta1/mult-proofs.lisp
-rtl/rel8/support/lib2.delta1/mult-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/mult-proofs.pcert1 : rtl/rel8/support/lib2.delta1/mult-proofs.pcert0
-rtl/rel8/support/lib2.delta1/mult-proofs.cert : | rtl/rel8/support/lib2.delta1/mult-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/mult.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/mult.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult.pcert0 : \
- rtl/rel8/support/lib2.delta1/add.pcert0 \
- rtl/rel8/support/lib2.delta1/mult-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/mult.lisp
-rtl/rel8/support/lib2.delta1/mult.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/mult.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/mult.pcert1 : rtl/rel8/support/lib2.delta1/mult.pcert0
-rtl/rel8/support/lib2.delta1/mult.cert : | rtl/rel8/support/lib2.delta1/mult.pcert1
-
-rtl/rel8/support/lib2.delta1/reps-new-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/reps-new-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps-new-proofs.pcert0 : \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2.delta1/float-new.pcert0 \
- rtl/rel8/support/lib2.delta1/log-support.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib2.delta1/reps-new-proofs.lisp
-rtl/rel8/support/lib2.delta1/reps-new-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps-new-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/reps-new-proofs.pcert1 : rtl/rel8/support/lib2.delta1/reps-new-proofs.pcert0
-rtl/rel8/support/lib2.delta1/reps-new-proofs.cert : | rtl/rel8/support/lib2.delta1/reps-new-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/reps-new.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/reps-new.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps-new.pcert0 : \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2.delta1/float-new.pcert0 \
- rtl/rel8/support/lib2.delta1/reps-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/reps-new.lisp
-rtl/rel8/support/lib2.delta1/reps-new.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps-new.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/reps-new.pcert1 : rtl/rel8/support/lib2.delta1/reps-new.pcert0
-rtl/rel8/support/lib2.delta1/reps-new.cert : | rtl/rel8/support/lib2.delta1/reps-new.pcert1
-
-rtl/rel8/support/lib2.delta1/reps-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/reps-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/log.pcert0 \
- rtl/rel8/support/lib2.delta1/float.pcert0 \
- rtl/rel8/support/lib2.delta1/reps-new.pcert0 \
- rtl/rel8/support/lib2.delta1/reps-proofs.lisp
-rtl/rel8/support/lib2.delta1/reps-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/reps-proofs.pcert1 : rtl/rel8/support/lib2.delta1/reps-proofs.pcert0
-rtl/rel8/support/lib2.delta1/reps-proofs.cert : | rtl/rel8/support/lib2.delta1/reps-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/reps.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/reps.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps.pcert0 : \
- rtl/rel8/support/lib2.delta1/reps-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log.pcert0 \
- rtl/rel8/support/lib2.delta1/float.pcert0 \
- rtl/rel8/support/lib2.delta1/reps.lisp
-rtl/rel8/support/lib2.delta1/reps.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/reps.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/reps.pcert1 : rtl/rel8/support/lib2.delta1/reps.pcert0
-rtl/rel8/support/lib2.delta1/reps.cert : | rtl/rel8/support/lib2.delta1/reps.pcert1
-
-rtl/rel8/support/lib2.delta1/round-new-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/round-new-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/round-new-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/float-new.pcert0 \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 \
- rtl/rel8/support/support/land.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib2.delta1/round-new-proofs.lisp
-rtl/rel8/support/lib2.delta1/round-new-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/round-new-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/round-new-proofs.pcert1 : rtl/rel8/support/lib2.delta1/round-new-proofs.pcert0
-rtl/rel8/support/lib2.delta1/round-new-proofs.cert : | rtl/rel8/support/lib2.delta1/round-new-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/round-new.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/round-new.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/round-new.pcert0 : \
- rtl/rel8/support/lib2.delta1/float-new.pcert0 \
- rtl/rel8/support/lib2.delta1/round-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/round-new.lisp
-rtl/rel8/support/lib2.delta1/round-new.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/round-new.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/round-new.pcert1 : rtl/rel8/support/lib2.delta1/round-new.pcert0
-rtl/rel8/support/lib2.delta1/round-new.cert : | rtl/rel8/support/lib2.delta1/round-new.pcert1
-
-rtl/rel8/support/lib2.delta1/round-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/round-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/round-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/float.pcert0 \
- rtl/rel8/support/lib2.delta1/round-new.pcert0 \
- rtl/rel8/support/lib2.delta1/round-proofs.lisp
-rtl/rel8/support/lib2.delta1/round-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/round-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/round-proofs.pcert1 : rtl/rel8/support/lib2.delta1/round-proofs.pcert0
-rtl/rel8/support/lib2.delta1/round-proofs.cert : | rtl/rel8/support/lib2.delta1/round-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/round.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/round.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/round.pcert0 : \
- rtl/rel8/support/lib2.delta1/float.pcert0 \
- rtl/rel8/support/lib2.delta1/round-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/round.lisp
-rtl/rel8/support/lib2.delta1/round.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/round.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/round.pcert1 : rtl/rel8/support/lib2.delta1/round.pcert0
-rtl/rel8/support/lib2.delta1/round.cert : | rtl/rel8/support/lib2.delta1/round.pcert1
-
-rtl/rel8/support/lib2.delta1/rtl-new-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtl-new-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl-new-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/lib2.delta1/rtl-new-proofs.lisp
-rtl/rel8/support/lib2.delta1/rtl-new-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl-new-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtl-new-proofs.pcert1 : rtl/rel8/support/lib2.delta1/rtl-new-proofs.pcert0
-rtl/rel8/support/lib2.delta1/rtl-new-proofs.cert : | rtl/rel8/support/lib2.delta1/rtl-new-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/rtl-new.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtl-new.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl-new.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/rtl-new.lisp
-rtl/rel8/support/lib2.delta1/rtl-new.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl-new.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtl-new.pcert1 : rtl/rel8/support/lib2.delta1/rtl-new.pcert0
-rtl/rel8/support/lib2.delta1/rtl-new.cert : | rtl/rel8/support/lib2.delta1/rtl-new.pcert1
-
-rtl/rel8/support/lib2.delta1/rtl-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtl-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl-new.pcert0 \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new.pcert0 \
- rtl/rel8/support/lib2.delta1/log-new.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib2.delta1/rtl-proofs.lisp
-rtl/rel8/support/lib2.delta1/rtl-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtl-proofs.pcert1 : rtl/rel8/support/lib2.delta1/rtl-proofs.pcert0
-rtl/rel8/support/lib2.delta1/rtl-proofs.cert : | rtl/rel8/support/lib2.delta1/rtl-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/rtl.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtl.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/rtl.lisp
-rtl/rel8/support/lib2.delta1/rtl.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtl.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtl.pcert1 : rtl/rel8/support/lib2.delta1/rtl.pcert0
-rtl/rel8/support/lib2.delta1/rtl.cert : | rtl/rel8/support/lib2.delta1/rtl.pcert1
-
-rtl/rel8/support/lib2.delta1/rtlarr-new.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtlarr-new.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtlarr-new.pcert0 : \
- rtl/rel8/support/lib2/top.pcert0 \
- misc/total-order.pcert0 \
- rtl/rel8/support/lib2.delta1/rtl-new.pcert0 \
- rtl/rel8/support/lib2.delta1/rtlarr-new.lisp
-rtl/rel8/support/lib2.delta1/rtlarr-new.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtlarr-new.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtlarr-new.pcert1 : rtl/rel8/support/lib2.delta1/rtlarr-new.pcert0
-rtl/rel8/support/lib2.delta1/rtlarr-new.cert : | rtl/rel8/support/lib2.delta1/rtlarr-new.pcert1
-
-rtl/rel8/support/lib2.delta1/rtlarr.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtlarr.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtlarr.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtlarr-new.pcert0 \
- misc/total-order.pcert0 \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/rtlarr.lisp
-rtl/rel8/support/lib2.delta1/rtlarr.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/rtlarr.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/rtlarr.pcert1 : rtl/rel8/support/lib2.delta1/rtlarr.pcert0
-rtl/rel8/support/lib2.delta1/rtlarr.cert : | rtl/rel8/support/lib2.delta1/rtlarr.pcert1
-
-rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/rtlarr.pcert0 \
- rtl/rel8/support/lib2.delta1/logn.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.lisp
-rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.pcert1 : rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.pcert0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.cert : | rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/simple-loop-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/rtlarr.pcert0 \
- rtl/rel8/support/lib2.delta1/log.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers.lisp
-rtl/rel8/support/lib2.delta1/simple-loop-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers.pcert1 : rtl/rel8/support/lib2.delta1/simple-loop-helpers.pcert0
-rtl/rel8/support/lib2.delta1/simple-loop-helpers.cert : | rtl/rel8/support/lib2.delta1/simple-loop-helpers.pcert1
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/bits-new.pcert0 \
- rtl/rel8/support/lib2.delta1/logn-new.pcert0 \
- rtl/rel8/support/lib2.delta1/arith.pcert0 \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/support/lib2.delta1/bits-new-proofs.pcert0 \
- rtl/rel8/support/lib2/simplify-model-helpers.pcert0 \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.lisp
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.pcert1 : rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.pcert0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.cert : | rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.pcert0 : \
- rtl/rel8/support/lib2.delta1/bits-new.pcert0 \
- rtl/rel8/support/lib2.delta1/logn-new.pcert0 \
- rtl/rel8/support/lib2.delta1/arith.pcert0 \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.lisp
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.pcert1 : rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.pcert0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.cert : | rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.pcert1
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/logn.pcert0 \
- rtl/rel8/support/lib2.delta1/arith.pcert0 \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-new.pcert0 \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.lisp
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.pcert1 : rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.pcert0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.cert : | rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.pcert1
-
-rtl/rel8/support/lib2.delta1/simplify-model-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/arith.pcert0 \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers-proofs.pcert0 \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers.lisp
-rtl/rel8/support/lib2.delta1/simplify-model-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers.pcert1 : rtl/rel8/support/lib2.delta1/simplify-model-helpers.pcert0
-rtl/rel8/support/lib2.delta1/simplify-model-helpers.cert : | rtl/rel8/support/lib2.delta1/simplify-model-helpers.pcert1
-
-rtl/rel8/support/lib2.delta1/top.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/top.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/top.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/rtlarr.pcert0 \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/log.pcert0 \
- rtl/rel8/support/lib2.delta1/float.pcert0 \
- rtl/rel8/support/lib2.delta1/reps.pcert0 \
- rtl/rel8/support/lib2.delta1/round.pcert0 \
- rtl/rel8/support/lib2.delta1/add.pcert0 \
- rtl/rel8/support/lib2.delta1/mult.pcert0 \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert0 \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers.pcert0 \
- rtl/rel8/support/lib2.delta1/arith.pcert0 \
- rtl/rel8/support/lib2.delta1/bvecp-helpers.pcert0 \
- rtl/rel8/support/lib2.delta1/logn.pcert0 \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers.pcert0 \
- rtl/rel8/support/lib2.delta1/top.lisp
-rtl/rel8/support/lib2.delta1/top.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/top.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/top.pcert1 : rtl/rel8/support/lib2.delta1/top.pcert0
-rtl/rel8/support/lib2.delta1/top.cert : | rtl/rel8/support/lib2.delta1/top.pcert1
-
-rtl/rel8/support/lib2.delta1/util.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/util.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta1/util.pcert0 : \
- rtl/rel8/support/lib2/top.pcert0 \
- rtl/rel8/support/lib2.delta1/util.lisp
-rtl/rel8/support/lib2.delta1/util.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta1/util.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta1/util.pcert1 : rtl/rel8/support/lib2.delta1/util.pcert0
-rtl/rel8/support/lib2.delta1/util.cert : | rtl/rel8/support/lib2.delta1/util.pcert1
-
-rtl/rel8/support/lib2.delta2/add-lib.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta2/add-lib.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta2/add-lib.pcert0 : \
- rtl/rel8/support/lib2.delta2/base.pcert0 \
- rtl/rel8/support/lib2.delta1/arith.pcert0 \
- rtl/rel8/support/lib2.delta2/add-lib.lisp
-rtl/rel8/support/lib2.delta2/add-lib.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta2/add-lib.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta2/add-lib.pcert1 : rtl/rel8/support/lib2.delta2/add-lib.pcert0
-rtl/rel8/support/lib2.delta2/add-lib.cert : | rtl/rel8/support/lib2.delta2/add-lib.pcert1
-
-rtl/rel8/support/lib2.delta2/add.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta2/add.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta2/add.pcert0 : \
- rtl/rel8/support/lib2.delta2/base.pcert0 \
- rtl/rel8/support/lib2.delta2/add-lib.pcert0 \
- rtl/rel8/support/lib2.delta2/add.lisp
-rtl/rel8/support/lib2.delta2/add.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta2/add.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta2/add.pcert1 : rtl/rel8/support/lib2.delta2/add.pcert0
-rtl/rel8/support/lib2.delta2/add.cert : | rtl/rel8/support/lib2.delta2/add.pcert1
-
-rtl/rel8/support/lib2.delta2/base.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta2/base.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta2/base.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/rtlarr.pcert0 \
- rtl/rel8/support/lib2/basic.pcert0 \
- rtl/rel8/support/lib2.delta1/bits.pcert0 \
- rtl/rel8/support/lib2.delta1/log.pcert0 \
- rtl/rel8/support/lib2.delta1/float.pcert0 \
- rtl/rel8/support/lib2.delta1/reps.pcert0 \
- rtl/rel8/support/lib2.delta1/round.pcert0 \
- rtl/rel8/support/lib2.delta1/add.pcert0 \
- rtl/rel8/support/lib2.delta1/mult.pcert0 \
- rtl/rel8/support/lib2.delta1/util.pcert0 \
- rtl/rel8/support/lib2.delta2/base.lisp
-rtl/rel8/support/lib2.delta2/base.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta2/base.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta2/base.pcert1 : rtl/rel8/support/lib2.delta2/base.pcert0
-rtl/rel8/support/lib2.delta2/base.cert : | rtl/rel8/support/lib2.delta2/base.pcert1
-
-rtl/rel8/support/lib2.delta2/bits.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta2/bits.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta2/bits.pcert0 : \
- rtl/rel8/support/lib2.delta2/base.pcert0 \
- rtl/rel8/support/lib2.delta2/add-lib.pcert0 \
- rtl/rel8/support/lib2.delta2/bits.lisp
-rtl/rel8/support/lib2.delta2/bits.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta2/bits.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta2/bits.pcert1 : rtl/rel8/support/lib2.delta2/bits.pcert0
-rtl/rel8/support/lib2.delta2/bits.cert : | rtl/rel8/support/lib2.delta2/bits.pcert1
-
-rtl/rel8/support/lib2.delta2/log.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2.delta2/log.pcert0 : acl2x = 0
-rtl/rel8/support/lib2.delta2/log.pcert0 : \
- rtl/rel8/support/lib2.delta2/base.pcert0 \
- rtl/rel8/support/lib2.delta2/add-lib.pcert0 \
- rtl/rel8/support/lib2.delta2/log.lisp
-rtl/rel8/support/lib2.delta2/log.pcert1 : acl2x = 0
-rtl/rel8/support/lib2.delta2/log.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2.delta2/log.pcert1 : rtl/rel8/support/lib2.delta2/log.pcert0
-rtl/rel8/support/lib2.delta2/log.cert : | rtl/rel8/support/lib2.delta2/log.pcert1
-
-rtl/rel8/support/lib2/add.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/add.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/add.pcert0 : \
- rtl/rel8/support/lib2/round.pcert0 \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/add.lisp
-rtl/rel8/support/lib2/add.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/add.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/add.pcert1 : rtl/rel8/support/lib2/add.pcert0
-rtl/rel8/support/lib2/add.cert : | rtl/rel8/support/lib2/add.pcert1
-
-rtl/rel8/support/lib2/arith.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/arith.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/arith.pcert0 : \
- rtl/rel8/support/lib2/base.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel8/support/lib2/arith.lisp
-rtl/rel8/support/lib2/arith.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/arith.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/arith.pcert1 : rtl/rel8/support/lib2/arith.pcert0
-rtl/rel8/support/lib2/arith.cert : | rtl/rel8/support/lib2/arith.pcert1
-
-rtl/rel8/support/lib2/base.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/base.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/base.pcert0 : \
- rtl/rel8/support/lib1/rtl.pcert0 \
- rtl/rel8/support/lib1/rtlarr.pcert0 \
- rtl/rel8/support/lib1.delta1/basic.pcert0 \
- rtl/rel8/support/lib1.delta1/bits.pcert0 \
- rtl/rel8/support/lib1/log.pcert0 \
- rtl/rel8/support/lib1.delta2/float.pcert0 \
- rtl/rel8/support/lib1/reps.pcert0 \
- rtl/rel8/support/lib1.delta1/round.pcert0 \
- rtl/rel8/support/lib1/add.pcert0 \
- rtl/rel8/support/lib1.delta1/mult.pcert0 \
- rtl/rel8/support/lib1.delta1/arith.pcert0 \
- rtl/rel8/support/lib1/util.pcert0 \
- rtl/rel8/support/lib1.delta1/bvecp-raw-helpers.pcert0 \
- rtl/rel8/support/lib1.delta1/simple-loop-helpers.pcert0 \
- rtl/rel8/support/lib2/base.lisp
-rtl/rel8/support/lib2/base.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/base.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/base.pcert1 : rtl/rel8/support/lib2/base.pcert0
-rtl/rel8/support/lib2/base.cert : | rtl/rel8/support/lib2/base.pcert1
-
-rtl/rel8/support/lib2/basic.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/basic.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/basic.pcert0 : \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/basic.lisp
-rtl/rel8/support/lib2/basic.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/basic.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/basic.pcert1 : rtl/rel8/support/lib2/basic.pcert0
-rtl/rel8/support/lib2/basic.cert : | rtl/rel8/support/lib2/basic.pcert1
-
-rtl/rel8/support/lib2/bits.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/bits.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/bits.pcert0 : \
- rtl/rel8/support/lib2/basic.pcert0 \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/bits.lisp
-rtl/rel8/support/lib2/bits.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/bits.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/bits.pcert1 : rtl/rel8/support/lib2/bits.pcert0
-rtl/rel8/support/lib2/bits.cert : | rtl/rel8/support/lib2/bits.pcert1
-
-rtl/rel8/support/lib2/bvecp-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/bvecp-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/bvecp-helpers.pcert0 : \
- rtl/rel8/support/lib2/rtl.pcert0 \
- rtl/rel8/support/lib2/rtlarr.pcert0 \
- rtl/rel8/support/support/bvecp-helpers.pcert0 \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/support/lib2/bvecp-helpers.lisp
-rtl/rel8/support/lib2/bvecp-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/bvecp-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/bvecp-helpers.pcert1 : rtl/rel8/support/lib2/bvecp-helpers.pcert0
-rtl/rel8/support/lib2/bvecp-helpers.cert : | rtl/rel8/support/lib2/bvecp-helpers.pcert1
-
-rtl/rel8/support/lib2/bvecp-raw-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/bvecp-raw-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/bvecp-raw-helpers.pcert0 : \
- rtl/rel8/support/lib2/rtl.pcert0 \
- rtl/rel8/support/lib2/rtlarr.pcert0 \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/bvecp-raw-helpers.lisp
-rtl/rel8/support/lib2/bvecp-raw-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/bvecp-raw-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/bvecp-raw-helpers.pcert1 : rtl/rel8/support/lib2/bvecp-raw-helpers.pcert0
-rtl/rel8/support/lib2/bvecp-raw-helpers.cert : | rtl/rel8/support/lib2/bvecp-raw-helpers.pcert1
-
-rtl/rel8/support/lib2/clocks.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/clocks.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/clocks.pcert0 : \
- rtl/rel8/support/support/clocks.pcert0 \
- rtl/rel8/support/lib2/clocks.lisp
-rtl/rel8/support/lib2/clocks.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/clocks.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/clocks.pcert1 : rtl/rel8/support/lib2/clocks.pcert0
-rtl/rel8/support/lib2/clocks.cert : | rtl/rel8/support/lib2/clocks.pcert1
-
-rtl/rel8/support/lib2/float.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/float.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/float.pcert0 : \
- rtl/rel8/support/lib2/log.pcert0 \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/float.lisp
-rtl/rel8/support/lib2/float.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/float.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/float.pcert1 : rtl/rel8/support/lib2/float.pcert0
-rtl/rel8/support/lib2/float.cert : | rtl/rel8/support/lib2/float.pcert1
-
-rtl/rel8/support/lib2/log.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/log.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/log.pcert0 : \
- rtl/rel8/support/lib2/bits.pcert0 \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/log.lisp
-rtl/rel8/support/lib2/log.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/log.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/log.pcert1 : rtl/rel8/support/lib2/log.pcert0
-rtl/rel8/support/lib2/log.cert : | rtl/rel8/support/lib2/log.pcert1
-
-rtl/rel8/support/lib2/mult.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/mult.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/mult.pcert0 : \
- rtl/rel8/support/lib2/add.pcert0 \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/mult.lisp
-rtl/rel8/support/lib2/mult.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/mult.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/mult.pcert1 : rtl/rel8/support/lib2/mult.pcert0
-rtl/rel8/support/lib2/mult.cert : | rtl/rel8/support/lib2/mult.pcert1
-
-rtl/rel8/support/lib2/openers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/openers.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/openers.pcert0 : \
- rtl/rel8/support/support/openers.pcert0 \
- rtl/rel8/support/lib2/openers.lisp
-rtl/rel8/support/lib2/openers.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/openers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/openers.pcert1 : rtl/rel8/support/lib2/openers.pcert0
-rtl/rel8/support/lib2/openers.cert : | rtl/rel8/support/lib2/openers.pcert1
-
-rtl/rel8/support/lib2/package-defs.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/package-defs.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/package-defs.pcert0 : \
- rtl/rel8/support/support/package-defs.pcert0 \
- rtl/rel8/support/lib2/package-defs.lisp
-rtl/rel8/support/lib2/package-defs.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/package-defs.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/package-defs.pcert1 : rtl/rel8/support/lib2/package-defs.pcert0
-rtl/rel8/support/lib2/package-defs.cert : | rtl/rel8/support/lib2/package-defs.pcert1
-
-rtl/rel8/support/lib2/reps.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/reps.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/reps.pcert0 : \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/log.pcert0 \
- rtl/rel8/support/lib2/float.pcert0 \
- rtl/rel8/support/lib2/reps.lisp
-rtl/rel8/support/lib2/reps.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/reps.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/reps.pcert1 : rtl/rel8/support/lib2/reps.pcert0
-rtl/rel8/support/lib2/reps.cert : | rtl/rel8/support/lib2/reps.pcert1
-
-rtl/rel8/support/lib2/rom-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/rom-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/rom-helpers.pcert0 : \
- rtl/rel8/support/support/rom-helpers.pcert0 \
- rtl/rel8/support/lib2/rom-helpers.lisp
-rtl/rel8/support/lib2/rom-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/rom-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/rom-helpers.pcert1 : rtl/rel8/support/lib2/rom-helpers.pcert0
-rtl/rel8/support/lib2/rom-helpers.cert : | rtl/rel8/support/lib2/rom-helpers.pcert1
-
-rtl/rel8/support/lib2/round.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/round.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/round.pcert0 : \
- rtl/rel8/support/lib2/float.pcert0 \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/round.lisp
-rtl/rel8/support/lib2/round.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/round.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/round.pcert1 : rtl/rel8/support/lib2/round.pcert0
-rtl/rel8/support/lib2/round.cert : | rtl/rel8/support/lib2/round.pcert1
-
-rtl/rel8/support/lib2/rtl.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/rtl.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/rtl.pcert0 : \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/rtl.lisp
-rtl/rel8/support/lib2/rtl.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/rtl.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/rtl.pcert1 : rtl/rel8/support/lib2/rtl.pcert0
-rtl/rel8/support/lib2/rtl.cert : | rtl/rel8/support/lib2/rtl.pcert1
-
-rtl/rel8/support/lib2/rtlarr.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/rtlarr.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/rtlarr.pcert0 : \
- rtl/rel8/support/lib2/base.pcert0 \
- misc/total-order.pcert0 \
- rtl/rel8/support/lib2/rtl.pcert0 \
- rtl/rel8/support/lib2/rtlarr.lisp
-rtl/rel8/support/lib2/rtlarr.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/rtlarr.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/rtlarr.pcert1 : rtl/rel8/support/lib2/rtlarr.pcert0
-rtl/rel8/support/lib2/rtlarr.cert : | rtl/rel8/support/lib2/rtlarr.pcert1
-
-rtl/rel8/support/lib2/simple-loop-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/simple-loop-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/simple-loop-helpers.pcert0 : \
- rtl/rel8/support/lib2/rtl.pcert0 \
- rtl/rel8/support/lib2/rtlarr.pcert0 \
- rtl/rel8/support/lib2/arith.pcert0 \
- rtl/rel8/support/lib2/log.pcert0 \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/simple-loop-helpers.lisp
-rtl/rel8/support/lib2/simple-loop-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/simple-loop-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/simple-loop-helpers.pcert1 : rtl/rel8/support/lib2/simple-loop-helpers.pcert0
-rtl/rel8/support/lib2/simple-loop-helpers.cert : | rtl/rel8/support/lib2/simple-loop-helpers.pcert1
-
-rtl/rel8/support/lib2/simplify-model-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/simplify-model-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/simplify-model-helpers.pcert0 : \
- rtl/rel8/support/lib2/rtl.pcert0 \
- rtl/rel8/support/lib2/arith.pcert0 \
- rtl/rel8/support/lib2/bits.pcert0 \
- rtl/rel8/support/support/simplify-model-helpers.pcert0 \
- rtl/rel8/support/lib2/simplify-model-helpers.lisp
-rtl/rel8/support/lib2/simplify-model-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/simplify-model-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/simplify-model-helpers.pcert1 : rtl/rel8/support/lib2/simplify-model-helpers.pcert0
-rtl/rel8/support/lib2/simplify-model-helpers.cert : | rtl/rel8/support/lib2/simplify-model-helpers.pcert1
-
-rtl/rel8/support/lib2/top.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/top.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/top.pcert0 : \
- rtl/rel8/support/lib2/rtl.pcert0 \
- rtl/rel8/support/lib2/rtlarr.pcert0 \
- rtl/rel8/support/lib2/basic.pcert0 \
- rtl/rel8/support/lib2/bits.pcert0 \
- rtl/rel8/support/lib2/log.pcert0 \
- rtl/rel8/support/lib2/float.pcert0 \
- rtl/rel8/support/lib2/reps.pcert0 \
- rtl/rel8/support/lib2/round.pcert0 \
- rtl/rel8/support/lib2/add.pcert0 \
- rtl/rel8/support/lib2/mult.pcert0 \
- rtl/rel8/support/lib2/arith.pcert0 \
- rtl/rel8/support/lib2/util.pcert0 \
- rtl/rel8/support/lib2/top.lisp
-rtl/rel8/support/lib2/top.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/top.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/top.pcert1 : rtl/rel8/support/lib2/top.pcert0
-rtl/rel8/support/lib2/top.cert : | rtl/rel8/support/lib2/top.pcert1
-
-rtl/rel8/support/lib2/util.pcert0 : no_pcert = 0
-rtl/rel8/support/lib2/util.pcert0 : acl2x = 0
-rtl/rel8/support/lib2/util.pcert0 : \
- rtl/rel8/support/lib2/base.pcert0 \
- rtl/rel8/support/lib2/util.lisp
-rtl/rel8/support/lib2/util.pcert1 : acl2x = 0
-rtl/rel8/support/lib2/util.pcert1 : no_pcert = 0
-rtl/rel8/support/lib2/util.pcert1 : rtl/rel8/support/lib2/util.pcert0
-rtl/rel8/support/lib2/util.cert : | rtl/rel8/support/lib2/util.pcert1
-
-rtl/rel8/support/support/add3-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/add3-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/add3-proofs.pcert0 : \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/support/support/add3-proofs.lisp
-rtl/rel8/support/support/add3-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/add3-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/add3-proofs.pcert1 : rtl/rel8/support/support/add3-proofs.pcert0
-rtl/rel8/support/support/add3-proofs.cert : | rtl/rel8/support/support/add3-proofs.pcert1
-
-rtl/rel8/support/support/add3.pcert0 : no_pcert = 0
-rtl/rel8/support/support/add3.pcert0 : acl2x = 0
-rtl/rel8/support/support/add3.pcert0 : \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/add3-proofs.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/support/support/add3.lisp
-rtl/rel8/support/support/add3.pcert1 : acl2x = 0
-rtl/rel8/support/support/add3.pcert1 : no_pcert = 0
-rtl/rel8/support/support/add3.pcert1 : rtl/rel8/support/support/add3.pcert0
-rtl/rel8/support/support/add3.cert : | rtl/rel8/support/support/add3.pcert1
-
-rtl/rel8/support/support/all-ones.pcert0 : no_pcert = 0
-rtl/rel8/support/support/all-ones.pcert0 : acl2x = 0
-rtl/rel8/support/support/all-ones.pcert0 : \
- rtl/rel8/support/support/all-ones.lisp
-rtl/rel8/support/support/all-ones.pcert1 : acl2x = 0
-rtl/rel8/support/support/all-ones.pcert1 : no_pcert = 0
-rtl/rel8/support/support/all-ones.pcert1 : rtl/rel8/support/support/all-ones.pcert0
-rtl/rel8/support/support/all-ones.cert : | rtl/rel8/support/support/all-ones.pcert1
-
-rtl/rel8/support/support/ash.pcert0 : no_pcert = 0
-rtl/rel8/support/support/ash.pcert0 : acl2x = 0
-rtl/rel8/support/support/ash.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/expt.pcert0 \
- rtl/rel8/arithmetic/expo.pcert0 \
- rtl/rel8/support/support/ash.lisp
-rtl/rel8/support/support/ash.pcert1 : acl2x = 0
-rtl/rel8/support/support/ash.pcert1 : no_pcert = 0
-rtl/rel8/support/support/ash.pcert1 : rtl/rel8/support/support/ash.pcert0
-rtl/rel8/support/support/ash.cert : | rtl/rel8/support/support/ash.pcert1
-
-rtl/rel8/support/support/away-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/away-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/away-proofs.pcert0 : \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/away-proofs.lisp
-rtl/rel8/support/support/away-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/away-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/away-proofs.pcert1 : rtl/rel8/support/support/away-proofs.pcert0
-rtl/rel8/support/support/away-proofs.cert : | rtl/rel8/support/support/away-proofs.pcert1
-
-rtl/rel8/support/support/away.pcert0 : no_pcert = 0
-rtl/rel8/support/support/away.pcert0 : acl2x = 0
-rtl/rel8/support/support/away.pcert0 : \
- rtl/rel8/support/support/away-proofs.pcert0 \
- rtl/rel8/support/support/away.lisp
-rtl/rel8/support/support/away.pcert1 : acl2x = 0
-rtl/rel8/support/support/away.pcert1 : no_pcert = 0
-rtl/rel8/support/support/away.pcert1 : rtl/rel8/support/support/away.pcert0
-rtl/rel8/support/support/away.cert : | rtl/rel8/support/support/away.pcert1
-
-rtl/rel8/support/support/badguys.pcert0 : no_pcert = 0
-rtl/rel8/support/support/badguys.pcert0 : acl2x = 0
-rtl/rel8/support/support/badguys.pcert0 : \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/badguys.lisp
-rtl/rel8/support/support/badguys.pcert1 : acl2x = 0
-rtl/rel8/support/support/badguys.pcert1 : no_pcert = 0
-rtl/rel8/support/support/badguys.pcert1 : rtl/rel8/support/support/badguys.pcert0
-rtl/rel8/support/support/badguys.cert : | rtl/rel8/support/support/badguys.pcert1
-
-rtl/rel8/support/support/bias-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bias-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/bias-proofs.pcert0 : \
- rtl/rel8/arithmetic/expt.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/support/support/bias-proofs.lisp
-rtl/rel8/support/support/bias-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/bias-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bias-proofs.pcert1 : rtl/rel8/support/support/bias-proofs.pcert0
-rtl/rel8/support/support/bias-proofs.cert : | rtl/rel8/support/support/bias-proofs.pcert1
-
-rtl/rel8/support/support/bias.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bias.pcert0 : acl2x = 0
-rtl/rel8/support/support/bias.pcert0 : \
- rtl/rel8/support/support/bias-proofs.pcert0 \
- rtl/rel8/support/support/bias.lisp
-rtl/rel8/support/support/bias.pcert1 : acl2x = 0
-rtl/rel8/support/support/bias.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bias.pcert1 : rtl/rel8/support/support/bias.pcert0
-rtl/rel8/support/support/bias.cert : | rtl/rel8/support/support/bias.pcert1
-
-rtl/rel8/support/support/bitn-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bitn-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/bitn-proofs.pcert0 : \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/power2p.pcert0 \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/bitn-proofs.lisp
-rtl/rel8/support/support/bitn-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/bitn-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bitn-proofs.pcert1 : rtl/rel8/support/support/bitn-proofs.pcert0
-rtl/rel8/support/support/bitn-proofs.cert : | rtl/rel8/support/support/bitn-proofs.pcert1
-
-rtl/rel8/support/support/bitn.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bitn.pcert0 : acl2x = 0
-rtl/rel8/support/support/bitn.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/arithmetic/power2p.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/support/support/bitn-proofs.pcert0 \
- rtl/rel8/support/support/bitn.lisp
-rtl/rel8/support/support/bitn.pcert1 : acl2x = 0
-rtl/rel8/support/support/bitn.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bitn.pcert1 : rtl/rel8/support/support/bitn.pcert0
-rtl/rel8/support/support/bitn.cert : | rtl/rel8/support/support/bitn.pcert1
-
-rtl/rel8/support/support/bits-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bits-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/bits-proofs.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/power2p.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/bits-proofs.lisp
-rtl/rel8/support/support/bits-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/bits-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bits-proofs.pcert1 : rtl/rel8/support/support/bits-proofs.pcert0
-rtl/rel8/support/support/bits-proofs.cert : | rtl/rel8/support/support/bits-proofs.pcert1
-
-rtl/rel8/support/support/bits-trunc-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bits-trunc-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/bits-trunc-proofs.pcert0 : \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/log.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/bits-trunc-proofs.lisp
-rtl/rel8/support/support/bits-trunc-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/bits-trunc-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bits-trunc-proofs.pcert1 : rtl/rel8/support/support/bits-trunc-proofs.pcert0
-rtl/rel8/support/support/bits-trunc-proofs.cert : | rtl/rel8/support/support/bits-trunc-proofs.pcert1
-
-rtl/rel8/support/support/bits-trunc.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bits-trunc.pcert0 : acl2x = 0
-rtl/rel8/support/support/bits-trunc.pcert0 : \
- rtl/rel8/support/support/log.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/bits-trunc-proofs.pcert0 \
- rtl/rel8/support/support/bits-trunc.lisp
-rtl/rel8/support/support/bits-trunc.pcert1 : acl2x = 0
-rtl/rel8/support/support/bits-trunc.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bits-trunc.pcert1 : rtl/rel8/support/support/bits-trunc.pcert0
-rtl/rel8/support/support/bits-trunc.cert : | rtl/rel8/support/support/bits-trunc.pcert1
-
-rtl/rel8/support/support/bits.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bits.pcert0 : acl2x = 0
-rtl/rel8/support/support/bits.pcert0 : \
- rtl/rel8/support/support/bits-proofs.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/power2p.pcert0 \
- rtl/rel8/support/support/bits.lisp
-rtl/rel8/support/support/bits.pcert1 : acl2x = 0
-rtl/rel8/support/support/bits.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bits.pcert1 : rtl/rel8/support/support/bits.pcert0
-rtl/rel8/support/support/bits.cert : | rtl/rel8/support/support/bits.pcert1
-
-rtl/rel8/support/support/bvecp-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bvecp-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/support/bvecp-helpers.pcert0 : \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/bvecp-lemmas.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bvecp-helpers.lisp
-rtl/rel8/support/support/bvecp-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/support/bvecp-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bvecp-helpers.pcert1 : rtl/rel8/support/support/bvecp-helpers.pcert0
-rtl/rel8/support/support/bvecp-helpers.cert : | rtl/rel8/support/support/bvecp-helpers.pcert1
-
-rtl/rel8/support/support/bvecp-lemmas.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bvecp-lemmas.pcert0 : acl2x = 0
-rtl/rel8/support/support/bvecp-lemmas.pcert0 : \
- rtl/rel8/arithmetic/expo.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/setbits.pcert0 \
- rtl/rel8/support/support/setbitn.pcert0 \
- rtl/rel8/support/support/encode.pcert0 \
- rtl/rel8/support/support/decode.pcert0 \
- rtl/rel8/support/support/logs.pcert0 \
- rtl/rel8/support/support/lnot.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/shft.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/mulcat.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/bvecp-lemmas.lisp
-rtl/rel8/support/support/bvecp-lemmas.pcert1 : acl2x = 0
-rtl/rel8/support/support/bvecp-lemmas.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bvecp-lemmas.pcert1 : rtl/rel8/support/support/bvecp-lemmas.pcert0
-rtl/rel8/support/support/bvecp-lemmas.cert : | rtl/rel8/support/support/bvecp-lemmas.pcert1
-
-rtl/rel8/support/support/bvecp-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bvecp-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/bvecp-proofs.pcert0 : \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bvecp-proofs.lisp
-rtl/rel8/support/support/bvecp-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/bvecp-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bvecp-proofs.pcert1 : rtl/rel8/support/support/bvecp-proofs.pcert0
-rtl/rel8/support/support/bvecp-proofs.cert : | rtl/rel8/support/support/bvecp-proofs.pcert1
-
-rtl/rel8/support/support/bvecp.pcert0 : no_pcert = 0
-rtl/rel8/support/support/bvecp.pcert0 : acl2x = 0
-rtl/rel8/support/support/bvecp.pcert0 : \
- rtl/rel8/support/support/bvecp-proofs.pcert0 \
- rtl/rel8/support/support/bvecp.lisp
-rtl/rel8/support/support/bvecp.pcert1 : acl2x = 0
-rtl/rel8/support/support/bvecp.pcert1 : no_pcert = 0
-rtl/rel8/support/support/bvecp.pcert1 : rtl/rel8/support/support/bvecp.pcert0
-rtl/rel8/support/support/bvecp.cert : | rtl/rel8/support/support/bvecp.pcert1
-
-rtl/rel8/support/support/cat-def.pcert0 : no_pcert = 0
-rtl/rel8/support/support/cat-def.pcert0 : acl2x = 0
-rtl/rel8/support/support/cat-def.pcert0 : \
- rtl/rel8/support/support/cat-def.lisp
-rtl/rel8/support/support/cat-def.pcert1 : acl2x = 0
-rtl/rel8/support/support/cat-def.pcert1 : no_pcert = 0
-rtl/rel8/support/support/cat-def.pcert1 : rtl/rel8/support/support/cat-def.pcert0
-rtl/rel8/support/support/cat-def.cert : | rtl/rel8/support/support/cat-def.pcert1
-
-rtl/rel8/support/support/cat-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/cat-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/cat-proofs.pcert0 : \
- rtl/rel8/support/support/cat-def.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/cat-proofs.lisp
-rtl/rel8/support/support/cat-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/cat-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/cat-proofs.pcert1 : rtl/rel8/support/support/cat-proofs.pcert0
-rtl/rel8/support/support/cat-proofs.cert : | rtl/rel8/support/support/cat-proofs.pcert1
-
-rtl/rel8/support/support/cat.pcert0 : no_pcert = 0
-rtl/rel8/support/support/cat.pcert0 : acl2x = 0
-rtl/rel8/support/support/cat.pcert0 : \
- rtl/rel8/support/support/cat-def.pcert0 \
- rtl/rel8/support/support/cat-proofs.pcert0 \
- rtl/rel8/support/support/cat.lisp
-rtl/rel8/support/support/cat.pcert1 : acl2x = 0
-rtl/rel8/support/support/cat.pcert1 : no_pcert = 0
-rtl/rel8/support/support/cat.pcert1 : rtl/rel8/support/support/cat.pcert0
-rtl/rel8/support/support/cat.cert : | rtl/rel8/support/support/cat.pcert1
-
-rtl/rel8/support/support/clocks.pcert0 : no_pcert = 0
-rtl/rel8/support/support/clocks.pcert0 : acl2x = 0
-rtl/rel8/support/support/clocks.pcert0 : \
- rtl/rel8/support/support/mod4.pcert0 \
- rtl/rel8/arithmetic/even-odd2.pcert0 \
- rtl/rel8/support/support/clocks.lisp
-rtl/rel8/support/support/clocks.pcert1 : acl2x = 0
-rtl/rel8/support/support/clocks.pcert1 : no_pcert = 0
-rtl/rel8/support/support/clocks.pcert1 : rtl/rel8/support/support/clocks.pcert0
-rtl/rel8/support/support/clocks.cert : | rtl/rel8/support/support/clocks.pcert1
-
-rtl/rel8/support/support/decode-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/decode-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/decode-proofs.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/support/support/ash.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/decode-proofs.lisp
-rtl/rel8/support/support/decode-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/decode-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/decode-proofs.pcert1 : rtl/rel8/support/support/decode-proofs.pcert0
-rtl/rel8/support/support/decode-proofs.cert : | rtl/rel8/support/support/decode-proofs.pcert1
-
-rtl/rel8/support/support/decode.pcert0 : no_pcert = 0
-rtl/rel8/support/support/decode.pcert0 : acl2x = 0
-rtl/rel8/support/support/decode.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/decode-proofs.pcert0 \
- rtl/rel8/support/support/decode.lisp
-rtl/rel8/support/support/decode.pcert1 : acl2x = 0
-rtl/rel8/support/support/decode.pcert1 : no_pcert = 0
-rtl/rel8/support/support/decode.pcert1 : rtl/rel8/support/support/decode.pcert0
-rtl/rel8/support/support/decode.cert : | rtl/rel8/support/support/decode.pcert1
-
-rtl/rel8/support/support/drnd-original.pcert0 : no_pcert = 0
-rtl/rel8/support/support/drnd-original.pcert0 : acl2x = 0
-rtl/rel8/support/support/drnd-original.pcert0 : \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/ireps.pcert0 \
- rtl/rel8/support/support/rnd.pcert0 \
- rtl/rel8/support/support/bias.pcert0 \
- rtl/rel8/support/support/sgn.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/away.pcert0 \
- rtl/rel8/support/support/near.pcert0 \
- rtl/rel8/support/support/near+.pcert0 \
- rtl/rel8/support/support/sticky.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/drnd-original.lisp
-rtl/rel8/support/support/drnd-original.pcert1 : acl2x = 0
-rtl/rel8/support/support/drnd-original.pcert1 : no_pcert = 0
-rtl/rel8/support/support/drnd-original.pcert1 : rtl/rel8/support/support/drnd-original.pcert0
-rtl/rel8/support/support/drnd-original.cert : | rtl/rel8/support/support/drnd-original.pcert1
-
-rtl/rel8/support/support/encode.pcert0 : no_pcert = 0
-rtl/rel8/support/support/encode.pcert0 : acl2x = 0
-rtl/rel8/support/support/encode.pcert0 : \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/ash.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/encode.lisp
-rtl/rel8/support/support/encode.pcert1 : acl2x = 0
-rtl/rel8/support/support/encode.pcert1 : no_pcert = 0
-rtl/rel8/support/support/encode.pcert1 : rtl/rel8/support/support/encode.pcert0
-rtl/rel8/support/support/encode.cert : | rtl/rel8/support/support/encode.pcert1
-
-rtl/rel8/support/support/ereps-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/ereps-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/ereps-proofs.pcert0 : \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/bias.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/mulcat.pcert0 \
- rtl/rel8/support/support/ereps-proofs.lisp
-rtl/rel8/support/support/ereps-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/ereps-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/ereps-proofs.pcert1 : rtl/rel8/support/support/ereps-proofs.pcert0
-rtl/rel8/support/support/ereps-proofs.cert : | rtl/rel8/support/support/ereps-proofs.pcert1
-
-rtl/rel8/support/support/ereps.pcert0 : no_pcert = 0
-rtl/rel8/support/support/ereps.pcert0 : acl2x = 0
-rtl/rel8/support/support/ereps.pcert0 : \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/ereps-proofs.pcert0 \
- rtl/rel8/support/support/ereps.lisp
-rtl/rel8/support/support/ereps.pcert1 : acl2x = 0
-rtl/rel8/support/support/ereps.pcert1 : no_pcert = 0
-rtl/rel8/support/support/ereps.pcert1 : rtl/rel8/support/support/ereps.pcert0
-rtl/rel8/support/support/ereps.cert : | rtl/rel8/support/support/ereps.pcert1
-
-rtl/rel8/support/support/fadd-extra.pcert0 : no_pcert = 0
-rtl/rel8/support/support/fadd-extra.pcert0 : acl2x = 0
-rtl/rel8/support/support/fadd-extra.pcert0 : \
- rtl/rel8/support/support/fadd-extra0.pcert0 \
- rtl/rel8/support/support/land.pcert0 \
- rtl/rel8/support/support/lior.pcert0 \
- rtl/rel8/support/support/lxor.pcert0 \
- rtl/rel8/support/support/top1.pcert0 \
- rtl/rel8/support/support/fadd-extra.lisp
-rtl/rel8/support/support/fadd-extra.pcert1 : acl2x = 0
-rtl/rel8/support/support/fadd-extra.pcert1 : no_pcert = 0
-rtl/rel8/support/support/fadd-extra.pcert1 : rtl/rel8/support/support/fadd-extra.pcert0
-rtl/rel8/support/support/fadd-extra.cert : | rtl/rel8/support/support/fadd-extra.pcert1
-
-rtl/rel8/support/support/fadd-extra0.pcert0 : no_pcert = 0
-rtl/rel8/support/support/fadd-extra0.pcert0 : acl2x = 0
-rtl/rel8/support/support/fadd-extra0.pcert0 : \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/fadd.pcert0 \
- rtl/rel8/support/support/top1.pcert0 \
- rtl/rel8/support/support/fadd-extra0.lisp
-rtl/rel8/support/support/fadd-extra0.pcert1 : acl2x = 0
-rtl/rel8/support/support/fadd-extra0.pcert1 : no_pcert = 0
-rtl/rel8/support/support/fadd-extra0.pcert1 : rtl/rel8/support/support/fadd-extra0.pcert0
-rtl/rel8/support/support/fadd-extra0.cert : | rtl/rel8/support/support/fadd-extra0.pcert1
-
-rtl/rel8/support/support/fadd.pcert0 : no_pcert = 0
-rtl/rel8/support/support/fadd.pcert0 : acl2x = 0
-rtl/rel8/support/support/fadd.pcert0 : \
- rtl/rel8/support/support/stick.pcert0 \
- rtl/rel8/support/support/lop3.pcert0 \
- rtl/rel8/support/support/add3.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/lextra0.pcert0 \
- rtl/rel8/support/support/fadd.lisp
-rtl/rel8/support/support/fadd.pcert1 : acl2x = 0
-rtl/rel8/support/support/fadd.pcert1 : no_pcert = 0
-rtl/rel8/support/support/fadd.pcert1 : rtl/rel8/support/support/fadd.pcert0
-rtl/rel8/support/support/fadd.cert : | rtl/rel8/support/support/fadd.pcert1
-
-rtl/rel8/support/support/fast-and.pcert0 : no_pcert = 0
-rtl/rel8/support/support/fast-and.pcert0 : acl2x = 0
-rtl/rel8/support/support/fast-and.pcert0 : \
- rtl/rel8/support/support/fast-and.lisp
-rtl/rel8/support/support/fast-and.pcert1 : acl2x = 0
-rtl/rel8/support/support/fast-and.pcert1 : no_pcert = 0
-rtl/rel8/support/support/fast-and.pcert1 : rtl/rel8/support/support/fast-and.pcert0
-rtl/rel8/support/support/fast-and.cert : | rtl/rel8/support/support/fast-and.pcert1
-
-rtl/rel8/support/support/float-extra.pcert0 : no_pcert = 0
-rtl/rel8/support/support/float-extra.pcert0 : acl2x = 0
-rtl/rel8/support/support/float-extra.pcert0 : \
- arithmetic/inequalities.pcert0 \
- rtl/rel8/support/support/sticky.pcert0 \
- rtl/rel8/support/support/util.pcert0 \
- rtl/rel8/support/support/top1.pcert0 \
- rtl/rel8/support/support/float-extra.lisp
-rtl/rel8/support/support/float-extra.pcert1 : acl2x = 0
-rtl/rel8/support/support/float-extra.pcert1 : no_pcert = 0
-rtl/rel8/support/support/float-extra.pcert1 : rtl/rel8/support/support/float-extra.pcert0
-rtl/rel8/support/support/float-extra.cert : | rtl/rel8/support/support/float-extra.pcert1
-
-rtl/rel8/support/support/float.pcert0 : no_pcert = 0
-rtl/rel8/support/support/float.pcert0 : acl2x = 0
-rtl/rel8/support/support/float.pcert0 : \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/arithmetic/negative-syntaxp.pcert0 \
- rtl/rel8/arithmetic/basic.pcert0 \
- rtl/rel8/arithmetic/power2p.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/cg.pcert0 \
- rtl/rel8/support/support/float.lisp
-rtl/rel8/support/support/float.pcert1 : acl2x = 0
-rtl/rel8/support/support/float.pcert1 : no_pcert = 0
-rtl/rel8/support/support/float.pcert1 : rtl/rel8/support/support/float.pcert0
-rtl/rel8/support/support/float.cert : | rtl/rel8/support/support/float.pcert1
-
-rtl/rel8/support/support/ground-zero.pcert0 : no_pcert = 0
-rtl/rel8/support/support/ground-zero.pcert0 : acl2x = 0
-rtl/rel8/support/support/ground-zero.pcert0 : \
- rtl/rel8/arithmetic/ground-zero.pcert0 \
- rtl/rel8/support/support/util.pcert0 \
- rtl/rel8/support/support/ground-zero.lisp
-rtl/rel8/support/support/ground-zero.pcert1 : acl2x = 0
-rtl/rel8/support/support/ground-zero.pcert1 : no_pcert = 0
-rtl/rel8/support/support/ground-zero.pcert1 : rtl/rel8/support/support/ground-zero.pcert0
-rtl/rel8/support/support/ground-zero.cert : | rtl/rel8/support/support/ground-zero.pcert1
-
-rtl/rel8/support/support/guards.pcert0 : no_pcert = 0
-rtl/rel8/support/support/guards.pcert0 : acl2x = 0
-rtl/rel8/support/support/guards.pcert0 : \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/top1.pcert0 \
- rtl/rel8/support/support/land.pcert0 \
- rtl/rel8/support/support/lior.pcert0 \
- rtl/rel8/support/support/lxor.pcert0 \
- rtl/rel8/support/support/guards.lisp
-rtl/rel8/support/support/guards.pcert1 : acl2x = 0
-rtl/rel8/support/support/guards.pcert1 : no_pcert = 0
-rtl/rel8/support/support/guards.pcert1 : rtl/rel8/support/support/guards.pcert0
-rtl/rel8/support/support/guards.cert : | rtl/rel8/support/support/guards.pcert1
-
-rtl/rel8/support/support/ireps.pcert0 : no_pcert = 0
-rtl/rel8/support/support/ireps.pcert0 : acl2x = 0
-rtl/rel8/support/support/ireps.pcert0 : \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/bias.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/ireps.lisp
-rtl/rel8/support/support/ireps.pcert1 : acl2x = 0
-rtl/rel8/support/support/ireps.pcert1 : no_pcert = 0
-rtl/rel8/support/support/ireps.pcert1 : rtl/rel8/support/support/ireps.pcert0
-rtl/rel8/support/support/ireps.cert : | rtl/rel8/support/support/ireps.pcert1
-
-rtl/rel8/support/support/land.pcert0 : no_pcert = 0
-rtl/rel8/support/support/land.pcert0 : acl2x = 0
-rtl/rel8/support/support/land.pcert0 : \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/top1.pcert0 \
- rtl/rel8/support/support/land.lisp
-rtl/rel8/support/support/land.pcert1 : acl2x = 0
-rtl/rel8/support/support/land.pcert1 : no_pcert = 0
-rtl/rel8/support/support/land.pcert1 : rtl/rel8/support/support/land.pcert0
-rtl/rel8/support/support/land.cert : | rtl/rel8/support/support/land.pcert1
-
-rtl/rel8/support/support/land0-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/land0-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/land0-proofs.pcert0 : \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/all-ones.pcert0 \
- rtl/rel8/support/support/log.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/arithmetic/fl-hacks.pcert0 \
- rtl/rel8/support/support/land0-proofs.lisp
-rtl/rel8/support/support/land0-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/land0-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/land0-proofs.pcert1 : rtl/rel8/support/support/land0-proofs.pcert0
-rtl/rel8/support/support/land0-proofs.cert : | rtl/rel8/support/support/land0-proofs.pcert1
-
-rtl/rel8/support/support/land0.pcert0 : no_pcert = 0
-rtl/rel8/support/support/land0.pcert0 : acl2x = 0
-rtl/rel8/support/support/land0.pcert0 : \
- rtl/rel8/support/support/land0-proofs.pcert0 \
- rtl/rel8/support/support/land0.lisp
-rtl/rel8/support/support/land0.pcert1 : acl2x = 0
-rtl/rel8/support/support/land0.pcert1 : no_pcert = 0
-rtl/rel8/support/support/land0.pcert1 : rtl/rel8/support/support/land0.pcert0
-rtl/rel8/support/support/land0.cert : | rtl/rel8/support/support/land0.pcert1
-
-rtl/rel8/support/support/lextra-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lextra-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/lextra-proofs.pcert0 : \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/support/logxor.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/lextra-proofs.lisp
-rtl/rel8/support/support/lextra-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/lextra-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lextra-proofs.pcert1 : rtl/rel8/support/support/lextra-proofs.pcert0
-rtl/rel8/support/support/lextra-proofs.cert : | rtl/rel8/support/support/lextra-proofs.pcert1
-
-rtl/rel8/support/support/lextra.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lextra.pcert0 : acl2x = 0
-rtl/rel8/support/support/lextra.pcert0 : \
- rtl/rel8/support/support/land.pcert0 \
- rtl/rel8/support/support/lior.pcert0 \
- rtl/rel8/support/support/lxor.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/lextra0.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/support/support/merge2.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bits-trunc.pcert0 \
- rtl/rel8/support/support/fadd.pcert0 \
- rtl/rel8/support/support/lextra.lisp
-rtl/rel8/support/support/lextra.pcert1 : acl2x = 0
-rtl/rel8/support/support/lextra.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lextra.pcert1 : rtl/rel8/support/support/lextra.pcert0
-rtl/rel8/support/support/lextra.cert : | rtl/rel8/support/support/lextra.pcert1
-
-rtl/rel8/support/support/lextra0.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lextra0.pcert0 : acl2x = 0
-rtl/rel8/support/support/lextra0.pcert0 : \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/support/support/lextra-proofs.pcert0 \
- rtl/rel8/support/support/lextra0.lisp
-rtl/rel8/support/support/lextra0.pcert1 : acl2x = 0
-rtl/rel8/support/support/lextra0.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lextra0.pcert1 : rtl/rel8/support/support/lextra0.pcert0
-rtl/rel8/support/support/lextra0.cert : | rtl/rel8/support/support/lextra0.pcert1
-
-rtl/rel8/support/support/lior.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lior.pcert0 : acl2x = 0
-rtl/rel8/support/support/lior.pcert0 : \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/top1.pcert0 \
- rtl/rel8/support/support/lior.lisp
-rtl/rel8/support/support/lior.pcert1 : acl2x = 0
-rtl/rel8/support/support/lior.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lior.pcert1 : rtl/rel8/support/support/lior.pcert0
-rtl/rel8/support/support/lior.cert : | rtl/rel8/support/support/lior.pcert1
-
-rtl/rel8/support/support/lior0-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lior0-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/lior0-proofs.pcert0 : \
- rtl/rel8/support/support/all-ones.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/lior0-proofs.lisp
-rtl/rel8/support/support/lior0-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/lior0-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lior0-proofs.pcert1 : rtl/rel8/support/support/lior0-proofs.pcert0
-rtl/rel8/support/support/lior0-proofs.cert : | rtl/rel8/support/support/lior0-proofs.pcert1
-
-rtl/rel8/support/support/lior0.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lior0.pcert0 : acl2x = 0
-rtl/rel8/support/support/lior0.pcert0 : \
- rtl/rel8/support/support/lior0-proofs.pcert0 \
- rtl/rel8/support/support/lior0.lisp
-rtl/rel8/support/support/lior0.pcert1 : acl2x = 0
-rtl/rel8/support/support/lior0.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lior0.pcert1 : rtl/rel8/support/support/lior0.pcert0
-rtl/rel8/support/support/lior0.cert : | rtl/rel8/support/support/lior0.pcert1
-
-rtl/rel8/support/support/lnot-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lnot-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/lnot-proofs.pcert0 : \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/arithmetic/expt.pcert0 \
- rtl/rel8/arithmetic/mod.pcert0 \
- rtl/rel8/arithmetic/mod.pcert0 \
- rtl/rel8/arithmetic/arith.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/lnot-proofs.lisp
-rtl/rel8/support/support/lnot-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/lnot-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lnot-proofs.pcert1 : rtl/rel8/support/support/lnot-proofs.pcert0
-rtl/rel8/support/support/lnot-proofs.cert : | rtl/rel8/support/support/lnot-proofs.pcert1
-
-rtl/rel8/support/support/lnot.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lnot.pcert0 : acl2x = 0
-rtl/rel8/support/support/lnot.pcert0 : \
- rtl/rel8/support/support/lnot-proofs.pcert0 \
- rtl/rel8/support/support/lnot.lisp
-rtl/rel8/support/support/lnot.pcert1 : acl2x = 0
-rtl/rel8/support/support/lnot.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lnot.pcert1 : rtl/rel8/support/support/lnot.pcert0
-rtl/rel8/support/support/lnot.cert : | rtl/rel8/support/support/lnot.pcert1
-
-rtl/rel8/support/support/log-equal.pcert0 : no_pcert = 0
-rtl/rel8/support/support/log-equal.pcert0 : acl2x = 0
-rtl/rel8/support/support/log-equal.pcert0 : \
- rtl/rel8/support/support/log-equal.lisp
-rtl/rel8/support/support/log-equal.pcert1 : acl2x = 0
-rtl/rel8/support/support/log-equal.pcert1 : no_pcert = 0
-rtl/rel8/support/support/log-equal.pcert1 : rtl/rel8/support/support/log-equal.pcert0
-rtl/rel8/support/support/log-equal.cert : | rtl/rel8/support/support/log-equal.pcert1
-
-rtl/rel8/support/support/log-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/log-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/log-proofs.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/lognot.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/lnot.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/logxor.pcert0 \
- rtl/rel8/support/support/log-proofs.lisp
-rtl/rel8/support/support/log-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/log-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/log-proofs.pcert1 : rtl/rel8/support/support/log-proofs.pcert0
-rtl/rel8/support/support/log-proofs.cert : | rtl/rel8/support/support/log-proofs.pcert1
-
-rtl/rel8/support/support/log.pcert0 : no_pcert = 0
-rtl/rel8/support/support/log.pcert0 : acl2x = 0
-rtl/rel8/support/support/log.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/log-proofs.pcert0 \
- rtl/rel8/support/support/lnot.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/support/logxor.pcert0 \
- rtl/rel8/support/support/log.lisp
-rtl/rel8/support/support/log.pcert1 : acl2x = 0
-rtl/rel8/support/support/log.pcert1 : no_pcert = 0
-rtl/rel8/support/support/log.pcert1 : rtl/rel8/support/support/log.pcert0
-rtl/rel8/support/support/log.cert : | rtl/rel8/support/support/log.pcert1
-
-rtl/rel8/support/support/logand-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/logand-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/logand-proofs.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/induct.pcert0 \
- rtl/rel8/support/support/lognot.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/logand-proofs.lisp
-rtl/rel8/support/support/logand-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/logand-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/logand-proofs.pcert1 : rtl/rel8/support/support/logand-proofs.pcert0
-rtl/rel8/support/support/logand-proofs.cert : | rtl/rel8/support/support/logand-proofs.pcert1
-
-rtl/rel8/support/support/logand.pcert0 : no_pcert = 0
-rtl/rel8/support/support/logand.pcert0 : acl2x = 0
-rtl/rel8/support/support/logand.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/logand-proofs.pcert0 \
- rtl/rel8/support/support/logand.lisp
-rtl/rel8/support/support/logand.pcert1 : acl2x = 0
-rtl/rel8/support/support/logand.pcert1 : no_pcert = 0
-rtl/rel8/support/support/logand.pcert1 : rtl/rel8/support/support/logand.pcert0
-rtl/rel8/support/support/logand.cert : | rtl/rel8/support/support/logand.pcert1
-
-rtl/rel8/support/support/logeqv.pcert0 : no_pcert = 0
-rtl/rel8/support/support/logeqv.pcert0 : acl2x = 0
-rtl/rel8/support/support/logeqv.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/logorc1.pcert0 \
- rtl/rel8/support/support/lognot.pcert0 \
- rtl/rel8/support/support/logeqv.lisp
-rtl/rel8/support/support/logeqv.pcert1 : acl2x = 0
-rtl/rel8/support/support/logeqv.pcert1 : no_pcert = 0
-rtl/rel8/support/support/logeqv.pcert1 : rtl/rel8/support/support/logeqv.pcert0
-rtl/rel8/support/support/logeqv.cert : | rtl/rel8/support/support/logeqv.pcert1
-
-rtl/rel8/support/support/logior-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/logior-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/logior-proofs.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/lognot.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/logior-proofs.lisp
-rtl/rel8/support/support/logior-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/logior-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/logior-proofs.pcert1 : rtl/rel8/support/support/logior-proofs.pcert0
-rtl/rel8/support/support/logior-proofs.cert : | rtl/rel8/support/support/logior-proofs.pcert1
-
-rtl/rel8/support/support/logior.pcert0 : no_pcert = 0
-rtl/rel8/support/support/logior.pcert0 : acl2x = 0
-rtl/rel8/support/support/logior.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/logior-proofs.pcert0 \
- rtl/rel8/support/support/logior.lisp
-rtl/rel8/support/support/logior.pcert1 : acl2x = 0
-rtl/rel8/support/support/logior.pcert1 : no_pcert = 0
-rtl/rel8/support/support/logior.pcert1 : rtl/rel8/support/support/logior.pcert0
-rtl/rel8/support/support/logior.cert : | rtl/rel8/support/support/logior.pcert1
-
-rtl/rel8/support/support/logior1-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/logior1-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/logior1-proofs.pcert0 : \
- rtl/rel8/support/support/logior1-proofs.lisp
-rtl/rel8/support/support/logior1-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/logior1-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/logior1-proofs.pcert1 : rtl/rel8/support/support/logior1-proofs.pcert0
-rtl/rel8/support/support/logior1-proofs.cert : | rtl/rel8/support/support/logior1-proofs.pcert1
-
-rtl/rel8/support/support/logior1.pcert0 : no_pcert = 0
-rtl/rel8/support/support/logior1.pcert0 : acl2x = 0
-rtl/rel8/support/support/logior1.pcert0 : \
- rtl/rel8/support/support/logior1-proofs.pcert0 \
- rtl/rel8/support/support/logior1.lisp
-rtl/rel8/support/support/logior1.pcert1 : acl2x = 0
-rtl/rel8/support/support/logior1.pcert1 : no_pcert = 0
-rtl/rel8/support/support/logior1.pcert1 : rtl/rel8/support/support/logior1.pcert0
-rtl/rel8/support/support/logior1.cert : | rtl/rel8/support/support/logior1.pcert1
-
-rtl/rel8/support/support/lognot.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lognot.pcert0 : acl2x = 0
-rtl/rel8/support/support/lognot.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/lognot.lisp
-rtl/rel8/support/support/lognot.pcert1 : acl2x = 0
-rtl/rel8/support/support/lognot.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lognot.pcert1 : rtl/rel8/support/support/lognot.pcert0
-rtl/rel8/support/support/lognot.cert : | rtl/rel8/support/support/lognot.pcert1
-
-rtl/rel8/support/support/logorc1.pcert0 : no_pcert = 0
-rtl/rel8/support/support/logorc1.pcert0 : acl2x = 0
-rtl/rel8/support/support/logorc1.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/support/support/lognot.pcert0 \
- rtl/rel8/support/support/logorc1.lisp
-rtl/rel8/support/support/logorc1.pcert1 : acl2x = 0
-rtl/rel8/support/support/logorc1.pcert1 : no_pcert = 0
-rtl/rel8/support/support/logorc1.pcert1 : rtl/rel8/support/support/logorc1.pcert0
-rtl/rel8/support/support/logorc1.cert : | rtl/rel8/support/support/logorc1.pcert1
-
-rtl/rel8/support/support/logs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/logs.pcert0 : acl2x = 0
-rtl/rel8/support/support/logs.pcert0 : \
- rtl/rel8/support/support/logs.lisp
-rtl/rel8/support/support/logs.pcert1 : acl2x = 0
-rtl/rel8/support/support/logs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/logs.pcert1 : rtl/rel8/support/support/logs.pcert0
-rtl/rel8/support/support/logs.cert : | rtl/rel8/support/support/logs.pcert1
-
-rtl/rel8/support/support/logxor.pcert0 : no_pcert = 0
-rtl/rel8/support/support/logxor.pcert0 : acl2x = 0
-rtl/rel8/support/support/logxor.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/logeqv.pcert0 \
- rtl/rel8/support/support/logorc1.pcert0 \
- rtl/rel8/support/support/lognot.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/logxor.lisp
-rtl/rel8/support/support/logxor.pcert1 : acl2x = 0
-rtl/rel8/support/support/logxor.pcert1 : no_pcert = 0
-rtl/rel8/support/support/logxor.pcert1 : rtl/rel8/support/support/logxor.pcert0
-rtl/rel8/support/support/logxor.cert : | rtl/rel8/support/support/logxor.pcert1
-
-rtl/rel8/support/support/lop1-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lop1-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/lop1-proofs.pcert0 : \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/lop1-proofs.lisp
-rtl/rel8/support/support/lop1-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/lop1-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lop1-proofs.pcert1 : rtl/rel8/support/support/lop1-proofs.pcert0
-rtl/rel8/support/support/lop1-proofs.cert : | rtl/rel8/support/support/lop1-proofs.pcert1
-
-rtl/rel8/support/support/lop1.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lop1.pcert0 : acl2x = 0
-rtl/rel8/support/support/lop1.pcert0 : \
- rtl/rel8/support/support/lop1-proofs.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/lop1.lisp
-rtl/rel8/support/support/lop1.pcert1 : acl2x = 0
-rtl/rel8/support/support/lop1.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lop1.pcert1 : rtl/rel8/support/support/lop1.pcert0
-rtl/rel8/support/support/lop1.cert : | rtl/rel8/support/support/lop1.pcert1
-
-rtl/rel8/support/support/lop2-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lop2-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/lop2-proofs.pcert0 : \
- rtl/rel8/support/support/lop1.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/support/lop2-proofs.lisp
-rtl/rel8/support/support/lop2-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/lop2-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lop2-proofs.pcert1 : rtl/rel8/support/support/lop2-proofs.pcert0
-rtl/rel8/support/support/lop2-proofs.cert : | rtl/rel8/support/support/lop2-proofs.pcert1
-
-rtl/rel8/support/support/lop2.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lop2.pcert0 : acl2x = 0
-rtl/rel8/support/support/lop2.pcert0 : \
- rtl/rel8/support/support/lop1.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/lop2-proofs.pcert0 \
- rtl/rel8/support/support/lop2.lisp
-rtl/rel8/support/support/lop2.pcert1 : acl2x = 0
-rtl/rel8/support/support/lop2.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lop2.pcert1 : rtl/rel8/support/support/lop2.pcert0
-rtl/rel8/support/support/lop2.cert : | rtl/rel8/support/support/lop2.pcert1
-
-rtl/rel8/support/support/lop3-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lop3-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/lop3-proofs.pcert0 : \
- rtl/rel8/support/support/lop2.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/support/support/lop3-proofs.lisp
-rtl/rel8/support/support/lop3-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/lop3-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lop3-proofs.pcert1 : rtl/rel8/support/support/lop3-proofs.pcert0
-rtl/rel8/support/support/lop3-proofs.cert : | rtl/rel8/support/support/lop3-proofs.pcert1
-
-rtl/rel8/support/support/lop3.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lop3.pcert0 : acl2x = 0
-rtl/rel8/support/support/lop3.pcert0 : \
- rtl/rel8/support/support/lop2.pcert0 \
- rtl/rel8/support/support/lop3-proofs.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/support/support/lop3.lisp
-rtl/rel8/support/support/lop3.pcert1 : acl2x = 0
-rtl/rel8/support/support/lop3.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lop3.pcert1 : rtl/rel8/support/support/lop3.pcert0
-rtl/rel8/support/support/lop3.cert : | rtl/rel8/support/support/lop3.pcert1
-
-rtl/rel8/support/support/lxor.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lxor.pcert0 : acl2x = 0
-rtl/rel8/support/support/lxor.pcert0 : \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/support/support/top1.pcert0 \
- rtl/rel8/support/support/lxor.lisp
-rtl/rel8/support/support/lxor.pcert1 : acl2x = 0
-rtl/rel8/support/support/lxor.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lxor.pcert1 : rtl/rel8/support/support/lxor.pcert0
-rtl/rel8/support/support/lxor.cert : | rtl/rel8/support/support/lxor.pcert1
-
-rtl/rel8/support/support/lxor0-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lxor0-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/lxor0-proofs.pcert0 : \
- rtl/rel8/support/support/all-ones.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/lxor0-proofs.lisp
-rtl/rel8/support/support/lxor0-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/lxor0-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lxor0-proofs.pcert1 : rtl/rel8/support/support/lxor0-proofs.pcert0
-rtl/rel8/support/support/lxor0-proofs.cert : | rtl/rel8/support/support/lxor0-proofs.pcert1
-
-rtl/rel8/support/support/lxor0.pcert0 : no_pcert = 0
-rtl/rel8/support/support/lxor0.pcert0 : acl2x = 0
-rtl/rel8/support/support/lxor0.pcert0 : \
- rtl/rel8/support/support/lxor0-proofs.pcert0 \
- rtl/rel8/support/support/lxor0.lisp
-rtl/rel8/support/support/lxor0.pcert1 : acl2x = 0
-rtl/rel8/support/support/lxor0.pcert1 : no_pcert = 0
-rtl/rel8/support/support/lxor0.pcert1 : rtl/rel8/support/support/lxor0.pcert0
-rtl/rel8/support/support/lxor0.cert : | rtl/rel8/support/support/lxor0.pcert1
-
-rtl/rel8/support/support/merge.pcert0 : no_pcert = 0
-rtl/rel8/support/support/merge.pcert0 : acl2x = 0
-rtl/rel8/support/support/merge.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/log.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/lnot.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/logxor.pcert0 \
- rtl/rel8/support/support/ocat.pcert0 \
- rtl/rel8/support/support/sumbits.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/merge.lisp
-rtl/rel8/support/support/merge.pcert1 : acl2x = 0
-rtl/rel8/support/support/merge.pcert1 : no_pcert = 0
-rtl/rel8/support/support/merge.pcert1 : rtl/rel8/support/support/merge.pcert0
-rtl/rel8/support/support/merge.cert : | rtl/rel8/support/support/merge.pcert1
-
-rtl/rel8/support/support/merge2.pcert0 : no_pcert = 0
-rtl/rel8/support/support/merge2.pcert0 : acl2x = 0
-rtl/rel8/support/support/merge2.pcert0 : \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/support/support/logs.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/merge2.lisp
-rtl/rel8/support/support/merge2.pcert1 : acl2x = 0
-rtl/rel8/support/support/merge2.pcert1 : no_pcert = 0
-rtl/rel8/support/support/merge2.pcert1 : rtl/rel8/support/support/merge2.pcert0
-rtl/rel8/support/support/merge2.cert : | rtl/rel8/support/support/merge2.pcert1
-
-rtl/rel8/support/support/mod4.pcert0 : no_pcert = 0
-rtl/rel8/support/support/mod4.pcert0 : acl2x = 0
-rtl/rel8/support/support/mod4.pcert0 : \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/mod4.lisp
-rtl/rel8/support/support/mod4.pcert1 : acl2x = 0
-rtl/rel8/support/support/mod4.pcert1 : no_pcert = 0
-rtl/rel8/support/support/mod4.pcert1 : rtl/rel8/support/support/mod4.pcert0
-rtl/rel8/support/support/mod4.cert : | rtl/rel8/support/support/mod4.pcert1
-
-rtl/rel8/support/support/model-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/support/model-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/support/model-helpers.pcert0 : \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/model-helpers.lisp
-rtl/rel8/support/support/model-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/support/model-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/support/model-helpers.pcert1 : rtl/rel8/support/support/model-helpers.pcert0
-rtl/rel8/support/support/model-helpers.cert : | rtl/rel8/support/support/model-helpers.pcert1
-
-rtl/rel8/support/support/mulcat-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/mulcat-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/mulcat-proofs.pcert0 : \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/cat-def.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/mulcat-proofs.lisp
-rtl/rel8/support/support/mulcat-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/mulcat-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/mulcat-proofs.pcert1 : rtl/rel8/support/support/mulcat-proofs.pcert0
-rtl/rel8/support/support/mulcat-proofs.cert : | rtl/rel8/support/support/mulcat-proofs.pcert1
-
-rtl/rel8/support/support/mulcat.pcert0 : no_pcert = 0
-rtl/rel8/support/support/mulcat.pcert0 : acl2x = 0
-rtl/rel8/support/support/mulcat.pcert0 : \
- rtl/rel8/support/support/cat-def.pcert0 \
- rtl/rel8/support/support/mulcat-proofs.pcert0 \
- rtl/rel8/support/support/mulcat.lisp
-rtl/rel8/support/support/mulcat.pcert1 : acl2x = 0
-rtl/rel8/support/support/mulcat.pcert1 : no_pcert = 0
-rtl/rel8/support/support/mulcat.pcert1 : rtl/rel8/support/support/mulcat.pcert0
-rtl/rel8/support/support/mulcat.cert : | rtl/rel8/support/support/mulcat.pcert1
-
-rtl/rel8/support/support/near+-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/near+-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/near+-proofs.pcert0 : \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/away.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/arithmetic/predicate.pcert0 \
- rtl/rel8/arithmetic/cg.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/fl.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/near+-proofs.lisp
-rtl/rel8/support/support/near+-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/near+-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/near+-proofs.pcert1 : rtl/rel8/support/support/near+-proofs.pcert0
-rtl/rel8/support/support/near+-proofs.cert : | rtl/rel8/support/support/near+-proofs.pcert1
-
-rtl/rel8/support/support/near+.pcert0 : no_pcert = 0
-rtl/rel8/support/support/near+.pcert0 : acl2x = 0
-rtl/rel8/support/support/near+.pcert0 : \
- rtl/rel8/support/support/near+-proofs.pcert0 \
- rtl/rel8/support/support/near+.lisp
-rtl/rel8/support/support/near+.pcert1 : acl2x = 0
-rtl/rel8/support/support/near+.pcert1 : no_pcert = 0
-rtl/rel8/support/support/near+.pcert1 : rtl/rel8/support/support/near+.pcert0
-rtl/rel8/support/support/near+.cert : | rtl/rel8/support/support/near+.pcert1
-
-rtl/rel8/support/support/near-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/near-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/near-proofs.pcert0 : \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/away.pcert0 \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/near-proofs.lisp
-rtl/rel8/support/support/near-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/near-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/near-proofs.pcert1 : rtl/rel8/support/support/near-proofs.pcert0
-rtl/rel8/support/support/near-proofs.cert : | rtl/rel8/support/support/near-proofs.pcert1
-
-rtl/rel8/support/support/near.pcert0 : no_pcert = 0
-rtl/rel8/support/support/near.pcert0 : acl2x = 0
-rtl/rel8/support/support/near.pcert0 : \
- rtl/rel8/support/support/near-proofs.pcert0 \
- rtl/rel8/support/support/near.lisp
-rtl/rel8/support/support/near.pcert1 : acl2x = 0
-rtl/rel8/support/support/near.pcert1 : no_pcert = 0
-rtl/rel8/support/support/near.pcert1 : rtl/rel8/support/support/near.pcert0
-rtl/rel8/support/support/near.cert : | rtl/rel8/support/support/near.pcert1
-
-rtl/rel8/support/support/ocat.pcert0 : no_pcert = 0
-rtl/rel8/support/support/ocat.pcert0 : acl2x = 0
-rtl/rel8/support/support/ocat.pcert0 : \
- rtl/rel8/arithmetic/expt.pcert0 \
- rtl/rel8/arithmetic/expo.pcert0 \
- rtl/rel8/arithmetic/arith2.pcert0 \
- rtl/rel8/arithmetic/fp2.pcert0 \
- rtl/rel8/arithmetic/integerp.pcert0 \
- rtl/rel8/support/support/ocat.lisp
-rtl/rel8/support/support/ocat.pcert1 : acl2x = 0
-rtl/rel8/support/support/ocat.pcert1 : no_pcert = 0
-rtl/rel8/support/support/ocat.pcert1 : rtl/rel8/support/support/ocat.pcert0
-rtl/rel8/support/support/ocat.cert : | rtl/rel8/support/support/ocat.pcert1
-
-rtl/rel8/support/support/oddr-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/oddr-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/oddr-proofs.pcert0 : \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/away.pcert0 \
- rtl/rel8/support/support/near.pcert0 \
- rtl/rel8/support/support/oddr-proofs.lisp
-rtl/rel8/support/support/oddr-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/oddr-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/oddr-proofs.pcert1 : rtl/rel8/support/support/oddr-proofs.pcert0
-rtl/rel8/support/support/oddr-proofs.cert : | rtl/rel8/support/support/oddr-proofs.pcert1
-
-rtl/rel8/support/support/oddr.pcert0 : no_pcert = 0
-rtl/rel8/support/support/oddr.pcert0 : acl2x = 0
-rtl/rel8/support/support/oddr.pcert0 : \
- rtl/rel8/support/support/oddr-proofs.pcert0 \
- rtl/rel8/support/support/oddr.lisp
-rtl/rel8/support/support/oddr.pcert1 : acl2x = 0
-rtl/rel8/support/support/oddr.pcert1 : no_pcert = 0
-rtl/rel8/support/support/oddr.pcert1 : rtl/rel8/support/support/oddr.pcert0
-rtl/rel8/support/support/oddr.cert : | rtl/rel8/support/support/oddr.pcert1
-
-rtl/rel8/support/support/openers.pcert0 : no_pcert = 0
-rtl/rel8/support/support/openers.pcert0 : acl2x = 0
-rtl/rel8/support/support/openers.pcert0 : \
- rtl/rel8/support/support/openers.lisp
-rtl/rel8/support/support/openers.pcert1 : acl2x = 0
-rtl/rel8/support/support/openers.pcert1 : no_pcert = 0
-rtl/rel8/support/support/openers.pcert1 : rtl/rel8/support/support/openers.pcert0
-rtl/rel8/support/support/openers.cert : | rtl/rel8/support/support/openers.pcert1
-
-rtl/rel8/support/support/package-defs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/package-defs.pcert0 : acl2x = 0
-rtl/rel8/support/support/package-defs.pcert0 : \
- rtl/rel8/support/support/package-defs.lisp
-rtl/rel8/support/support/package-defs.pcert1 : acl2x = 0
-rtl/rel8/support/support/package-defs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/package-defs.pcert1 : rtl/rel8/support/support/package-defs.pcert0
-rtl/rel8/support/support/package-defs.cert : | rtl/rel8/support/support/package-defs.pcert1
-
-rtl/rel8/support/support/rewrite-theory.pcert0 : no_pcert = 0
-rtl/rel8/support/support/rewrite-theory.pcert0 : acl2x = 0
-rtl/rel8/support/support/rewrite-theory.pcert0 : \
- rtl/rel8/support/support/rewrite-theory.lisp
-rtl/rel8/support/support/rewrite-theory.pcert1 : acl2x = 0
-rtl/rel8/support/support/rewrite-theory.pcert1 : no_pcert = 0
-rtl/rel8/support/support/rewrite-theory.pcert1 : rtl/rel8/support/support/rewrite-theory.pcert0
-rtl/rel8/support/support/rewrite-theory.cert : | rtl/rel8/support/support/rewrite-theory.pcert1
-
-rtl/rel8/support/support/rnd.pcert0 : no_pcert = 0
-rtl/rel8/support/support/rnd.pcert0 : acl2x = 0
-rtl/rel8/support/support/rnd.pcert0 : \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/away.pcert0 \
- rtl/rel8/support/support/near.pcert0 \
- rtl/rel8/support/support/near+.pcert0 \
- rtl/rel8/support/support/sticky.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/bits-trunc.pcert0 \
- rtl/rel8/support/support/rnd.lisp
-rtl/rel8/support/support/rnd.pcert1 : acl2x = 0
-rtl/rel8/support/support/rnd.pcert1 : no_pcert = 0
-rtl/rel8/support/support/rnd.pcert1 : rtl/rel8/support/support/rnd.pcert0
-rtl/rel8/support/support/rnd.cert : | rtl/rel8/support/support/rnd.pcert1
-
-rtl/rel8/support/support/rom-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/support/rom-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/support/rom-helpers.pcert0 : \
- rtl/rel8/support/support/rom-helpers.lisp
-rtl/rel8/support/support/rom-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/support/rom-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/support/rom-helpers.pcert1 : rtl/rel8/support/support/rom-helpers.pcert0
-rtl/rel8/support/support/rom-helpers.cert : | rtl/rel8/support/support/rom-helpers.pcert1
-
-rtl/rel8/support/support/round-extra.pcert0 : no_pcert = 0
-rtl/rel8/support/support/round-extra.pcert0 : acl2x = 0
-rtl/rel8/support/support/round-extra.pcert0 : \
- rtl/rel8/support/support/sticky.pcert0 \
- rtl/rel8/support/support/util.pcert0 \
- rtl/rel8/support/support/top1.pcert0 \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/round-extra.lisp
-rtl/rel8/support/support/round-extra.pcert1 : acl2x = 0
-rtl/rel8/support/support/round-extra.pcert1 : no_pcert = 0
-rtl/rel8/support/support/round-extra.pcert1 : rtl/rel8/support/support/round-extra.pcert0
-rtl/rel8/support/support/round-extra.cert : | rtl/rel8/support/support/round-extra.pcert1
-
-rtl/rel8/support/support/rtl.pcert0 : no_pcert = 0
-rtl/rel8/support/support/rtl.pcert0 : acl2x = 0
-rtl/rel8/support/support/rtl.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/rtlarr.pcert0 \
- rtl/rel8/support/support/cat-def.pcert0 \
- rtl/rel8/support/support/rtl.lisp
-rtl/rel8/support/support/rtl.pcert1 : acl2x = 0
-rtl/rel8/support/support/rtl.pcert1 : no_pcert = 0
-rtl/rel8/support/support/rtl.pcert1 : rtl/rel8/support/support/rtl.pcert0
-rtl/rel8/support/support/rtl.cert : | rtl/rel8/support/support/rtl.pcert1
-
-rtl/rel8/support/support/rtlarr.pcert0 : no_pcert = 0
-rtl/rel8/support/support/rtlarr.pcert0 : acl2x = 0
-rtl/rel8/support/support/rtlarr.pcert0 : \
- misc/total-order.pcert0 \
- rtl/rel8/support/support/rtlarr.lisp
-rtl/rel8/support/support/rtlarr.pcert1 : acl2x = 0
-rtl/rel8/support/support/rtlarr.pcert1 : no_pcert = 0
-rtl/rel8/support/support/rtlarr.pcert1 : rtl/rel8/support/support/rtlarr.pcert0
-rtl/rel8/support/support/rtlarr.cert : | rtl/rel8/support/support/rtlarr.pcert1
-
-rtl/rel8/support/support/setbitn-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/setbitn-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/setbitn-proofs.pcert0 : \
- rtl/rel8/support/support/cat-def.pcert0 \
- rtl/rel8/support/support/setbits.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/setbitn-proofs.lisp
-rtl/rel8/support/support/setbitn-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/setbitn-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/setbitn-proofs.pcert1 : rtl/rel8/support/support/setbitn-proofs.pcert0
-rtl/rel8/support/support/setbitn-proofs.cert : | rtl/rel8/support/support/setbitn-proofs.pcert1
-
-rtl/rel8/support/support/setbitn.pcert0 : no_pcert = 0
-rtl/rel8/support/support/setbitn.pcert0 : acl2x = 0
-rtl/rel8/support/support/setbitn.pcert0 : \
- rtl/rel8/support/support/cat-def.pcert0 \
- rtl/rel8/support/support/setbitn-proofs.pcert0 \
- rtl/rel8/support/support/setbitn.lisp
-rtl/rel8/support/support/setbitn.pcert1 : acl2x = 0
-rtl/rel8/support/support/setbitn.pcert1 : no_pcert = 0
-rtl/rel8/support/support/setbitn.pcert1 : rtl/rel8/support/support/setbitn.pcert0
-rtl/rel8/support/support/setbitn.cert : | rtl/rel8/support/support/setbitn.pcert1
-
-rtl/rel8/support/support/setbits-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/setbits-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/setbits-proofs.pcert0 : \
- rtl/rel8/support/support/cat-def.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/setbits-proofs.lisp
-rtl/rel8/support/support/setbits-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/setbits-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/setbits-proofs.pcert1 : rtl/rel8/support/support/setbits-proofs.pcert0
-rtl/rel8/support/support/setbits-proofs.cert : | rtl/rel8/support/support/setbits-proofs.pcert1
-
-rtl/rel8/support/support/setbits.pcert0 : no_pcert = 0
-rtl/rel8/support/support/setbits.pcert0 : acl2x = 0
-rtl/rel8/support/support/setbits.pcert0 : \
- rtl/rel8/support/support/cat-def.pcert0 \
- rtl/rel8/support/support/setbits-proofs.pcert0 \
- rtl/rel8/support/support/setbits.lisp
-rtl/rel8/support/support/setbits.pcert1 : acl2x = 0
-rtl/rel8/support/support/setbits.pcert1 : no_pcert = 0
-rtl/rel8/support/support/setbits.pcert1 : rtl/rel8/support/support/setbits.pcert0
-rtl/rel8/support/support/setbits.cert : | rtl/rel8/support/support/setbits.pcert1
-
-rtl/rel8/support/support/sgn.pcert0 : no_pcert = 0
-rtl/rel8/support/support/sgn.pcert0 : acl2x = 0
-rtl/rel8/support/support/sgn.pcert0 : \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/sgn.lisp
-rtl/rel8/support/support/sgn.pcert1 : acl2x = 0
-rtl/rel8/support/support/sgn.pcert1 : no_pcert = 0
-rtl/rel8/support/support/sgn.pcert1 : rtl/rel8/support/support/sgn.pcert0
-rtl/rel8/support/support/sgn.cert : | rtl/rel8/support/support/sgn.pcert1
-
-rtl/rel8/support/support/shft.pcert0 : no_pcert = 0
-rtl/rel8/support/support/shft.pcert0 : acl2x = 0
-rtl/rel8/support/support/shft.pcert0 : \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/shft.lisp
-rtl/rel8/support/support/shft.pcert1 : acl2x = 0
-rtl/rel8/support/support/shft.pcert1 : no_pcert = 0
-rtl/rel8/support/support/shft.pcert1 : rtl/rel8/support/support/shft.pcert0
-rtl/rel8/support/support/shft.cert : | rtl/rel8/support/support/shft.pcert1
-
-rtl/rel8/support/support/simple-loop-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/support/simple-loop-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/support/simple-loop-helpers.pcert0 : \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/setbitn.pcert0 \
- rtl/rel8/support/support/simple-loop-helpers.lisp
-rtl/rel8/support/support/simple-loop-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/support/simple-loop-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/support/simple-loop-helpers.pcert1 : rtl/rel8/support/support/simple-loop-helpers.pcert0
-rtl/rel8/support/support/simple-loop-helpers.cert : | rtl/rel8/support/support/simple-loop-helpers.pcert1
-
-rtl/rel8/support/support/simplify-model-helpers.pcert0 : no_pcert = 0
-rtl/rel8/support/support/simplify-model-helpers.pcert0 : acl2x = 0
-rtl/rel8/support/support/simplify-model-helpers.pcert0 : \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/simplify-model-helpers.lisp
-rtl/rel8/support/support/simplify-model-helpers.pcert1 : acl2x = 0
-rtl/rel8/support/support/simplify-model-helpers.pcert1 : no_pcert = 0
-rtl/rel8/support/support/simplify-model-helpers.pcert1 : rtl/rel8/support/support/simplify-model-helpers.pcert0
-rtl/rel8/support/support/simplify-model-helpers.cert : | rtl/rel8/support/support/simplify-model-helpers.pcert1
-
-rtl/rel8/support/support/stick-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/stick-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/stick-proofs.pcert0 : \
- rtl/rel8/support/support/merge.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/lnot.pcert0 \
- rtl/rel8/support/support/stick-proofs.lisp
-rtl/rel8/support/support/stick-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/stick-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/stick-proofs.pcert1 : rtl/rel8/support/support/stick-proofs.pcert0
-rtl/rel8/support/support/stick-proofs.cert : | rtl/rel8/support/support/stick-proofs.pcert1
-
-rtl/rel8/support/support/stick.pcert0 : no_pcert = 0
-rtl/rel8/support/support/stick.pcert0 : acl2x = 0
-rtl/rel8/support/support/stick.pcert0 : \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/stick-proofs.pcert0 \
- rtl/rel8/support/support/stick.lisp
-rtl/rel8/support/support/stick.pcert1 : acl2x = 0
-rtl/rel8/support/support/stick.pcert1 : no_pcert = 0
-rtl/rel8/support/support/stick.pcert1 : rtl/rel8/support/support/stick.pcert0
-rtl/rel8/support/support/stick.cert : | rtl/rel8/support/support/stick.pcert1
-
-rtl/rel8/support/support/sticky-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/sticky-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/sticky-proofs.pcert0 : \
- rtl/rel8/arithmetic/arith.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/away.pcert0 \
- rtl/rel8/support/support/near.pcert0 \
- rtl/rel8/support/support/near+.pcert0 \
- rtl/rel8/support/support/sticky-proofs.lisp
-rtl/rel8/support/support/sticky-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/sticky-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/sticky-proofs.pcert1 : rtl/rel8/support/support/sticky-proofs.pcert0
-rtl/rel8/support/support/sticky-proofs.cert : | rtl/rel8/support/support/sticky-proofs.pcert1
-
-rtl/rel8/support/support/sticky.pcert0 : no_pcert = 0
-rtl/rel8/support/support/sticky.pcert0 : acl2x = 0
-rtl/rel8/support/support/sticky.pcert0 : \
- rtl/rel8/support/support/sticky-proofs.pcert0 \
- rtl/rel8/support/support/sticky.lisp
-rtl/rel8/support/support/sticky.pcert1 : acl2x = 0
-rtl/rel8/support/support/sticky.pcert1 : no_pcert = 0
-rtl/rel8/support/support/sticky.pcert1 : rtl/rel8/support/support/sticky.pcert0
-rtl/rel8/support/support/sticky.cert : | rtl/rel8/support/support/sticky.pcert1
-
-rtl/rel8/support/support/sumbits.pcert0 : no_pcert = 0
-rtl/rel8/support/support/sumbits.pcert0 : acl2x = 0
-rtl/rel8/support/support/sumbits.pcert0 : \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/sumbits.lisp
-rtl/rel8/support/support/sumbits.pcert1 : acl2x = 0
-rtl/rel8/support/support/sumbits.pcert1 : no_pcert = 0
-rtl/rel8/support/support/sumbits.pcert1 : rtl/rel8/support/support/sumbits.pcert0
-rtl/rel8/support/support/sumbits.cert : | rtl/rel8/support/support/sumbits.pcert1
-
-rtl/rel8/support/support/top.pcert0 : no_pcert = 0
-rtl/rel8/support/support/top.pcert0 : acl2x = 0
-rtl/rel8/support/support/top.pcert0 : \
- rtl/rel8/support/support/top1.pcert0 \
- rtl/rel8/support/support/lextra.pcert0 \
- rtl/rel8/support/support/fadd-extra.pcert0 \
- rtl/rel8/support/support/float-extra.pcert0 \
- rtl/rel8/support/support/round-extra.pcert0 \
- rtl/rel8/support/support/guards.pcert0 \
- rtl/rel8/support/support/badguys.pcert0 \
- rtl/rel8/support/support/top.lisp
-rtl/rel8/support/support/top.pcert1 : acl2x = 0
-rtl/rel8/support/support/top.pcert1 : no_pcert = 0
-rtl/rel8/support/support/top.pcert1 : rtl/rel8/support/support/top.pcert0
-rtl/rel8/support/support/top.cert : | rtl/rel8/support/support/top.pcert1
-
-rtl/rel8/support/support/top1.pcert0 : no_pcert = 0
-rtl/rel8/support/support/top1.pcert0 : acl2x = 0
-rtl/rel8/support/support/top1.pcert0 : \
- rtl/rel8/support/support/util.pcert0 \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/rewrite-theory.pcert0 \
- rtl/rel8/support/support/rtl.pcert0 \
- rtl/rel8/support/support/rtlarr.pcert0 \
- rtl/rel8/support/support/bvecp-lemmas.pcert0 \
- rtl/rel8/support/support/bits.pcert0 \
- rtl/rel8/support/support/bitn.pcert0 \
- rtl/rel8/support/support/ocat.pcert0 \
- rtl/rel8/support/support/cat-def.pcert0 \
- rtl/rel8/support/support/cat.pcert0 \
- rtl/rel8/support/support/bvecp.pcert0 \
- rtl/rel8/support/support/ash.pcert0 \
- rtl/rel8/support/support/decode.pcert0 \
- rtl/rel8/support/support/encode.pcert0 \
- rtl/rel8/support/support/mulcat.pcert0 \
- rtl/rel8/support/support/shft.pcert0 \
- rtl/rel8/support/support/all-ones.pcert0 \
- rtl/rel8/support/support/merge2.pcert0 \
- rtl/rel8/support/support/logior1.pcert0 \
- rtl/rel8/support/support/setbits.pcert0 \
- rtl/rel8/support/support/setbitn.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/support/support/bias.pcert0 \
- rtl/rel8/support/support/ereps.pcert0 \
- rtl/rel8/support/support/ireps.pcert0 \
- rtl/rel8/support/support/logeqv.pcert0 \
- rtl/rel8/support/support/logorc1.pcert0 \
- rtl/rel8/support/support/lognot.pcert0 \
- rtl/rel8/support/support/logand.pcert0 \
- rtl/rel8/support/support/logior.pcert0 \
- rtl/rel8/support/support/logxor.pcert0 \
- rtl/rel8/support/support/log.pcert0 \
- rtl/rel8/support/support/lnot.pcert0 \
- rtl/rel8/support/support/land0.pcert0 \
- rtl/rel8/support/support/lior0.pcert0 \
- rtl/rel8/support/support/lxor0.pcert0 \
- rtl/rel8/support/support/lextra0.pcert0 \
- rtl/rel8/support/support/logs.pcert0 \
- rtl/rel8/support/support/trunc.pcert0 \
- rtl/rel8/support/support/away.pcert0 \
- rtl/rel8/support/support/near.pcert0 \
- rtl/rel8/support/support/near+.pcert0 \
- rtl/rel8/support/support/oddr.pcert0 \
- rtl/rel8/support/support/sticky.pcert0 \
- rtl/rel8/support/support/rnd.pcert0 \
- rtl/rel8/support/support/drnd-original.pcert0 \
- rtl/rel8/support/support/bits-trunc.pcert0 \
- rtl/rel8/support/support/add3.pcert0 \
- rtl/rel8/support/support/lop1.pcert0 \
- rtl/rel8/support/support/lop2.pcert0 \
- rtl/rel8/support/support/lop3.pcert0 \
- rtl/rel8/support/support/stick.pcert0 \
- rtl/rel8/support/support/bvecp-helpers.pcert0 \
- rtl/rel8/support/support/model-helpers.pcert0 \
- rtl/rel8/support/support/rom-helpers.pcert0 \
- rtl/rel8/support/support/simple-loop-helpers.pcert0 \
- rtl/rel8/support/support/clocks.pcert0 \
- rtl/rel8/support/support/openers.pcert0 \
- rtl/rel8/support/support/package-defs.pcert0 \
- rtl/rel8/support/support/simplify-model-helpers.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/arithmetic/fp.pcert0 \
- rtl/rel8/support/support/fadd.pcert0 \
- rtl/rel8/support/support/top1.lisp
-rtl/rel8/support/support/top1.pcert1 : acl2x = 0
-rtl/rel8/support/support/top1.pcert1 : no_pcert = 0
-rtl/rel8/support/support/top1.pcert1 : rtl/rel8/support/support/top1.pcert0
-rtl/rel8/support/support/top1.cert : | rtl/rel8/support/support/top1.pcert1
-
-rtl/rel8/support/support/trunc-proofs.pcert0 : no_pcert = 0
-rtl/rel8/support/support/trunc-proofs.pcert0 : acl2x = 0
-rtl/rel8/support/support/trunc-proofs.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/float.pcert0 \
- rtl/rel8/arithmetic/top.pcert0 \
- rtl/rel8/support/support/trunc-proofs.lisp
-rtl/rel8/support/support/trunc-proofs.pcert1 : acl2x = 0
-rtl/rel8/support/support/trunc-proofs.pcert1 : no_pcert = 0
-rtl/rel8/support/support/trunc-proofs.pcert1 : rtl/rel8/support/support/trunc-proofs.pcert0
-rtl/rel8/support/support/trunc-proofs.cert : | rtl/rel8/support/support/trunc-proofs.pcert1
-
-rtl/rel8/support/support/trunc.pcert0 : no_pcert = 0
-rtl/rel8/support/support/trunc.pcert0 : acl2x = 0
-rtl/rel8/support/support/trunc.pcert0 : \
- rtl/rel8/support/support/ground-zero.pcert0 \
- rtl/rel8/support/support/trunc-proofs.pcert0 \
- rtl/rel8/support/support/trunc.lisp
-rtl/rel8/support/support/trunc.pcert1 : acl2x = 0
-rtl/rel8/support/support/trunc.pcert1 : no_pcert = 0
-rtl/rel8/support/support/trunc.pcert1 : rtl/rel8/support/support/trunc.pcert0
-rtl/rel8/support/support/trunc.cert : | rtl/rel8/support/support/trunc.pcert1
-
-rtl/rel8/support/support/util.pcert0 : no_pcert = 0
-rtl/rel8/support/support/util.pcert0 : acl2x = 0
-rtl/rel8/support/support/util.pcert0 : \
- rtl/rel8/support/support/util.lisp
-rtl/rel8/support/support/util.pcert1 : acl2x = 0
-rtl/rel8/support/support/util.pcert1 : no_pcert = 0
-rtl/rel8/support/support/util.pcert1 : rtl/rel8/support/support/util.pcert0
-rtl/rel8/support/support/util.cert : | rtl/rel8/support/support/util.pcert1
-
-rtl/rel8/support/top/top.pcert0 : no_pcert = 0
-rtl/rel8/support/top/top.pcert0 : acl2x = 0
-rtl/rel8/support/top/top.pcert0 : \
- rtl/rel8/support/lib2.delta1/rtl.pcert0 \
- rtl/rel8/support/lib2.delta1/rtlarr.pcert0 \
- rtl/rel8/support/lib2/basic.pcert0 \
- rtl/rel8/support/lib2.delta2/bits.pcert0 \
- rtl/rel8/support/lib2.delta2/log.pcert0 \
- rtl/rel8/support/lib2.delta1/float.pcert0 \
- rtl/rel8/support/lib2.delta1/reps.pcert0 \
- rtl/rel8/support/lib2.delta1/round.pcert0 \
- rtl/rel8/support/lib2.delta2/add.pcert0 \
- rtl/rel8/support/lib2.delta1/mult.pcert0 \
- rtl/rel8/support/lib2.delta1/arith.pcert0 \
- rtl/rel8/support/lib2.delta1/util.pcert0 \
- rtl/rel8/support/lib2.delta1/bvecp-raw-helpers.pcert0 \
- rtl/rel8/support/lib2.delta1/simple-loop-helpers.pcert0 \
- rtl/rel8/support/lib2/rom-helpers.pcert0 \
- rtl/rel8/support/lib2.delta1/bvecp-helpers.pcert0 \
- rtl/rel8/support/lib2.delta1/logn.pcert0 \
- rtl/rel8/support/lib2.delta1/simplify-model-helpers.pcert0 \
- rtl/rel8/support/lib2.delta1/logn2log.pcert0 \
- rtl/rel8/support/top/top.lisp
-rtl/rel8/support/top/top.pcert1 : acl2x = 0
-rtl/rel8/support/top/top.pcert1 : no_pcert = 0
-rtl/rel8/support/top/top.pcert1 : rtl/rel8/support/top/top.pcert0
-rtl/rel8/support/top/top.cert : | rtl/rel8/support/top/top.pcert1
-
-security/jfkr/diffie-helman.pcert0 : no_pcert = 0
-security/jfkr/diffie-helman.pcert0 : acl2x = 0
-security/jfkr/diffie-helman.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- security/jfkr/diffie-helman.lisp \
- security/jfkr/cert.acl2 \
- security/jfkr/package.lsp
-security/jfkr/diffie-helman.pcert1 : acl2x = 0
-security/jfkr/diffie-helman.pcert1 : no_pcert = 0
-security/jfkr/diffie-helman.pcert1 : security/jfkr/diffie-helman.pcert0
-security/jfkr/diffie-helman.cert : | security/jfkr/diffie-helman.pcert1
-
-security/jfkr/encryption.pcert0 : no_pcert = 0
-security/jfkr/encryption.pcert0 : acl2x = 0
-security/jfkr/encryption.pcert0 : \
- security/jfkr/encryption.lisp \
- security/jfkr/cert.acl2 \
- security/jfkr/package.lsp
-security/jfkr/encryption.pcert1 : acl2x = 0
-security/jfkr/encryption.pcert1 : no_pcert = 0
-security/jfkr/encryption.pcert1 : security/jfkr/encryption.pcert0
-security/jfkr/encryption.cert : | security/jfkr/encryption.pcert1
-
-security/jfkr/jfkr.pcert0 : no_pcert = 0
-security/jfkr/jfkr.pcert0 : acl2x = 0
-security/jfkr/jfkr.pcert0 : \
- security/jfkr/encryption.pcert0 \
- security/jfkr/diffie-helman.pcert0 \
- security/jfkr/random.pcert0 \
- misc/assert.pcert0 \
- misc/untranslate-patterns.pcert0 \
- security/jfkr/jfkr.lisp \
- security/jfkr/cert.acl2 \
- security/jfkr/package.lsp
-security/jfkr/jfkr.pcert1 : acl2x = 0
-security/jfkr/jfkr.pcert1 : no_pcert = 0
-security/jfkr/jfkr.pcert1 : security/jfkr/jfkr.pcert0
-security/jfkr/jfkr.cert : | security/jfkr/jfkr.pcert1
-
-security/jfkr/random.pcert0 : no_pcert = 0
-security/jfkr/random.pcert0 : acl2x = 0
-security/jfkr/random.pcert0 : \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- security/jfkr/random.lisp \
- security/jfkr/cert.acl2 \
- security/jfkr/package.lsp
-security/jfkr/random.pcert1 : acl2x = 0
-security/jfkr/random.pcert1 : no_pcert = 0
-security/jfkr/random.pcert1 : security/jfkr/random.pcert0
-security/jfkr/random.cert : | security/jfkr/random.pcert1
-
-security/suite-b/sha-2.pcert0 : no_pcert = 0
-security/suite-b/sha-2.pcert0 : acl2x = 0
-security/suite-b/sha-2.pcert0 : \
- security/util/byte-operations.pcert0 \
- security/suite-b/sha-2.lisp
-security/suite-b/sha-2.pcert1 : acl2x = 0
-security/suite-b/sha-2.pcert1 : no_pcert = 0
-security/suite-b/sha-2.pcert1 : security/suite-b/sha-2.pcert0
-security/suite-b/sha-2.cert : | security/suite-b/sha-2.pcert1
-
-security/util/byte-operations.pcert0 : no_pcert = 0
-security/util/byte-operations.pcert0 : acl2x = 0
-security/util/byte-operations.pcert0 : \
- arithmetic-5/top.pcert0 \
- security/util/byte-operations.lisp
-security/util/byte-operations.pcert1 : acl2x = 0
-security/util/byte-operations.pcert1 : no_pcert = 0
-security/util/byte-operations.pcert1 : security/util/byte-operations.pcert0
-security/util/byte-operations.cert : | security/util/byte-operations.pcert1
-
-serialize/serialize-tests.pcert0 : no_pcert = 0
-serialize/serialize-tests.pcert0 : acl2x = 0
-serialize/serialize-tests.pcert0 : \
- serialize/unsound-read.pcert0 \
- tools/bstar.pcert0 \
- serialize/serialize-tests.lisp \
- serialize/serialize-tests.acl2
-serialize/serialize-tests.pcert1 : acl2x = 0
-serialize/serialize-tests.pcert1 : no_pcert = 0
-serialize/serialize-tests.pcert1 : serialize/serialize-tests.pcert0
-serialize/serialize-tests.cert : | serialize/serialize-tests.pcert1
-
-serialize/serialize-tests2.pcert0 : no_pcert = 0
-serialize/serialize-tests2.pcert0 : acl2x = 0
-serialize/serialize-tests2.pcert0 : \
- serialize/serialize-tests.pcert0 \
- serialize/serialize-tests2.lisp \
- serialize/serialize-tests2.acl2
-serialize/serialize-tests2.pcert1 : acl2x = 0
-serialize/serialize-tests2.pcert1 : no_pcert = 0
-serialize/serialize-tests2.pcert1 : serialize/serialize-tests2.pcert0
-serialize/serialize-tests2.cert : | serialize/serialize-tests2.pcert1
-
-serialize/unsound-read.pcert0 : no_pcert = 0
-serialize/unsound-read.pcert0 : acl2x = 0
-serialize/unsound-read.pcert0 : \
- tools/include-raw.pcert0 \
- serialize/unsound-read.lisp \
- serialize/unsound-read.acl2 \
- serialize/unsound-read-raw.lsp
-serialize/unsound-read.pcert1 : acl2x = 0
-serialize/unsound-read.pcert1 : no_pcert = 0
-serialize/unsound-read.pcert1 : serialize/unsound-read.pcert0
-serialize/unsound-read.cert : | serialize/unsound-read.pcert1
-
-sorting/bsort.pcert0 : no_pcert = 0
-sorting/bsort.pcert0 : acl2x = 0
-sorting/bsort.pcert0 : \
- sorting/ordered-perms.pcert0 \
- sorting/convert-perm-to-how-many.pcert0 \
- sorting/bsort.lisp
-sorting/bsort.pcert1 : acl2x = 0
-sorting/bsort.pcert1 : no_pcert = 0
-sorting/bsort.pcert1 : sorting/bsort.pcert0
-sorting/bsort.cert : | sorting/bsort.pcert1
-
-sorting/convert-perm-to-how-many.pcert0 : no_pcert = 0
-sorting/convert-perm-to-how-many.pcert0 : acl2x = 0
-sorting/convert-perm-to-how-many.pcert0 : \
- sorting/perm.pcert0 \
- sorting/convert-perm-to-how-many.lisp
-sorting/convert-perm-to-how-many.pcert1 : acl2x = 0
-sorting/convert-perm-to-how-many.pcert1 : no_pcert = 0
-sorting/convert-perm-to-how-many.pcert1 : sorting/convert-perm-to-how-many.pcert0
-sorting/convert-perm-to-how-many.cert : | sorting/convert-perm-to-how-many.pcert1
-
-sorting/equisort.pcert0 : no_pcert = 0
-sorting/equisort.pcert0 : acl2x = 0
-sorting/equisort.pcert0 : \
- sorting/perm.pcert0 \
- sorting/ordered-perms.pcert0 \
- sorting/convert-perm-to-how-many.pcert0 \
- sorting/equisort.lisp
-sorting/equisort.pcert1 : acl2x = 0
-sorting/equisort.pcert1 : no_pcert = 0
-sorting/equisort.pcert1 : sorting/equisort.pcert0
-sorting/equisort.cert : | sorting/equisort.pcert1
-
-sorting/equisort2.pcert0 : no_pcert = 0
-sorting/equisort2.pcert0 : acl2x = 0
-sorting/equisort2.pcert0 : \
- sorting/perm.pcert0 \
- sorting/ordered-perms.pcert0 \
- sorting/convert-perm-to-how-many.pcert0 \
- sorting/equisort2.lisp
-sorting/equisort2.pcert1 : acl2x = 0
-sorting/equisort2.pcert1 : no_pcert = 0
-sorting/equisort2.pcert1 : sorting/equisort2.pcert0
-sorting/equisort2.cert : | sorting/equisort2.pcert1
-
-sorting/equisort3.pcert0 : no_pcert = 0
-sorting/equisort3.pcert0 : acl2x = 0
-sorting/equisort3.pcert0 : \
- sorting/perm.pcert0 \
- sorting/ordered-perms.pcert0 \
- sorting/convert-perm-to-how-many.pcert0 \
- sorting/equisort3.lisp
-sorting/equisort3.pcert1 : acl2x = 0
-sorting/equisort3.pcert1 : no_pcert = 0
-sorting/equisort3.pcert1 : sorting/equisort3.pcert0
-sorting/equisort3.cert : | sorting/equisort3.pcert1
-
-sorting/isort.pcert0 : no_pcert = 0
-sorting/isort.pcert0 : acl2x = 0
-sorting/isort.pcert0 : \
- sorting/perm.pcert0 \
- sorting/ordered-perms.pcert0 \
- sorting/convert-perm-to-how-many.pcert0 \
- sorting/isort.lisp
-sorting/isort.pcert1 : acl2x = 0
-sorting/isort.pcert1 : no_pcert = 0
-sorting/isort.pcert1 : sorting/isort.pcert0
-sorting/isort.cert : | sorting/isort.pcert1
-
-sorting/msort.pcert0 : no_pcert = 0
-sorting/msort.pcert0 : acl2x = 0
-sorting/msort.pcert0 : \
- sorting/perm.pcert0 \
- sorting/ordered-perms.pcert0 \
- sorting/convert-perm-to-how-many.pcert0 \
- sorting/msort.lisp
-sorting/msort.pcert1 : acl2x = 0
-sorting/msort.pcert1 : no_pcert = 0
-sorting/msort.pcert1 : sorting/msort.pcert0
-sorting/msort.cert : | sorting/msort.pcert1
-
-sorting/no-dups-qsort.pcert0 : no_pcert = 0
-sorting/no-dups-qsort.pcert0 : acl2x = 0
-sorting/no-dups-qsort.pcert0 : \
- sorting/qsort.pcert0 \
- sorting/no-dups-qsort.lisp
-sorting/no-dups-qsort.pcert1 : acl2x = 0
-sorting/no-dups-qsort.pcert1 : no_pcert = 0
-sorting/no-dups-qsort.pcert1 : sorting/no-dups-qsort.pcert0
-sorting/no-dups-qsort.cert : | sorting/no-dups-qsort.pcert1
-
-sorting/ordered-perms.pcert0 : no_pcert = 0
-sorting/ordered-perms.pcert0 : acl2x = 0
-sorting/ordered-perms.pcert0 : \
- sorting/perm.pcert0 \
- sorting/ordered-perms.lisp
-sorting/ordered-perms.pcert1 : acl2x = 0
-sorting/ordered-perms.pcert1 : no_pcert = 0
-sorting/ordered-perms.pcert1 : sorting/ordered-perms.pcert0
-sorting/ordered-perms.cert : | sorting/ordered-perms.pcert1
-
-sorting/perm.pcert0 : no_pcert = 0
-sorting/perm.pcert0 : acl2x = 0
-sorting/perm.pcert0 : \
- sorting/perm.lisp
-sorting/perm.pcert1 : acl2x = 0
-sorting/perm.pcert1 : no_pcert = 0
-sorting/perm.pcert1 : sorting/perm.pcert0
-sorting/perm.cert : | sorting/perm.pcert1
-
-sorting/qsort.pcert0 : no_pcert = 0
-sorting/qsort.pcert0 : acl2x = 0
-sorting/qsort.pcert0 : \
- sorting/perm.pcert0 \
- sorting/ordered-perms.pcert0 \
- sorting/convert-perm-to-how-many.pcert0 \
- arithmetic-3/extra/top-ext.pcert0 \
- sorting/qsort.lisp
-sorting/qsort.pcert1 : acl2x = 0
-sorting/qsort.pcert1 : no_pcert = 0
-sorting/qsort.pcert1 : sorting/qsort.pcert0
-sorting/qsort.cert : | sorting/qsort.pcert1
-
-sorting/sorts-equivalent.pcert0 : no_pcert = 0
-sorting/sorts-equivalent.pcert0 : acl2x = 0
-sorting/sorts-equivalent.pcert0 : \
- sorting/equisort.pcert0 \
- sorting/isort.pcert0 \
- sorting/msort.pcert0 \
- sorting/qsort.pcert0 \
- sorting/bsort.pcert0 \
- sorting/sorts-equivalent.lisp
-sorting/sorts-equivalent.pcert1 : acl2x = 0
-sorting/sorts-equivalent.pcert1 : no_pcert = 0
-sorting/sorts-equivalent.pcert1 : sorting/sorts-equivalent.pcert0
-sorting/sorts-equivalent.cert : | sorting/sorts-equivalent.pcert1
-
-sorting/sorts-equivalent2.pcert0 : no_pcert = 0
-sorting/sorts-equivalent2.pcert0 : acl2x = 0
-sorting/sorts-equivalent2.pcert0 : \
- sorting/equisort2.pcert0 \
- sorting/isort.pcert0 \
- sorting/msort.pcert0 \
- sorting/qsort.pcert0 \
- sorting/bsort.pcert0 \
- sorting/sorts-equivalent2.lisp
-sorting/sorts-equivalent2.pcert1 : acl2x = 0
-sorting/sorts-equivalent2.pcert1 : no_pcert = 0
-sorting/sorts-equivalent2.pcert1 : sorting/sorts-equivalent2.pcert0
-sorting/sorts-equivalent2.cert : | sorting/sorts-equivalent2.pcert1
-
-sorting/sorts-equivalent3.pcert0 : no_pcert = 0
-sorting/sorts-equivalent3.pcert0 : acl2x = 0
-sorting/sorts-equivalent3.pcert0 : \
- sorting/equisort3.pcert0 \
- sorting/isort.pcert0 \
- sorting/msort.pcert0 \
- sorting/qsort.pcert0 \
- sorting/bsort.pcert0 \
- sorting/sorts-equivalent3.lisp
-sorting/sorts-equivalent3.pcert1 : acl2x = 0
-sorting/sorts-equivalent3.pcert1 : no_pcert = 0
-sorting/sorts-equivalent3.pcert1 : sorting/sorts-equivalent3.pcert0
-sorting/sorts-equivalent3.cert : | sorting/sorts-equivalent3.pcert1
-
-std/io/base.pcert0 : no_pcert = 0
-std/io/base.pcert0 : acl2x = 0
-std/io/base.pcert0 : \
- xdoc/top.pcert0 \
- system/f-put-global.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- std/io/base.lisp
-std/io/base.pcert1 : acl2x = 0
-std/io/base.pcert1 : no_pcert = 0
-std/io/base.pcert1 : std/io/base.pcert0
-std/io/base.cert : | std/io/base.pcert1
-
-std/io/close-input-channel.pcert0 : no_pcert = 0
-std/io/close-input-channel.pcert0 : acl2x = 0
-std/io/close-input-channel.pcert0 : \
- std/io/base.pcert0 \
- std/io/close-input-channel.lisp
-std/io/close-input-channel.pcert1 : acl2x = 0
-std/io/close-input-channel.pcert1 : no_pcert = 0
-std/io/close-input-channel.pcert1 : std/io/close-input-channel.pcert0
-std/io/close-input-channel.cert : | std/io/close-input-channel.pcert1
-
-std/io/combine.pcert0 : no_pcert = 0
-std/io/combine.pcert0 : acl2x = 0
-std/io/combine.pcert0 : \
- std/io/sign-byte.pcert0 \
- std/io/unsigned-byte-listp.pcert0 \
- std/io/signed-byte-listp.pcert0 \
- std/io/combine.lisp
-std/io/combine.pcert1 : acl2x = 0
-std/io/combine.pcert1 : no_pcert = 0
-std/io/combine.pcert1 : std/io/combine.pcert0
-std/io/combine.cert : | std/io/combine.pcert1
-
-std/io/file-measure.pcert0 : no_pcert = 0
-std/io/file-measure.pcert0 : acl2x = 0
-std/io/file-measure.pcert0 : \
- std/io/base.pcert0 \
- std/io/file-measure.lisp
-std/io/file-measure.pcert1 : acl2x = 0
-std/io/file-measure.pcert1 : no_pcert = 0
-std/io/file-measure.pcert1 : std/io/file-measure.pcert0
-std/io/file-measure.cert : | std/io/file-measure.pcert1
-
-std/io/nthcdr-bytes.pcert0 : no_pcert = 0
-std/io/nthcdr-bytes.pcert0 : acl2x = 0
-std/io/nthcdr-bytes.pcert0 : \
- std/io/read-byte.pcert0 \
- std/io/read-file-bytes.pcert0 \
- tools/mv-nth.pcert0 \
- std/io/nthcdr-bytes.lisp
-std/io/nthcdr-bytes.pcert1 : acl2x = 0
-std/io/nthcdr-bytes.pcert1 : no_pcert = 0
-std/io/nthcdr-bytes.pcert1 : std/io/nthcdr-bytes.pcert0
-std/io/nthcdr-bytes.cert : | std/io/nthcdr-bytes.pcert1
-
-std/io/open-input-channel.pcert0 : no_pcert = 0
-std/io/open-input-channel.pcert0 : acl2x = 0
-std/io/open-input-channel.pcert0 : \
- tools/mv-nth.pcert0 \
- system/update-state.pcert0 \
- std/io/open-input-channels.pcert0 \
- arithmetic/top.pcert0 \
- std/ks/explode-nonnegative-integer.pcert0 \
- std/ks/intern-in-package-of-symbol.pcert0 \
- std/lists/coerce.pcert0 \
- std/io/open-input-channel.lisp
-std/io/open-input-channel.pcert1 : acl2x = 0
-std/io/open-input-channel.pcert1 : no_pcert = 0
-std/io/open-input-channel.pcert1 : std/io/open-input-channel.pcert0
-std/io/open-input-channel.cert : | std/io/open-input-channel.pcert1
-
-std/io/open-input-channels.pcert0 : no_pcert = 0
-std/io/open-input-channels.pcert0 : acl2x = 0
-std/io/open-input-channels.pcert0 : \
- std/io/open-input-channels.lisp
-std/io/open-input-channels.pcert1 : acl2x = 0
-std/io/open-input-channels.pcert1 : no_pcert = 0
-std/io/open-input-channels.pcert1 : std/io/open-input-channels.pcert0
-std/io/open-input-channels.cert : | std/io/open-input-channels.pcert1
-
-std/io/peek-char.pcert0 : no_pcert = 0
-std/io/peek-char.pcert0 : acl2x = 0
-std/io/peek-char.pcert0 : \
- std/io/base.pcert0 \
- std/io/peek-char.lisp
-std/io/peek-char.pcert1 : acl2x = 0
-std/io/peek-char.pcert1 : no_pcert = 0
-std/io/peek-char.pcert1 : std/io/peek-char.pcert0
-std/io/peek-char.cert : | std/io/peek-char.pcert1
-
-std/io/read-byte.pcert0 : no_pcert = 0
-std/io/read-byte.pcert0 : acl2x = 0
-std/io/read-byte.pcert0 : \
- std/io/base.pcert0 \
- std/io/read-byte.lisp
-std/io/read-byte.pcert1 : acl2x = 0
-std/io/read-byte.pcert1 : no_pcert = 0
-std/io/read-byte.pcert1 : std/io/read-byte.pcert0
-std/io/read-byte.cert : | std/io/read-byte.pcert1
-
-std/io/read-char.pcert0 : no_pcert = 0
-std/io/read-char.pcert0 : acl2x = 0
-std/io/read-char.pcert0 : \
- std/io/base.pcert0 \
- std/io/read-char.lisp
-std/io/read-char.pcert1 : acl2x = 0
-std/io/read-char.pcert1 : no_pcert = 0
-std/io/read-char.pcert1 : std/io/read-char.pcert0
-std/io/read-char.cert : | std/io/read-char.pcert1
-
-std/io/read-file-bytes.pcert0 : no_pcert = 0
-std/io/read-file-bytes.pcert0 : acl2x = 0
-std/io/read-file-bytes.pcert0 : \
- std/io/base.pcert0 \
- std/io/unsigned-byte-listp.pcert0 \
- tools/mv-nth.pcert0 \
- std/io/read-file-bytes.lisp
-std/io/read-file-bytes.pcert1 : acl2x = 0
-std/io/read-file-bytes.pcert1 : no_pcert = 0
-std/io/read-file-bytes.pcert1 : std/io/read-file-bytes.pcert0
-std/io/read-file-bytes.cert : | std/io/read-file-bytes.pcert1
-
-std/io/read-file-characters-no-error.pcert0 : no_pcert = 0
-std/io/read-file-characters-no-error.pcert0 : acl2x = 0
-std/io/read-file-characters-no-error.pcert0 : \
- std/io/read-file-characters.pcert0 \
- tools/mv-nth.pcert0 \
- std/io/read-file-characters-no-error.lisp \
- std/io/read-file-characters-no-error.acl2
-std/io/read-file-characters-no-error.pcert1 : acl2x = 0
-std/io/read-file-characters-no-error.pcert1 : no_pcert = 0
-std/io/read-file-characters-no-error.pcert1 : std/io/read-file-characters-no-error.pcert0
-std/io/read-file-characters-no-error.cert : | std/io/read-file-characters-no-error.pcert1
-
-std/io/read-file-characters.pcert0 : no_pcert = 0
-std/io/read-file-characters.pcert0 : acl2x = 0
-std/io/read-file-characters.pcert0 : \
- std/io/base.pcert0 \
- std/lists/revappend.pcert0 \
- tools/mv-nth.pcert0 \
- std/lists/rev.pcert0 \
- std/io/read-file-characters.lisp
-std/io/read-file-characters.pcert1 : acl2x = 0
-std/io/read-file-characters.pcert1 : no_pcert = 0
-std/io/read-file-characters.pcert1 : std/io/read-file-characters.pcert0
-std/io/read-file-characters.cert : | std/io/read-file-characters.pcert1
-
-std/io/read-file-lines.pcert0 : no_pcert = 0
-std/io/read-file-lines.pcert0 : acl2x = 0
-std/io/read-file-lines.pcert0 : \
- std/io/base.pcert0 \
- std/lists/revappend.pcert0 \
- std/lists/rev.pcert0 \
- tools/mv-nth.pcert0 \
- tools/bstar.pcert0 \
- std/io/read-file-lines.lisp
-std/io/read-file-lines.pcert1 : acl2x = 0
-std/io/read-file-lines.pcert1 : no_pcert = 0
-std/io/read-file-lines.pcert1 : std/io/read-file-lines.pcert0
-std/io/read-file-lines.cert : | std/io/read-file-lines.pcert1
-
-std/io/read-file-objects.pcert0 : no_pcert = 0
-std/io/read-file-objects.pcert0 : acl2x = 0
-std/io/read-file-objects.pcert0 : \
- std/io/base.pcert0 \
- tools/mv-nth.pcert0 \
- std/io/read-file-objects.lisp
-std/io/read-file-objects.pcert1 : acl2x = 0
-std/io/read-file-objects.pcert1 : no_pcert = 0
-std/io/read-file-objects.pcert1 : std/io/read-file-objects.pcert0
-std/io/read-file-objects.cert : | std/io/read-file-objects.pcert1
-
-std/io/read-ints.pcert0 : no_pcert = 0
-std/io/read-ints.pcert0 : acl2x = 0
-std/io/read-ints.pcert0 : \
- std/io/read-byte.pcert0 \
- std/io/unsigned-byte-listp.pcert0 \
- std/io/signed-byte-listp.pcert0 \
- std/io/sign-byte.pcert0 \
- std/io/combine.pcert0 \
- tools/mv-nth.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- std/io/read-ints.lisp
-std/io/read-ints.pcert1 : acl2x = 0
-std/io/read-ints.pcert1 : no_pcert = 0
-std/io/read-ints.pcert1 : std/io/read-ints.pcert0
-std/io/read-ints.cert : | std/io/read-ints.pcert1
-
-std/io/read-object.pcert0 : no_pcert = 0
-std/io/read-object.pcert0 : acl2x = 0
-std/io/read-object.pcert0 : \
- std/io/base.pcert0 \
- std/io/read-object.lisp
-std/io/read-object.pcert1 : acl2x = 0
-std/io/read-object.pcert1 : no_pcert = 0
-std/io/read-object.pcert1 : std/io/read-object.pcert0
-std/io/read-object.cert : | std/io/read-object.pcert1
-
-std/io/sign-byte.pcert0 : no_pcert = 0
-std/io/sign-byte.pcert0 : acl2x = 0
-std/io/sign-byte.pcert0 : \
- std/io/sign-byte.lisp
-std/io/sign-byte.pcert1 : acl2x = 0
-std/io/sign-byte.pcert1 : no_pcert = 0
-std/io/sign-byte.pcert1 : std/io/sign-byte.pcert0
-std/io/sign-byte.cert : | std/io/sign-byte.pcert1
-
-std/io/signed-byte-listp.pcert0 : no_pcert = 0
-std/io/signed-byte-listp.pcert0 : acl2x = 0
-std/io/signed-byte-listp.pcert0 : \
- ihs/logops-lemmas.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- std/io/unsigned-byte-listp.pcert0 \
- std/io/signed-byte-listp.lisp
-std/io/signed-byte-listp.pcert1 : acl2x = 0
-std/io/signed-byte-listp.pcert1 : no_pcert = 0
-std/io/signed-byte-listp.pcert1 : std/io/signed-byte-listp.pcert0
-std/io/signed-byte-listp.cert : | std/io/signed-byte-listp.pcert1
-
-std/io/take-bytes.pcert0 : no_pcert = 0
-std/io/take-bytes.pcert0 : acl2x = 0
-std/io/take-bytes.pcert0 : \
- std/io/read-byte.pcert0 \
- std/io/read-file-bytes.pcert0 \
- std/io/nthcdr-bytes.pcert0 \
- std/io/take-bytes.lisp
-std/io/take-bytes.pcert1 : acl2x = 0
-std/io/take-bytes.pcert1 : no_pcert = 0
-std/io/take-bytes.pcert1 : std/io/take-bytes.pcert0
-std/io/take-bytes.cert : | std/io/take-bytes.pcert1
-
-std/io/unsigned-byte-listp.pcert0 : no_pcert = 0
-std/io/unsigned-byte-listp.pcert0 : acl2x = 0
-std/io/unsigned-byte-listp.pcert0 : \
- std/lists/take.pcert0 \
- std/lists/nat-listp.pcert0 \
- std/lists/repeat.pcert0 \
- ihs/logops-lemmas.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- std/io/unsigned-byte-listp.lisp
-std/io/unsigned-byte-listp.pcert1 : acl2x = 0
-std/io/unsigned-byte-listp.pcert1 : no_pcert = 0
-std/io/unsigned-byte-listp.pcert1 : std/io/unsigned-byte-listp.pcert0
-std/io/unsigned-byte-listp.cert : | std/io/unsigned-byte-listp.pcert1
-
-std/ks/base10-digit-charp.pcert0 : no_pcert = 0
-std/ks/base10-digit-charp.pcert0 : acl2x = 0
-std/ks/base10-digit-charp.pcert0 : \
- std/ks/base10-digit-charp.lisp
-std/ks/base10-digit-charp.pcert1 : acl2x = 0
-std/ks/base10-digit-charp.pcert1 : no_pcert = 0
-std/ks/base10-digit-charp.pcert1 : std/ks/base10-digit-charp.pcert0
-std/ks/base10-digit-charp.cert : | std/ks/base10-digit-charp.pcert1
-
-std/ks/explode-atom.pcert0 : no_pcert = 0
-std/ks/explode-atom.pcert0 : acl2x = 0
-std/ks/explode-atom.pcert0 : \
- std/ks/base10-digit-charp.pcert0 \
- std/lists/append.pcert0 \
- std/ks/explode-nonnegative-integer.pcert0 \
- std/ks/explode-atom.lisp
-std/ks/explode-atom.pcert1 : acl2x = 0
-std/ks/explode-atom.pcert1 : no_pcert = 0
-std/ks/explode-atom.pcert1 : std/ks/explode-atom.pcert0
-std/ks/explode-atom.cert : | std/ks/explode-atom.pcert1
-
-std/ks/explode-nonnegative-integer.pcert0 : no_pcert = 0
-std/ks/explode-nonnegative-integer.pcert0 : acl2x = 0
-std/ks/explode-nonnegative-integer.pcert0 : \
- ihs/quotient-remainder-lemmas.pcert0 \
- std/lists/revappend.pcert0 \
- std/ks/base10-digit-charp.pcert0 \
- std/lists/rev.pcert0 \
- std/ks/explode-nonnegative-integer.lisp
-std/ks/explode-nonnegative-integer.pcert1 : acl2x = 0
-std/ks/explode-nonnegative-integer.pcert1 : no_pcert = 0
-std/ks/explode-nonnegative-integer.pcert1 : std/ks/explode-nonnegative-integer.pcert0
-std/ks/explode-nonnegative-integer.cert : | std/ks/explode-nonnegative-integer.pcert1
-
-std/ks/intern-in-package-of-symbol.pcert0 : no_pcert = 0
-std/ks/intern-in-package-of-symbol.pcert0 : acl2x = 0
-std/ks/intern-in-package-of-symbol.pcert0 : \
- std/ks/intern-in-package-of-symbol.lisp
-std/ks/intern-in-package-of-symbol.pcert1 : acl2x = 0
-std/ks/intern-in-package-of-symbol.pcert1 : no_pcert = 0
-std/ks/intern-in-package-of-symbol.pcert1 : std/ks/intern-in-package-of-symbol.pcert0
-std/ks/intern-in-package-of-symbol.cert : | std/ks/intern-in-package-of-symbol.pcert1
-
-std/ks/string-append.pcert0 : no_pcert = 0
-std/ks/string-append.pcert0 : acl2x = 0
-std/ks/string-append.pcert0 : \
- std/lists/append.pcert0 \
- std/lists/coerce.pcert0 \
- std/ks/string-append.lisp
-std/ks/string-append.pcert1 : acl2x = 0
-std/ks/string-append.pcert1 : no_pcert = 0
-std/ks/string-append.pcert1 : std/ks/string-append.pcert0
-std/ks/string-append.cert : | std/ks/string-append.pcert1
-
-std/ks/two-nats-measure.pcert0 : no_pcert = 0
-std/ks/two-nats-measure.pcert0 : acl2x = 0
-std/ks/two-nats-measure.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- std/ks/two-nats-measure.lisp
-std/ks/two-nats-measure.pcert1 : acl2x = 0
-std/ks/two-nats-measure.pcert1 : no_pcert = 0
-std/ks/two-nats-measure.pcert1 : std/ks/two-nats-measure.pcert0
-std/ks/two-nats-measure.cert : | std/ks/two-nats-measure.pcert1
-
-std/lists/app.pcert0 : no_pcert = 0
-std/lists/app.pcert0 : acl2x = 0
-std/lists/app.pcert0 : \
- std/lists/list-fix.pcert0 \
- std/lists/take.pcert0 \
- std/lists/nthcdr.pcert0 \
- arithmetic/top.pcert0 \
- std/lists/app.lisp
-std/lists/app.pcert1 : acl2x = 0
-std/lists/app.pcert1 : no_pcert = 0
-std/lists/app.pcert1 : std/lists/app.pcert0
-std/lists/app.cert : | std/lists/app.pcert1
-
-std/lists/append.pcert0 : no_pcert = 0
-std/lists/append.pcert0 : acl2x = 0
-std/lists/append.pcert0 : \
- std/lists/list-fix.pcert0 \
- arithmetic/top.pcert0 \
- std/lists/append.lisp
-std/lists/append.pcert1 : acl2x = 0
-std/lists/append.pcert1 : no_pcert = 0
-std/lists/append.pcert1 : std/lists/append.pcert0
-std/lists/append.cert : | std/lists/append.pcert1
-
-std/lists/coerce.pcert0 : no_pcert = 0
-std/lists/coerce.pcert0 : acl2x = 0
-std/lists/coerce.pcert0 : \
- std/lists/make-character-list.pcert0 \
- std/lists/coerce.lisp
-std/lists/coerce.pcert1 : acl2x = 0
-std/lists/coerce.pcert1 : no_pcert = 0
-std/lists/coerce.pcert1 : std/lists/coerce.pcert0
-std/lists/coerce.cert : | std/lists/coerce.pcert1
-
-std/lists/consless-listp.pcert0 : no_pcert = 0
-std/lists/consless-listp.pcert0 : acl2x = 0
-std/lists/consless-listp.pcert0 : \
- std/lists/app.pcert0 \
- std/lists/consless-listp.lisp
-std/lists/consless-listp.pcert1 : acl2x = 0
-std/lists/consless-listp.pcert1 : no_pcert = 0
-std/lists/consless-listp.pcert1 : std/lists/consless-listp.pcert0
-std/lists/consless-listp.cert : | std/lists/consless-listp.pcert1
-
-std/lists/equiv.pcert0 : no_pcert = 0
-std/lists/equiv.pcert0 : acl2x = 0
-std/lists/equiv.pcert0 : \
- std/lists/list-fix.pcert0 \
- std/lists/take.pcert0 \
- arithmetic/top.pcert0 \
- std/lists/equiv.lisp
-std/lists/equiv.pcert1 : acl2x = 0
-std/lists/equiv.pcert1 : no_pcert = 0
-std/lists/equiv.pcert1 : std/lists/equiv.pcert0
-std/lists/equiv.cert : | std/lists/equiv.pcert1
-
-std/lists/final-cdr.pcert0 : no_pcert = 0
-std/lists/final-cdr.pcert0 : acl2x = 0
-std/lists/final-cdr.pcert0 : \
- std/lists/nthcdr.pcert0 \
- std/lists/final-cdr.lisp
-std/lists/final-cdr.pcert1 : acl2x = 0
-std/lists/final-cdr.pcert1 : no_pcert = 0
-std/lists/final-cdr.pcert1 : std/lists/final-cdr.pcert0
-std/lists/final-cdr.cert : | std/lists/final-cdr.pcert1
-
-std/lists/flatten.pcert0 : no_pcert = 0
-std/lists/flatten.pcert0 : acl2x = 0
-std/lists/flatten.pcert0 : \
- std/lists/app.pcert0 \
- std/lists/consless-listp.pcert0 \
- std/lists/flatten.lisp
-std/lists/flatten.pcert1 : acl2x = 0
-std/lists/flatten.pcert1 : no_pcert = 0
-std/lists/flatten.pcert1 : std/lists/flatten.pcert0
-std/lists/flatten.cert : | std/lists/flatten.pcert1
-
-std/lists/list-defuns.pcert0 : no_pcert = 0
-std/lists/list-defuns.pcert0 : acl2x = 0
-std/lists/list-defuns.pcert0 : \
- std/lists/app.pcert0 \
- std/lists/append.pcert0 \
- std/lists/list-fix.pcert0 \
- std/lists/flatten.pcert0 \
- std/lists/final-cdr.pcert0 \
- std/lists/prefixp.pcert0 \
- std/lists/take.pcert0 \
- std/lists/repeat.pcert0 \
- std/lists/revappend.pcert0 \
- std/lists/rev.pcert0 \
- std/lists/equiv.pcert0 \
- std/lists/sets.pcert0 \
- std/lists/list-defuns.lisp
-std/lists/list-defuns.pcert1 : acl2x = 0
-std/lists/list-defuns.pcert1 : no_pcert = 0
-std/lists/list-defuns.pcert1 : std/lists/list-defuns.pcert0
-std/lists/list-defuns.cert : | std/lists/list-defuns.pcert1
-
-std/lists/list-fix.pcert0 : no_pcert = 0
-std/lists/list-fix.pcert0 : acl2x = 0
-std/lists/list-fix.pcert0 : \
- std/lists/take.pcert0 \
- arithmetic/top.pcert0 \
- std/lists/list-fix.lisp
-std/lists/list-fix.pcert1 : acl2x = 0
-std/lists/list-fix.pcert1 : no_pcert = 0
-std/lists/list-fix.pcert1 : std/lists/list-fix.pcert0
-std/lists/list-fix.cert : | std/lists/list-fix.pcert1
-
-std/lists/make-character-list.pcert0 : no_pcert = 0
-std/lists/make-character-list.pcert0 : acl2x = 0
-std/lists/make-character-list.pcert0 : \
- std/lists/make-character-list.lisp
-std/lists/make-character-list.pcert1 : acl2x = 0
-std/lists/make-character-list.pcert1 : no_pcert = 0
-std/lists/make-character-list.pcert1 : std/lists/make-character-list.pcert0
-std/lists/make-character-list.cert : | std/lists/make-character-list.pcert1
-
-std/lists/mfc-utils.pcert0 : no_pcert = 0
-std/lists/mfc-utils.pcert0 : acl2x = 0
-std/lists/mfc-utils.pcert0 : \
- std/lists/mfc-utils.lisp
-std/lists/mfc-utils.pcert1 : acl2x = 0
-std/lists/mfc-utils.pcert1 : no_pcert = 0
-std/lists/mfc-utils.pcert1 : std/lists/mfc-utils.pcert0
-std/lists/mfc-utils.cert : | std/lists/mfc-utils.pcert1
-
-std/lists/nat-listp.pcert0 : no_pcert = 0
-std/lists/nat-listp.pcert0 : acl2x = 0
-std/lists/nat-listp.pcert0 : \
- std/lists/app.pcert0 \
- arithmetic/nat-listp.pcert0 \
- std/lists/nat-listp.lisp
-std/lists/nat-listp.pcert1 : acl2x = 0
-std/lists/nat-listp.pcert1 : no_pcert = 0
-std/lists/nat-listp.pcert1 : std/lists/nat-listp.pcert0
-std/lists/nat-listp.cert : | std/lists/nat-listp.pcert1
-
-std/lists/nthcdr.pcert0 : no_pcert = 0
-std/lists/nthcdr.pcert0 : acl2x = 0
-std/lists/nthcdr.pcert0 : \
- std/lists/nthcdr.lisp
-std/lists/nthcdr.pcert1 : acl2x = 0
-std/lists/nthcdr.pcert1 : no_pcert = 0
-std/lists/nthcdr.pcert1 : std/lists/nthcdr.pcert0
-std/lists/nthcdr.cert : | std/lists/nthcdr.pcert1
-
-std/lists/prefixp.pcert0 : no_pcert = 0
-std/lists/prefixp.pcert0 : acl2x = 0
-std/lists/prefixp.pcert0 : \
- std/lists/list-fix.pcert0 \
- std/lists/take.pcert0 \
- arithmetic/top.pcert0 \
- std/lists/prefixp.lisp
-std/lists/prefixp.pcert1 : acl2x = 0
-std/lists/prefixp.pcert1 : no_pcert = 0
-std/lists/prefixp.pcert1 : std/lists/prefixp.pcert0
-std/lists/prefixp.cert : | std/lists/prefixp.pcert1
-
-std/lists/repeat.pcert0 : no_pcert = 0
-std/lists/repeat.pcert0 : acl2x = 0
-std/lists/repeat.pcert0 : \
- std/lists/take.pcert0 \
- std/lists/append.pcert0 \
- std/lists/repeat.lisp
-std/lists/repeat.pcert1 : acl2x = 0
-std/lists/repeat.pcert1 : no_pcert = 0
-std/lists/repeat.pcert1 : std/lists/repeat.pcert0
-std/lists/repeat.cert : | std/lists/repeat.pcert1
-
-std/lists/rev.pcert0 : no_pcert = 0
-std/lists/rev.pcert0 : acl2x = 0
-std/lists/rev.pcert0 : \
- std/lists/revappend.pcert0 \
- std/lists/reverse.pcert0 \
- std/lists/append.pcert0 \
- std/lists/make-character-list.pcert0 \
- std/lists/rev.lisp
-std/lists/rev.pcert1 : acl2x = 0
-std/lists/rev.pcert1 : no_pcert = 0
-std/lists/rev.pcert1 : std/lists/rev.pcert0
-std/lists/rev.cert : | std/lists/rev.pcert1
-
-std/lists/revappend.pcert0 : no_pcert = 0
-std/lists/revappend.pcert0 : acl2x = 0
-std/lists/revappend.pcert0 : \
- arithmetic/top.pcert0 \
- std/lists/revappend.lisp
-std/lists/revappend.pcert1 : acl2x = 0
-std/lists/revappend.pcert1 : no_pcert = 0
-std/lists/revappend.pcert1 : std/lists/revappend.pcert0
-std/lists/revappend.cert : | std/lists/revappend.pcert1
-
-std/lists/reverse.pcert0 : no_pcert = 0
-std/lists/reverse.pcert0 : acl2x = 0
-std/lists/reverse.pcert0 : \
- std/lists/revappend.pcert0 \
- std/lists/coerce.pcert0 \
- std/lists/reverse.lisp
-std/lists/reverse.pcert1 : acl2x = 0
-std/lists/reverse.pcert1 : no_pcert = 0
-std/lists/reverse.pcert1 : std/lists/reverse.pcert0
-std/lists/reverse.cert : | std/lists/reverse.pcert1
-
-std/lists/sets.pcert0 : no_pcert = 0
-std/lists/sets.pcert0 : acl2x = 0
-std/lists/sets.pcert0 : \
- std/lists/equiv.pcert0 \
- std/lists/mfc-utils.pcert0 \
- std/lists/rev.pcert0 \
- std/lists/sets.lisp
-std/lists/sets.pcert1 : acl2x = 0
-std/lists/sets.pcert1 : no_pcert = 0
-std/lists/sets.pcert1 : std/lists/sets.pcert0
-std/lists/sets.cert : | std/lists/sets.pcert1
-
-std/lists/take.pcert0 : no_pcert = 0
-std/lists/take.pcert0 : acl2x = 0
-std/lists/take.pcert0 : \
- arithmetic/top.pcert0 \
- std/lists/take.lisp
-std/lists/take.pcert1 : acl2x = 0
-std/lists/take.pcert1 : no_pcert = 0
-std/lists/take.pcert1 : std/lists/take.pcert0
-std/lists/take.cert : | std/lists/take.pcert1
-
-str/abbrevs.pcert0 : no_pcert = 0
-str/abbrevs.pcert0 : acl2x = 0
-str/abbrevs.pcert0 : \
- str/top.pcert0 \
- str/portcullis.pcert0 \
- str/abbrevs.lisp \
- str/cert.acl2
-str/abbrevs.pcert1 : acl2x = 0
-str/abbrevs.pcert1 : no_pcert = 0
-str/abbrevs.pcert1 : str/abbrevs.pcert0
-str/abbrevs.cert : | str/abbrevs.pcert1
-
-str/arithmetic.pcert0 : no_pcert = 0
-str/arithmetic.pcert0 : acl2x = 0
-str/arithmetic.pcert0 : \
- arithmetic/top.pcert0 \
- std/lists/nthcdr.pcert0 \
- std/lists/append.pcert0 \
- std/lists/repeat.pcert0 \
- str/portcullis.pcert0 \
- str/arithmetic.lisp \
- str/cert.acl2
-str/arithmetic.pcert1 : acl2x = 0
-str/arithmetic.pcert1 : no_pcert = 0
-str/arithmetic.pcert1 : str/arithmetic.pcert0
-str/arithmetic.cert : | str/arithmetic.pcert1
-
-str/case-conversion.pcert0 : no_pcert = 0
-str/case-conversion.pcert0 : acl2x = 0
-str/case-conversion.pcert0 : \
- str/char-case.pcert0 \
- str/cat.pcert0 \
- str/arithmetic.pcert0 \
- std/lists/rev.pcert0 \
- std/lists/coerce.pcert0 \
- std/lists/take.pcert0 \
- std/lists/nthcdr.pcert0 \
- str/subseq.pcert0 \
- str/portcullis.pcert0 \
- str/case-conversion.lisp \
- str/cert.acl2
-str/case-conversion.pcert1 : acl2x = 0
-str/case-conversion.pcert1 : no_pcert = 0
-str/case-conversion.pcert1 : str/case-conversion.pcert0
-str/case-conversion.cert : | str/case-conversion.pcert1
-
-str/cat.pcert0 : no_pcert = 0
-str/cat.pcert0 : acl2x = 0
-str/cat.pcert0 : \
- xdoc/top.pcert0 \
- misc/definline.pcert0 \
- str/arithmetic.pcert0 \
- std/lists/take.pcert0 \
- str/portcullis.pcert0 \
- str/cat.lisp \
- str/cert.acl2
-str/cat.pcert1 : acl2x = 0
-str/cat.pcert1 : no_pcert = 0
-str/cat.pcert1 : str/cat.pcert0
-str/cat.cert : | str/cat.pcert1
-
-str/char-case.pcert0 : no_pcert = 0
-str/char-case.pcert0 : acl2x = 0
-str/char-case.pcert0 : \
- str/eqv.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/char-case.lisp \
- str/cert.acl2
-str/char-case.pcert1 : acl2x = 0
-str/char-case.pcert1 : no_pcert = 0
-str/char-case.pcert1 : str/char-case.pcert0
-str/char-case.cert : | str/char-case.pcert1
-
-str/digitp.pcert0 : no_pcert = 0
-str/digitp.pcert0 : acl2x = 0
-str/digitp.pcert0 : \
- str/eqv.pcert0 \
- std/lists/list-fix.pcert0 \
- std/lists/rev.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/digitp.lisp \
- str/cert.acl2
-str/digitp.pcert1 : acl2x = 0
-str/digitp.pcert1 : no_pcert = 0
-str/digitp.pcert1 : str/digitp.pcert0
-str/digitp.cert : | str/digitp.pcert1
-
-str/eqv.pcert0 : no_pcert = 0
-str/eqv.pcert0 : acl2x = 0
-str/eqv.pcert0 : \
- xdoc/top.pcert0 \
- std/lists/list-fix.pcert0 \
- misc/definline.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/eqv.lisp \
- str/cert.acl2
-str/eqv.pcert1 : acl2x = 0
-str/eqv.pcert1 : no_pcert = 0
-str/eqv.pcert1 : str/eqv.pcert0
-str/eqv.cert : | str/eqv.pcert1
-
-str/fast-cat.pcert0 : no_pcert = 0
-str/fast-cat.pcert0 : acl2x = 0
-str/fast-cat.pcert0 : \
- str/cat.pcert0 \
- str/portcullis.pcert0 \
- str/fast-cat.lisp \
- str/fast-cat.acl2 \
- str/cert.acl2
-str/fast-cat.pcert1 : acl2x = 0
-str/fast-cat.pcert1 : no_pcert = 0
-str/fast-cat.pcert1 : str/fast-cat.pcert0
-str/fast-cat.cert : | str/fast-cat.pcert1
-
-str/firstn-chars.pcert0 : no_pcert = 0
-str/firstn-chars.pcert0 : acl2x = 0
-str/firstn-chars.pcert0 : \
- str/eqv.pcert0 \
- str/arithmetic.pcert0 \
- std/lists/take.pcert0 \
- str/portcullis.pcert0 \
- str/firstn-chars.lisp \
- str/cert.acl2
-str/firstn-chars.pcert1 : acl2x = 0
-str/firstn-chars.pcert1 : no_pcert = 0
-str/firstn-chars.pcert1 : str/firstn-chars.pcert0
-str/firstn-chars.cert : | str/firstn-chars.pcert1
-
-str/hexify.pcert0 : no_pcert = 0
-str/hexify.pcert0 : acl2x = 0
-str/hexify.pcert0 : \
- tools/bstar.pcert0 \
- std/ks/explode-atom.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/hexify.lisp \
- str/cert.acl2
-str/hexify.pcert1 : acl2x = 0
-str/hexify.pcert1 : no_pcert = 0
-str/hexify.pcert1 : str/hexify.pcert0
-str/hexify.cert : | str/hexify.pcert1
-
-str/html-encode.pcert0 : no_pcert = 0
-str/html-encode.pcert0 : acl2x = 0
-str/html-encode.pcert0 : \
- str/cat.pcert0 \
- tools/bstar.pcert0 \
- misc/assert.pcert0 \
- str/arithmetic.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- str/portcullis.pcert0 \
- str/html-encode.lisp \
- str/cert.acl2
-str/html-encode.pcert1 : acl2x = 0
-str/html-encode.pcert1 : no_pcert = 0
-str/html-encode.pcert1 : str/html-encode.pcert0
-str/html-encode.cert : | str/html-encode.pcert1
-
-str/ieqv.pcert0 : no_pcert = 0
-str/ieqv.pcert0 : acl2x = 0
-str/ieqv.pcert0 : \
- str/char-case.pcert0 \
- std/lists/nthcdr.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/ieqv.lisp \
- str/cert.acl2
-str/ieqv.pcert1 : acl2x = 0
-str/ieqv.pcert1 : no_pcert = 0
-str/ieqv.pcert1 : str/ieqv.pcert0
-str/ieqv.cert : | str/ieqv.pcert1
-
-str/iless.pcert0 : no_pcert = 0
-str/iless.pcert0 : acl2x = 0
-str/iless.pcert0 : \
- str/ieqv.pcert0 \
- std/lists/nthcdr.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/iless.lisp \
- str/cert.acl2
-str/iless.pcert1 : acl2x = 0
-str/iless.pcert1 : no_pcert = 0
-str/iless.pcert1 : str/iless.pcert0
-str/iless.cert : | str/iless.pcert1
-
-str/iprefixp.pcert0 : no_pcert = 0
-str/iprefixp.pcert0 : acl2x = 0
-str/iprefixp.pcert0 : \
- str/ieqv.pcert0 \
- std/lists/prefixp.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/iprefixp.lisp \
- str/cert.acl2
-str/iprefixp.pcert1 : acl2x = 0
-str/iprefixp.pcert1 : no_pcert = 0
-str/iprefixp.pcert1 : str/iprefixp.pcert0
-str/iprefixp.cert : | str/iprefixp.pcert1
-
-str/isort.pcert0 : no_pcert = 0
-str/isort.pcert0 : acl2x = 0
-str/isort.pcert0 : \
- str/iless.pcert0 \
- defsort/defsort.pcert0 \
- std/lists/list-fix.pcert0 \
- str/portcullis.pcert0 \
- str/isort.lisp \
- str/cert.acl2
-str/isort.pcert1 : acl2x = 0
-str/isort.pcert1 : no_pcert = 0
-str/isort.pcert1 : str/isort.pcert0
-str/isort.cert : | str/isort.pcert1
-
-str/istrpos.pcert0 : no_pcert = 0
-str/istrpos.pcert0 : acl2x = 0
-str/istrpos.pcert0 : \
- str/iprefixp.pcert0 \
- str/istrprefixp.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/istrpos.lisp \
- str/cert.acl2
-str/istrpos.pcert1 : acl2x = 0
-str/istrpos.pcert1 : no_pcert = 0
-str/istrpos.pcert1 : str/istrpos.pcert0
-str/istrpos.cert : | str/istrpos.pcert1
-
-str/istrprefixp.pcert0 : no_pcert = 0
-str/istrprefixp.pcert0 : acl2x = 0
-str/istrprefixp.pcert0 : \
- str/ieqv.pcert0 \
- str/iprefixp.pcert0 \
- std/lists/nthcdr.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/istrprefixp.lisp \
- str/cert.acl2
-str/istrprefixp.pcert1 : acl2x = 0
-str/istrprefixp.pcert1 : no_pcert = 0
-str/istrprefixp.pcert1 : str/istrprefixp.pcert0
-str/istrprefixp.cert : | str/istrprefixp.pcert1
-
-str/isubstrp.pcert0 : no_pcert = 0
-str/isubstrp.pcert0 : acl2x = 0
-str/isubstrp.pcert0 : \
- str/istrpos.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/isubstrp.lisp \
- str/cert.acl2
-str/isubstrp.pcert1 : acl2x = 0
-str/isubstrp.pcert1 : no_pcert = 0
-str/isubstrp.pcert1 : str/isubstrp.pcert0
-str/isubstrp.cert : | str/isubstrp.pcert1
-
-str/natstr.pcert0 : no_pcert = 0
-str/natstr.pcert0 : acl2x = 0
-str/natstr.pcert0 : \
- str/digitp.pcert0 \
- arithmetic/nat-listp.pcert0 \
- std/lists/revappend.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- std/lists/rev.pcert0 \
- std/lists/coerce.pcert0 \
- str/portcullis.pcert0 \
- str/natstr.lisp \
- str/cert.acl2
-str/natstr.pcert1 : acl2x = 0
-str/natstr.pcert1 : no_pcert = 0
-str/natstr.pcert1 : str/natstr.pcert0
-str/natstr.cert : | str/natstr.pcert1
-
-str/pad.pcert0 : no_pcert = 0
-str/pad.pcert0 : acl2x = 0
-str/pad.pcert0 : \
- str/cat.pcert0 \
- std/lists/take.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/pad.lisp \
- str/cert.acl2
-str/pad.pcert1 : acl2x = 0
-str/pad.pcert1 : no_pcert = 0
-str/pad.pcert1 : str/pad.pcert0
-str/pad.cert : | str/pad.pcert1
-
-str/portcullis.pcert0 : no_pcert = 0
-str/portcullis.pcert0 : acl2x = 0
-str/portcullis.pcert0 : \
- str/portcullis.lisp \
- str/portcullis.acl2 \
- str/package.lsp \
- xdoc/package.lsp
-str/portcullis.pcert1 : acl2x = 0
-str/portcullis.pcert1 : no_pcert = 0
-str/portcullis.pcert1 : str/portcullis.pcert0
-str/portcullis.cert : | str/portcullis.pcert1
-
-str/prefix-lines.pcert0 : no_pcert = 0
-str/prefix-lines.pcert0 : acl2x = 0
-str/prefix-lines.pcert0 : \
- str/cat.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/prefix-lines.lisp \
- str/cert.acl2
-str/prefix-lines.pcert1 : acl2x = 0
-str/prefix-lines.pcert1 : no_pcert = 0
-str/prefix-lines.pcert1 : str/prefix-lines.pcert0
-str/prefix-lines.cert : | str/prefix-lines.pcert1
-
-str/stringify.pcert0 : no_pcert = 0
-str/stringify.pcert0 : acl2x = 0
-str/stringify.pcert0 : \
- str/natstr.pcert0 \
- str/portcullis.pcert0 \
- str/stringify.lisp \
- str/cert.acl2
-str/stringify.pcert1 : acl2x = 0
-str/stringify.pcert1 : no_pcert = 0
-str/stringify.pcert1 : str/stringify.pcert0
-str/stringify.cert : | str/stringify.pcert1
-
-str/strline.pcert0 : no_pcert = 0
-str/strline.pcert0 : acl2x = 0
-str/strline.pcert0 : \
- xdoc/top.pcert0 \
- misc/assert.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/strline.lisp \
- str/cert.acl2
-str/strline.pcert1 : acl2x = 0
-str/strline.pcert1 : no_pcert = 0
-str/strline.pcert1 : str/strline.pcert0
-str/strline.cert : | str/strline.pcert1
-
-str/strnatless.pcert0 : no_pcert = 0
-str/strnatless.pcert0 : acl2x = 0
-str/strnatless.pcert0 : \
- str/digitp.pcert0 \
- tools/mv-nth.pcert0 \
- tools/bstar.pcert0 \
- str/arithmetic.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- str/portcullis.pcert0 \
- str/strnatless.lisp \
- str/cert.acl2
-str/strnatless.pcert1 : acl2x = 0
-str/strnatless.pcert1 : no_pcert = 0
-str/strnatless.pcert1 : str/strnatless.pcert0
-str/strnatless.cert : | str/strnatless.pcert1
-
-str/strpos.pcert0 : no_pcert = 0
-str/strpos.pcert0 : acl2x = 0
-str/strpos.pcert0 : \
- misc/definline.pcert0 \
- str/strprefixp.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/strpos.lisp \
- str/cert.acl2
-str/strpos.pcert1 : acl2x = 0
-str/strpos.pcert1 : no_pcert = 0
-str/strpos.pcert1 : str/strpos.pcert0
-str/strpos.cert : | str/strpos.pcert1
-
-str/strprefixp.pcert0 : no_pcert = 0
-str/strprefixp.pcert0 : acl2x = 0
-str/strprefixp.pcert0 : \
- misc/definline.pcert0 \
- xdoc/top.pcert0 \
- std/lists/prefixp.pcert0 \
- std/lists/nthcdr.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/strprefixp.lisp \
- str/cert.acl2
-str/strprefixp.pcert1 : acl2x = 0
-str/strprefixp.pcert1 : no_pcert = 0
-str/strprefixp.pcert1 : str/strprefixp.pcert0
-str/strprefixp.cert : | str/strprefixp.pcert1
-
-str/strrpos.pcert0 : no_pcert = 0
-str/strrpos.pcert0 : acl2x = 0
-str/strrpos.pcert0 : \
- str/strprefixp.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/strrpos.lisp \
- str/cert.acl2
-str/strrpos.pcert1 : acl2x = 0
-str/strrpos.pcert1 : no_pcert = 0
-str/strrpos.pcert1 : str/strrpos.pcert0
-str/strrpos.cert : | str/strrpos.pcert1
-
-str/strsplit.pcert0 : no_pcert = 0
-str/strsplit.pcert0 : acl2x = 0
-str/strsplit.pcert0 : \
- str/arithmetic.pcert0 \
- tools/mv-nth.pcert0 \
- misc/assert.pcert0 \
- str/portcullis.pcert0 \
- str/strsplit.lisp \
- str/cert.acl2
-str/strsplit.pcert1 : acl2x = 0
-str/strsplit.pcert1 : no_pcert = 0
-str/strsplit.pcert1 : str/strsplit.pcert0
-str/strsplit.cert : | str/strsplit.pcert1
-
-str/strsubst.pcert0 : no_pcert = 0
-str/strsubst.pcert0 : acl2x = 0
-str/strsubst.pcert0 : \
- str/cat.pcert0 \
- str/strprefixp.pcert0 \
- misc/assert.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/strsubst.lisp \
- str/cert.acl2
-str/strsubst.pcert1 : acl2x = 0
-str/strsubst.pcert1 : no_pcert = 0
-str/strsubst.pcert1 : str/strsubst.pcert0
-str/strsubst.cert : | str/strsubst.pcert1
-
-str/strtok.pcert0 : no_pcert = 0
-str/strtok.pcert0 : acl2x = 0
-str/strtok.pcert0 : \
- str/cat.pcert0 \
- misc/assert.pcert0 \
- str/arithmetic.pcert0 \
- std/lists/revappend.pcert0 \
- str/portcullis.pcert0 \
- str/strtok.lisp \
- str/cert.acl2
-str/strtok.pcert1 : acl2x = 0
-str/strtok.pcert1 : no_pcert = 0
-str/strtok.pcert1 : str/strtok.pcert0
-str/strtok.cert : | str/strtok.pcert1
-
-str/strval.pcert0 : no_pcert = 0
-str/strval.pcert0 : acl2x = 0
-str/strval.pcert0 : \
- str/strnatless.pcert0 \
- misc/definline.pcert0 \
- str/arithmetic.pcert0 \
- misc/assert.pcert0 \
- str/portcullis.pcert0 \
- str/strval.lisp \
- str/cert.acl2
-str/strval.pcert1 : acl2x = 0
-str/strval.pcert1 : no_pcert = 0
-str/strval.pcert1 : str/strval.pcert0
-str/strval.cert : | str/strval.pcert1
-
-str/subseq.pcert0 : no_pcert = 0
-str/subseq.pcert0 : acl2x = 0
-str/subseq.pcert0 : \
- str/arithmetic.pcert0 \
- std/lists/take.pcert0 \
- std/lists/nthcdr.pcert0 \
- std/lists/coerce.pcert0 \
- str/portcullis.pcert0 \
- str/subseq.lisp \
- str/cert.acl2
-str/subseq.pcert1 : acl2x = 0
-str/subseq.pcert1 : no_pcert = 0
-str/subseq.pcert1 : str/subseq.pcert0
-str/subseq.cert : | str/subseq.pcert1
-
-str/substrp.pcert0 : no_pcert = 0
-str/substrp.pcert0 : acl2x = 0
-str/substrp.pcert0 : \
- str/strpos.pcert0 \
- str/arithmetic.pcert0 \
- str/portcullis.pcert0 \
- str/substrp.lisp \
- str/cert.acl2
-str/substrp.pcert1 : acl2x = 0
-str/substrp.pcert1 : no_pcert = 0
-str/substrp.pcert1 : str/substrp.pcert0
-str/substrp.cert : | str/substrp.pcert1
-
-str/suffixp.pcert0 : no_pcert = 0
-str/suffixp.pcert0 : acl2x = 0
-str/suffixp.pcert0 : \
- str/strprefixp.pcert0 \
- misc/assert.pcert0 \
- str/portcullis.pcert0 \
- str/suffixp.lisp \
- str/cert.acl2
-str/suffixp.pcert1 : acl2x = 0
-str/suffixp.pcert1 : no_pcert = 0
-str/suffixp.pcert1 : str/suffixp.pcert0
-str/suffixp.cert : | str/suffixp.pcert1
-
-str/top.pcert0 : no_pcert = 0
-str/top.pcert0 : acl2x = 0
-str/top.pcert0 : \
- str/case-conversion.pcert0 \
- str/cat.pcert0 \
- str/digitp.pcert0 \
- str/eqv.pcert0 \
- str/firstn-chars.pcert0 \
- str/html-encode.pcert0 \
- str/ieqv.pcert0 \
- str/iprefixp.pcert0 \
- str/iless.pcert0 \
- str/isort.pcert0 \
- str/istrpos.pcert0 \
- str/istrprefixp.pcert0 \
- str/isubstrp.pcert0 \
- str/natstr.pcert0 \
- str/strline.pcert0 \
- str/pad.pcert0 \
- str/prefix-lines.pcert0 \
- str/strpos.pcert0 \
- str/strrpos.pcert0 \
- str/strprefixp.pcert0 \
- str/strnatless.pcert0 \
- str/strsplit.pcert0 \
- str/strsubst.pcert0 \
- str/strtok.pcert0 \
- str/strval.pcert0 \
- str/substrp.pcert0 \
- str/subseq.pcert0 \
- str/suffixp.pcert0 \
- str/portcullis.pcert0 \
- str/top.lisp \
- str/cert.acl2
-str/top.pcert1 : acl2x = 0
-str/top.pcert1 : no_pcert = 0
-str/top.pcert1 : str/top.pcert0
-str/top.cert : | str/top.pcert1
-
-symbolic/generic/assertions.pcert0 : no_pcert = 0
-symbolic/generic/assertions.pcert0 : acl2x = 0
-symbolic/generic/assertions.pcert0 : \
- ordinals/ordinals.pcert0 \
- misc/defpun.pcert0 \
- symbolic/generic/assertions.lisp
-symbolic/generic/assertions.pcert1 : acl2x = 0
-symbolic/generic/assertions.pcert1 : no_pcert = 0
-symbolic/generic/assertions.pcert1 : symbolic/generic/assertions.pcert0
-symbolic/generic/assertions.cert : | symbolic/generic/assertions.pcert1
-
-symbolic/generic/defsimulate.pcert0 : no_pcert = 0
-symbolic/generic/defsimulate.pcert0 : acl2x = 0
-symbolic/generic/defsimulate.pcert0 : \
- symbolic/generic/assertions.pcert0 \
- symbolic/generic/measures.pcert0 \
- symbolic/generic/partial-correctness.pcert0 \
- symbolic/generic/total-correctness.pcert0 \
- ordinals/ordinals-without-arithmetic.pcert0 \
- misc/defpun.pcert0 \
- symbolic/generic/assertions.pcert0 \
- symbolic/generic/partial-correctness.pcert0 \
- symbolic/generic/assertions.pcert0 \
- symbolic/generic/measures.pcert0 \
- symbolic/generic/total-correctness.pcert0 \
- symbolic/generic/defsimulate.lisp
-symbolic/generic/defsimulate.pcert1 : acl2x = 0
-symbolic/generic/defsimulate.pcert1 : no_pcert = 0
-symbolic/generic/defsimulate.pcert1 : symbolic/generic/defsimulate.pcert0
-symbolic/generic/defsimulate.cert : | symbolic/generic/defsimulate.pcert1
-
-symbolic/generic/factorial-jvm-correct.pcert0 : no_pcert = 0
-symbolic/generic/factorial-jvm-correct.pcert0 : acl2x = 0
-symbolic/generic/factorial-jvm-correct.pcert0 : \
- symbolic/m5/demo.pcert0 \
- ordinals/ordinals.pcert0 \
- symbolic/generic/defsimulate.pcert0 \
- symbolic/m5/utilities.pcert0 \
- symbolic/generic/factorial-jvm-correct.lisp \
- symbolic/generic/factorial-jvm-correct.acl2
-symbolic/generic/factorial-jvm-correct.pcert1 : acl2x = 0
-symbolic/generic/factorial-jvm-correct.pcert1 : no_pcert = 0
-symbolic/generic/factorial-jvm-correct.pcert1 : symbolic/generic/factorial-jvm-correct.pcert0
-symbolic/generic/factorial-jvm-correct.cert : | symbolic/generic/factorial-jvm-correct.pcert1
-
-symbolic/generic/measures.pcert0 : no_pcert = 0
-symbolic/generic/measures.pcert0 : acl2x = 0
-symbolic/generic/measures.pcert0 : \
- misc/defpun.pcert0 \
- ordinals/ordinals.pcert0 \
- arithmetic-2/meta/top.pcert0 \
- symbolic/generic/measures.lisp
-symbolic/generic/measures.pcert1 : acl2x = 0
-symbolic/generic/measures.pcert1 : no_pcert = 0
-symbolic/generic/measures.pcert1 : symbolic/generic/measures.pcert0
-symbolic/generic/measures.cert : | symbolic/generic/measures.pcert1
-
-symbolic/generic/partial-correctness.pcert0 : no_pcert = 0
-symbolic/generic/partial-correctness.pcert0 : acl2x = 0
-symbolic/generic/partial-correctness.pcert0 : \
- misc/defpun.pcert0 \
- ordinals/ordinals.pcert0 \
- symbolic/generic/partial-correctness.lisp
-symbolic/generic/partial-correctness.pcert1 : acl2x = 0
-symbolic/generic/partial-correctness.pcert1 : no_pcert = 0
-symbolic/generic/partial-correctness.pcert1 : symbolic/generic/partial-correctness.pcert0
-symbolic/generic/partial-correctness.cert : | symbolic/generic/partial-correctness.pcert1
-
-symbolic/generic/tiny-fib-correct.pcert0 : no_pcert = 0
-symbolic/generic/tiny-fib-correct.pcert0 : acl2x = 0
-symbolic/generic/tiny-fib-correct.pcert0 : \
- symbolic/tiny-fib/tiny-rewrites.pcert0 \
- symbolic/tiny-fib/fib-def.pcert0 \
- ordinals/ordinals.pcert0 \
- symbolic/generic/defsimulate.pcert0 \
- symbolic/generic/tiny-fib-correct.lisp
-symbolic/generic/tiny-fib-correct.pcert1 : acl2x = 0
-symbolic/generic/tiny-fib-correct.pcert1 : no_pcert = 0
-symbolic/generic/tiny-fib-correct.pcert1 : symbolic/generic/tiny-fib-correct.pcert0
-symbolic/generic/tiny-fib-correct.cert : | symbolic/generic/tiny-fib-correct.pcert1
-
-symbolic/generic/total-correctness.pcert0 : no_pcert = 0
-symbolic/generic/total-correctness.pcert0 : acl2x = 0
-symbolic/generic/total-correctness.pcert0 : \
- misc/defpun.pcert0 \
- ordinals/ordinals-without-arithmetic.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- symbolic/generic/total-correctness.lisp
-symbolic/generic/total-correctness.pcert1 : acl2x = 0
-symbolic/generic/total-correctness.pcert1 : no_pcert = 0
-symbolic/generic/total-correctness.pcert1 : symbolic/generic/total-correctness.pcert0
-symbolic/generic/total-correctness.cert : | symbolic/generic/total-correctness.pcert1
-
-symbolic/m5/demo.pcert0 : no_pcert = 0
-symbolic/m5/demo.pcert0 : acl2x = 0
-symbolic/m5/demo.pcert0 : \
- symbolic/m5/utilities.pcert0 \
- symbolic/m5/utilities.pcert0 \
- symbolic/m5/demo.lisp \
- symbolic/m5/demo.acl2
-symbolic/m5/demo.pcert1 : acl2x = 0
-symbolic/m5/demo.pcert1 : no_pcert = 0
-symbolic/m5/demo.pcert1 : symbolic/m5/demo.pcert0
-symbolic/m5/demo.cert : | symbolic/m5/demo.pcert1
-
-symbolic/m5/utilities.pcert0 : no_pcert = 0
-symbolic/m5/utilities.pcert0 : acl2x = 0
-symbolic/m5/utilities.pcert0 : \
- models/jvm/m5/m5.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- models/jvm/m5/m5.pcert0 \
- symbolic/m5/utilities.lisp \
- symbolic/m5/utilities.acl2
-symbolic/m5/utilities.pcert1 : acl2x = 0
-symbolic/m5/utilities.pcert1 : no_pcert = 0
-symbolic/m5/utilities.pcert1 : symbolic/m5/utilities.pcert0
-symbolic/m5/utilities.cert : | symbolic/m5/utilities.pcert1
-
-symbolic/tiny-fib/defstobj+.pcert0 : no_pcert = 0
-symbolic/tiny-fib/defstobj+.pcert0 : acl2x = 0
-symbolic/tiny-fib/defstobj+.pcert0 : \
- arithmetic-2/meta/top.pcert0 \
- symbolic/tiny-fib/defstobj+.lisp
-symbolic/tiny-fib/defstobj+.pcert1 : acl2x = 0
-symbolic/tiny-fib/defstobj+.pcert1 : no_pcert = 0
-symbolic/tiny-fib/defstobj+.pcert1 : symbolic/tiny-fib/defstobj+.pcert0
-symbolic/tiny-fib/defstobj+.cert : | symbolic/tiny-fib/defstobj+.pcert1
-
-symbolic/tiny-fib/fib-def.pcert0 : no_pcert = 0
-symbolic/tiny-fib/fib-def.pcert0 : acl2x = 0
-symbolic/tiny-fib/fib-def.pcert0 : \
- symbolic/tiny-fib/tiny.pcert0 \
- symbolic/tiny-fib/fib-def.lisp
-symbolic/tiny-fib/fib-def.pcert1 : acl2x = 0
-symbolic/tiny-fib/fib-def.pcert1 : no_pcert = 0
-symbolic/tiny-fib/fib-def.pcert1 : symbolic/tiny-fib/fib-def.pcert0
-symbolic/tiny-fib/fib-def.cert : | symbolic/tiny-fib/fib-def.pcert1
-
-symbolic/tiny-fib/tiny-rewrites.pcert0 : no_pcert = 0
-symbolic/tiny-fib/tiny-rewrites.pcert0 : acl2x = 0
-symbolic/tiny-fib/tiny-rewrites.pcert0 : \
- symbolic/tiny-fib/tiny.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- symbolic/tiny-fib/tiny-rewrites.lisp
-symbolic/tiny-fib/tiny-rewrites.pcert1 : acl2x = 0
-symbolic/tiny-fib/tiny-rewrites.pcert1 : no_pcert = 0
-symbolic/tiny-fib/tiny-rewrites.pcert1 : symbolic/tiny-fib/tiny-rewrites.pcert0
-symbolic/tiny-fib/tiny-rewrites.cert : | symbolic/tiny-fib/tiny-rewrites.pcert1
-
-symbolic/tiny-fib/tiny.pcert0 : no_pcert = 0
-symbolic/tiny-fib/tiny.pcert0 : acl2x = 0
-symbolic/tiny-fib/tiny.pcert0 : \
- symbolic/tiny-fib/defstobj+.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- data-structures/list-defthms.pcert0 \
- ihs/logops-lemmas.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- symbolic/tiny-fib/tiny.lisp
-symbolic/tiny-fib/tiny.pcert1 : acl2x = 0
-symbolic/tiny-fib/tiny.pcert1 : no_pcert = 0
-symbolic/tiny-fib/tiny.pcert1 : symbolic/tiny-fib/tiny.pcert0
-symbolic/tiny-fib/tiny.cert : | symbolic/tiny-fib/tiny.pcert1
-
-symbolic/tiny-triangle/tiny-triangle-correct.pcert0 : no_pcert = 0
-symbolic/tiny-triangle/tiny-triangle-correct.pcert0 : acl2x = 0
-symbolic/tiny-triangle/tiny-triangle-correct.pcert0 : \
- symbolic/tiny-fib/tiny-rewrites.pcert0 \
- ordinals/ordinals.pcert0 \
- symbolic/tiny-triangle/triangle-def.pcert0 \
- symbolic/generic/defsimulate.pcert0 \
- symbolic/tiny-triangle/tiny-triangle-correct.lisp
-symbolic/tiny-triangle/tiny-triangle-correct.pcert1 : acl2x = 0
-symbolic/tiny-triangle/tiny-triangle-correct.pcert1 : no_pcert = 0
-symbolic/tiny-triangle/tiny-triangle-correct.pcert1 : symbolic/tiny-triangle/tiny-triangle-correct.pcert0
-symbolic/tiny-triangle/tiny-triangle-correct.cert : | symbolic/tiny-triangle/tiny-triangle-correct.pcert1
-
-symbolic/tiny-triangle/triangle-def.pcert0 : no_pcert = 0
-symbolic/tiny-triangle/triangle-def.pcert0 : acl2x = 0
-symbolic/tiny-triangle/triangle-def.pcert0 : \
- symbolic/tiny-fib/tiny.pcert0 \
- symbolic/tiny-triangle/triangle-def.lisp
-symbolic/tiny-triangle/triangle-def.pcert1 : acl2x = 0
-symbolic/tiny-triangle/triangle-def.pcert1 : no_pcert = 0
-symbolic/tiny-triangle/triangle-def.pcert1 : symbolic/tiny-triangle/triangle-def.pcert0
-symbolic/tiny-triangle/triangle-def.cert : | symbolic/tiny-triangle/triangle-def.pcert1
-
-system/compare-out-files.pcert0 : no_pcert = 0
-system/compare-out-files.pcert0 : acl2x = 0
-system/compare-out-files.pcert0 : \
- system/compare-out-files.lisp
-system/compare-out-files.pcert1 : acl2x = 0
-system/compare-out-files.pcert1 : no_pcert = 0
-system/compare-out-files.pcert1 : system/compare-out-files.pcert0
-system/compare-out-files.cert : | system/compare-out-files.pcert1
-
-system/convert-normalized-term-to-pairs.pcert0 : no_pcert = 0
-system/convert-normalized-term-to-pairs.pcert0 : acl2x = 0
-system/convert-normalized-term-to-pairs.pcert0 : \
- system/convert-normalized-term-to-pairs.lisp
-system/convert-normalized-term-to-pairs.pcert1 : acl2x = 0
-system/convert-normalized-term-to-pairs.pcert1 : no_pcert = 0
-system/convert-normalized-term-to-pairs.pcert1 : system/convert-normalized-term-to-pairs.pcert0
-system/convert-normalized-term-to-pairs.cert : | system/convert-normalized-term-to-pairs.pcert1
-
-system/extend-pathname.pcert0 : no_pcert = 0
-system/extend-pathname.pcert0 : acl2x = 0
-system/extend-pathname.pcert0 : \
- system/extend-pathname.lisp
-system/extend-pathname.pcert1 : acl2x = 0
-system/extend-pathname.pcert1 : no_pcert = 0
-system/extend-pathname.pcert1 : system/extend-pathname.pcert0
-system/extend-pathname.cert : | system/extend-pathname.pcert1
-
-system/f-put-global.pcert0 : no_pcert = 0
-system/f-put-global.pcert0 : acl2x = 0
-system/f-put-global.pcert0 : \
- system/f-put-global.lisp
-system/f-put-global.pcert1 : acl2x = 0
-system/f-put-global.pcert1 : no_pcert = 0
-system/f-put-global.pcert1 : system/f-put-global.pcert0
-system/f-put-global.cert : | system/f-put-global.pcert1
-
-system/gather-dcls.pcert0 : no_pcert = 0
-system/gather-dcls.pcert0 : acl2x = 0
-system/gather-dcls.pcert0 : \
- system/gather-dcls.lisp
-system/gather-dcls.pcert1 : acl2x = 0
-system/gather-dcls.pcert1 : no_pcert = 0
-system/gather-dcls.pcert1 : system/gather-dcls.pcert0
-system/gather-dcls.cert : | system/gather-dcls.pcert1
-
-system/hl-addr-combine.pcert0 : no_pcert = 0
-system/hl-addr-combine.pcert0 : acl2x = 0
-system/hl-addr-combine.pcert0 : \
- arithmetic-5/top.pcert0 \
- system/hl-addr-combine.lisp
-system/hl-addr-combine.pcert1 : acl2x = 0
-system/hl-addr-combine.pcert1 : no_pcert = 0
-system/hl-addr-combine.pcert1 : system/hl-addr-combine.pcert0
-system/hl-addr-combine.cert : | system/hl-addr-combine.pcert1
-
-system/io.pcert0 : no_pcert = 0
-system/io.pcert0 : acl2x = 0
-system/io.pcert0 : \
- std/io/base.pcert0 \
- system/io.lisp
-system/io.pcert1 : acl2x = 0
-system/io.pcert1 : no_pcert = 0
-system/io.pcert1 : system/io.pcert0
-system/io.cert : | system/io.pcert1
-
-system/legal-variablep.pcert0 : no_pcert = 0
-system/legal-variablep.pcert0 : acl2x = 0
-system/legal-variablep.pcert0 : \
- system/legal-variablep.lisp
-system/legal-variablep.pcert1 : acl2x = 0
-system/legal-variablep.pcert1 : no_pcert = 0
-system/legal-variablep.pcert1 : system/legal-variablep.pcert0
-system/legal-variablep.cert : | system/legal-variablep.pcert1
-
-system/meta-extract.pcert0 : no_pcert = 0
-system/meta-extract.pcert0 : acl2x = 0
-system/meta-extract.pcert0 : \
- system/sublis-var.pcert0 \
- system/meta-extract.lisp
-system/meta-extract.pcert1 : acl2x = 0
-system/meta-extract.pcert1 : no_pcert = 0
-system/meta-extract.pcert1 : system/meta-extract.pcert0
-system/meta-extract.cert : | system/meta-extract.pcert1
-
-system/pseudo-good-worldp.pcert0 : no_pcert = 0
-system/pseudo-good-worldp.pcert0 : acl2x = 0
-system/pseudo-good-worldp.pcert0 : \
- system/pseudo-good-worldp.lisp
-system/pseudo-good-worldp.pcert1 : acl2x = 0
-system/pseudo-good-worldp.pcert1 : no_pcert = 0
-system/pseudo-good-worldp.pcert1 : system/pseudo-good-worldp.pcert0
-system/pseudo-good-worldp.cert : | system/pseudo-good-worldp.pcert1
-
-system/pseudo-termp-lemmas.pcert0 : no_pcert = 0
-system/pseudo-termp-lemmas.pcert0 : acl2x = 0
-system/pseudo-termp-lemmas.pcert0 : \
- system/pseudo-termp-lemmas.lisp
-system/pseudo-termp-lemmas.pcert1 : acl2x = 0
-system/pseudo-termp-lemmas.pcert1 : no_pcert = 0
-system/pseudo-termp-lemmas.pcert1 : system/pseudo-termp-lemmas.pcert0
-system/pseudo-termp-lemmas.cert : | system/pseudo-termp-lemmas.pcert1
-
-system/subcor-var.pcert0 : no_pcert = 0
-system/subcor-var.pcert0 : acl2x = 0
-system/subcor-var.pcert0 : \
- system/sublis-var.pcert0 \
- system/pseudo-termp-lemmas.pcert0 \
- system/subcor-var.lisp
-system/subcor-var.pcert1 : acl2x = 0
-system/subcor-var.pcert1 : no_pcert = 0
-system/subcor-var.pcert1 : system/subcor-var.pcert0
-system/subcor-var.cert : | system/subcor-var.pcert1
-
-system/sublis-var.pcert0 : no_pcert = 0
-system/sublis-var.pcert0 : acl2x = 0
-system/sublis-var.pcert0 : \
- system/sublis-var.lisp
-system/sublis-var.pcert1 : acl2x = 0
-system/sublis-var.pcert1 : no_pcert = 0
-system/sublis-var.pcert1 : system/sublis-var.pcert0
-system/sublis-var.cert : | system/sublis-var.pcert1
-
-system/subst-expr.pcert0 : no_pcert = 0
-system/subst-expr.pcert0 : acl2x = 0
-system/subst-expr.pcert0 : \
- system/sublis-var.pcert0 \
- system/pseudo-termp-lemmas.pcert0 \
- system/subst-var.pcert0 \
- system/subst-expr.lisp
-system/subst-expr.pcert1 : acl2x = 0
-system/subst-expr.pcert1 : no_pcert = 0
-system/subst-expr.pcert1 : system/subst-expr.pcert0
-system/subst-expr.cert : | system/subst-expr.pcert1
-
-system/subst-var.pcert0 : no_pcert = 0
-system/subst-var.pcert0 : acl2x = 0
-system/subst-var.pcert0 : \
- system/sublis-var.pcert0 \
- system/pseudo-termp-lemmas.pcert0 \
- system/subst-var.lisp
-system/subst-var.pcert1 : acl2x = 0
-system/subst-var.pcert1 : no_pcert = 0
-system/subst-var.pcert1 : system/subst-var.pcert0
-system/subst-var.cert : | system/subst-var.pcert1
-
-system/too-many-ifs.pcert0 : no_pcert = 0
-system/too-many-ifs.pcert0 : acl2x = 0
-system/too-many-ifs.pcert0 : \
- tools/flag.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- tools/flag.pcert0 \
- system/too-many-ifs.lisp \
- system/too-many-ifs.acl2
-system/too-many-ifs.pcert1 : acl2x = 0
-system/too-many-ifs.pcert1 : no_pcert = 0
-system/too-many-ifs.pcert1 : system/too-many-ifs.pcert0
-system/too-many-ifs.cert : | system/too-many-ifs.pcert1
-
-system/top.pcert0 : no_pcert = 0
-system/top.pcert0 : acl2x = 0
-system/top.pcert0 : \
- system/hl-addr-combine.pcert0 \
- system/extend-pathname.pcert0 \
- system/too-many-ifs.pcert0 \
- system/verified-termination-and-guards.pcert0 \
- system/sublis-var.pcert0 \
- system/subcor-var.pcert0 \
- system/subst-expr.pcert0 \
- system/convert-normalized-term-to-pairs.pcert0 \
- system/gather-dcls.pcert0 \
- system/meta-extract.pcert0 \
- system/legal-variablep.pcert0 \
- system/top.lisp
-system/top.pcert1 : acl2x = 0
-system/top.pcert1 : no_pcert = 0
-system/top.pcert1 : system/top.pcert0
-system/top.cert : | system/top.pcert1
-
-system/update-state.pcert0 : no_pcert = 0
-system/update-state.pcert0 : acl2x = 0
-system/update-state.pcert0 : \
- system/update-state.lisp
-system/update-state.pcert1 : acl2x = 0
-system/update-state.pcert1 : no_pcert = 0
-system/update-state.pcert1 : system/update-state.pcert0
-system/update-state.cert : | system/update-state.pcert1
-
-system/verified-termination-and-guards.pcert0 : no_pcert = 0
-system/verified-termination-and-guards.pcert0 : acl2x = 0
-system/verified-termination-and-guards.pcert0 : \
- system/verified-termination-and-guards.lisp
-system/verified-termination-and-guards.pcert1 : acl2x = 0
-system/verified-termination-and-guards.pcert1 : no_pcert = 0
-system/verified-termination-and-guards.pcert1 : system/verified-termination-and-guards.pcert0
-system/verified-termination-and-guards.cert : | system/verified-termination-and-guards.pcert1
-
-system/worldp-check.pcert0 : no_pcert = 0
-system/worldp-check.pcert0 : acl2x = 0
-system/worldp-check.pcert0 : \
- system/pseudo-good-worldp.pcert0 \
- system/worldp-check.lisp \
- system/worldp-check.acl2
-system/worldp-check.pcert1 : acl2x = 0
-system/worldp-check.pcert1 : no_pcert = 0
-system/worldp-check.pcert1 : system/worldp-check.pcert0
-system/worldp-check.cert : | system/worldp-check.pcert1
-
-taspi/code/brlens/brlens.pcert0 : no_pcert = 0
-taspi/code/brlens/brlens.pcert0 : acl2x = 0
-taspi/code/brlens/brlens.pcert0 : \
- taspi/code/gen-helper/extra.pcert0 \
- taspi/code/brlens/brlens.lisp
-taspi/code/brlens/brlens.pcert1 : acl2x = 0
-taspi/code/brlens/brlens.pcert1 : no_pcert = 0
-taspi/code/brlens/brlens.pcert1 : taspi/code/brlens/brlens.pcert0
-taspi/code/brlens/brlens.cert : | taspi/code/brlens/brlens.pcert1
-
-taspi/code/brlens/trees-with-brlens.pcert0 : no_pcert = 0
-taspi/code/brlens/trees-with-brlens.pcert0 : acl2x = 0
-taspi/code/brlens/trees-with-brlens.pcert0 : \
- taspi/code/brlens/brlens.pcert0 \
- taspi/code/gen-trees/tree-predicates.pcert0 \
- taspi/code/brlens/trees-with-brlens.lisp
-taspi/code/brlens/trees-with-brlens.pcert1 : acl2x = 0
-taspi/code/brlens/trees-with-brlens.pcert1 : no_pcert = 0
-taspi/code/brlens/trees-with-brlens.pcert1 : taspi/code/brlens/trees-with-brlens.pcert0
-taspi/code/brlens/trees-with-brlens.cert : | taspi/code/brlens/trees-with-brlens.pcert1
-
-taspi/code/build/build-term-guards.pcert0 : no_pcert = 0
-taspi/code/build/build-term-guards.pcert0 : acl2x = 0
-taspi/code/build/build-term-guards.pcert0 : \
- taspi/code/build/build-term.pcert0 \
- taspi/code/fringes/fringes-guards.pcert0 \
- taspi/code/build/build-term-guards.lisp
-taspi/code/build/build-term-guards.pcert1 : acl2x = 0
-taspi/code/build/build-term-guards.pcert1 : no_pcert = 0
-taspi/code/build/build-term-guards.pcert1 : taspi/code/build/build-term-guards.pcert0
-taspi/code/build/build-term-guards.cert : | taspi/code/build/build-term-guards.pcert1
-
-taspi/code/build/build-term.pcert0 : no_pcert = 0
-taspi/code/build/build-term.pcert0 : acl2x = 0
-taspi/code/build/build-term.pcert0 : \
- taspi/code/fringes/fringes.pcert0 \
- taspi/code/build/build-term.lisp
-taspi/code/build/build-term.pcert1 : acl2x = 0
-taspi/code/build/build-term.pcert1 : no_pcert = 0
-taspi/code/build/build-term.pcert1 : taspi/code/build/build-term.pcert0
-taspi/code/build/build-term.cert : | taspi/code/build/build-term.pcert1
-
-taspi/code/fringes/fringes-guards.pcert0 : no_pcert = 0
-taspi/code/fringes/fringes-guards.pcert0 : acl2x = 0
-taspi/code/fringes/fringes-guards.pcert0 : \
- taspi/code/fringes/fringes.pcert0 \
- taspi/code/replete/replete-guards.pcert0 \
- taspi/code/gen-trees/btrees-bdds-sets.pcert0 \
- taspi/code/gen-trees/app-rev-lists.pcert0 \
- taspi/code/fringes/fringes-guards.lisp
-taspi/code/fringes/fringes-guards.pcert1 : acl2x = 0
-taspi/code/fringes/fringes-guards.pcert1 : no_pcert = 0
-taspi/code/fringes/fringes-guards.pcert1 : taspi/code/fringes/fringes-guards.pcert0
-taspi/code/fringes/fringes-guards.cert : | taspi/code/fringes/fringes-guards.pcert1
-
-taspi/code/fringes/fringes-props.pcert0 : no_pcert = 0
-taspi/code/fringes/fringes-props.pcert0 : acl2x = 0
-taspi/code/fringes/fringes-props.pcert0 : \
- taspi/code/fringes/fringes-guards.pcert0 \
- taspi/code/fringes/fringes-props.lisp
-taspi/code/fringes/fringes-props.pcert1 : acl2x = 0
-taspi/code/fringes/fringes-props.pcert1 : no_pcert = 0
-taspi/code/fringes/fringes-props.pcert1 : taspi/code/fringes/fringes-props.pcert0
-taspi/code/fringes/fringes-props.cert : | taspi/code/fringes/fringes-props.pcert1
-
-taspi/code/fringes/fringes.pcert0 : no_pcert = 0
-taspi/code/fringes/fringes.pcert0 : acl2x = 0
-taspi/code/fringes/fringes.pcert0 : \
- taspi/code/gen-trees/sets-lists-trees.pcert0 \
- taspi/code/replete/replete.pcert0 \
- taspi/code/gen-trees/btrees-bdds.pcert0 \
- taspi/code/fringes/fringes.lisp
-taspi/code/fringes/fringes.pcert1 : acl2x = 0
-taspi/code/fringes/fringes.pcert1 : no_pcert = 0
-taspi/code/fringes/fringes.pcert1 : taspi/code/fringes/fringes.pcert0
-taspi/code/fringes/fringes.cert : | taspi/code/fringes/fringes.pcert1
-
-taspi/code/gen-helper/bdd-functions.pcert0 : no_pcert = 0
-taspi/code/gen-helper/bdd-functions.pcert0 : acl2x = 0
-taspi/code/gen-helper/bdd-functions.pcert0 : \
- taspi/code/gen-helper/sets.pcert0 \
- taspi/code/gen-helper/bdd-functions.lisp
-taspi/code/gen-helper/bdd-functions.pcert1 : acl2x = 0
-taspi/code/gen-helper/bdd-functions.pcert1 : no_pcert = 0
-taspi/code/gen-helper/bdd-functions.pcert1 : taspi/code/gen-helper/bdd-functions.pcert0
-taspi/code/gen-helper/bdd-functions.cert : | taspi/code/gen-helper/bdd-functions.pcert1
-
-taspi/code/gen-helper/extra.pcert0 : no_pcert = 0
-taspi/code/gen-helper/extra.pcert0 : acl2x = 0
-taspi/code/gen-helper/extra.pcert0 : \
- misc/hons-help2.pcert0 \
- taspi/code/gen-helper/extra.lisp
-taspi/code/gen-helper/extra.pcert1 : acl2x = 0
-taspi/code/gen-helper/extra.pcert1 : no_pcert = 0
-taspi/code/gen-helper/extra.pcert1 : taspi/code/gen-helper/extra.pcert0
-taspi/code/gen-helper/extra.cert : | taspi/code/gen-helper/extra.pcert1
-
-taspi/code/gen-helper/fast-lists.pcert0 : no_pcert = 0
-taspi/code/gen-helper/fast-lists.pcert0 : acl2x = 0
-taspi/code/gen-helper/fast-lists.pcert0 : \
- taspi/code/gen-helper/extra.pcert0 \
- taspi/code/gen-helper/fast-lists.lisp
-taspi/code/gen-helper/fast-lists.pcert1 : acl2x = 0
-taspi/code/gen-helper/fast-lists.pcert1 : no_pcert = 0
-taspi/code/gen-helper/fast-lists.pcert1 : taspi/code/gen-helper/fast-lists.pcert0
-taspi/code/gen-helper/fast-lists.cert : | taspi/code/gen-helper/fast-lists.pcert1
-
-taspi/code/gen-helper/sets.pcert0 : no_pcert = 0
-taspi/code/gen-helper/sets.pcert0 : acl2x = 0
-taspi/code/gen-helper/sets.pcert0 : \
- taspi/code/gen-helper/extra.pcert0 \
- taspi/code/gen-helper/sets.lisp
-taspi/code/gen-helper/sets.pcert1 : acl2x = 0
-taspi/code/gen-helper/sets.pcert1 : no_pcert = 0
-taspi/code/gen-helper/sets.pcert1 : taspi/code/gen-helper/sets.pcert0
-taspi/code/gen-helper/sets.cert : | taspi/code/gen-helper/sets.pcert1
-
-taspi/code/gen-helper/top.pcert0 : no_pcert = 0
-taspi/code/gen-helper/top.pcert0 : acl2x = 0
-taspi/code/gen-helper/top.pcert0 : \
- taspi/code/gen-helper/sets.pcert0 \
- taspi/code/gen-helper/fast-lists.pcert0 \
- taspi/code/gen-helper/bdd-functions.pcert0 \
- taspi/code/gen-helper/top.lisp
-taspi/code/gen-helper/top.pcert1 : acl2x = 0
-taspi/code/gen-helper/top.pcert1 : no_pcert = 0
-taspi/code/gen-helper/top.pcert1 : taspi/code/gen-helper/top.pcert0
-taspi/code/gen-helper/top.cert : | taspi/code/gen-helper/top.pcert1
-
-taspi/code/gen-trees/app-rev-lists.pcert0 : no_pcert = 0
-taspi/code/gen-trees/app-rev-lists.pcert0 : acl2x = 0
-taspi/code/gen-trees/app-rev-lists.pcert0 : \
- taspi/code/gen-trees/sets-lists-trees.pcert0 \
- taspi/code/gen-trees/app-rev-lists.lisp
-taspi/code/gen-trees/app-rev-lists.pcert1 : acl2x = 0
-taspi/code/gen-trees/app-rev-lists.pcert1 : no_pcert = 0
-taspi/code/gen-trees/app-rev-lists.pcert1 : taspi/code/gen-trees/app-rev-lists.pcert0
-taspi/code/gen-trees/app-rev-lists.cert : | taspi/code/gen-trees/app-rev-lists.pcert1
-
-taspi/code/gen-trees/btrees-bdds-sets.pcert0 : no_pcert = 0
-taspi/code/gen-trees/btrees-bdds-sets.pcert0 : acl2x = 0
-taspi/code/gen-trees/btrees-bdds-sets.pcert0 : \
- taspi/code/gen-trees/btrees-bdds.pcert0 \
- taspi/code/gen-trees/sets-lists-trees.pcert0 \
- taspi/code/gen-trees/btrees-bdds-sets.lisp
-taspi/code/gen-trees/btrees-bdds-sets.pcert1 : acl2x = 0
-taspi/code/gen-trees/btrees-bdds-sets.pcert1 : no_pcert = 0
-taspi/code/gen-trees/btrees-bdds-sets.pcert1 : taspi/code/gen-trees/btrees-bdds-sets.pcert0
-taspi/code/gen-trees/btrees-bdds-sets.cert : | taspi/code/gen-trees/btrees-bdds-sets.pcert1
-
-taspi/code/gen-trees/btrees-bdds.pcert0 : no_pcert = 0
-taspi/code/gen-trees/btrees-bdds.pcert0 : acl2x = 0
-taspi/code/gen-trees/btrees-bdds.pcert0 : \
- taspi/code/gen-helper/extra.pcert0 \
- taspi/code/gen-trees/btrees.pcert0 \
- taspi/code/gen-helper/bdd-functions.pcert0 \
- taspi/code/gen-trees/btrees-bdds.lisp
-taspi/code/gen-trees/btrees-bdds.pcert1 : acl2x = 0
-taspi/code/gen-trees/btrees-bdds.pcert1 : no_pcert = 0
-taspi/code/gen-trees/btrees-bdds.pcert1 : taspi/code/gen-trees/btrees-bdds.pcert0
-taspi/code/gen-trees/btrees-bdds.cert : | taspi/code/gen-trees/btrees-bdds.pcert1
-
-taspi/code/gen-trees/btrees.pcert0 : no_pcert = 0
-taspi/code/gen-trees/btrees.pcert0 : acl2x = 0
-taspi/code/gen-trees/btrees.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- taspi/code/gen-helper/fast-lists.pcert0 \
- taspi/code/gen-trees/btrees.lisp
-taspi/code/gen-trees/btrees.pcert1 : acl2x = 0
-taspi/code/gen-trees/btrees.pcert1 : no_pcert = 0
-taspi/code/gen-trees/btrees.pcert1 : taspi/code/gen-trees/btrees.pcert0
-taspi/code/gen-trees/btrees.cert : | taspi/code/gen-trees/btrees.pcert1
-
-taspi/code/gen-trees/sets-lists-trees.pcert0 : no_pcert = 0
-taspi/code/gen-trees/sets-lists-trees.pcert0 : acl2x = 0
-taspi/code/gen-trees/sets-lists-trees.pcert0 : \
- taspi/code/gen-helper/sets.pcert0 \
- taspi/code/gen-helper/fast-lists.pcert0 \
- taspi/code/gen-trees/tree-predicates.pcert0 \
- taspi/code/gen-trees/sets-lists-trees.lisp
-taspi/code/gen-trees/sets-lists-trees.pcert1 : acl2x = 0
-taspi/code/gen-trees/sets-lists-trees.pcert1 : no_pcert = 0
-taspi/code/gen-trees/sets-lists-trees.pcert1 : taspi/code/gen-trees/sets-lists-trees.pcert0
-taspi/code/gen-trees/sets-lists-trees.cert : | taspi/code/gen-trees/sets-lists-trees.pcert1
-
-taspi/code/gen-trees/top.pcert0 : no_pcert = 0
-taspi/code/gen-trees/top.pcert0 : acl2x = 0
-taspi/code/gen-trees/top.pcert0 : \
- taspi/code/gen-trees/btrees-bdds-sets.pcert0 \
- taspi/code/gen-trees/app-rev-lists.pcert0 \
- taspi/code/gen-trees/sets-lists-trees.pcert0 \
- taspi/code/gen-trees/tree-predicates.pcert0 \
- taspi/code/gen-trees/top.lisp
-taspi/code/gen-trees/top.pcert1 : acl2x = 0
-taspi/code/gen-trees/top.pcert1 : no_pcert = 0
-taspi/code/gen-trees/top.pcert1 : taspi/code/gen-trees/top.pcert0
-taspi/code/gen-trees/top.cert : | taspi/code/gen-trees/top.pcert1
-
-taspi/code/gen-trees/tree-predicates.pcert0 : no_pcert = 0
-taspi/code/gen-trees/tree-predicates.pcert0 : acl2x = 0
-taspi/code/gen-trees/tree-predicates.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- taspi/code/gen-helper/extra.pcert0 \
- taspi/code/gen-trees/tree-predicates.lisp
-taspi/code/gen-trees/tree-predicates.pcert1 : acl2x = 0
-taspi/code/gen-trees/tree-predicates.pcert1 : no_pcert = 0
-taspi/code/gen-trees/tree-predicates.pcert1 : taspi/code/gen-trees/tree-predicates.pcert0
-taspi/code/gen-trees/tree-predicates.cert : | taspi/code/gen-trees/tree-predicates.pcert1
-
-taspi/code/replete/replete-guards.pcert0 : no_pcert = 0
-taspi/code/replete/replete-guards.pcert0 : acl2x = 0
-taspi/code/replete/replete-guards.pcert0 : \
- taspi/code/replete/replete.pcert0 \
- taspi/code/brlens/trees-with-brlens.pcert0 \
- taspi/code/replete/replete-guards.lisp
-taspi/code/replete/replete-guards.pcert1 : acl2x = 0
-taspi/code/replete/replete-guards.pcert1 : no_pcert = 0
-taspi/code/replete/replete-guards.pcert1 : taspi/code/replete/replete-guards.pcert0
-taspi/code/replete/replete-guards.cert : | taspi/code/replete/replete-guards.pcert1
-
-taspi/code/replete/replete-helper.pcert0 : no_pcert = 0
-taspi/code/replete/replete-helper.pcert0 : acl2x = 0
-taspi/code/replete/replete-helper.pcert0 : \
- taspi/code/gen-trees/sets-lists-trees.pcert0 \
- taspi/code/replete/replete-helper.lisp
-taspi/code/replete/replete-helper.pcert1 : acl2x = 0
-taspi/code/replete/replete-helper.pcert1 : no_pcert = 0
-taspi/code/replete/replete-helper.pcert1 : taspi/code/replete/replete-helper.pcert0
-taspi/code/replete/replete-helper.cert : | taspi/code/replete/replete-helper.pcert1
-
-taspi/code/replete/replete.pcert0 : no_pcert = 0
-taspi/code/replete/replete.pcert0 : acl2x = 0
-taspi/code/replete/replete.pcert0 : \
- taspi/code/replete/replete-helper.pcert0 \
- taspi/code/replete/replete.lisp
-taspi/code/replete/replete.pcert1 : acl2x = 0
-taspi/code/replete/replete.pcert1 : no_pcert = 0
-taspi/code/replete/replete.pcert1 : taspi/code/replete/replete.pcert0
-taspi/code/replete/replete.cert : | taspi/code/replete/replete.pcert1
-
-taspi/code/sequences/align.pcert0 : no_pcert = 0
-taspi/code/sequences/align.pcert0 : acl2x = 0
-taspi/code/sequences/align.pcert0 : \
- taspi/code/gen-helper/extra.pcert0 \
- taspi/code/sequences/align.lisp
-taspi/code/sequences/align.pcert1 : acl2x = 0
-taspi/code/sequences/align.pcert1 : no_pcert = 0
-taspi/code/sequences/align.pcert1 : taspi/code/sequences/align.pcert0
-taspi/code/sequences/align.cert : | taspi/code/sequences/align.pcert1
-
-taspi/code/sequences/p-inform.pcert0 : no_pcert = 0
-taspi/code/sequences/p-inform.pcert0 : acl2x = 0
-taspi/code/sequences/p-inform.pcert0 : \
- taspi/code/sequences/seqs.pcert0 \
- taspi/code/sequences/p-inform.lisp
-taspi/code/sequences/p-inform.pcert1 : acl2x = 0
-taspi/code/sequences/p-inform.pcert1 : no_pcert = 0
-taspi/code/sequences/p-inform.pcert1 : taspi/code/sequences/p-inform.pcert0
-taspi/code/sequences/p-inform.cert : | taspi/code/sequences/p-inform.pcert1
-
-taspi/code/sequences/seqs.pcert0 : no_pcert = 0
-taspi/code/sequences/seqs.pcert0 : acl2x = 0
-taspi/code/sequences/seqs.pcert0 : \
- misc/hons-help2.pcert0 \
- taspi/code/gen-trees/top.pcert0 \
- taspi/code/sequences/seqs.lisp
-taspi/code/sequences/seqs.pcert1 : acl2x = 0
-taspi/code/sequences/seqs.pcert1 : no_pcert = 0
-taspi/code/sequences/seqs.pcert1 : taspi/code/sequences/seqs.pcert0
-taspi/code/sequences/seqs.cert : | taspi/code/sequences/seqs.pcert1
-
-taspi/code/tree-manip/insertion-based-sort.pcert0 : no_pcert = 0
-taspi/code/tree-manip/insertion-based-sort.pcert0 : acl2x = 0
-taspi/code/tree-manip/insertion-based-sort.pcert0 : \
- taspi/code/tree-manip/sort-help.pcert0 \
- taspi/code/tree-manip/insertion-based-sort.lisp
-taspi/code/tree-manip/insertion-based-sort.pcert1 : acl2x = 0
-taspi/code/tree-manip/insertion-based-sort.pcert1 : no_pcert = 0
-taspi/code/tree-manip/insertion-based-sort.pcert1 : taspi/code/tree-manip/insertion-based-sort.pcert0
-taspi/code/tree-manip/insertion-based-sort.cert : | taspi/code/tree-manip/insertion-based-sort.pcert1
-
-taspi/code/tree-manip/merge-based-sort.pcert0 : no_pcert = 0
-taspi/code/tree-manip/merge-based-sort.pcert0 : acl2x = 0
-taspi/code/tree-manip/merge-based-sort.pcert0 : \
- taspi/code/tree-manip/sort-help.pcert0 \
- taspi/code/tree-manip/merge-based-sort.lisp
-taspi/code/tree-manip/merge-based-sort.pcert1 : acl2x = 0
-taspi/code/tree-manip/merge-based-sort.pcert1 : no_pcert = 0
-taspi/code/tree-manip/merge-based-sort.pcert1 : taspi/code/tree-manip/merge-based-sort.pcert0
-taspi/code/tree-manip/merge-based-sort.cert : | taspi/code/tree-manip/merge-based-sort.pcert1
-
-taspi/code/tree-manip/mv-root.pcert0 : no_pcert = 0
-taspi/code/tree-manip/mv-root.pcert0 : acl2x = 0
-taspi/code/tree-manip/mv-root.pcert0 : \
- taspi/code/build/build-term-guards.pcert0 \
- taspi/code/tree-manip/mv-root.lisp
-taspi/code/tree-manip/mv-root.pcert1 : acl2x = 0
-taspi/code/tree-manip/mv-root.pcert1 : no_pcert = 0
-taspi/code/tree-manip/mv-root.pcert1 : taspi/code/tree-manip/mv-root.pcert0
-taspi/code/tree-manip/mv-root.cert : | taspi/code/tree-manip/mv-root.pcert1
-
-taspi/code/tree-manip/quicksort.pcert0 : no_pcert = 0
-taspi/code/tree-manip/quicksort.pcert0 : acl2x = 0
-taspi/code/tree-manip/quicksort.pcert0 : \
- taspi/code/tree-manip/quicksort.lisp
-taspi/code/tree-manip/quicksort.pcert1 : acl2x = 0
-taspi/code/tree-manip/quicksort.pcert1 : no_pcert = 0
-taspi/code/tree-manip/quicksort.pcert1 : taspi/code/tree-manip/quicksort.pcert0
-taspi/code/tree-manip/quicksort.cert : | taspi/code/tree-manip/quicksort.pcert1
-
-taspi/code/tree-manip/sort-help.pcert0 : no_pcert = 0
-taspi/code/tree-manip/sort-help.pcert0 : acl2x = 0
-taspi/code/tree-manip/sort-help.pcert0 : \
- taspi/code/gen-trees/sets-lists-trees.pcert0 \
- taspi/code/tree-manip/sort-help.lisp
-taspi/code/tree-manip/sort-help.pcert1 : acl2x = 0
-taspi/code/tree-manip/sort-help.pcert1 : no_pcert = 0
-taspi/code/tree-manip/sort-help.pcert1 : taspi/code/tree-manip/sort-help.pcert0
-taspi/code/tree-manip/sort-help.cert : | taspi/code/tree-manip/sort-help.pcert1
-
-taspi/code/tree-manip/top.pcert0 : no_pcert = 0
-taspi/code/tree-manip/top.pcert0 : acl2x = 0
-taspi/code/tree-manip/top.pcert0 : \
- taspi/code/tree-manip/mv-root.pcert0 \
- taspi/code/tree-manip/merge-based-sort.pcert0 \
- taspi/code/tree-manip/insertion-based-sort.pcert0 \
- taspi/code/tree-manip/top.lisp
-taspi/code/tree-manip/top.pcert1 : acl2x = 0
-taspi/code/tree-manip/top.pcert1 : no_pcert = 0
-taspi/code/tree-manip/top.pcert1 : taspi/code/tree-manip/top.pcert0
-taspi/code/tree-manip/top.cert : | taspi/code/tree-manip/top.pcert1
-
-taspi/database/db-from-list.pcert0 : no_pcert = 0
-taspi/database/db-from-list.pcert0 : acl2x = 0
-taspi/database/db-from-list.pcert0 : \
- taspi/database/db-from-list.lisp
-taspi/database/db-from-list.pcert1 : acl2x = 0
-taspi/database/db-from-list.pcert1 : no_pcert = 0
-taspi/database/db-from-list.pcert1 : taspi/database/db-from-list.pcert0
-taspi/database/db-from-list.cert : | taspi/database/db-from-list.pcert1
-
-taspi/database/db.pcert0 : no_pcert = 0
-taspi/database/db.pcert0 : acl2x = 0
-taspi/database/db.pcert0 : \
- taspi/database/entry.pcert0 \
- taspi/code/tree-manip/top.pcert0 \
- taspi/database/db.lisp
-taspi/database/db.pcert1 : acl2x = 0
-taspi/database/db.pcert1 : no_pcert = 0
-taspi/database/db.pcert1 : taspi/database/db.pcert0
-taspi/database/db.cert : | taspi/database/db.pcert1
-
-taspi/database/entry.pcert0 : no_pcert = 0
-taspi/database/entry.pcert0 : acl2x = 0
-taspi/database/entry.pcert0 : \
- taspi/database/props.pcert0 \
- taspi/database/entry.lisp
-taspi/database/entry.pcert1 : acl2x = 0
-taspi/database/entry.pcert1 : no_pcert = 0
-taspi/database/entry.pcert1 : taspi/database/entry.pcert0
-taspi/database/entry.cert : | taspi/database/entry.pcert1
-
-taspi/database/filters.pcert0 : no_pcert = 0
-taspi/database/filters.pcert0 : acl2x = 0
-taspi/database/filters.pcert0 : \
- taspi/database/db.pcert0 \
- taspi/database/filters.lisp
-taspi/database/filters.pcert1 : acl2x = 0
-taspi/database/filters.pcert1 : no_pcert = 0
-taspi/database/filters.pcert1 : taspi/database/filters.pcert0
-taspi/database/filters.cert : | taspi/database/filters.pcert1
-
-taspi/database/props.pcert0 : no_pcert = 0
-taspi/database/props.pcert0 : acl2x = 0
-taspi/database/props.pcert0 : \
- misc/hons-help2.pcert0 \
- taspi/code/gen-trees/sets-lists-trees.pcert0 \
- taspi/code/gen-trees/app-rev-lists.pcert0 \
- taspi/code/tree-manip/sort-help.pcert0 \
- taspi/database/props.lisp
-taspi/database/props.pcert1 : acl2x = 0
-taspi/database/props.pcert1 : no_pcert = 0
-taspi/database/props.pcert1 : taspi/database/props.pcert0
-taspi/database/props.cert : | taspi/database/props.pcert1
-
-taspi/proofs/fringes-taspi.pcert0 : no_pcert = 0
-taspi/proofs/fringes-taspi.pcert0 : acl2x = 0
-taspi/proofs/fringes-taspi.pcert0 : \
- taspi/proofs/omerge-good-order.pcert0 \
- taspi/proofs/fringes-taspi.lisp \
- taspi/proofs/fringes-taspi.acl2
-taspi/proofs/fringes-taspi.pcert1 : acl2x = 0
-taspi/proofs/fringes-taspi.pcert1 : no_pcert = 0
-taspi/proofs/fringes-taspi.pcert1 : taspi/proofs/fringes-taspi.pcert0
-taspi/proofs/fringes-taspi.cert : | taspi/proofs/fringes-taspi.pcert1
-
-taspi/proofs/omerge-good-order.pcert0 : no_pcert = 0
-taspi/proofs/omerge-good-order.pcert0 : acl2x = 0
-taspi/proofs/omerge-good-order.pcert0 : \
- taspi/proofs/sets.pcert0 \
- taspi/proofs/omerge-good-order.lisp \
- taspi/proofs/omerge-good-order.acl2
-taspi/proofs/omerge-good-order.pcert1 : acl2x = 0
-taspi/proofs/omerge-good-order.pcert1 : no_pcert = 0
-taspi/proofs/omerge-good-order.pcert1 : taspi/proofs/omerge-good-order.pcert0
-taspi/proofs/omerge-good-order.cert : | taspi/proofs/omerge-good-order.pcert1
-
-taspi/proofs/sets.pcert0 : no_pcert = 0
-taspi/proofs/sets.pcert0 : acl2x = 0
-taspi/proofs/sets.pcert0 : \
- taspi/proofs/sets.lisp \
- taspi/proofs/sets.acl2
-taspi/proofs/sets.pcert1 : acl2x = 0
-taspi/proofs/sets.pcert1 : no_pcert = 0
-taspi/proofs/sets.pcert1 : taspi/proofs/sets.pcert0
-taspi/proofs/sets.cert : | taspi/proofs/sets.pcert1
-
-taspi/sets-input/consensus.pcert0 : no_pcert = 0
-taspi/sets-input/consensus.pcert0 : acl2x = 0
-taspi/sets-input/consensus.pcert0 : \
- taspi/code/build/build-term-guards.pcert0 \
- taspi/code/gen-trees/btrees-bdds.pcert0 \
- taspi/sets-input/consensus.lisp
-taspi/sets-input/consensus.pcert1 : acl2x = 0
-taspi/sets-input/consensus.pcert1 : no_pcert = 0
-taspi/sets-input/consensus.pcert1 : taspi/sets-input/consensus.pcert0
-taspi/sets-input/consensus.cert : | taspi/sets-input/consensus.pcert1
-
-taspi/sets-input/greedy.pcert0 : no_pcert = 0
-taspi/sets-input/greedy.pcert0 : acl2x = 0
-taspi/sets-input/greedy.pcert0 : \
- taspi/sets-input/consensus.pcert0 \
- taspi/sets-input/greedy.lisp
-taspi/sets-input/greedy.pcert1 : acl2x = 0
-taspi/sets-input/greedy.pcert1 : no_pcert = 0
-taspi/sets-input/greedy.pcert1 : taspi/sets-input/greedy.pcert0
-taspi/sets-input/greedy.cert : | taspi/sets-input/greedy.pcert1
-
-taspi/sets-input/mast.pcert0 : no_pcert = 0
-taspi/sets-input/mast.pcert0 : acl2x = 0
-taspi/sets-input/mast.pcert0 : \
- taspi/single-input/taxa-based.pcert0 \
- taspi/sets-input/mast.lisp
-taspi/sets-input/mast.pcert1 : acl2x = 0
-taspi/sets-input/mast.pcert1 : no_pcert = 0
-taspi/sets-input/mast.pcert1 : taspi/sets-input/mast.pcert0
-taspi/sets-input/mast.cert : | taspi/sets-input/mast.pcert1
-
-taspi/sets-input/mct.pcert0 : no_pcert = 0
-taspi/sets-input/mct.pcert0 : acl2x = 0
-taspi/sets-input/mct.pcert0 : \
- taspi/sets-input/mast.pcert0 \
- taspi/code/build/build-term-guards.pcert0 \
- taspi/sets-input/mct.lisp
-taspi/sets-input/mct.pcert1 : acl2x = 0
-taspi/sets-input/mct.pcert1 : no_pcert = 0
-taspi/sets-input/mct.pcert1 : taspi/sets-input/mct.pcert0
-taspi/sets-input/mct.cert : | taspi/sets-input/mct.pcert1
-
-taspi/sets-input/multipolar-loose.pcert0 : no_pcert = 0
-taspi/sets-input/multipolar-loose.pcert0 : acl2x = 0
-taspi/sets-input/multipolar-loose.pcert0 : \
- taspi/sets-input/consensus.pcert0 \
- taspi/sets-input/multipolar-loose.lisp
-taspi/sets-input/multipolar-loose.pcert1 : acl2x = 0
-taspi/sets-input/multipolar-loose.pcert1 : no_pcert = 0
-taspi/sets-input/multipolar-loose.pcert1 : taspi/sets-input/multipolar-loose.pcert0
-taspi/sets-input/multipolar-loose.cert : | taspi/sets-input/multipolar-loose.pcert1
-
-taspi/sets-input/top.pcert0 : no_pcert = 0
-taspi/sets-input/top.pcert0 : acl2x = 0
-taspi/sets-input/top.pcert0 : \
- taspi/sets-input/consensus.pcert0 \
- taspi/sets-input/tree-compat.pcert0 \
- taspi/sets-input/tree-support-in-set.pcert0 \
- taspi/sets-input/mast.pcert0 \
- taspi/sets-input/multipolar-loose.pcert0 \
- taspi/sets-input/greedy.pcert0 \
- taspi/sets-input/mct.pcert0 \
- taspi/sets-input/top.lisp
-taspi/sets-input/top.pcert1 : acl2x = 0
-taspi/sets-input/top.pcert1 : no_pcert = 0
-taspi/sets-input/top.pcert1 : taspi/sets-input/top.pcert0
-taspi/sets-input/top.cert : | taspi/sets-input/top.pcert1
-
-taspi/sets-input/tree-compat.pcert0 : no_pcert = 0
-taspi/sets-input/tree-compat.pcert0 : acl2x = 0
-taspi/sets-input/tree-compat.pcert0 : \
- taspi/code/build/build-term-guards.pcert0 \
- taspi/code/gen-trees/btrees-bdds.pcert0 \
- taspi/code/fringes/fringes-props.pcert0 \
- taspi/sets-input/tree-compat.lisp
-taspi/sets-input/tree-compat.pcert1 : acl2x = 0
-taspi/sets-input/tree-compat.pcert1 : no_pcert = 0
-taspi/sets-input/tree-compat.pcert1 : taspi/sets-input/tree-compat.pcert0
-taspi/sets-input/tree-compat.cert : | taspi/sets-input/tree-compat.pcert1
-
-taspi/sets-input/tree-support-in-set.pcert0 : no_pcert = 0
-taspi/sets-input/tree-support-in-set.pcert0 : acl2x = 0
-taspi/sets-input/tree-support-in-set.pcert0 : \
- taspi/code/build/build-term-guards.pcert0 \
- taspi/sets-input/tree-support-in-set.lisp
-taspi/sets-input/tree-support-in-set.pcert1 : acl2x = 0
-taspi/sets-input/tree-support-in-set.pcert1 : no_pcert = 0
-taspi/sets-input/tree-support-in-set.pcert1 : taspi/sets-input/tree-support-in-set.pcert0
-taspi/sets-input/tree-support-in-set.cert : | taspi/sets-input/tree-support-in-set.pcert1
-
-taspi/single-input/taxa-based.pcert0 : no_pcert = 0
-taspi/single-input/taxa-based.pcert0 : acl2x = 0
-taspi/single-input/taxa-based.pcert0 : \
- taspi/code/fringes/fringes-guards.pcert0 \
- taspi/code/tree-manip/merge-based-sort.pcert0 \
- taspi/code/tree-manip/mv-root.pcert0 \
- taspi/single-input/taxa-based.lisp
-taspi/single-input/taxa-based.pcert1 : acl2x = 0
-taspi/single-input/taxa-based.pcert1 : no_pcert = 0
-taspi/single-input/taxa-based.pcert1 : taspi/single-input/taxa-based.pcert0
-taspi/single-input/taxa-based.cert : | taspi/single-input/taxa-based.pcert1
-
-taspi/single-input/tree-stats.pcert0 : no_pcert = 0
-taspi/single-input/tree-stats.pcert0 : acl2x = 0
-taspi/single-input/tree-stats.pcert0 : \
- taspi/code/gen-trees/sets-lists-trees.pcert0 \
- taspi/single-input/taxa-based.pcert0 \
- taspi/single-input/tree-stats.lisp
-taspi/single-input/tree-stats.pcert1 : acl2x = 0
-taspi/single-input/tree-stats.pcert1 : no_pcert = 0
-taspi/single-input/tree-stats.pcert1 : taspi/single-input/tree-stats.pcert0
-taspi/single-input/tree-stats.cert : | taspi/single-input/tree-stats.pcert1
-
-taspi/tree-distance/rf.pcert0 : no_pcert = 0
-taspi/tree-distance/rf.pcert0 : acl2x = 0
-taspi/tree-distance/rf.pcert0 : \
- taspi/code/fringes/fringes-guards.pcert0 \
- taspi/database/props.pcert0 \
- taspi/tree-distance/rf.lisp
-taspi/tree-distance/rf.pcert1 : acl2x = 0
-taspi/tree-distance/rf.pcert1 : no_pcert = 0
-taspi/tree-distance/rf.pcert1 : taspi/tree-distance/rf.pcert0
-taspi/tree-distance/rf.cert : | taspi/tree-distance/rf.pcert1
-
-taspi/tree-distance/symm-diff.pcert0 : no_pcert = 0
-taspi/tree-distance/symm-diff.pcert0 : acl2x = 0
-taspi/tree-distance/symm-diff.pcert0 : \
- taspi/code/fringes/fringes-guards.pcert0 \
- taspi/database/props.pcert0 \
- taspi/tree-distance/symm-diff.lisp
-taspi/tree-distance/symm-diff.pcert1 : acl2x = 0
-taspi/tree-distance/symm-diff.pcert1 : no_pcert = 0
-taspi/tree-distance/symm-diff.pcert1 : taspi/tree-distance/symm-diff.pcert0
-taspi/tree-distance/symm-diff.cert : | taspi/tree-distance/symm-diff.pcert1
-
-taspi/tree-generation/branch-and-bound/bandb.pcert0 : no_pcert = 0
-taspi/tree-generation/branch-and-bound/bandb.pcert0 : acl2x = 0
-taspi/tree-generation/branch-and-bound/bandb.pcert0 : \
- taspi/tree-generation/tree-gen-helper/basics.pcert0 \
- taspi/code/tree-manip/top.pcert0 \
- taspi/tree-generation/branch-and-bound/bandb.lisp
-taspi/tree-generation/branch-and-bound/bandb.pcert1 : acl2x = 0
-taspi/tree-generation/branch-and-bound/bandb.pcert1 : no_pcert = 0
-taspi/tree-generation/branch-and-bound/bandb.pcert1 : taspi/tree-generation/branch-and-bound/bandb.pcert0
-taspi/tree-generation/branch-and-bound/bandb.cert : | taspi/tree-generation/branch-and-bound/bandb.pcert1
-
-taspi/tree-generation/distance-based/naive-quartet-method.pcert0 : no_pcert = 0
-taspi/tree-generation/distance-based/naive-quartet-method.pcert0 : acl2x = 0
-taspi/tree-generation/distance-based/naive-quartet-method.pcert0 : \
- taspi/tree-generation/distance-based/naive-quartet-method.lisp
-taspi/tree-generation/distance-based/naive-quartet-method.pcert1 : acl2x = 0
-taspi/tree-generation/distance-based/naive-quartet-method.pcert1 : no_pcert = 0
-taspi/tree-generation/distance-based/naive-quartet-method.pcert1 : taspi/tree-generation/distance-based/naive-quartet-method.pcert0
-taspi/tree-generation/distance-based/naive-quartet-method.cert : | taspi/tree-generation/distance-based/naive-quartet-method.pcert1
-
-taspi/tree-generation/heuristics/do-search.pcert0 : no_pcert = 0
-taspi/tree-generation/heuristics/do-search.pcert0 : acl2x = 0
-taspi/tree-generation/heuristics/do-search.pcert0 : \
- taspi/tree-generation/heuristics/tbr.pcert0 \
- taspi/tree-generation/heuristics/do-search.lisp
-taspi/tree-generation/heuristics/do-search.pcert1 : acl2x = 0
-taspi/tree-generation/heuristics/do-search.pcert1 : no_pcert = 0
-taspi/tree-generation/heuristics/do-search.pcert1 : taspi/tree-generation/heuristics/do-search.pcert0
-taspi/tree-generation/heuristics/do-search.cert : | taspi/tree-generation/heuristics/do-search.pcert1
-
-taspi/tree-generation/heuristics/spr.pcert0 : no_pcert = 0
-taspi/tree-generation/heuristics/spr.pcert0 : acl2x = 0
-taspi/tree-generation/heuristics/spr.pcert0 : \
- taspi/tree-generation/tree-gen-helper/basics.pcert0 \
- taspi/code/tree-manip/top.pcert0 \
- taspi/tree-generation/heuristics/spr.lisp
-taspi/tree-generation/heuristics/spr.pcert1 : acl2x = 0
-taspi/tree-generation/heuristics/spr.pcert1 : no_pcert = 0
-taspi/tree-generation/heuristics/spr.pcert1 : taspi/tree-generation/heuristics/spr.pcert0
-taspi/tree-generation/heuristics/spr.cert : | taspi/tree-generation/heuristics/spr.pcert1
-
-taspi/tree-generation/heuristics/tbr.pcert0 : no_pcert = 0
-taspi/tree-generation/heuristics/tbr.pcert0 : acl2x = 0
-taspi/tree-generation/heuristics/tbr.pcert0 : \
- taspi/tree-generation/heuristics/spr.pcert0 \
- taspi/tree-generation/heuristics/tbr.lisp
-taspi/tree-generation/heuristics/tbr.pcert1 : acl2x = 0
-taspi/tree-generation/heuristics/tbr.pcert1 : no_pcert = 0
-taspi/tree-generation/heuristics/tbr.pcert1 : taspi/tree-generation/heuristics/tbr.pcert0
-taspi/tree-generation/heuristics/tbr.cert : | taspi/tree-generation/heuristics/tbr.pcert1
-
-taspi/tree-generation/tree-gen-helper/basics.pcert0 : no_pcert = 0
-taspi/tree-generation/tree-gen-helper/basics.pcert0 : acl2x = 0
-taspi/tree-generation/tree-gen-helper/basics.pcert0 : \
- taspi/code/build/build-term-guards.pcert0 \
- taspi/tree-score/pscores.pcert0 \
- taspi/tree-generation/tree-gen-helper/basics.lisp
-taspi/tree-generation/tree-gen-helper/basics.pcert1 : acl2x = 0
-taspi/tree-generation/tree-gen-helper/basics.pcert1 : no_pcert = 0
-taspi/tree-generation/tree-gen-helper/basics.pcert1 : taspi/tree-generation/tree-gen-helper/basics.pcert0
-taspi/tree-generation/tree-gen-helper/basics.cert : | taspi/tree-generation/tree-gen-helper/basics.pcert1
-
-taspi/tree-score/ambig-score.pcert0 : no_pcert = 0
-taspi/tree-score/ambig-score.pcert0 : acl2x = 0
-taspi/tree-score/ambig-score.pcert0 : \
- taspi/tree-score/min-length.pcert0 \
- taspi/tree-score/ambig-score.lisp
-taspi/tree-score/ambig-score.pcert1 : acl2x = 0
-taspi/tree-score/ambig-score.pcert1 : no_pcert = 0
-taspi/tree-score/ambig-score.pcert1 : taspi/tree-score/ambig-score.pcert0
-taspi/tree-score/ambig-score.cert : | taspi/tree-score/ambig-score.pcert1
-
-taspi/tree-score/circle-scoring.pcert0 : no_pcert = 0
-taspi/tree-score/circle-scoring.pcert0 : acl2x = 0
-taspi/tree-score/circle-scoring.pcert0 : \
- taspi/tree-score/min-length.pcert0 \
- taspi/code/gen-trees/top.pcert0 \
- taspi/tree-score/circle-scoring.lisp
-taspi/tree-score/circle-scoring.pcert1 : acl2x = 0
-taspi/tree-score/circle-scoring.pcert1 : no_pcert = 0
-taspi/tree-score/circle-scoring.pcert1 : taspi/tree-score/circle-scoring.pcert0
-taspi/tree-score/circle-scoring.cert : | taspi/tree-score/circle-scoring.pcert1
-
-taspi/tree-score/costs.pcert0 : no_pcert = 0
-taspi/tree-score/costs.pcert0 : acl2x = 0
-taspi/tree-score/costs.pcert0 : \
- taspi/code/sequences/seqs.pcert0 \
- taspi/tree-score/costs.lisp
-taspi/tree-score/costs.pcert1 : acl2x = 0
-taspi/tree-score/costs.pcert1 : no_pcert = 0
-taspi/tree-score/costs.pcert1 : taspi/tree-score/costs.pcert0
-taspi/tree-score/costs.cert : | taspi/tree-score/costs.pcert1
-
-taspi/tree-score/efficient-pscores-help.pcert0 : no_pcert = 0
-taspi/tree-score/efficient-pscores-help.pcert0 : acl2x = 0
-taspi/tree-score/efficient-pscores-help.pcert0 : \
- taspi/tree-score/efficient-pscores-help.lisp
-taspi/tree-score/efficient-pscores-help.pcert1 : acl2x = 0
-taspi/tree-score/efficient-pscores-help.pcert1 : no_pcert = 0
-taspi/tree-score/efficient-pscores-help.pcert1 : taspi/tree-score/efficient-pscores-help.pcert0
-taspi/tree-score/efficient-pscores-help.cert : | taspi/tree-score/efficient-pscores-help.pcert1
-
-taspi/tree-score/efficient-pscores.pcert0 : no_pcert = 0
-taspi/tree-score/efficient-pscores.pcert0 : acl2x = 0
-taspi/tree-score/efficient-pscores.pcert0 : \
- taspi/code/gen-helper/extra.pcert0 \
- taspi/tree-score/efficient-pscores-help.pcert0 \
- taspi/tree-score/efficient-pscores.lisp
-taspi/tree-score/efficient-pscores.pcert1 : acl2x = 0
-taspi/tree-score/efficient-pscores.pcert1 : no_pcert = 0
-taspi/tree-score/efficient-pscores.pcert1 : taspi/tree-score/efficient-pscores.pcert0
-taspi/tree-score/efficient-pscores.cert : | taspi/tree-score/efficient-pscores.pcert1
-
-taspi/tree-score/fitch-scoring.pcert0 : no_pcert = 0
-taspi/tree-score/fitch-scoring.pcert0 : acl2x = 0
-taspi/tree-score/fitch-scoring.pcert0 : \
- taspi/tree-score/costs.pcert0 \
- taspi/tree-score/fitch-scoring.lisp
-taspi/tree-score/fitch-scoring.pcert1 : acl2x = 0
-taspi/tree-score/fitch-scoring.pcert1 : no_pcert = 0
-taspi/tree-score/fitch-scoring.pcert1 : taspi/tree-score/fitch-scoring.pcert0
-taspi/tree-score/fitch-scoring.cert : | taspi/tree-score/fitch-scoring.pcert1
-
-taspi/tree-score/min-length.pcert0 : no_pcert = 0
-taspi/tree-score/min-length.pcert0 : acl2x = 0
-taspi/tree-score/min-length.pcert0 : \
- taspi/tree-score/efficient-pscores.pcert0 \
- taspi/code/gen-helper/sets.pcert0 \
- taspi/tree-score/min-length.lisp
-taspi/tree-score/min-length.pcert1 : acl2x = 0
-taspi/tree-score/min-length.pcert1 : no_pcert = 0
-taspi/tree-score/min-length.pcert1 : taspi/tree-score/min-length.pcert0
-taspi/tree-score/min-length.cert : | taspi/tree-score/min-length.pcert1
-
-taspi/tree-score/opt-pairwise.pcert0 : no_pcert = 0
-taspi/tree-score/opt-pairwise.pcert0 : acl2x = 0
-taspi/tree-score/opt-pairwise.pcert0 : \
- taspi/code/sequences/align.pcert0 \
- taspi/code/gen-helper/extra.pcert0 \
- taspi/tree-score/opt-pairwise.lisp
-taspi/tree-score/opt-pairwise.pcert1 : acl2x = 0
-taspi/tree-score/opt-pairwise.pcert1 : no_pcert = 0
-taspi/tree-score/opt-pairwise.pcert1 : taspi/tree-score/opt-pairwise.pcert0
-taspi/tree-score/opt-pairwise.cert : | taspi/tree-score/opt-pairwise.pcert1
-
-taspi/tree-score/pscores.pcert0 : no_pcert = 0
-taspi/tree-score/pscores.pcert0 : acl2x = 0
-taspi/tree-score/pscores.pcert0 : \
- taspi/tree-score/costs.pcert0 \
- taspi/tree-score/pscores.lisp
-taspi/tree-score/pscores.pcert1 : acl2x = 0
-taspi/tree-score/pscores.pcert1 : no_pcert = 0
-taspi/tree-score/pscores.pcert1 : taspi/tree-score/pscores.pcert0
-taspi/tree-score/pscores.cert : | taspi/tree-score/pscores.pcert1
-
-tau/bounders/elementary-bounders.pcert0 : no_pcert = 0
-tau/bounders/elementary-bounders.pcert0 : acl2x = 0
-tau/bounders/elementary-bounders.pcert0 : \
- arithmetic-5/top.pcert0 \
- tau/bounders/find-minimal-2d.pcert0 \
- tau/bounders/find-maximal-2d.pcert0 \
- tau/bounders/elementary-bounders.lisp
-tau/bounders/elementary-bounders.pcert1 : acl2x = 0
-tau/bounders/elementary-bounders.pcert1 : no_pcert = 0
-tau/bounders/elementary-bounders.pcert1 : tau/bounders/elementary-bounders.pcert0
-tau/bounders/elementary-bounders.cert : | tau/bounders/elementary-bounders.pcert1
-
-tau/bounders/find-maximal-1d.pcert0 : no_pcert = 0
-tau/bounders/find-maximal-1d.pcert0 : acl2x = 0
-tau/bounders/find-maximal-1d.pcert0 : \
- tau/bounders/find-maximal-1d.lisp
-tau/bounders/find-maximal-1d.pcert1 : acl2x = 0
-tau/bounders/find-maximal-1d.pcert1 : no_pcert = 0
-tau/bounders/find-maximal-1d.pcert1 : tau/bounders/find-maximal-1d.pcert0
-tau/bounders/find-maximal-1d.cert : | tau/bounders/find-maximal-1d.pcert1
-
-tau/bounders/find-maximal-2d.pcert0 : no_pcert = 0
-tau/bounders/find-maximal-2d.pcert0 : acl2x = 0
-tau/bounders/find-maximal-2d.pcert0 : \
- tau/bounders/find-maximal-2d.lisp
-tau/bounders/find-maximal-2d.pcert1 : acl2x = 0
-tau/bounders/find-maximal-2d.pcert1 : no_pcert = 0
-tau/bounders/find-maximal-2d.pcert1 : tau/bounders/find-maximal-2d.pcert0
-tau/bounders/find-maximal-2d.cert : | tau/bounders/find-maximal-2d.pcert1
-
-tau/bounders/find-minimal-1d.pcert0 : no_pcert = 0
-tau/bounders/find-minimal-1d.pcert0 : acl2x = 0
-tau/bounders/find-minimal-1d.pcert0 : \
- tau/bounders/find-minimal-1d.lisp
-tau/bounders/find-minimal-1d.pcert1 : acl2x = 0
-tau/bounders/find-minimal-1d.pcert1 : no_pcert = 0
-tau/bounders/find-minimal-1d.pcert1 : tau/bounders/find-minimal-1d.pcert0
-tau/bounders/find-minimal-1d.cert : | tau/bounders/find-minimal-1d.pcert1
-
-tau/bounders/find-minimal-2d.pcert0 : no_pcert = 0
-tau/bounders/find-minimal-2d.pcert0 : acl2x = 0
-tau/bounders/find-minimal-2d.pcert0 : \
- tau/bounders/find-minimal-2d.lisp
-tau/bounders/find-minimal-2d.pcert1 : acl2x = 0
-tau/bounders/find-minimal-2d.pcert1 : no_pcert = 0
-tau/bounders/find-minimal-2d.pcert1 : tau/bounders/find-minimal-2d.pcert0
-tau/bounders/find-minimal-2d.cert : | tau/bounders/find-minimal-2d.pcert1
-
-textbook/chap10/ac-example.pcert0 : no_pcert = 0
-textbook/chap10/ac-example.pcert0 : acl2x = 0
-textbook/chap10/ac-example.pcert0 : \
- textbook/chap10/ac-example.lisp
-textbook/chap10/ac-example.pcert1 : acl2x = 0
-textbook/chap10/ac-example.pcert1 : no_pcert = 0
-textbook/chap10/ac-example.pcert1 : textbook/chap10/ac-example.pcert0
-textbook/chap10/ac-example.cert : | textbook/chap10/ac-example.pcert1
-
-textbook/chap10/adder.pcert0 : no_pcert = 0
-textbook/chap10/adder.pcert0 : acl2x = 0
-textbook/chap10/adder.pcert0 : \
- textbook/chap10/adder.lisp
-textbook/chap10/adder.pcert1 : acl2x = 0
-textbook/chap10/adder.pcert1 : no_pcert = 0
-textbook/chap10/adder.pcert1 : textbook/chap10/adder.pcert0
-textbook/chap10/adder.cert : | textbook/chap10/adder.pcert1
-
-textbook/chap10/compiler.pcert0 : no_pcert = 0
-textbook/chap10/compiler.pcert0 : acl2x = 0
-textbook/chap10/compiler.pcert0 : \
- textbook/chap10/compiler.lisp \
- textbook/chap10/compiler.acl2
-textbook/chap10/compiler.pcert1 : acl2x = 0
-textbook/chap10/compiler.pcert1 : no_pcert = 0
-textbook/chap10/compiler.pcert1 : textbook/chap10/compiler.pcert0
-textbook/chap10/compiler.cert : | textbook/chap10/compiler.pcert1
-
-textbook/chap10/fact.pcert0 : no_pcert = 0
-textbook/chap10/fact.pcert0 : acl2x = 0
-textbook/chap10/fact.pcert0 : \
- textbook/chap10/fact.lisp
-textbook/chap10/fact.pcert1 : acl2x = 0
-textbook/chap10/fact.pcert1 : no_pcert = 0
-textbook/chap10/fact.pcert1 : textbook/chap10/fact.pcert0
-textbook/chap10/fact.cert : | textbook/chap10/fact.pcert1
-
-textbook/chap10/insertion-sort.pcert0 : no_pcert = 0
-textbook/chap10/insertion-sort.pcert0 : acl2x = 0
-textbook/chap10/insertion-sort.pcert0 : \
- textbook/chap10/insertion-sort.lisp
-textbook/chap10/insertion-sort.pcert1 : acl2x = 0
-textbook/chap10/insertion-sort.pcert1 : no_pcert = 0
-textbook/chap10/insertion-sort.pcert1 : textbook/chap10/insertion-sort.pcert0
-textbook/chap10/insertion-sort.cert : | textbook/chap10/insertion-sort.pcert1
-
-textbook/chap10/tree.pcert0 : no_pcert = 0
-textbook/chap10/tree.pcert0 : acl2x = 0
-textbook/chap10/tree.pcert0 : \
- textbook/chap10/tree.lisp
-textbook/chap10/tree.pcert1 : acl2x = 0
-textbook/chap10/tree.pcert1 : no_pcert = 0
-textbook/chap10/tree.pcert1 : textbook/chap10/tree.pcert0
-textbook/chap10/tree.cert : | textbook/chap10/tree.pcert1
-
-textbook/chap11/compress.pcert0 : no_pcert = 0
-textbook/chap11/compress.pcert0 : acl2x = 0
-textbook/chap11/compress.pcert0 : \
- textbook/chap11/compress.lisp
-textbook/chap11/compress.pcert1 : acl2x = 0
-textbook/chap11/compress.pcert1 : no_pcert = 0
-textbook/chap11/compress.pcert1 : textbook/chap11/compress.pcert0
-textbook/chap11/compress.cert : | textbook/chap11/compress.pcert1
-
-textbook/chap11/encap.pcert0 : no_pcert = 0
-textbook/chap11/encap.pcert0 : acl2x = 0
-textbook/chap11/encap.pcert0 : \
- textbook/chap10/ac-example.pcert0 \
- textbook/chap11/encap.lisp
-textbook/chap11/encap.pcert1 : acl2x = 0
-textbook/chap11/encap.pcert1 : no_pcert = 0
-textbook/chap11/encap.pcert1 : textbook/chap11/encap.pcert0
-textbook/chap11/encap.cert : | textbook/chap11/encap.pcert1
-
-textbook/chap11/finite-sets.pcert0 : no_pcert = 0
-textbook/chap11/finite-sets.pcert0 : acl2x = 0
-textbook/chap11/finite-sets.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- textbook/chap11/finite-sets.lisp
-textbook/chap11/finite-sets.pcert1 : acl2x = 0
-textbook/chap11/finite-sets.pcert1 : no_pcert = 0
-textbook/chap11/finite-sets.pcert1 : textbook/chap11/finite-sets.pcert0
-textbook/chap11/finite-sets.cert : | textbook/chap11/finite-sets.pcert1
-
-textbook/chap11/how-many-soln1.pcert0 : no_pcert = 0
-textbook/chap11/how-many-soln1.pcert0 : acl2x = 0
-textbook/chap11/how-many-soln1.pcert0 : \
- textbook/chap11/perm.pcert0 \
- arithmetic/top.pcert0 \
- textbook/chap11/how-many-soln1.lisp
-textbook/chap11/how-many-soln1.pcert1 : acl2x = 0
-textbook/chap11/how-many-soln1.pcert1 : no_pcert = 0
-textbook/chap11/how-many-soln1.pcert1 : textbook/chap11/how-many-soln1.pcert0
-textbook/chap11/how-many-soln1.cert : | textbook/chap11/how-many-soln1.pcert1
-
-textbook/chap11/how-many-soln2.pcert0 : no_pcert = 0
-textbook/chap11/how-many-soln2.pcert0 : acl2x = 0
-textbook/chap11/how-many-soln2.pcert0 : \
- textbook/chap11/perm.pcert0 \
- textbook/chap11/how-many-soln2.lisp
-textbook/chap11/how-many-soln2.pcert1 : acl2x = 0
-textbook/chap11/how-many-soln2.pcert1 : no_pcert = 0
-textbook/chap11/how-many-soln2.pcert1 : textbook/chap11/how-many-soln2.pcert0
-textbook/chap11/how-many-soln2.cert : | textbook/chap11/how-many-soln2.pcert1
-
-textbook/chap11/mergesort.pcert0 : no_pcert = 0
-textbook/chap11/mergesort.pcert0 : acl2x = 0
-textbook/chap11/mergesort.pcert0 : \
- textbook/chap11/perm.pcert0 \
- textbook/chap11/perm-append.pcert0 \
- textbook/chap11/mergesort.lisp
-textbook/chap11/mergesort.pcert1 : acl2x = 0
-textbook/chap11/mergesort.pcert1 : no_pcert = 0
-textbook/chap11/mergesort.pcert1 : textbook/chap11/mergesort.pcert0
-textbook/chap11/mergesort.cert : | textbook/chap11/mergesort.pcert1
-
-textbook/chap11/perm-append.pcert0 : no_pcert = 0
-textbook/chap11/perm-append.pcert0 : acl2x = 0
-textbook/chap11/perm-append.pcert0 : \
- textbook/chap11/perm.pcert0 \
- textbook/chap11/perm-append.lisp
-textbook/chap11/perm-append.pcert1 : acl2x = 0
-textbook/chap11/perm-append.pcert1 : no_pcert = 0
-textbook/chap11/perm-append.pcert1 : textbook/chap11/perm-append.pcert0
-textbook/chap11/perm-append.cert : | textbook/chap11/perm-append.pcert1
-
-textbook/chap11/perm.pcert0 : no_pcert = 0
-textbook/chap11/perm.pcert0 : acl2x = 0
-textbook/chap11/perm.pcert0 : \
- textbook/chap11/perm.lisp
-textbook/chap11/perm.pcert1 : acl2x = 0
-textbook/chap11/perm.pcert1 : no_pcert = 0
-textbook/chap11/perm.pcert1 : textbook/chap11/perm.pcert0
-textbook/chap11/perm.cert : | textbook/chap11/perm.pcert1
-
-textbook/chap11/qsort.pcert0 : no_pcert = 0
-textbook/chap11/qsort.pcert0 : acl2x = 0
-textbook/chap11/qsort.pcert0 : \
- textbook/chap11/perm-append.pcert0 \
- textbook/chap11/qsort.lisp
-textbook/chap11/qsort.pcert1 : acl2x = 0
-textbook/chap11/qsort.pcert1 : no_pcert = 0
-textbook/chap11/qsort.pcert1 : textbook/chap11/qsort.pcert0
-textbook/chap11/qsort.cert : | textbook/chap11/qsort.pcert1
-
-textbook/chap11/starters.pcert0 : no_pcert = 0
-textbook/chap11/starters.pcert0 : acl2x = 0
-textbook/chap11/starters.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- textbook/chap11/starters.lisp
-textbook/chap11/starters.pcert1 : acl2x = 0
-textbook/chap11/starters.pcert1 : no_pcert = 0
-textbook/chap11/starters.pcert1 : textbook/chap11/starters.pcert0
-textbook/chap11/starters.cert : | textbook/chap11/starters.pcert1
-
-textbook/chap11/summations-book.pcert0 : no_pcert = 0
-textbook/chap11/summations-book.pcert0 : acl2x = 0
-textbook/chap11/summations-book.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- textbook/chap11/summations-book.lisp
-textbook/chap11/summations-book.pcert1 : acl2x = 0
-textbook/chap11/summations-book.pcert1 : no_pcert = 0
-textbook/chap11/summations-book.pcert1 : textbook/chap11/summations-book.pcert0
-textbook/chap11/summations-book.cert : | textbook/chap11/summations-book.pcert1
-
-textbook/chap11/summations.pcert0 : no_pcert = 0
-textbook/chap11/summations.pcert0 : acl2x = 0
-textbook/chap11/summations.pcert0 : \
- textbook/chap10/ac-example.pcert0 \
- textbook/chap11/summations.lisp
-textbook/chap11/summations.pcert1 : acl2x = 0
-textbook/chap11/summations.pcert1 : no_pcert = 0
-textbook/chap11/summations.pcert1 : textbook/chap11/summations.pcert0
-textbook/chap11/summations.cert : | textbook/chap11/summations.pcert1
-
-textbook/chap11/tautology.pcert0 : no_pcert = 0
-textbook/chap11/tautology.pcert0 : acl2x = 0
-textbook/chap11/tautology.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- arithmetic/top.pcert0 \
- textbook/chap11/tautology.lisp
-textbook/chap11/tautology.pcert1 : acl2x = 0
-textbook/chap11/tautology.pcert1 : no_pcert = 0
-textbook/chap11/tautology.pcert1 : textbook/chap11/tautology.pcert0
-textbook/chap11/tautology.cert : | textbook/chap11/tautology.pcert1
-
-textbook/chap11/xtr.pcert0 : no_pcert = 0
-textbook/chap11/xtr.pcert0 : acl2x = 0
-textbook/chap11/xtr.pcert0 : \
- textbook/chap11/xtr.lisp
-textbook/chap11/xtr.pcert1 : acl2x = 0
-textbook/chap11/xtr.pcert1 : no_pcert = 0
-textbook/chap11/xtr.pcert1 : textbook/chap11/xtr.pcert0
-textbook/chap11/xtr.cert : | textbook/chap11/xtr.pcert1
-
-textbook/chap11/xtr2.pcert0 : no_pcert = 0
-textbook/chap11/xtr2.pcert0 : acl2x = 0
-textbook/chap11/xtr2.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- textbook/chap11/xtr2.lisp
-textbook/chap11/xtr2.pcert1 : acl2x = 0
-textbook/chap11/xtr2.pcert1 : no_pcert = 0
-textbook/chap11/xtr2.pcert1 : textbook/chap11/xtr2.pcert0
-textbook/chap11/xtr2.cert : | textbook/chap11/xtr2.pcert1
-
-textbook/chap3/programs.pcert0 : no_pcert = 0
-textbook/chap3/programs.pcert0 : acl2x = 0
-textbook/chap3/programs.pcert0 : \
- textbook/chap3/programs.lisp
-textbook/chap3/programs.pcert1 : acl2x = 0
-textbook/chap3/programs.pcert1 : no_pcert = 0
-textbook/chap3/programs.pcert1 : textbook/chap3/programs.pcert0
-textbook/chap3/programs.cert : | textbook/chap3/programs.pcert1
-
-textbook/chap4/solutions-logic-mode.pcert0 : no_pcert = 0
-textbook/chap4/solutions-logic-mode.pcert0 : acl2x = 0
-textbook/chap4/solutions-logic-mode.pcert0 : \
- ihs/ihs-lemmas.pcert0 \
- textbook/chap4/solutions-logic-mode.lisp
-textbook/chap4/solutions-logic-mode.pcert1 : acl2x = 0
-textbook/chap4/solutions-logic-mode.pcert1 : no_pcert = 0
-textbook/chap4/solutions-logic-mode.pcert1 : textbook/chap4/solutions-logic-mode.pcert0
-textbook/chap4/solutions-logic-mode.cert : | textbook/chap4/solutions-logic-mode.pcert1
-
-textbook/chap4/solutions-program-mode.pcert0 : no_pcert = 0
-textbook/chap4/solutions-program-mode.pcert0 : acl2x = 0
-textbook/chap4/solutions-program-mode.pcert0 : \
- textbook/chap4/solutions-program-mode.lisp
-textbook/chap4/solutions-program-mode.pcert1 : acl2x = 0
-textbook/chap4/solutions-program-mode.pcert1 : no_pcert = 0
-textbook/chap4/solutions-program-mode.pcert1 : textbook/chap4/solutions-program-mode.pcert0
-textbook/chap4/solutions-program-mode.cert : | textbook/chap4/solutions-program-mode.pcert1
-
-textbook/chap5/solutions.pcert0 : no_pcert = 0
-textbook/chap5/solutions.pcert0 : acl2x = 0
-textbook/chap5/solutions.pcert0 : \
- textbook/chap5/solutions.lisp
-textbook/chap5/solutions.pcert1 : acl2x = 0
-textbook/chap5/solutions.pcert1 : no_pcert = 0
-textbook/chap5/solutions.pcert1 : textbook/chap5/solutions.pcert0
-textbook/chap5/solutions.cert : | textbook/chap5/solutions.pcert1
-
-textbook/chap6/selected-solutions.pcert0 : no_pcert = 0
-textbook/chap6/selected-solutions.pcert0 : acl2x = 0
-textbook/chap6/selected-solutions.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- textbook/chap6/selected-solutions.lisp
-textbook/chap6/selected-solutions.pcert1 : acl2x = 0
-textbook/chap6/selected-solutions.pcert1 : no_pcert = 0
-textbook/chap6/selected-solutions.pcert1 : textbook/chap6/selected-solutions.pcert0
-textbook/chap6/selected-solutions.cert : | textbook/chap6/selected-solutions.pcert1
-
-tools/bstar.pcert0 : no_pcert = 0
-tools/bstar.pcert0 : acl2x = 0
-tools/bstar.pcert0 : \
- tools/pack.pcert0 \
- tools/bstar.lisp
-tools/bstar.pcert1 : acl2x = 0
-tools/bstar.pcert1 : no_pcert = 0
-tools/bstar.pcert1 : tools/bstar.pcert0
-tools/bstar.cert : | tools/bstar.pcert1
-
-tools/case-splitting-rules.pcert0 : no_pcert = 0
-tools/case-splitting-rules.pcert0 : acl2x = 0
-tools/case-splitting-rules.pcert0 : \
- tools/bstar.pcert0 \
- tools/case-splitting-rules.lisp
-tools/case-splitting-rules.pcert1 : acl2x = 0
-tools/case-splitting-rules.pcert1 : no_pcert = 0
-tools/case-splitting-rules.pcert1 : tools/case-splitting-rules.pcert0
-tools/case-splitting-rules.cert : | tools/case-splitting-rules.pcert1
-
-tools/clone-stobj.pcert0 : no_pcert = 0
-tools/clone-stobj.pcert0 : acl2x = 0
-tools/clone-stobj.pcert0 : \
- tools/bstar.pcert0 \
- tools/rulesets.pcert0 \
- tools/templates.pcert0 \
- xdoc/top.pcert0 \
- tools/clone-stobj.lisp
-tools/clone-stobj.pcert1 : acl2x = 0
-tools/clone-stobj.pcert1 : no_pcert = 0
-tools/clone-stobj.pcert1 : tools/clone-stobj.pcert0
-tools/clone-stobj.cert : | tools/clone-stobj.pcert1
-
-tools/cws.pcert0 : no_pcert = 0
-tools/cws.pcert0 : acl2x = 0
-tools/cws.pcert0 : \
- tools/cws.lisp
-tools/cws.pcert1 : acl2x = 0
-tools/cws.pcert1 : no_pcert = 0
-tools/cws.pcert1 : tools/cws.pcert0
-tools/cws.cert : | tools/cws.pcert1
-
-tools/def-functional-instance.pcert0 : no_pcert = 0
-tools/def-functional-instance.pcert0 : acl2x = 0
-tools/def-functional-instance.pcert0 : \
- tools/bstar.pcert0 \
- tools/def-functional-instance.lisp
-tools/def-functional-instance.pcert1 : acl2x = 0
-tools/def-functional-instance.pcert1 : no_pcert = 0
-tools/def-functional-instance.pcert1 : tools/def-functional-instance.pcert0
-tools/def-functional-instance.cert : | tools/def-functional-instance.pcert1
-
-tools/defconsts.pcert0 : no_pcert = 0
-tools/defconsts.pcert0 : acl2x = 0
-tools/defconsts.pcert0 : \
- tools/bstar.pcert0 \
- tools/defconsts.lisp
-tools/defconsts.pcert1 : acl2x = 0
-tools/defconsts.pcert1 : no_pcert = 0
-tools/defconsts.pcert1 : tools/defconsts.pcert0
-tools/defconsts.cert : | tools/defconsts.pcert1
-
-tools/defevaluator-fast.pcert0 : no_pcert = 0
-tools/defevaluator-fast.pcert0 : acl2x = 0
-tools/defevaluator-fast.pcert0 : \
- tools/defevaluator-fast.lisp
-tools/defevaluator-fast.pcert1 : acl2x = 0
-tools/defevaluator-fast.pcert1 : no_pcert = 0
-tools/defevaluator-fast.pcert1 : tools/defevaluator-fast.pcert0
-tools/defevaluator-fast.cert : | tools/defevaluator-fast.pcert1
-
-tools/define-keyed-function.pcert0 : no_pcert = 0
-tools/define-keyed-function.pcert0 : acl2x = 0
-tools/define-keyed-function.pcert0 : \
- tools/define-keyed-function.lisp
-tools/define-keyed-function.pcert1 : acl2x = 0
-tools/define-keyed-function.pcert1 : no_pcert = 0
-tools/define-keyed-function.pcert1 : tools/define-keyed-function.pcert0
-tools/define-keyed-function.cert : | tools/define-keyed-function.pcert1
-
-tools/defined-const.pcert0 : no_pcert = 0
-tools/defined-const.pcert0 : acl2x = 0
-tools/defined-const.pcert0 : \
- tools/defined-const.lisp
-tools/defined-const.pcert1 : acl2x = 0
-tools/defined-const.pcert1 : no_pcert = 0
-tools/defined-const.pcert1 : tools/defined-const.pcert0
-tools/defined-const.cert : | tools/defined-const.pcert1
-
-tools/defmacfun.pcert0 : no_pcert = 0
-tools/defmacfun.pcert0 : acl2x = 0
-tools/defmacfun.pcert0 : \
- tools/defmacfun.lisp
-tools/defmacfun.pcert1 : acl2x = 0
-tools/defmacfun.pcert1 : no_pcert = 0
-tools/defmacfun.pcert1 : tools/defmacfun.pcert0
-tools/defmacfun.cert : | tools/defmacfun.pcert1
-
-tools/defredundant.pcert0 : no_pcert = 0
-tools/defredundant.pcert0 : acl2x = 0
-tools/defredundant.pcert0 : \
- tools/bstar.pcert0 \
- tools/defredundant.lisp
-tools/defredundant.pcert1 : acl2x = 0
-tools/defredundant.pcert1 : no_pcert = 0
-tools/defredundant.pcert1 : tools/defredundant.pcert0
-tools/defredundant.cert : | tools/defredundant.pcert1
-
-tools/defsum.pcert0 : no_pcert = 0
-tools/defsum.pcert0 : acl2x = 0
-tools/defsum.pcert0 : \
- tools/pattern-match.pcert0 \
- tools/types-misc.pcert0 \
- tools/defsum.lisp
-tools/defsum.pcert1 : acl2x = 0
-tools/defsum.pcert1 : no_pcert = 0
-tools/defsum.pcert1 : tools/defsum.pcert0
-tools/defsum.cert : | tools/defsum.pcert1
-
-tools/deftuple.pcert0 : no_pcert = 0
-tools/deftuple.pcert0 : acl2x = 0
-tools/deftuple.pcert0 : \
- tools/types-misc.pcert0 \
- tools/bstar.pcert0 \
- tools/deftuple.lisp
-tools/deftuple.pcert1 : acl2x = 0
-tools/deftuple.pcert1 : no_pcert = 0
-tools/deftuple.pcert1 : tools/deftuple.pcert0
-tools/deftuple.cert : | tools/deftuple.pcert1
-
-tools/do-not.pcert0 : no_pcert = 0
-tools/do-not.pcert0 : acl2x = 0
-tools/do-not.pcert0 : \
- tools/bstar.pcert0 \
- tools/do-not.lisp
-tools/do-not.pcert1 : acl2x = 0
-tools/do-not.pcert1 : no_pcert = 0
-tools/do-not.pcert1 : tools/do-not.pcert0
-tools/do-not.cert : | tools/do-not.pcert1
-
-tools/easy-simplify.pcert0 : no_pcert = 0
-tools/easy-simplify.pcert0 : acl2x = 0
-tools/easy-simplify.pcert0 : \
- tools/bstar.pcert0 \
- tools/easy-simplify.lisp
-tools/easy-simplify.pcert1 : acl2x = 0
-tools/easy-simplify.pcert1 : no_pcert = 0
-tools/easy-simplify.pcert1 : tools/easy-simplify.pcert0
-tools/easy-simplify.cert : | tools/easy-simplify.pcert1
-
-tools/fake-event.pcert0 : no_pcert = 0
-tools/fake-event.pcert0 : acl2x = 0
-tools/fake-event.pcert0 : \
- tools/fake-event.lisp
-tools/fake-event.pcert1 : acl2x = 0
-tools/fake-event.pcert1 : no_pcert = 0
-tools/fake-event.pcert1 : tools/fake-event.pcert0
-tools/fake-event.cert : | tools/fake-event.pcert1
-
-tools/flag.pcert0 : no_pcert = 0
-tools/flag.pcert0 : acl2x = 0
-tools/flag.pcert0 : \
- xdoc/top.pcert0 \
- tools/flag.lisp \
- tools/flag.acl2 \
- tools/flag-package.lsp
-tools/flag.pcert1 : acl2x = 0
-tools/flag.pcert1 : no_pcert = 0
-tools/flag.pcert1 : tools/flag.pcert0
-tools/flag.cert : | tools/flag.pcert1
-
-tools/in-raw-mode.pcert0 : no_pcert = 0
-tools/in-raw-mode.pcert0 : acl2x = 0
-tools/in-raw-mode.pcert0 : \
- tools/in-raw-mode.lisp \
- tools/in-raw-mode.acl2
-tools/in-raw-mode.pcert1 : acl2x = 0
-tools/in-raw-mode.pcert1 : no_pcert = 0
-tools/in-raw-mode.pcert1 : tools/in-raw-mode.pcert0
-tools/in-raw-mode.cert : | tools/in-raw-mode.pcert1
-
-tools/include-raw.pcert0 : no_pcert = 0
-tools/include-raw.pcert0 : acl2x = 0
-tools/include-raw.pcert0 : \
- xdoc/top.pcert0 \
- tools/include-raw.lisp
-tools/include-raw.pcert1 : acl2x = 0
-tools/include-raw.pcert1 : no_pcert = 0
-tools/include-raw.pcert1 : tools/include-raw.pcert0
-tools/include-raw.cert : | tools/include-raw.pcert1
-
-tools/mv-nth.pcert0 : no_pcert = 0
-tools/mv-nth.pcert0 : acl2x = 0
-tools/mv-nth.pcert0 : \
- tools/mv-nth.lisp
-tools/mv-nth.pcert1 : acl2x = 0
-tools/mv-nth.pcert1 : no_pcert = 0
-tools/mv-nth.pcert1 : tools/mv-nth.pcert0
-tools/mv-nth.cert : | tools/mv-nth.pcert1
-
-tools/oracle-eval-real.pcert0 : no_pcert = 0
-tools/oracle-eval-real.pcert0 : acl2x = 0
-tools/oracle-eval-real.pcert0 : \
- tools/oracle-eval-real.lisp \
- tools/oracle-eval-real.acl2
-tools/oracle-eval-real.pcert1 : acl2x = 0
-tools/oracle-eval-real.pcert1 : no_pcert = 0
-tools/oracle-eval-real.pcert1 : tools/oracle-eval-real.pcert0
-tools/oracle-eval-real.cert : | tools/oracle-eval-real.pcert1
-
-tools/oracle-eval.pcert0 : no_pcert = 0
-tools/oracle-eval.pcert0 : acl2x = 0
-tools/oracle-eval.pcert0 : \
- tools/oracle-eval-real.pcert0 \
- tools/oracle-eval.lisp
-tools/oracle-eval.pcert1 : acl2x = 0
-tools/oracle-eval.pcert1 : no_pcert = 0
-tools/oracle-eval.pcert1 : tools/oracle-eval.pcert0
-tools/oracle-eval.cert : | tools/oracle-eval.pcert1
-
-tools/pack.pcert0 : no_pcert = 0
-tools/pack.pcert0 : acl2x = 0
-tools/pack.pcert0 : \
- tools/pack.lisp
-tools/pack.pcert1 : acl2x = 0
-tools/pack.pcert1 : no_pcert = 0
-tools/pack.pcert1 : tools/pack.pcert0
-tools/pack.cert : | tools/pack.pcert1
-
-tools/pattern-match.pcert0 : no_pcert = 0
-tools/pattern-match.pcert0 : acl2x = 0
-tools/pattern-match.pcert0 : \
- tools/pattern-match.lisp
-tools/pattern-match.pcert1 : acl2x = 0
-tools/pattern-match.pcert1 : no_pcert = 0
-tools/pattern-match.pcert1 : tools/pattern-match.pcert0
-tools/pattern-match.cert : | tools/pattern-match.pcert1
-
-tools/plev-ccl.pcert0 : no_pcert = 0
-tools/plev-ccl.pcert0 : acl2x = 0
-tools/plev-ccl.pcert0 : \
- tools/plev.pcert0 \
- tools/include-raw.pcert0 \
- tools/plev-ccl.lisp \
- tools/plev-ccl.acl2
-tools/plev-ccl.pcert1 : acl2x = 0
-tools/plev-ccl.pcert1 : no_pcert = 0
-tools/plev-ccl.pcert1 : tools/plev-ccl.pcert0
-tools/plev-ccl.cert : | tools/plev-ccl.pcert1
-
-tools/plev.pcert0 : no_pcert = 0
-tools/plev.pcert0 : acl2x = 0
-tools/plev.pcert0 : \
- tools/plev.lisp
-tools/plev.pcert1 : acl2x = 0
-tools/plev.pcert1 : no_pcert = 0
-tools/plev.pcert1 : tools/plev.pcert0
-tools/plev.cert : | tools/plev.pcert1
-
-tools/rulesets.pcert0 : no_pcert = 0
-tools/rulesets.pcert0 : acl2x = 0
-tools/rulesets.pcert0 : \
- xdoc/top.pcert0 \
- tools/rulesets.lisp
-tools/rulesets.pcert1 : acl2x = 0
-tools/rulesets.pcert1 : no_pcert = 0
-tools/rulesets.pcert1 : tools/rulesets.pcert0
-tools/rulesets.cert : | tools/rulesets.pcert1
-
-tools/safe-case.pcert0 : no_pcert = 0
-tools/safe-case.pcert0 : acl2x = 0
-tools/safe-case.pcert0 : \
- tools/safe-case.lisp
-tools/safe-case.pcert1 : acl2x = 0
-tools/safe-case.pcert1 : no_pcert = 0
-tools/safe-case.pcert1 : tools/safe-case.pcert0
-tools/safe-case.cert : | tools/safe-case.pcert1
-
-tools/saved-errors.pcert0 : no_pcert = 0
-tools/saved-errors.pcert0 : acl2x = 0
-tools/saved-errors.pcert0 : \
- tools/saved-errors.lisp
-tools/saved-errors.pcert1 : acl2x = 0
-tools/saved-errors.pcert1 : no_pcert = 0
-tools/saved-errors.pcert1 : tools/saved-errors.pcert0
-tools/saved-errors.cert : | tools/saved-errors.pcert1
-
-tools/stobj-frame.pcert0 : no_pcert = 0
-tools/stobj-frame.pcert0 : acl2x = 0
-tools/stobj-frame.pcert0 : \
- tools/rulesets.pcert0 \
- tools/bstar.pcert0 \
- data-structures/list-defthms.pcert0 \
- tools/stobj-frame.lisp
-tools/stobj-frame.pcert1 : acl2x = 0
-tools/stobj-frame.pcert1 : no_pcert = 0
-tools/stobj-frame.pcert1 : tools/stobj-frame.pcert0
-tools/stobj-frame.cert : | tools/stobj-frame.pcert1
-
-tools/stobj-help.pcert0 : no_pcert = 0
-tools/stobj-help.pcert0 : acl2x = 0
-tools/stobj-help.pcert0 : \
- arithmetic-5/top.pcert0 \
- misc/simplify-thm.pcert0 \
- tools/stobj-help.lisp
-tools/stobj-help.pcert1 : acl2x = 0
-tools/stobj-help.pcert1 : no_pcert = 0
-tools/stobj-help.pcert1 : tools/stobj-help.pcert0
-tools/stobj-help.cert : | tools/stobj-help.pcert1
-
-tools/templates.pcert0 : no_pcert = 0
-tools/templates.pcert0 : acl2x = 0
-tools/templates.pcert0 : \
- tools/bstar.pcert0 \
- tools/defmacfun.pcert0 \
- xdoc/top.pcert0 \
- tools/templates.lisp
-tools/templates.pcert1 : acl2x = 0
-tools/templates.pcert1 : no_pcert = 0
-tools/templates.pcert1 : tools/templates.pcert0
-tools/templates.cert : | tools/templates.pcert1
-
-tools/theory-tools.pcert0 : no_pcert = 0
-tools/theory-tools.pcert0 : acl2x = 0
-tools/theory-tools.pcert0 : \
- tools/theory-tools.lisp
-tools/theory-tools.pcert1 : acl2x = 0
-tools/theory-tools.pcert1 : no_pcert = 0
-tools/theory-tools.pcert1 : tools/theory-tools.pcert0
-tools/theory-tools.cert : | tools/theory-tools.pcert1
-
-tools/time-dollar-with-gc.pcert0 : no_pcert = 0
-tools/time-dollar-with-gc.pcert0 : acl2x = 0
-tools/time-dollar-with-gc.pcert0 : \
- tools/time-dollar-with-gc.lisp \
- tools/time-dollar-with-gc.acl2
-tools/time-dollar-with-gc.pcert1 : acl2x = 0
-tools/time-dollar-with-gc.pcert1 : no_pcert = 0
-tools/time-dollar-with-gc.pcert1 : tools/time-dollar-with-gc.pcert0
-tools/time-dollar-with-gc.cert : | tools/time-dollar-with-gc.pcert1
-
-tools/types-misc.pcert0 : no_pcert = 0
-tools/types-misc.pcert0 : acl2x = 0
-tools/types-misc.pcert0 : \
- tools/theory-tools.pcert0 \
- tools/types-misc.lisp
-tools/types-misc.pcert1 : acl2x = 0
-tools/types-misc.pcert1 : no_pcert = 0
-tools/types-misc.pcert1 : tools/types-misc.pcert0
-tools/types-misc.cert : | tools/types-misc.pcert1
-
-tools/with-arith5-help.pcert0 : no_pcert = 0
-tools/with-arith5-help.pcert0 : acl2x = 0
-tools/with-arith5-help.pcert0 : \
- tools/rulesets.pcert0 \
- arithmetic-5/top.pcert0 \
- tools/with-arith5-help.lisp
-tools/with-arith5-help.pcert1 : acl2x = 0
-tools/with-arith5-help.pcert1 : no_pcert = 0
-tools/with-arith5-help.pcert1 : tools/with-arith5-help.pcert0
-tools/with-arith5-help.cert : | tools/with-arith5-help.pcert1
-
-tools/with-quoted-forms.pcert0 : no_pcert = 0
-tools/with-quoted-forms.pcert0 : acl2x = 0
-tools/with-quoted-forms.pcert0 : \
- tools/bstar.pcert0 \
- tools/with-quoted-forms.lisp
-tools/with-quoted-forms.pcert1 : acl2x = 0
-tools/with-quoted-forms.pcert1 : no_pcert = 0
-tools/with-quoted-forms.pcert1 : tools/with-quoted-forms.pcert0
-tools/with-quoted-forms.cert : | tools/with-quoted-forms.pcert1
-
-tutorial-problems/introductory-challenge-problem-4-athena.pcert0 : no_pcert = 0
-tutorial-problems/introductory-challenge-problem-4-athena.pcert0 : acl2x = 0
-tutorial-problems/introductory-challenge-problem-4-athena.pcert0 : \
- tutorial-problems/introductory-challenge-problem-4-athena.lisp
-tutorial-problems/introductory-challenge-problem-4-athena.pcert1 : acl2x = 0
-tutorial-problems/introductory-challenge-problem-4-athena.pcert1 : no_pcert = 0
-tutorial-problems/introductory-challenge-problem-4-athena.pcert1 : tutorial-problems/introductory-challenge-problem-4-athena.pcert0
-tutorial-problems/introductory-challenge-problem-4-athena.cert : | tutorial-problems/introductory-challenge-problem-4-athena.pcert1
-
-tutorial-problems/introductory-challenge-problem-4.pcert0 : no_pcert = 0
-tutorial-problems/introductory-challenge-problem-4.pcert0 : acl2x = 0
-tutorial-problems/introductory-challenge-problem-4.pcert0 : \
- tutorial-problems/introductory-challenge-problem-4.lisp
-tutorial-problems/introductory-challenge-problem-4.pcert1 : acl2x = 0
-tutorial-problems/introductory-challenge-problem-4.pcert1 : no_pcert = 0
-tutorial-problems/introductory-challenge-problem-4.pcert1 : tutorial-problems/introductory-challenge-problem-4.pcert0
-tutorial-problems/introductory-challenge-problem-4.cert : | tutorial-problems/introductory-challenge-problem-4.pcert1
-
-unicode/partition.pcert0 : no_pcert = 0
-unicode/partition.pcert0 : acl2x = 0
-unicode/partition.pcert0 : \
- std/lists/flatten.pcert0 \
- unicode/sum-list.pcert0 \
- std/lists/take.pcert0 \
- unicode/z-listp.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- std/lists/nthcdr.pcert0 \
- unicode/partition.lisp
-unicode/partition.pcert1 : acl2x = 0
-unicode/partition.pcert1 : no_pcert = 0
-unicode/partition.pcert1 : unicode/partition.pcert0
-unicode/partition.cert : | unicode/partition.pcert1
-
-unicode/read-utf8.pcert0 : no_pcert = 0
-unicode/read-utf8.pcert0 : acl2x = 0
-unicode/read-utf8.pcert0 : \
- unicode/utf8-decode.pcert0 \
- std/io/take-bytes.pcert0 \
- std/io/base.pcert0 \
- tools/mv-nth.pcert0 \
- std/io/signed-byte-listp.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- unicode/read-utf8.lisp
-unicode/read-utf8.pcert1 : acl2x = 0
-unicode/read-utf8.pcert1 : no_pcert = 0
-unicode/read-utf8.pcert1 : unicode/read-utf8.pcert0
-unicode/read-utf8.cert : | unicode/read-utf8.pcert1
-
-unicode/sum-list.pcert0 : no_pcert = 0
-unicode/sum-list.pcert0 : acl2x = 0
-unicode/sum-list.pcert0 : \
- std/lists/nat-listp.pcert0 \
- unicode/sum-list.lisp
-unicode/sum-list.pcert1 : acl2x = 0
-unicode/sum-list.pcert1 : no_pcert = 0
-unicode/sum-list.pcert1 : unicode/sum-list.pcert0
-unicode/sum-list.cert : | unicode/sum-list.pcert1
-
-unicode/uchar.pcert0 : no_pcert = 0
-unicode/uchar.pcert0 : acl2x = 0
-unicode/uchar.pcert0 : \
- unicode/uchar.lisp
-unicode/uchar.pcert1 : acl2x = 0
-unicode/uchar.pcert1 : no_pcert = 0
-unicode/uchar.pcert1 : unicode/uchar.pcert0
-unicode/uchar.cert : | unicode/uchar.pcert1
-
-unicode/utf8-decode.pcert0 : no_pcert = 0
-unicode/utf8-decode.pcert0 : acl2x = 0
-unicode/utf8-decode.pcert0 : \
- unicode/uchar.pcert0 \
- unicode/utf8-table35.pcert0 \
- unicode/utf8-table36.pcert0 \
- unicode/utf8-encode.pcert0 \
- unicode/partition.pcert0 \
- std/lists/nthcdr.pcert0 \
- std/io/signed-byte-listp.pcert0 \
- tools/mv-nth.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- std/lists/revappend.pcert0 \
- unicode/utf8-decode.lisp
-unicode/utf8-decode.pcert1 : acl2x = 0
-unicode/utf8-decode.pcert1 : no_pcert = 0
-unicode/utf8-decode.pcert1 : unicode/utf8-decode.pcert0
-unicode/utf8-decode.cert : | unicode/utf8-decode.pcert1
-
-unicode/utf8-encode.pcert0 : no_pcert = 0
-unicode/utf8-encode.pcert0 : acl2x = 0
-unicode/utf8-encode.pcert0 : \
- unicode/utf8-table35.pcert0 \
- unicode/utf8-table36.pcert0 \
- std/lists/append.pcert0 \
- std/io/signed-byte-listp.pcert0 \
- unicode/utf8-encode.lisp
-unicode/utf8-encode.pcert1 : acl2x = 0
-unicode/utf8-encode.pcert1 : no_pcert = 0
-unicode/utf8-encode.pcert1 : unicode/utf8-encode.pcert0
-unicode/utf8-encode.cert : | unicode/utf8-encode.pcert1
-
-unicode/utf8-table35.pcert0 : no_pcert = 0
-unicode/utf8-table35.pcert0 : acl2x = 0
-unicode/utf8-table35.pcert0 : \
- unicode/uchar.pcert0 \
- std/io/unsigned-byte-listp.pcert0 \
- std/io/signed-byte-listp.pcert0 \
- unicode/utf8-table35.lisp
-unicode/utf8-table35.pcert1 : acl2x = 0
-unicode/utf8-table35.pcert1 : no_pcert = 0
-unicode/utf8-table35.pcert1 : unicode/utf8-table35.pcert0
-unicode/utf8-table35.cert : | unicode/utf8-table35.pcert1
-
-unicode/utf8-table36.pcert0 : no_pcert = 0
-unicode/utf8-table36.pcert0 : acl2x = 0
-unicode/utf8-table36.pcert0 : \
- unicode/uchar.pcert0 \
- std/io/unsigned-byte-listp.pcert0 \
- std/io/signed-byte-listp.pcert0 \
- unicode/utf8-table36.lisp
-unicode/utf8-table36.pcert1 : acl2x = 0
-unicode/utf8-table36.pcert1 : no_pcert = 0
-unicode/utf8-table36.pcert1 : unicode/utf8-table36.pcert0
-unicode/utf8-table36.cert : | unicode/utf8-table36.pcert1
-
-unicode/z-listp.pcert0 : no_pcert = 0
-unicode/z-listp.pcert0 : acl2x = 0
-unicode/z-listp.pcert0 : \
- std/lists/app.pcert0 \
- unicode/z-listp.lisp
-unicode/z-listp.pcert1 : acl2x = 0
-unicode/z-listp.pcert1 : no_pcert = 0
-unicode/z-listp.pcert1 : unicode/z-listp.pcert0
-unicode/z-listp.cert : | unicode/z-listp.pcert1
-
-workshops/1999/calculus/solutions/mesh-append.pcert0 : no_pcert = 0
-workshops/1999/calculus/solutions/mesh-append.pcert0 : acl2x = 0
-workshops/1999/calculus/solutions/mesh-append.pcert0 : \
- workshops/1999/calculus/solutions/partition-defuns.pcert0 \
- workshops/1999/calculus/solutions/mesh-append.lisp
-workshops/1999/calculus/solutions/mesh-append.pcert1 : acl2x = 0
-workshops/1999/calculus/solutions/mesh-append.pcert1 : no_pcert = 0
-workshops/1999/calculus/solutions/mesh-append.pcert1 : workshops/1999/calculus/solutions/mesh-append.pcert0
-workshops/1999/calculus/solutions/mesh-append.cert : | workshops/1999/calculus/solutions/mesh-append.pcert1
-
-workshops/1999/calculus/solutions/mesh-make-partition.pcert0 : no_pcert = 0
-workshops/1999/calculus/solutions/mesh-make-partition.pcert0 : acl2x = 0
-workshops/1999/calculus/solutions/mesh-make-partition.pcert0 : \
- workshops/1999/calculus/solutions/partition-defuns.pcert0 \
- workshops/1999/calculus/solutions/mesh-make-partition.lisp
-workshops/1999/calculus/solutions/mesh-make-partition.pcert1 : acl2x = 0
-workshops/1999/calculus/solutions/mesh-make-partition.pcert1 : no_pcert = 0
-workshops/1999/calculus/solutions/mesh-make-partition.pcert1 : workshops/1999/calculus/solutions/mesh-make-partition.pcert0
-workshops/1999/calculus/solutions/mesh-make-partition.cert : | workshops/1999/calculus/solutions/mesh-make-partition.pcert1
-
-workshops/1999/calculus/solutions/partition-defuns.pcert0 : no_pcert = 0
-workshops/1999/calculus/solutions/partition-defuns.pcert0 : acl2x = 0
-workshops/1999/calculus/solutions/partition-defuns.pcert0 : \
- workshops/1999/calculus/solutions/partition-defuns.lisp
-workshops/1999/calculus/solutions/partition-defuns.pcert1 : acl2x = 0
-workshops/1999/calculus/solutions/partition-defuns.pcert1 : no_pcert = 0
-workshops/1999/calculus/solutions/partition-defuns.pcert1 : workshops/1999/calculus/solutions/partition-defuns.pcert0
-workshops/1999/calculus/solutions/partition-defuns.cert : | workshops/1999/calculus/solutions/partition-defuns.pcert1
-
-workshops/1999/calculus/solutions/partitionp-make-partition-rec.pcert0 : no_pcert = 0
-workshops/1999/calculus/solutions/partitionp-make-partition-rec.pcert0 : acl2x = 0
-workshops/1999/calculus/solutions/partitionp-make-partition-rec.pcert0 : \
- workshops/1999/calculus/solutions/partition-defuns.pcert0 \
- workshops/1999/calculus/solutions/partitionp-make-partition-rec.lisp
-workshops/1999/calculus/solutions/partitionp-make-partition-rec.pcert1 : acl2x = 0
-workshops/1999/calculus/solutions/partitionp-make-partition-rec.pcert1 : no_pcert = 0
-workshops/1999/calculus/solutions/partitionp-make-partition-rec.pcert1 : workshops/1999/calculus/solutions/partitionp-make-partition-rec.pcert0
-workshops/1999/calculus/solutions/partitionp-make-partition-rec.cert : | workshops/1999/calculus/solutions/partitionp-make-partition-rec.pcert1
-
-workshops/1999/calculus/solutions/partitionp-make-partition.pcert0 : no_pcert = 0
-workshops/1999/calculus/solutions/partitionp-make-partition.pcert0 : acl2x = 0
-workshops/1999/calculus/solutions/partitionp-make-partition.pcert0 : \
- workshops/1999/calculus/solutions/partition-defuns.pcert0 \
- workshops/1999/calculus/solutions/partitionp-make-partition-rec.pcert0 \
- workshops/1999/calculus/solutions/partitionp-make-partition.lisp
-workshops/1999/calculus/solutions/partitionp-make-partition.pcert1 : acl2x = 0
-workshops/1999/calculus/solutions/partitionp-make-partition.pcert1 : no_pcert = 0
-workshops/1999/calculus/solutions/partitionp-make-partition.pcert1 : workshops/1999/calculus/solutions/partitionp-make-partition.pcert0
-workshops/1999/calculus/solutions/partitionp-make-partition.cert : | workshops/1999/calculus/solutions/partitionp-make-partition.pcert1
-
-workshops/1999/calculus/solutions/riemann-rcfn-helpers.pcert0 : no_pcert = 0
-workshops/1999/calculus/solutions/riemann-rcfn-helpers.pcert0 : acl2x = 0
-workshops/1999/calculus/solutions/riemann-rcfn-helpers.pcert0 : \
- workshops/1999/calculus/solutions/riemann-rcfn-helpers.lisp
-workshops/1999/calculus/solutions/riemann-rcfn-helpers.pcert1 : acl2x = 0
-workshops/1999/calculus/solutions/riemann-rcfn-helpers.pcert1 : no_pcert = 0
-workshops/1999/calculus/solutions/riemann-rcfn-helpers.pcert1 : workshops/1999/calculus/solutions/riemann-rcfn-helpers.pcert0
-workshops/1999/calculus/solutions/riemann-rcfn-helpers.cert : | workshops/1999/calculus/solutions/riemann-rcfn-helpers.pcert1
-
-workshops/1999/compiler/compiler.pcert0 : no_pcert = 0
-workshops/1999/compiler/compiler.pcert0 : acl2x = 0
-workshops/1999/compiler/compiler.pcert0 : \
- workshops/1999/compiler/machine.pcert0 \
- workshops/1999/compiler/compiler.lisp
-workshops/1999/compiler/compiler.pcert1 : acl2x = 0
-workshops/1999/compiler/compiler.pcert1 : no_pcert = 0
-workshops/1999/compiler/compiler.pcert1 : workshops/1999/compiler/compiler.pcert0
-workshops/1999/compiler/compiler.cert : | workshops/1999/compiler/compiler.pcert1
-
-workshops/1999/compiler/evaluator.pcert0 : no_pcert = 0
-workshops/1999/compiler/evaluator.pcert0 : acl2x = 0
-workshops/1999/compiler/evaluator.pcert0 : \
- workshops/1999/compiler/compiler.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/compiler/evaluator.lisp
-workshops/1999/compiler/evaluator.pcert1 : acl2x = 0
-workshops/1999/compiler/evaluator.pcert1 : no_pcert = 0
-workshops/1999/compiler/evaluator.pcert1 : workshops/1999/compiler/evaluator.pcert0
-workshops/1999/compiler/evaluator.cert : | workshops/1999/compiler/evaluator.pcert1
-
-workshops/1999/compiler/exercises.pcert0 : no_pcert = 0
-workshops/1999/compiler/exercises.pcert0 : acl2x = 0
-workshops/1999/compiler/exercises.pcert0 : \
- workshops/1999/compiler/compiler.pcert0 \
- workshops/1999/compiler/exercises.lisp
-workshops/1999/compiler/exercises.pcert1 : acl2x = 0
-workshops/1999/compiler/exercises.pcert1 : no_pcert = 0
-workshops/1999/compiler/exercises.pcert1 : workshops/1999/compiler/exercises.pcert0
-workshops/1999/compiler/exercises.cert : | workshops/1999/compiler/exercises.pcert1
-
-workshops/1999/compiler/machine.pcert0 : no_pcert = 0
-workshops/1999/compiler/machine.pcert0 : acl2x = 0
-workshops/1999/compiler/machine.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/compiler/machine.lisp
-workshops/1999/compiler/machine.pcert1 : acl2x = 0
-workshops/1999/compiler/machine.pcert1 : no_pcert = 0
-workshops/1999/compiler/machine.pcert1 : workshops/1999/compiler/machine.pcert0
-workshops/1999/compiler/machine.cert : | workshops/1999/compiler/machine.pcert1
-
-workshops/1999/compiler/proof.pcert0 : no_pcert = 0
-workshops/1999/compiler/proof.pcert0 : acl2x = 0
-workshops/1999/compiler/proof.pcert0 : \
- workshops/1999/compiler/proof1.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/compiler/proof.lisp
-workshops/1999/compiler/proof.pcert1 : acl2x = 0
-workshops/1999/compiler/proof.pcert1 : no_pcert = 0
-workshops/1999/compiler/proof.pcert1 : workshops/1999/compiler/proof.pcert0
-workshops/1999/compiler/proof.cert : | workshops/1999/compiler/proof.pcert1
-
-workshops/1999/compiler/proof1.pcert0 : no_pcert = 0
-workshops/1999/compiler/proof1.pcert0 : acl2x = 0
-workshops/1999/compiler/proof1.pcert0 : \
- workshops/1999/compiler/evaluator.pcert0 \
- arithmetic/equalities.pcert0 \
- workshops/1999/compiler/proof1.lisp
-workshops/1999/compiler/proof1.pcert1 : acl2x = 0
-workshops/1999/compiler/proof1.pcert1 : no_pcert = 0
-workshops/1999/compiler/proof1.pcert1 : workshops/1999/compiler/proof1.pcert0
-workshops/1999/compiler/proof1.cert : | workshops/1999/compiler/proof1.pcert1
-
-workshops/1999/de-hdl/arity.pcert0 : no_pcert = 0
-workshops/1999/de-hdl/arity.pcert0 : acl2x = 0
-workshops/1999/de-hdl/arity.pcert0 : \
- workshops/1999/de-hdl/syntax.pcert0 \
- workshops/1999/de-hdl/arity.lisp
-workshops/1999/de-hdl/arity.pcert1 : acl2x = 0
-workshops/1999/de-hdl/arity.pcert1 : no_pcert = 0
-workshops/1999/de-hdl/arity.pcert1 : workshops/1999/de-hdl/arity.pcert0
-workshops/1999/de-hdl/arity.cert : | workshops/1999/de-hdl/arity.pcert1
-
-workshops/1999/de-hdl/de4.pcert0 : no_pcert = 0
-workshops/1999/de-hdl/de4.pcert0 : acl2x = 0
-workshops/1999/de-hdl/de4.pcert0 : \
- workshops/1999/de-hdl/sts-okp.pcert0 \
- workshops/1999/de-hdl/de4.lisp
-workshops/1999/de-hdl/de4.pcert1 : acl2x = 0
-workshops/1999/de-hdl/de4.pcert1 : no_pcert = 0
-workshops/1999/de-hdl/de4.pcert1 : workshops/1999/de-hdl/de4.pcert0
-workshops/1999/de-hdl/de4.cert : | workshops/1999/de-hdl/de4.pcert1
-
-workshops/1999/de-hdl/examples.pcert0 : no_pcert = 0
-workshops/1999/de-hdl/examples.pcert0 : acl2x = 0
-workshops/1999/de-hdl/examples.pcert0 : \
- workshops/1999/de-hdl/de4.pcert0 \
- workshops/1999/de-hdl/examples.lisp
-workshops/1999/de-hdl/examples.pcert1 : acl2x = 0
-workshops/1999/de-hdl/examples.pcert1 : no_pcert = 0
-workshops/1999/de-hdl/examples.pcert1 : workshops/1999/de-hdl/examples.pcert0
-workshops/1999/de-hdl/examples.cert : | workshops/1999/de-hdl/examples.pcert1
-
-workshops/1999/de-hdl/help-defuns.pcert0 : no_pcert = 0
-workshops/1999/de-hdl/help-defuns.pcert0 : acl2x = 0
-workshops/1999/de-hdl/help-defuns.pcert0 : \
- workshops/1999/de-hdl/help-defuns.lisp
-workshops/1999/de-hdl/help-defuns.pcert1 : acl2x = 0
-workshops/1999/de-hdl/help-defuns.pcert1 : no_pcert = 0
-workshops/1999/de-hdl/help-defuns.pcert1 : workshops/1999/de-hdl/help-defuns.pcert0
-workshops/1999/de-hdl/help-defuns.cert : | workshops/1999/de-hdl/help-defuns.pcert1
-
-workshops/1999/de-hdl/measure.pcert0 : no_pcert = 0
-workshops/1999/de-hdl/measure.pcert0 : acl2x = 0
-workshops/1999/de-hdl/measure.pcert0 : \
- workshops/1999/de-hdl/help-defuns.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/de-hdl/measure.lisp
-workshops/1999/de-hdl/measure.pcert1 : acl2x = 0
-workshops/1999/de-hdl/measure.pcert1 : no_pcert = 0
-workshops/1999/de-hdl/measure.pcert1 : workshops/1999/de-hdl/measure.pcert0
-workshops/1999/de-hdl/measure.cert : | workshops/1999/de-hdl/measure.pcert1
-
-workshops/1999/de-hdl/primitives.pcert0 : no_pcert = 0
-workshops/1999/de-hdl/primitives.pcert0 : acl2x = 0
-workshops/1999/de-hdl/primitives.pcert0 : \
- workshops/1999/de-hdl/measure.pcert0 \
- workshops/1999/de-hdl/primitives.lisp
-workshops/1999/de-hdl/primitives.pcert1 : acl2x = 0
-workshops/1999/de-hdl/primitives.pcert1 : no_pcert = 0
-workshops/1999/de-hdl/primitives.pcert1 : workshops/1999/de-hdl/primitives.pcert0
-workshops/1999/de-hdl/primitives.cert : | workshops/1999/de-hdl/primitives.pcert1
-
-workshops/1999/de-hdl/sts-okp.pcert0 : no_pcert = 0
-workshops/1999/de-hdl/sts-okp.pcert0 : acl2x = 0
-workshops/1999/de-hdl/sts-okp.pcert0 : \
- workshops/1999/de-hdl/arity.pcert0 \
- workshops/1999/de-hdl/sts-okp.lisp
-workshops/1999/de-hdl/sts-okp.pcert1 : acl2x = 0
-workshops/1999/de-hdl/sts-okp.pcert1 : no_pcert = 0
-workshops/1999/de-hdl/sts-okp.pcert1 : workshops/1999/de-hdl/sts-okp.pcert0
-workshops/1999/de-hdl/sts-okp.cert : | workshops/1999/de-hdl/sts-okp.pcert1
-
-workshops/1999/de-hdl/syntax.pcert0 : no_pcert = 0
-workshops/1999/de-hdl/syntax.pcert0 : acl2x = 0
-workshops/1999/de-hdl/syntax.pcert0 : \
- workshops/1999/de-hdl/primitives.pcert0 \
- workshops/1999/de-hdl/syntax.lisp
-workshops/1999/de-hdl/syntax.pcert1 : acl2x = 0
-workshops/1999/de-hdl/syntax.pcert1 : no_pcert = 0
-workshops/1999/de-hdl/syntax.pcert1 : workshops/1999/de-hdl/syntax.pcert0
-workshops/1999/de-hdl/syntax.cert : | workshops/1999/de-hdl/syntax.pcert1
-
-workshops/1999/de-hdl/thm-example.pcert0 : no_pcert = 0
-workshops/1999/de-hdl/thm-example.pcert0 : acl2x = 0
-workshops/1999/de-hdl/thm-example.pcert0 : \
- workshops/1999/de-hdl/de4.pcert0 \
- workshops/1999/de-hdl/thm-example.lisp
-workshops/1999/de-hdl/thm-example.pcert1 : acl2x = 0
-workshops/1999/de-hdl/thm-example.pcert1 : no_pcert = 0
-workshops/1999/de-hdl/thm-example.pcert1 : workshops/1999/de-hdl/thm-example.pcert0
-workshops/1999/de-hdl/thm-example.cert : | workshops/1999/de-hdl/thm-example.pcert1
-
-workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.pcert0 : no_pcert = 0
-workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.pcert0 : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.pcert0 : \
- workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.lisp
-workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.pcert1 : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.pcert1 : no_pcert = 0
-workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.pcert1 : workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.pcert0
-workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.cert : | workshops/1999/embedded/Exercises/Exercise1-1/Exercise1.1.pcert1
-
-workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.pcert0 : no_pcert = 0
-workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.pcert0 : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.pcert0 : \
- arithmetic/mod-gcd.pcert0 \
- rtl/rel1/lib1/basic.pcert0 \
- rtl/rel1/support/fp.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.pcert0 \
- workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.lisp
-workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.pcert1 : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.pcert1 : no_pcert = 0
-workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.pcert1 : workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.pcert0
-workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.cert : | workshops/1999/embedded/Exercises/Exercise1-2/Exercise1.2.pcert1
-
-workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.pcert0 : no_pcert = 0
-workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.pcert0 : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.pcert0 : \
- workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.pcert0 \
- workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.lisp
-workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.pcert1 : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.pcert1 : no_pcert = 0
-workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.pcert1 : workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.pcert0
-workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.cert : | workshops/1999/embedded/Exercises/Exercise1-2/Minimal-Mod-Lemmas.pcert1
-
-workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.pcert0 : no_pcert = 0
-workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.pcert0 : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.pcert0 : \
- ihs/ihs-init.pcert0 \
- ihs/ihs-theories.pcert0 \
- ihs/math-lemmas.pcert0 \
- workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.lisp
-workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.pcert1 : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.pcert1 : no_pcert = 0
-workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.pcert1 : workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.pcert0
-workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.cert : | workshops/1999/embedded/Exercises/Exercise1-2/private-qr-lemmas.pcert1
-
-workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.pcert0 : no_pcert = 0
-workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.pcert0 : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.pcert0 : \
- workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.lisp
-workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.pcert1 : acl2x = 0
-workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.pcert1 : no_pcert = 0
-workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.pcert1 : workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.pcert0
-workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.cert : | workshops/1999/embedded/Exercises/Exercise1-3/Exercise1.3.pcert1
-
-workshops/1999/embedded/Proof-Of-Contribution/CRT.pcert0 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/CRT.pcert0 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/CRT.pcert0 : \
- arithmetic/mod-gcd.pcert0 \
- rtl/rel1/lib1/basic.pcert0 \
- rtl/rel1/support/fp.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/CRT.lisp
-workshops/1999/embedded/Proof-Of-Contribution/CRT.pcert1 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/CRT.pcert1 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/CRT.pcert1 : workshops/1999/embedded/Proof-Of-Contribution/CRT.pcert0
-workshops/1999/embedded/Proof-Of-Contribution/CRT.cert : | workshops/1999/embedded/Proof-Of-Contribution/CRT.pcert1
-
-workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.pcert0 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.pcert0 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.pcert0 : \
- workshops/1999/embedded/Proof-Of-Contribution/CRT.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.lisp
-workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.pcert1 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.pcert1 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.pcert1 : workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.pcert0
-workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.cert : | workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.pcert1
-
-workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.pcert0 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.pcert0 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.pcert0 : \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.lisp
-workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.pcert1 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.pcert1 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.pcert1 : workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.pcert0
-workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.cert : | workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.pcert1
-
-workshops/1999/embedded/Proof-Of-Contribution/Generic.pcert0 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Generic.pcert0 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Generic.pcert0 : \
- workshops/1999/embedded/Proof-Of-Contribution/Generic.lisp
-workshops/1999/embedded/Proof-Of-Contribution/Generic.pcert1 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Generic.pcert1 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Generic.pcert1 : workshops/1999/embedded/Proof-Of-Contribution/Generic.pcert0
-workshops/1999/embedded/Proof-Of-Contribution/Generic.cert : | workshops/1999/embedded/Proof-Of-Contribution/Generic.pcert1
-
-workshops/1999/embedded/Proof-Of-Contribution/Mapping.pcert0 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Mapping.pcert0 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Mapping.pcert0 : \
- workshops/1999/embedded/Proof-Of-Contribution/Generic.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/Mapping.lisp
-workshops/1999/embedded/Proof-Of-Contribution/Mapping.pcert1 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Mapping.pcert1 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Mapping.pcert1 : workshops/1999/embedded/Proof-Of-Contribution/Mapping.pcert0
-workshops/1999/embedded/Proof-Of-Contribution/Mapping.cert : | workshops/1999/embedded/Proof-Of-Contribution/Mapping.pcert1
-
-workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.pcert0 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.pcert0 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.pcert0 : \
- workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.lisp
-workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.pcert1 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.pcert1 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.pcert1 : workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.pcert0
-workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.cert : | workshops/1999/embedded/Proof-Of-Contribution/Memory-Assoc.pcert1
-
-workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.pcert0 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.pcert0 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.pcert0 : \
- workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.lisp
-workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.pcert1 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.pcert1 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.pcert1 : workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.pcert0
-workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.cert : | workshops/1999/embedded/Proof-Of-Contribution/Minimal-Mod-Lemmas.pcert1
-
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.pcert0 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.pcert0 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.pcert0 : \
- workshops/1999/embedded/Proof-Of-Contribution/Disjoint-lists.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.lisp
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.pcert1 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.pcert1 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.pcert1 : workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.pcert0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.cert : | workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.pcert1
-
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.pcert0 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.pcert0 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.pcert0 : \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness-OneCycle.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.lisp
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.pcert1 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.pcert1 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.pcert1 : workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.pcert0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.cert : | workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Correctness.pcert1
-
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.pcert0 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.pcert0 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.pcert0 : \
- workshops/1999/embedded/Proof-Of-Contribution/CRTcorollaries.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/Mapping.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.lisp
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.pcert1 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.pcert1 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.pcert1 : workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.pcert0
-workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.cert : | workshops/1999/embedded/Proof-Of-Contribution/Proof-Of-Equiv-From-M-Corr.pcert1
-
-workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.pcert0 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.pcert0 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.pcert0 : \
- ihs/ihs-init.pcert0 \
- ihs/ihs-theories.pcert0 \
- ihs/math-lemmas.pcert0 \
- workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.lisp
-workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.pcert1 : acl2x = 0
-workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.pcert1 : no_pcert = 0
-workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.pcert1 : workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.pcert0
-workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.cert : | workshops/1999/embedded/Proof-Of-Contribution/private-qr-lemmas.pcert1
-
-workshops/1999/graph/find-path1.pcert0 : no_pcert = 0
-workshops/1999/graph/find-path1.pcert0 : acl2x = 0
-workshops/1999/graph/find-path1.pcert0 : \
- arithmetic/top.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/graph/find-path1.lisp
-workshops/1999/graph/find-path1.pcert1 : acl2x = 0
-workshops/1999/graph/find-path1.pcert1 : no_pcert = 0
-workshops/1999/graph/find-path1.pcert1 : workshops/1999/graph/find-path1.pcert0
-workshops/1999/graph/find-path1.cert : | workshops/1999/graph/find-path1.pcert1
-
-workshops/1999/graph/find-path2.pcert0 : no_pcert = 0
-workshops/1999/graph/find-path2.pcert0 : acl2x = 0
-workshops/1999/graph/find-path2.pcert0 : \
- arithmetic/top.pcert0 \
- workshops/1999/graph/helpers.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/graph/find-path2.lisp
-workshops/1999/graph/find-path2.pcert1 : acl2x = 0
-workshops/1999/graph/find-path2.pcert1 : no_pcert = 0
-workshops/1999/graph/find-path2.pcert1 : workshops/1999/graph/find-path2.pcert0
-workshops/1999/graph/find-path2.cert : | workshops/1999/graph/find-path2.pcert1
-
-workshops/1999/graph/find-path3.pcert0 : no_pcert = 0
-workshops/1999/graph/find-path3.pcert0 : acl2x = 0
-workshops/1999/graph/find-path3.pcert0 : \
- arithmetic/top.pcert0 \
- workshops/1999/graph/helpers.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/graph/find-path3.lisp
-workshops/1999/graph/find-path3.pcert1 : acl2x = 0
-workshops/1999/graph/find-path3.pcert1 : no_pcert = 0
-workshops/1999/graph/find-path3.pcert1 : workshops/1999/graph/find-path3.pcert0
-workshops/1999/graph/find-path3.cert : | workshops/1999/graph/find-path3.pcert1
-
-workshops/1999/graph/helpers.pcert0 : no_pcert = 0
-workshops/1999/graph/helpers.pcert0 : acl2x = 0
-workshops/1999/graph/helpers.pcert0 : \
- workshops/1999/graph/helpers.lisp
-workshops/1999/graph/helpers.pcert1 : acl2x = 0
-workshops/1999/graph/helpers.pcert1 : no_pcert = 0
-workshops/1999/graph/helpers.pcert1 : workshops/1999/graph/helpers.pcert0
-workshops/1999/graph/helpers.cert : | workshops/1999/graph/helpers.pcert1
-
-workshops/1999/graph/linear-find-path.pcert0 : no_pcert = 0
-workshops/1999/graph/linear-find-path.pcert0 : acl2x = 0
-workshops/1999/graph/linear-find-path.pcert0 : \
- workshops/1999/graph/find-path3.pcert0 \
- workshops/1999/graph/linear-find-path.lisp
-workshops/1999/graph/linear-find-path.pcert1 : acl2x = 0
-workshops/1999/graph/linear-find-path.pcert1 : no_pcert = 0
-workshops/1999/graph/linear-find-path.pcert1 : workshops/1999/graph/linear-find-path.pcert0
-workshops/1999/graph/linear-find-path.cert : | workshops/1999/graph/linear-find-path.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/alls.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/alls.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/alls.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/variables.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/alls.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/alls.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/alls.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/alls.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/alls.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/alls.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/alls.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.pcert0 : \
- arithmetic/top.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sets.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/base.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/keval.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/close.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/cnf.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/cnf.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/cnf.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/cnf.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/cnf.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/cnf.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/cnf.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/cnf.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/cnf.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/cnf.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/derive.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/derive.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/derive.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/substitution.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/resolve.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/paramod.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/flip.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/derive.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/derive.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/derive.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/derive.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/derive.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/derive.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/derive.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution1.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution2.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution3.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution4.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution5.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/exercises/solution6.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/flip.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/flip.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/flip.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/paramod.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/flip.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/flip.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/flip.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/flip.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/flip.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/flip.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/flip.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/instance.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/instance.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/instance.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/instance.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/instance.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/keval.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/keval.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/keval.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/keval.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/keval.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/keval.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/keval.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/keval.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/keval.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/keval.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/modeler.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/modeler.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/modeler.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/nnf.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/cnf.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/derive.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/modeler.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/modeler.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/modeler.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/modeler.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/modeler.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/modeler.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/modeler.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/nnf.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/nnf.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/nnf.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/nnf.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/nnf.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/nnf.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/nnf.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/nnf.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/nnf.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/nnf.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/paramod.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/paramod.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/paramod.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/paramod.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/paramod.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/paramod.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/paramod.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/paramod.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/paramod.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/paramod.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sets.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/permutations.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/prop-subsume.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/prover.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/prover.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/prover.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/nnf.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/cnf.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/derive.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/simplify.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/prover.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/prover.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/prover.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/prover.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/prover.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/prover.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/prover.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-sound.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-pulls.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/pull-top.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/pull.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/pull.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/pull.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/pull.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/pull.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/pull.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/xeval.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-sound.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/rename-top.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/rename-unique.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/rename.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/rename.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/rename.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/rename.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/rename.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/rename.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/resolve.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/resolve.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/resolve.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/resolve.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/resolve.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/resolve.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/resolve.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/resolve.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/resolve.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/resolve.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/right-assoc.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sets.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sets.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sets.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sets.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/sets.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sets.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sets.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/sets.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/sets.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/sets.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/derive.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/simple-check.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/simplify.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simplify.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simplify.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/simplify.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/simplify.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simplify.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simplify.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/simplify.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/simplify.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/simplify.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/substitution.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/simultaneous-d.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-misc-lemmas.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-useless.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/arithmetic.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/sk-xbuild.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/sk-step-sound.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/permutations.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/skolem-top.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/xeval.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/stage.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/substitution.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/substitution.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/substitution.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/instance-closure.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/gensym-e.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/substitution.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/substitution.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/substitution.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/substitution.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/substitution.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/substitution.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/substitution.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/sugar.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sugar.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sugar.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/sugar.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/sugar.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sugar.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/sugar.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/sugar.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/sugar.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/sugar.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/top.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/top.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/top.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/prover.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/modeler.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/top.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/top.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/top.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/top.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/top.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/top.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/top.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/stage.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/close.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/uc-conj.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/variables.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/variables.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/variables.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/variables.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/variables.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/variables.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/variables.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/variables.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/variables.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/variables.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/alls.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/wfftype.pcert1
-
-workshops/1999/ivy/ivy-v2/ivy-sources/xeval.pcert0 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/xeval.pcert0 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/xeval.pcert0 : \
- workshops/1999/ivy/ivy-v2/ivy-sources/base.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/ivy/ivy-v2/ivy-sources/xeval.lisp
-workshops/1999/ivy/ivy-v2/ivy-sources/xeval.pcert1 : acl2x = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/xeval.pcert1 : no_pcert = 0
-workshops/1999/ivy/ivy-v2/ivy-sources/xeval.pcert1 : workshops/1999/ivy/ivy-v2/ivy-sources/xeval.pcert0
-workshops/1999/ivy/ivy-v2/ivy-sources/xeval.cert : | workshops/1999/ivy/ivy-v2/ivy-sources/xeval.pcert1
-
-workshops/1999/knuth-91/aof.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/aof.pcert0 : acl2x = 0
-workshops/1999/knuth-91/aof.pcert0 : \
- arithmetic/inequalities.pcert0 \
- workshops/1999/knuth-91/aof.lisp \
- workshops/1999/knuth-91/aof.acl2
-workshops/1999/knuth-91/aof.pcert1 : acl2x = 0
-workshops/1999/knuth-91/aof.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/aof.pcert1 : workshops/1999/knuth-91/aof.pcert0
-workshops/1999/knuth-91/aof.cert : | workshops/1999/knuth-91/aof.pcert1
-
-workshops/1999/knuth-91/exercise1.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/exercise1.pcert0 : acl2x = 0
-workshops/1999/knuth-91/exercise1.pcert0 : \
- workshops/1999/knuth-91/exercise1.lisp \
- workshops/1999/knuth-91/exercise1.acl2
-workshops/1999/knuth-91/exercise1.pcert1 : acl2x = 0
-workshops/1999/knuth-91/exercise1.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/exercise1.pcert1 : workshops/1999/knuth-91/exercise1.pcert0
-workshops/1999/knuth-91/exercise1.cert : | workshops/1999/knuth-91/exercise1.pcert1
-
-workshops/1999/knuth-91/exercise2.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/exercise2.pcert0 : acl2x = 0
-workshops/1999/knuth-91/exercise2.pcert0 : \
- workshops/1999/knuth-91/exercise2.lisp
-workshops/1999/knuth-91/exercise2.pcert1 : acl2x = 0
-workshops/1999/knuth-91/exercise2.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/exercise2.pcert1 : workshops/1999/knuth-91/exercise2.pcert0
-workshops/1999/knuth-91/exercise2.cert : | workshops/1999/knuth-91/exercise2.pcert1
-
-workshops/1999/knuth-91/exercise3.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/exercise3.pcert0 : acl2x = 0
-workshops/1999/knuth-91/exercise3.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/knuth-91/exercise3.lisp
-workshops/1999/knuth-91/exercise3.pcert1 : acl2x = 0
-workshops/1999/knuth-91/exercise3.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/exercise3.pcert1 : workshops/1999/knuth-91/exercise3.pcert0
-workshops/1999/knuth-91/exercise3.cert : | workshops/1999/knuth-91/exercise3.pcert1
-
-workshops/1999/knuth-91/exercise4a.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/exercise4a.pcert0 : acl2x = 0
-workshops/1999/knuth-91/exercise4a.pcert0 : \
- workshops/1999/knuth-91/exercise4a.lisp
-workshops/1999/knuth-91/exercise4a.pcert1 : acl2x = 0
-workshops/1999/knuth-91/exercise4a.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/exercise4a.pcert1 : workshops/1999/knuth-91/exercise4a.pcert0
-workshops/1999/knuth-91/exercise4a.cert : | workshops/1999/knuth-91/exercise4a.pcert1
-
-workshops/1999/knuth-91/exercise4b.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/exercise4b.pcert0 : acl2x = 0
-workshops/1999/knuth-91/exercise4b.pcert0 : \
- workshops/1999/knuth-91/exercise4b.lisp
-workshops/1999/knuth-91/exercise4b.pcert1 : acl2x = 0
-workshops/1999/knuth-91/exercise4b.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/exercise4b.pcert1 : workshops/1999/knuth-91/exercise4b.pcert0
-workshops/1999/knuth-91/exercise4b.cert : | workshops/1999/knuth-91/exercise4b.pcert1
-
-workshops/1999/knuth-91/exercise5.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/exercise5.pcert0 : acl2x = 0
-workshops/1999/knuth-91/exercise5.pcert0 : \
- workshops/1999/knuth-91/exercise5.lisp
-workshops/1999/knuth-91/exercise5.pcert1 : acl2x = 0
-workshops/1999/knuth-91/exercise5.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/exercise5.pcert1 : workshops/1999/knuth-91/exercise5.pcert0
-workshops/1999/knuth-91/exercise5.cert : | workshops/1999/knuth-91/exercise5.pcert1
-
-workshops/1999/knuth-91/exercise6a.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/exercise6a.pcert0 : acl2x = 0
-workshops/1999/knuth-91/exercise6a.pcert0 : \
- workshops/1999/knuth-91/exercise6a.lisp
-workshops/1999/knuth-91/exercise6a.pcert1 : acl2x = 0
-workshops/1999/knuth-91/exercise6a.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/exercise6a.pcert1 : workshops/1999/knuth-91/exercise6a.pcert0
-workshops/1999/knuth-91/exercise6a.cert : | workshops/1999/knuth-91/exercise6a.pcert1
-
-workshops/1999/knuth-91/exercise6b.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/exercise6b.pcert0 : acl2x = 0
-workshops/1999/knuth-91/exercise6b.pcert0 : \
- workshops/1999/knuth-91/exercise6b.lisp
-workshops/1999/knuth-91/exercise6b.pcert1 : acl2x = 0
-workshops/1999/knuth-91/exercise6b.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/exercise6b.pcert1 : workshops/1999/knuth-91/exercise6b.pcert0
-workshops/1999/knuth-91/exercise6b.cert : | workshops/1999/knuth-91/exercise6b.pcert1
-
-workshops/1999/knuth-91/exercise7a.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/exercise7a.pcert0 : acl2x = 0
-workshops/1999/knuth-91/exercise7a.pcert0 : \
- workshops/1999/knuth-91/exercise7a.lisp
-workshops/1999/knuth-91/exercise7a.pcert1 : acl2x = 0
-workshops/1999/knuth-91/exercise7a.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/exercise7a.pcert1 : workshops/1999/knuth-91/exercise7a.pcert0
-workshops/1999/knuth-91/exercise7a.cert : | workshops/1999/knuth-91/exercise7a.pcert1
-
-workshops/1999/knuth-91/exercise7b.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/exercise7b.pcert0 : acl2x = 0
-workshops/1999/knuth-91/exercise7b.pcert0 : \
- workshops/1999/knuth-91/exercise7b.lisp
-workshops/1999/knuth-91/exercise7b.pcert1 : acl2x = 0
-workshops/1999/knuth-91/exercise7b.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/exercise7b.pcert1 : workshops/1999/knuth-91/exercise7b.pcert0
-workshops/1999/knuth-91/exercise7b.cert : | workshops/1999/knuth-91/exercise7b.pcert1
-
-workshops/1999/knuth-91/knuth-arch.pcert0 : no_pcert = 0
-workshops/1999/knuth-91/knuth-arch.pcert0 : acl2x = 0
-workshops/1999/knuth-91/knuth-arch.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/knuth-91/aof.pcert0 \
- workshops/1999/knuth-91/knuth-arch.lisp
-workshops/1999/knuth-91/knuth-arch.pcert1 : acl2x = 0
-workshops/1999/knuth-91/knuth-arch.pcert1 : no_pcert = 0
-workshops/1999/knuth-91/knuth-arch.pcert1 : workshops/1999/knuth-91/knuth-arch.pcert0
-workshops/1999/knuth-91/knuth-arch.cert : | workshops/1999/knuth-91/knuth-arch.pcert1
-
-workshops/1999/mu-calculus/book/fast-sets.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/book/fast-sets.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/book/fast-sets.pcert0 : \
- workshops/1999/mu-calculus/book/sets.pcert0 \
- workshops/1999/mu-calculus/book/fast-sets.lisp \
- workshops/1999/mu-calculus/book/fast-sets.acl2
-workshops/1999/mu-calculus/book/fast-sets.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/book/fast-sets.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/book/fast-sets.pcert1 : workshops/1999/mu-calculus/book/fast-sets.pcert0
-workshops/1999/mu-calculus/book/fast-sets.cert : | workshops/1999/mu-calculus/book/fast-sets.pcert1
-
-workshops/1999/mu-calculus/book/fixpoints.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/book/fixpoints.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/book/fixpoints.pcert0 : \
- workshops/1999/mu-calculus/book/sets.pcert0 \
- workshops/1999/mu-calculus/book/fixpoints.lisp \
- workshops/1999/mu-calculus/book/fixpoints.acl2
-workshops/1999/mu-calculus/book/fixpoints.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/book/fixpoints.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/book/fixpoints.pcert1 : workshops/1999/mu-calculus/book/fixpoints.pcert0
-workshops/1999/mu-calculus/book/fixpoints.cert : | workshops/1999/mu-calculus/book/fixpoints.pcert1
-
-workshops/1999/mu-calculus/book/models.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/book/models.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/book/models.pcert0 : \
- workshops/1999/mu-calculus/book/relations.pcert0 \
- workshops/1999/mu-calculus/book/fixpoints.pcert0 \
- workshops/1999/mu-calculus/book/models.lisp \
- workshops/1999/mu-calculus/book/models.acl2
-workshops/1999/mu-calculus/book/models.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/book/models.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/book/models.pcert1 : workshops/1999/mu-calculus/book/models.pcert0
-workshops/1999/mu-calculus/book/models.cert : | workshops/1999/mu-calculus/book/models.pcert1
-
-workshops/1999/mu-calculus/book/relations.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/book/relations.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/book/relations.pcert0 : \
- workshops/1999/mu-calculus/book/fast-sets.pcert0 \
- workshops/1999/mu-calculus/book/relations.lisp \
- workshops/1999/mu-calculus/book/relations.acl2
-workshops/1999/mu-calculus/book/relations.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/book/relations.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/book/relations.pcert1 : workshops/1999/mu-calculus/book/relations.pcert0
-workshops/1999/mu-calculus/book/relations.cert : | workshops/1999/mu-calculus/book/relations.pcert1
-
-workshops/1999/mu-calculus/book/semantics.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/book/semantics.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/book/semantics.pcert0 : \
- workshops/1999/mu-calculus/book/syntax.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/mu-calculus/book/semantics.lisp \
- workshops/1999/mu-calculus/book/semantics.acl2
-workshops/1999/mu-calculus/book/semantics.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/book/semantics.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/book/semantics.pcert1 : workshops/1999/mu-calculus/book/semantics.pcert0
-workshops/1999/mu-calculus/book/semantics.cert : | workshops/1999/mu-calculus/book/semantics.pcert1
-
-workshops/1999/mu-calculus/book/sets.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/book/sets.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/book/sets.pcert0 : \
- workshops/1999/mu-calculus/book/sets.lisp \
- workshops/1999/mu-calculus/book/sets.acl2
-workshops/1999/mu-calculus/book/sets.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/book/sets.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/book/sets.pcert1 : workshops/1999/mu-calculus/book/sets.pcert0
-workshops/1999/mu-calculus/book/sets.cert : | workshops/1999/mu-calculus/book/sets.pcert1
-
-workshops/1999/mu-calculus/book/syntax.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/book/syntax.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/book/syntax.pcert0 : \
- workshops/1999/mu-calculus/book/models.pcert0 \
- workshops/1999/mu-calculus/book/syntax.lisp \
- workshops/1999/mu-calculus/book/syntax.acl2
-workshops/1999/mu-calculus/book/syntax.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/book/syntax.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/book/syntax.pcert1 : workshops/1999/mu-calculus/book/syntax.pcert0
-workshops/1999/mu-calculus/book/syntax.cert : | workshops/1999/mu-calculus/book/syntax.pcert1
-
-workshops/1999/mu-calculus/solutions/ctl.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/ctl.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/solutions/ctl.pcert0 : \
- workshops/1999/mu-calculus/solutions/semantics.pcert0 \
- workshops/1999/mu-calculus/solutions/ctl.lisp \
- workshops/1999/mu-calculus/solutions/ctl.acl2
-workshops/1999/mu-calculus/solutions/ctl.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/solutions/ctl.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/ctl.pcert1 : workshops/1999/mu-calculus/solutions/ctl.pcert0
-workshops/1999/mu-calculus/solutions/ctl.cert : | workshops/1999/mu-calculus/solutions/ctl.pcert1
-
-workshops/1999/mu-calculus/solutions/defung.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/defung.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/solutions/defung.pcert0 : \
- workshops/1999/mu-calculus/solutions/defung.lisp
-workshops/1999/mu-calculus/solutions/defung.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/solutions/defung.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/defung.pcert1 : workshops/1999/mu-calculus/solutions/defung.pcert0
-workshops/1999/mu-calculus/solutions/defung.cert : | workshops/1999/mu-calculus/solutions/defung.pcert1
-
-workshops/1999/mu-calculus/solutions/fast-sets.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/fast-sets.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/solutions/fast-sets.pcert0 : \
- workshops/1999/mu-calculus/solutions/sets.pcert0 \
- workshops/1999/mu-calculus/solutions/fast-sets.lisp \
- workshops/1999/mu-calculus/solutions/fast-sets.acl2
-workshops/1999/mu-calculus/solutions/fast-sets.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/solutions/fast-sets.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/fast-sets.pcert1 : workshops/1999/mu-calculus/solutions/fast-sets.pcert0
-workshops/1999/mu-calculus/solutions/fast-sets.cert : | workshops/1999/mu-calculus/solutions/fast-sets.pcert1
-
-workshops/1999/mu-calculus/solutions/fixpoints.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/fixpoints.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/solutions/fixpoints.pcert0 : \
- workshops/1999/mu-calculus/solutions/sets.pcert0 \
- workshops/1999/mu-calculus/solutions/fixpoints.lisp \
- workshops/1999/mu-calculus/solutions/fixpoints.acl2
-workshops/1999/mu-calculus/solutions/fixpoints.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/solutions/fixpoints.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/fixpoints.pcert1 : workshops/1999/mu-calculus/solutions/fixpoints.pcert0
-workshops/1999/mu-calculus/solutions/fixpoints.cert : | workshops/1999/mu-calculus/solutions/fixpoints.pcert1
-
-workshops/1999/mu-calculus/solutions/meta.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/meta.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/solutions/meta.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- workshops/1999/mu-calculus/solutions/meta.lisp
-workshops/1999/mu-calculus/solutions/meta.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/solutions/meta.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/meta.pcert1 : workshops/1999/mu-calculus/solutions/meta.pcert0
-workshops/1999/mu-calculus/solutions/meta.cert : | workshops/1999/mu-calculus/solutions/meta.pcert1
-
-workshops/1999/mu-calculus/solutions/models.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/models.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/solutions/models.pcert0 : \
- workshops/1999/mu-calculus/solutions/relations.pcert0 \
- workshops/1999/mu-calculus/solutions/models.lisp \
- workshops/1999/mu-calculus/solutions/models.acl2
-workshops/1999/mu-calculus/solutions/models.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/solutions/models.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/models.pcert1 : workshops/1999/mu-calculus/solutions/models.pcert0
-workshops/1999/mu-calculus/solutions/models.cert : | workshops/1999/mu-calculus/solutions/models.pcert1
-
-workshops/1999/mu-calculus/solutions/perm.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/perm.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/solutions/perm.pcert0 : \
- workshops/1999/mu-calculus/solutions/defung.pcert0 \
- workshops/1999/mu-calculus/solutions/perm.lisp
-workshops/1999/mu-calculus/solutions/perm.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/solutions/perm.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/perm.pcert1 : workshops/1999/mu-calculus/solutions/perm.pcert0
-workshops/1999/mu-calculus/solutions/perm.cert : | workshops/1999/mu-calculus/solutions/perm.pcert1
-
-workshops/1999/mu-calculus/solutions/relations.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/relations.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/solutions/relations.pcert0 : \
- workshops/1999/mu-calculus/solutions/fast-sets.pcert0 \
- workshops/1999/mu-calculus/solutions/relations.lisp \
- workshops/1999/mu-calculus/solutions/relations.acl2
-workshops/1999/mu-calculus/solutions/relations.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/solutions/relations.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/relations.pcert1 : workshops/1999/mu-calculus/solutions/relations.pcert0
-workshops/1999/mu-calculus/solutions/relations.cert : | workshops/1999/mu-calculus/solutions/relations.pcert1
-
-workshops/1999/mu-calculus/solutions/semantics.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/semantics.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/solutions/semantics.pcert0 : \
- workshops/1999/mu-calculus/solutions/syntax.pcert0 \
- workshops/1999/mu-calculus/solutions/fixpoints.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/1999/mu-calculus/solutions/semantics.lisp \
- workshops/1999/mu-calculus/solutions/semantics.acl2
-workshops/1999/mu-calculus/solutions/semantics.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/solutions/semantics.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/semantics.pcert1 : workshops/1999/mu-calculus/solutions/semantics.pcert0
-workshops/1999/mu-calculus/solutions/semantics.cert : | workshops/1999/mu-calculus/solutions/semantics.pcert1
-
-workshops/1999/mu-calculus/solutions/sets.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/sets.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/solutions/sets.pcert0 : \
- workshops/1999/mu-calculus/solutions/defung.pcert0 \
- workshops/1999/mu-calculus/solutions/meta.pcert0 \
- workshops/1999/mu-calculus/solutions/perm.pcert0 \
- workshops/1999/mu-calculus/solutions/sets.lisp \
- workshops/1999/mu-calculus/solutions/sets.acl2
-workshops/1999/mu-calculus/solutions/sets.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/solutions/sets.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/sets.pcert1 : workshops/1999/mu-calculus/solutions/sets.pcert0
-workshops/1999/mu-calculus/solutions/sets.cert : | workshops/1999/mu-calculus/solutions/sets.pcert1
-
-workshops/1999/mu-calculus/solutions/syntax.pcert0 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/syntax.pcert0 : acl2x = 0
-workshops/1999/mu-calculus/solutions/syntax.pcert0 : \
- workshops/1999/mu-calculus/solutions/models.pcert0 \
- workshops/1999/mu-calculus/solutions/syntax.lisp \
- workshops/1999/mu-calculus/solutions/syntax.acl2
-workshops/1999/mu-calculus/solutions/syntax.pcert1 : acl2x = 0
-workshops/1999/mu-calculus/solutions/syntax.pcert1 : no_pcert = 0
-workshops/1999/mu-calculus/solutions/syntax.pcert1 : workshops/1999/mu-calculus/solutions/syntax.pcert0
-workshops/1999/mu-calculus/solutions/syntax.cert : | workshops/1999/mu-calculus/solutions/syntax.pcert1
-
-workshops/1999/pipeline/b-ops-aux-def.pcert0 : no_pcert = 0
-workshops/1999/pipeline/b-ops-aux-def.pcert0 : acl2x = 0
-workshops/1999/pipeline/b-ops-aux-def.pcert0 : \
- workshops/1999/pipeline/trivia.pcert0 \
- workshops/1999/pipeline/ihs.pcert0 \
- workshops/1999/pipeline/b-ops-aux-def.lisp
-workshops/1999/pipeline/b-ops-aux-def.pcert1 : acl2x = 0
-workshops/1999/pipeline/b-ops-aux-def.pcert1 : no_pcert = 0
-workshops/1999/pipeline/b-ops-aux-def.pcert1 : workshops/1999/pipeline/b-ops-aux-def.pcert0
-workshops/1999/pipeline/b-ops-aux-def.cert : | workshops/1999/pipeline/b-ops-aux-def.pcert1
-
-workshops/1999/pipeline/b-ops-aux.pcert0 : no_pcert = 0
-workshops/1999/pipeline/b-ops-aux.pcert0 : acl2x = 0
-workshops/1999/pipeline/b-ops-aux.pcert0 : \
- workshops/1999/pipeline/b-ops-aux-def.pcert0 \
- workshops/1999/pipeline/b-ops-aux.lisp
-workshops/1999/pipeline/b-ops-aux.pcert1 : acl2x = 0
-workshops/1999/pipeline/b-ops-aux.pcert1 : no_pcert = 0
-workshops/1999/pipeline/b-ops-aux.pcert1 : workshops/1999/pipeline/b-ops-aux.pcert0
-workshops/1999/pipeline/b-ops-aux.cert : | workshops/1999/pipeline/b-ops-aux.pcert1
-
-workshops/1999/pipeline/basic-def.pcert0 : no_pcert = 0
-workshops/1999/pipeline/basic-def.pcert0 : acl2x = 0
-workshops/1999/pipeline/basic-def.pcert0 : \
- data-structures/array1.pcert0 \
- data-structures/deflist.pcert0 \
- data-structures/list-defthms.pcert0 \
- data-structures/structures.pcert0 \
- workshops/1999/pipeline/ihs.pcert0 \
- workshops/1999/pipeline/trivia.pcert0 \
- workshops/1999/pipeline/b-ops-aux.pcert0 \
- workshops/1999/pipeline/basic-def.lisp \
- workshops/1999/pipeline/basic-def.acl2 \
- workshops/1999/pipeline/define-u-package.lsp
-workshops/1999/pipeline/basic-def.pcert1 : acl2x = 0
-workshops/1999/pipeline/basic-def.pcert1 : no_pcert = 0
-workshops/1999/pipeline/basic-def.pcert1 : workshops/1999/pipeline/basic-def.pcert0
-workshops/1999/pipeline/basic-def.cert : | workshops/1999/pipeline/basic-def.pcert1
-
-workshops/1999/pipeline/basic-lemmas.pcert0 : no_pcert = 0
-workshops/1999/pipeline/basic-lemmas.pcert0 : acl2x = 0
-workshops/1999/pipeline/basic-lemmas.pcert0 : \
- workshops/1999/pipeline/basic-def.pcert0 \
- workshops/1999/pipeline/model.pcert0 \
- workshops/1999/pipeline/table-def.pcert0 \
- workshops/1999/pipeline/basic-lemmas.lisp
-workshops/1999/pipeline/basic-lemmas.pcert1 : acl2x = 0
-workshops/1999/pipeline/basic-lemmas.pcert1 : no_pcert = 0
-workshops/1999/pipeline/basic-lemmas.pcert1 : workshops/1999/pipeline/basic-lemmas.pcert0
-workshops/1999/pipeline/basic-lemmas.cert : | workshops/1999/pipeline/basic-lemmas.pcert1
-
-workshops/1999/pipeline/exercise.pcert0 : no_pcert = 0
-workshops/1999/pipeline/exercise.pcert0 : acl2x = 0
-workshops/1999/pipeline/exercise.pcert0 : \
- workshops/1999/pipeline/exercise.lisp
-workshops/1999/pipeline/exercise.pcert1 : acl2x = 0
-workshops/1999/pipeline/exercise.pcert1 : no_pcert = 0
-workshops/1999/pipeline/exercise.pcert1 : workshops/1999/pipeline/exercise.pcert0
-workshops/1999/pipeline/exercise.cert : | workshops/1999/pipeline/exercise.pcert1
-
-workshops/1999/pipeline/ihs.pcert0 : no_pcert = 0
-workshops/1999/pipeline/ihs.pcert0 : acl2x = 0
-workshops/1999/pipeline/ihs.pcert0 : \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- workshops/1999/pipeline/ihs.lisp
-workshops/1999/pipeline/ihs.pcert1 : acl2x = 0
-workshops/1999/pipeline/ihs.pcert1 : no_pcert = 0
-workshops/1999/pipeline/ihs.pcert1 : workshops/1999/pipeline/ihs.pcert0
-workshops/1999/pipeline/ihs.cert : | workshops/1999/pipeline/ihs.pcert1
-
-workshops/1999/pipeline/model.pcert0 : no_pcert = 0
-workshops/1999/pipeline/model.pcert0 : acl2x = 0
-workshops/1999/pipeline/model.pcert0 : \
- workshops/1999/pipeline/basic-def.pcert0 \
- workshops/1999/pipeline/model.lisp
-workshops/1999/pipeline/model.pcert1 : acl2x = 0
-workshops/1999/pipeline/model.pcert1 : no_pcert = 0
-workshops/1999/pipeline/model.pcert1 : workshops/1999/pipeline/model.pcert0
-workshops/1999/pipeline/model.cert : | workshops/1999/pipeline/model.pcert1
-
-workshops/1999/pipeline/proof.pcert0 : no_pcert = 0
-workshops/1999/pipeline/proof.pcert0 : acl2x = 0
-workshops/1999/pipeline/proof.pcert0 : \
- workshops/1999/pipeline/basic-def.pcert0 \
- workshops/1999/pipeline/model.pcert0 \
- workshops/1999/pipeline/table-def.pcert0 \
- workshops/1999/pipeline/basic-lemmas.pcert0 \
- workshops/1999/pipeline/proof.lisp
-workshops/1999/pipeline/proof.pcert1 : acl2x = 0
-workshops/1999/pipeline/proof.pcert1 : no_pcert = 0
-workshops/1999/pipeline/proof.pcert1 : workshops/1999/pipeline/proof.pcert0
-workshops/1999/pipeline/proof.cert : | workshops/1999/pipeline/proof.pcert1
-
-workshops/1999/pipeline/table-def.pcert0 : no_pcert = 0
-workshops/1999/pipeline/table-def.pcert0 : acl2x = 0
-workshops/1999/pipeline/table-def.pcert0 : \
- workshops/1999/pipeline/utils.pcert0 \
- workshops/1999/pipeline/basic-def.pcert0 \
- workshops/1999/pipeline/model.pcert0 \
- workshops/1999/pipeline/table-def.lisp
-workshops/1999/pipeline/table-def.pcert1 : acl2x = 0
-workshops/1999/pipeline/table-def.pcert1 : no_pcert = 0
-workshops/1999/pipeline/table-def.pcert1 : workshops/1999/pipeline/table-def.pcert0
-workshops/1999/pipeline/table-def.cert : | workshops/1999/pipeline/table-def.pcert1
-
-workshops/1999/pipeline/trivia.pcert0 : no_pcert = 0
-workshops/1999/pipeline/trivia.pcert0 : acl2x = 0
-workshops/1999/pipeline/trivia.pcert0 : \
- data-structures/array1.pcert0 \
- arithmetic/top.pcert0 \
- workshops/1999/pipeline/trivia.lisp
-workshops/1999/pipeline/trivia.pcert1 : acl2x = 0
-workshops/1999/pipeline/trivia.pcert1 : no_pcert = 0
-workshops/1999/pipeline/trivia.pcert1 : workshops/1999/pipeline/trivia.pcert0
-workshops/1999/pipeline/trivia.cert : | workshops/1999/pipeline/trivia.pcert1
-
-workshops/1999/pipeline/utils.pcert0 : no_pcert = 0
-workshops/1999/pipeline/utils.pcert0 : acl2x = 0
-workshops/1999/pipeline/utils.pcert0 : \
- data-structures/utilities.pcert0 \
- workshops/1999/pipeline/utils.lisp \
- workshops/1999/pipeline/utils.acl2 \
- workshops/1999/pipeline/define-u-package.lsp
-workshops/1999/pipeline/utils.pcert1 : acl2x = 0
-workshops/1999/pipeline/utils.pcert1 : no_pcert = 0
-workshops/1999/pipeline/utils.pcert1 : workshops/1999/pipeline/utils.pcert0
-workshops/1999/pipeline/utils.cert : | workshops/1999/pipeline/utils.pcert1
-
-workshops/1999/simulator/exercises.pcert0 : no_pcert = 0
-workshops/1999/simulator/exercises.pcert0 : acl2x = 0
-workshops/1999/simulator/exercises.pcert0 : \
- workshops/1999/simulator/tiny.pcert0 \
- workshops/1999/simulator/exercises.lisp
-workshops/1999/simulator/exercises.pcert1 : acl2x = 0
-workshops/1999/simulator/exercises.pcert1 : no_pcert = 0
-workshops/1999/simulator/exercises.pcert1 : workshops/1999/simulator/exercises.pcert0
-workshops/1999/simulator/exercises.cert : | workshops/1999/simulator/exercises.pcert1
-
-workshops/1999/simulator/tiny.pcert0 : no_pcert = 0
-workshops/1999/simulator/tiny.pcert0 : acl2x = 0
-workshops/1999/simulator/tiny.pcert0 : \
- arithmetic/top.pcert0 \
- data-structures/list-defthms.pcert0 \
- meta/meta.pcert0 \
- ihs/logops-lemmas.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/1999/simulator/tiny.lisp
-workshops/1999/simulator/tiny.pcert1 : acl2x = 0
-workshops/1999/simulator/tiny.pcert1 : no_pcert = 0
-workshops/1999/simulator/tiny.pcert1 : workshops/1999/simulator/tiny.pcert0
-workshops/1999/simulator/tiny.cert : | workshops/1999/simulator/tiny.pcert1
-
-workshops/1999/ste/assertion.pcert0 : no_pcert = 0
-workshops/1999/ste/assertion.pcert0 : acl2x = 0
-workshops/1999/ste/assertion.pcert0 : \
- workshops/1999/ste/trajectory.pcert0 \
- workshops/1999/ste/assertion.lisp
-workshops/1999/ste/assertion.pcert1 : acl2x = 0
-workshops/1999/ste/assertion.pcert1 : no_pcert = 0
-workshops/1999/ste/assertion.pcert1 : workshops/1999/ste/assertion.pcert0
-workshops/1999/ste/assertion.cert : | workshops/1999/ste/assertion.pcert1
-
-workshops/1999/ste/boolean.pcert0 : no_pcert = 0
-workshops/1999/ste/boolean.pcert0 : acl2x = 0
-workshops/1999/ste/boolean.pcert0 : \
- workshops/1999/ste/util.pcert0 \
- workshops/1999/ste/boolean.lisp
-workshops/1999/ste/boolean.pcert1 : acl2x = 0
-workshops/1999/ste/boolean.pcert1 : no_pcert = 0
-workshops/1999/ste/boolean.pcert1 : workshops/1999/ste/boolean.pcert0
-workshops/1999/ste/boolean.cert : | workshops/1999/ste/boolean.pcert1
-
-workshops/1999/ste/circuit.pcert0 : no_pcert = 0
-workshops/1999/ste/circuit.pcert0 : acl2x = 0
-workshops/1999/ste/circuit.pcert0 : \
- workshops/1999/ste/expression.pcert0 \
- workshops/1999/ste/circuit.lisp
-workshops/1999/ste/circuit.pcert1 : acl2x = 0
-workshops/1999/ste/circuit.pcert1 : no_pcert = 0
-workshops/1999/ste/circuit.pcert1 : workshops/1999/ste/circuit.pcert0
-workshops/1999/ste/circuit.cert : | workshops/1999/ste/circuit.pcert1
-
-workshops/1999/ste/example.pcert0 : no_pcert = 0
-workshops/1999/ste/example.pcert0 : acl2x = 0
-workshops/1999/ste/example.pcert0 : \
- workshops/1999/ste/inference.pcert0 \
- workshops/1999/ste/example.lisp
-workshops/1999/ste/example.pcert1 : acl2x = 0
-workshops/1999/ste/example.pcert1 : no_pcert = 0
-workshops/1999/ste/example.pcert1 : workshops/1999/ste/example.pcert0
-workshops/1999/ste/example.cert : | workshops/1999/ste/example.pcert1
-
-workshops/1999/ste/expression.pcert0 : no_pcert = 0
-workshops/1999/ste/expression.pcert0 : acl2x = 0
-workshops/1999/ste/expression.pcert0 : \
- workshops/1999/ste/run.pcert0 \
- workshops/1999/ste/expression.lisp
-workshops/1999/ste/expression.pcert1 : acl2x = 0
-workshops/1999/ste/expression.pcert1 : no_pcert = 0
-workshops/1999/ste/expression.pcert1 : workshops/1999/ste/expression.pcert0
-workshops/1999/ste/expression.cert : | workshops/1999/ste/expression.pcert1
-
-workshops/1999/ste/fundamental.pcert0 : no_pcert = 0
-workshops/1999/ste/fundamental.pcert0 : acl2x = 0
-workshops/1999/ste/fundamental.pcert0 : \
- workshops/1999/ste/lemma-4.pcert0 \
- workshops/1999/ste/fundamental.lisp
-workshops/1999/ste/fundamental.pcert1 : acl2x = 0
-workshops/1999/ste/fundamental.pcert1 : no_pcert = 0
-workshops/1999/ste/fundamental.pcert1 : workshops/1999/ste/fundamental.pcert0
-workshops/1999/ste/fundamental.cert : | workshops/1999/ste/fundamental.pcert1
-
-workshops/1999/ste/inference.pcert0 : no_pcert = 0
-workshops/1999/ste/inference.pcert0 : acl2x = 0
-workshops/1999/ste/inference.pcert0 : \
- workshops/1999/ste/fundamental.pcert0 \
- workshops/1999/ste/inference.lisp
-workshops/1999/ste/inference.pcert1 : acl2x = 0
-workshops/1999/ste/inference.pcert1 : no_pcert = 0
-workshops/1999/ste/inference.pcert1 : workshops/1999/ste/inference.pcert0
-workshops/1999/ste/inference.cert : | workshops/1999/ste/inference.pcert1
-
-workshops/1999/ste/lemma-4.pcert0 : no_pcert = 0
-workshops/1999/ste/lemma-4.pcert0 : acl2x = 0
-workshops/1999/ste/lemma-4.pcert0 : \
- workshops/1999/ste/assertion.pcert0 \
- workshops/1999/ste/lemma-4.lisp
-workshops/1999/ste/lemma-4.pcert1 : acl2x = 0
-workshops/1999/ste/lemma-4.pcert1 : no_pcert = 0
-workshops/1999/ste/lemma-4.pcert1 : workshops/1999/ste/lemma-4.pcert0
-workshops/1999/ste/lemma-4.cert : | workshops/1999/ste/lemma-4.pcert1
-
-workshops/1999/ste/run.pcert0 : no_pcert = 0
-workshops/1999/ste/run.pcert0 : acl2x = 0
-workshops/1999/ste/run.pcert0 : \
- workshops/1999/ste/state.pcert0 \
- workshops/1999/ste/run.lisp
-workshops/1999/ste/run.pcert1 : acl2x = 0
-workshops/1999/ste/run.pcert1 : no_pcert = 0
-workshops/1999/ste/run.pcert1 : workshops/1999/ste/run.pcert0
-workshops/1999/ste/run.cert : | workshops/1999/ste/run.pcert1
-
-workshops/1999/ste/state.pcert0 : no_pcert = 0
-workshops/1999/ste/state.pcert0 : acl2x = 0
-workshops/1999/ste/state.pcert0 : \
- workshops/1999/ste/boolean.pcert0 \
- workshops/1999/ste/state.lisp
-workshops/1999/ste/state.pcert1 : acl2x = 0
-workshops/1999/ste/state.pcert1 : no_pcert = 0
-workshops/1999/ste/state.pcert1 : workshops/1999/ste/state.pcert0
-workshops/1999/ste/state.cert : | workshops/1999/ste/state.pcert1
-
-workshops/1999/ste/trajectory.pcert0 : no_pcert = 0
-workshops/1999/ste/trajectory.pcert0 : acl2x = 0
-workshops/1999/ste/trajectory.pcert0 : \
- workshops/1999/ste/circuit.pcert0 \
- workshops/1999/ste/trajectory.lisp
-workshops/1999/ste/trajectory.pcert1 : acl2x = 0
-workshops/1999/ste/trajectory.pcert1 : no_pcert = 0
-workshops/1999/ste/trajectory.pcert1 : workshops/1999/ste/trajectory.pcert0
-workshops/1999/ste/trajectory.cert : | workshops/1999/ste/trajectory.pcert1
-
-workshops/1999/ste/util.pcert0 : no_pcert = 0
-workshops/1999/ste/util.pcert0 : acl2x = 0
-workshops/1999/ste/util.pcert0 : \
- data-structures/utilities.pcert0 \
- data-structures/list-theory.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/1999/ste/util.lisp
-workshops/1999/ste/util.pcert1 : acl2x = 0
-workshops/1999/ste/util.pcert1 : no_pcert = 0
-workshops/1999/ste/util.pcert1 : workshops/1999/ste/util.pcert0
-workshops/1999/ste/util.cert : | workshops/1999/ste/util.pcert1
-
-workshops/1999/vhdl/exercises.pcert0 : no_pcert = 0
-workshops/1999/vhdl/exercises.pcert0 : acl2x = 0
-workshops/1999/vhdl/exercises.pcert0 : \
- workshops/1999/vhdl/fact.pcert0 \
- workshops/1999/vhdl/exercises.lisp
-workshops/1999/vhdl/exercises.pcert1 : acl2x = 0
-workshops/1999/vhdl/exercises.pcert1 : no_pcert = 0
-workshops/1999/vhdl/exercises.pcert1 : workshops/1999/vhdl/exercises.pcert0
-workshops/1999/vhdl/exercises.cert : | workshops/1999/vhdl/exercises.pcert1
-
-workshops/1999/vhdl/fact-proof.pcert0 : no_pcert = 0
-workshops/1999/vhdl/fact-proof.pcert0 : acl2x = 0
-workshops/1999/vhdl/fact-proof.pcert0 : \
- arithmetic/top.pcert0 \
- workshops/1999/vhdl/fact.pcert0 \
- workshops/1999/vhdl/fact-proof.lisp
-workshops/1999/vhdl/fact-proof.pcert1 : acl2x = 0
-workshops/1999/vhdl/fact-proof.pcert1 : no_pcert = 0
-workshops/1999/vhdl/fact-proof.pcert1 : workshops/1999/vhdl/fact-proof.pcert0
-workshops/1999/vhdl/fact-proof.cert : | workshops/1999/vhdl/fact-proof.pcert1
-
-workshops/1999/vhdl/fact.pcert0 : no_pcert = 0
-workshops/1999/vhdl/fact.pcert0 : acl2x = 0
-workshops/1999/vhdl/fact.pcert0 : \
- workshops/1999/vhdl/vhdl.pcert0 \
- workshops/1999/vhdl/fact.lisp
-workshops/1999/vhdl/fact.pcert1 : acl2x = 0
-workshops/1999/vhdl/fact.pcert1 : no_pcert = 0
-workshops/1999/vhdl/fact.pcert1 : workshops/1999/vhdl/fact.pcert0
-workshops/1999/vhdl/fact.cert : | workshops/1999/vhdl/fact.pcert1
-
-workshops/1999/vhdl/vhdl.pcert0 : no_pcert = 0
-workshops/1999/vhdl/vhdl.pcert0 : acl2x = 0
-workshops/1999/vhdl/vhdl.pcert0 : \
- workshops/1999/vhdl/vhdl.lisp
-workshops/1999/vhdl/vhdl.pcert1 : acl2x = 0
-workshops/1999/vhdl/vhdl.pcert1 : no_pcert = 0
-workshops/1999/vhdl/vhdl.pcert1 : workshops/1999/vhdl/vhdl.pcert0
-workshops/1999/vhdl/vhdl.cert : | workshops/1999/vhdl/vhdl.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/base.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/base.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/base.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/util.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/base.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/base.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/base.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/base.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/base.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/base.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/base.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/compile.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/compile.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/compile.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/pstate.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/compile.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/compile.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/compile.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/compile.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/compile.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/compile.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/compile.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/cstate.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/cstate.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/cstate.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/expr.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/cstate.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/cstate.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/cstate.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/cstate.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/cstate.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/cstate.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/cstate.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/expr.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/expr.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/expr.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/base.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/expr.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/expr.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/expr.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/expr.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/expr.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/expr.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/expr.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/gensym-e.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/lstate.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/lstate.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/lstate.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/base.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/cstate.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/lstate.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/lstate.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/lstate.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/lstate.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/lstate.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/lstate.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/lstate.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/mstate.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/mstate.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/mstate.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/cstate.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/pstate.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/lstate.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/mstate.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/mstate.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/mstate.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/mstate.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/mstate.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/mstate.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/mstate.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/pstate.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/pstate.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/pstate.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/expr.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/pstate.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/pstate.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/pstate.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/pstate.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/pstate.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/pstate.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/pstate.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/setup.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/setup.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/setup.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/mstate.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/setup.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/setup.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/setup.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/setup.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/setup.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/setup.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/setup.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/simulator.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/simulator.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/simulator.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.pcert0 \
- arithmetic/mod-gcd.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/simulator.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/simulator.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/simulator.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/simulator.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/simulator.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/simulator.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/simulator.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/mstate.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/mstate.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/setup.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc1.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc2.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepproc0.pcert0 \
- workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/stepprocess.pcert1
-
-workshops/2000/lusk-mccune/lusk-mccune-final/util.pcert0 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/util.pcert0 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/util.pcert0 : \
- workshops/2000/lusk-mccune/lusk-mccune-final/util.lisp
-workshops/2000/lusk-mccune/lusk-mccune-final/util.pcert1 : acl2x = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/util.pcert1 : no_pcert = 0
-workshops/2000/lusk-mccune/lusk-mccune-final/util.pcert1 : workshops/2000/lusk-mccune/lusk-mccune-final/util.pcert0
-workshops/2000/lusk-mccune/lusk-mccune-final/util.cert : | workshops/2000/lusk-mccune/lusk-mccune-final/util.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net-ma128serial.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/ma128net.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial-ma128.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/ma128serial.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/ihs.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128-isa128.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/isa128.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/top/ma128.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa-flush.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/isa.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma-isa.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/ma/ma.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-encap-wfbisim.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/det-macros.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.lisp
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.pcert1 : workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.pcert0
-workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.cert : | workshops/2000/manolios/pipeline/pipeline/deterministic-systems/top/inst.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet-ma128intserial.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/netlist/netlist.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/netlist/ma128intnet.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial-ma128int.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/deterministic-systems/128/serial/serial.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/serial/ma128intserial.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int-isa128int.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/isa128int.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/128/top/ma128int.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int-isa-int.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/isa-int.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/int/ma-int.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/isa.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma-isa.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/ma/ma.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/inst.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-encap-wfbisim.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.lisp
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.pcert1 : workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.pcert0
-workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.cert : | workshops/2000/manolios/pipeline/pipeline/non-deterministic-systems/top/non-det-macros.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/alist-thms.lisp
-workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert1 : workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert0
-workshops/2000/manolios/pipeline/pipeline/top/alist-thms.cert : | workshops/2000/manolios/pipeline/pipeline/top/alist-thms.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.lisp
-workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert1 : workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert0
-workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.cert : | workshops/2000/manolios/pipeline/pipeline/top/defun-weak-sk.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/top/ihs.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/top/ihs.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/ihs.pcert0 : \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/ihs.lisp
-workshops/2000/manolios/pipeline/pipeline/top/ihs.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/ihs.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/top/ihs.pcert1 : workshops/2000/manolios/pipeline/pipeline/top/ihs.pcert0
-workshops/2000/manolios/pipeline/pipeline/top/ihs.cert : | workshops/2000/manolios/pipeline/pipeline/top/ihs.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- workshops/2000/manolios/pipeline/pipeline/top/meta.lisp
-workshops/2000/manolios/pipeline/pipeline/top/meta.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/meta.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/top/meta.pcert1 : workshops/2000/manolios/pipeline/pipeline/top/meta.pcert0
-workshops/2000/manolios/pipeline/pipeline/top/meta.cert : | workshops/2000/manolios/pipeline/pipeline/top/meta.pcert1
-
-workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0 : \
- workshops/2000/manolios/pipeline/pipeline/top/nth-thms.lisp
-workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert1 : workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert0
-workshops/2000/manolios/pipeline/pipeline/top/nth-thms.cert : | workshops/2000/manolios/pipeline/pipeline/top/nth-thms.pcert1
-
-workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/trivia.pcert0 \
- workshops/2000/manolios/pipeline/trivial/ihs.pcert0 \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.lisp
-workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.pcert1 : workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.pcert0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.cert : | workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.pcert1
-
-workshops/2000/manolios/pipeline/trivial/b-ops-aux.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux.lisp
-workshops/2000/manolios/pipeline/trivial/b-ops-aux.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux.pcert1 : workshops/2000/manolios/pipeline/trivial/b-ops-aux.pcert0
-workshops/2000/manolios/pipeline/trivial/b-ops-aux.cert : | workshops/2000/manolios/pipeline/trivial/b-ops-aux.pcert1
-
-workshops/2000/manolios/pipeline/trivial/basic-def.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/basic-def.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/basic-def.pcert0 : \
- data-structures/array1.pcert0 \
- data-structures/deflist.pcert0 \
- data-structures/list-defthms.pcert0 \
- data-structures/structures.pcert0 \
- workshops/2000/manolios/pipeline/trivial/ihs.pcert0 \
- workshops/2000/manolios/pipeline/trivial/trivia.pcert0 \
- workshops/2000/manolios/pipeline/trivial/b-ops-aux.pcert0 \
- workshops/2000/manolios/pipeline/trivial/basic-def.lisp \
- workshops/2000/manolios/pipeline/trivial/basic-def.acl2 \
- workshops/2000/manolios/pipeline/trivial/define-u-package.lsp
-workshops/2000/manolios/pipeline/trivial/basic-def.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/basic-def.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/basic-def.pcert1 : workshops/2000/manolios/pipeline/trivial/basic-def.pcert0
-workshops/2000/manolios/pipeline/trivial/basic-def.cert : | workshops/2000/manolios/pipeline/trivial/basic-def.pcert1
-
-workshops/2000/manolios/pipeline/trivial/basic-lemmas.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/basic-lemmas.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/basic-lemmas.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/basic-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/model.pcert0 \
- workshops/2000/manolios/pipeline/trivial/table-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/basic-lemmas.lisp
-workshops/2000/manolios/pipeline/trivial/basic-lemmas.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/basic-lemmas.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/basic-lemmas.pcert1 : workshops/2000/manolios/pipeline/trivial/basic-lemmas.pcert0
-workshops/2000/manolios/pipeline/trivial/basic-lemmas.cert : | workshops/2000/manolios/pipeline/trivial/basic-lemmas.pcert1
-
-workshops/2000/manolios/pipeline/trivial/ihs.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/ihs.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/ihs.pcert0 : \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- workshops/2000/manolios/pipeline/trivial/ihs.lisp
-workshops/2000/manolios/pipeline/trivial/ihs.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/ihs.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/ihs.pcert1 : workshops/2000/manolios/pipeline/trivial/ihs.pcert0
-workshops/2000/manolios/pipeline/trivial/ihs.cert : | workshops/2000/manolios/pipeline/trivial/ihs.pcert1
-
-workshops/2000/manolios/pipeline/trivial/model.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/model.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/model.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/basic-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/model.lisp
-workshops/2000/manolios/pipeline/trivial/model.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/model.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/model.pcert1 : workshops/2000/manolios/pipeline/trivial/model.pcert0
-workshops/2000/manolios/pipeline/trivial/model.cert : | workshops/2000/manolios/pipeline/trivial/model.pcert1
-
-workshops/2000/manolios/pipeline/trivial/proof.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/proof.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/proof.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/model.pcert0 \
- workshops/2000/manolios/pipeline/trivial/proof.lisp
-workshops/2000/manolios/pipeline/trivial/proof.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/proof.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/proof.pcert1 : workshops/2000/manolios/pipeline/trivial/proof.pcert0
-workshops/2000/manolios/pipeline/trivial/proof.cert : | workshops/2000/manolios/pipeline/trivial/proof.pcert1
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.lisp
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.pcert1 : workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.pcert0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.cert : | workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.pcert1
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.lisp
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.pcert1 : workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.pcert0
-workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.cert : | workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.pcert1
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert0 : \
- data-structures/array1.pcert0 \
- data-structures/deflist.pcert0 \
- data-structures/list-defthms.pcert0 \
- data-structures/structures.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/b-ops-aux.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.acl2 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/define-u-package.lsp
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert1 : workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.cert : | workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert1
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/model.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.lisp
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.pcert1 : workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.pcert0
-workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.cert : | workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.pcert1
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.pcert0 : \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.lisp
-workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.pcert1 : workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.pcert0
-workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.cert : | workshops/2000/manolios/pipeline/trivial/sawada-model/ihs.pcert1
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/model.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/model.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/model.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/model.lisp
-workshops/2000/manolios/pipeline/trivial/sawada-model/model.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/model.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/model.pcert1 : workshops/2000/manolios/pipeline/trivial/sawada-model/model.pcert0
-workshops/2000/manolios/pipeline/trivial/sawada-model/model.cert : | workshops/2000/manolios/pipeline/trivial/sawada-model/model.pcert1
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/proof.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/proof.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/proof.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/model.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-lemmas.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/proof.lisp
-workshops/2000/manolios/pipeline/trivial/sawada-model/proof.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/proof.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/proof.pcert1 : workshops/2000/manolios/pipeline/trivial/sawada-model/proof.pcert0
-workshops/2000/manolios/pipeline/trivial/sawada-model/proof.cert : | workshops/2000/manolios/pipeline/trivial/sawada-model/proof.pcert1
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/sawada-model/utils.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/basic-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/model.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.lisp
-workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.pcert1 : workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.pcert0
-workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.cert : | workshops/2000/manolios/pipeline/trivial/sawada-model/table-def.pcert1
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.pcert0 : \
- data-structures/array1.pcert0 \
- arithmetic/top.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.lisp
-workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.pcert1 : workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.pcert0
-workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.cert : | workshops/2000/manolios/pipeline/trivial/sawada-model/trivia.pcert1
-
-workshops/2000/manolios/pipeline/trivial/sawada-model/utils.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/utils.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/utils.pcert0 : \
- data-structures/utilities.pcert0 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/utils.lisp \
- workshops/2000/manolios/pipeline/trivial/sawada-model/utils.acl2 \
- workshops/2000/manolios/pipeline/trivial/sawada-model/define-u-package.lsp
-workshops/2000/manolios/pipeline/trivial/sawada-model/utils.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/utils.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/sawada-model/utils.pcert1 : workshops/2000/manolios/pipeline/trivial/sawada-model/utils.pcert0
-workshops/2000/manolios/pipeline/trivial/sawada-model/utils.cert : | workshops/2000/manolios/pipeline/trivial/sawada-model/utils.pcert1
-
-workshops/2000/manolios/pipeline/trivial/table-def.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/table-def.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/table-def.pcert0 : \
- workshops/2000/manolios/pipeline/trivial/utils.pcert0 \
- workshops/2000/manolios/pipeline/trivial/basic-def.pcert0 \
- workshops/2000/manolios/pipeline/trivial/model.pcert0 \
- workshops/2000/manolios/pipeline/trivial/table-def.lisp
-workshops/2000/manolios/pipeline/trivial/table-def.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/table-def.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/table-def.pcert1 : workshops/2000/manolios/pipeline/trivial/table-def.pcert0
-workshops/2000/manolios/pipeline/trivial/table-def.cert : | workshops/2000/manolios/pipeline/trivial/table-def.pcert1
-
-workshops/2000/manolios/pipeline/trivial/trivia.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/trivia.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/trivia.pcert0 : \
- data-structures/array1.pcert0 \
- arithmetic/top.pcert0 \
- workshops/2000/manolios/pipeline/trivial/trivia.lisp
-workshops/2000/manolios/pipeline/trivial/trivia.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/trivia.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/trivia.pcert1 : workshops/2000/manolios/pipeline/trivial/trivia.pcert0
-workshops/2000/manolios/pipeline/trivial/trivia.cert : | workshops/2000/manolios/pipeline/trivial/trivia.pcert1
-
-workshops/2000/manolios/pipeline/trivial/utils.pcert0 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/utils.pcert0 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/utils.pcert0 : \
- data-structures/utilities.pcert0 \
- workshops/2000/manolios/pipeline/trivial/utils.lisp \
- workshops/2000/manolios/pipeline/trivial/utils.acl2 \
- workshops/2000/manolios/pipeline/trivial/define-u-package.lsp
-workshops/2000/manolios/pipeline/trivial/utils.pcert1 : acl2x = 0
-workshops/2000/manolios/pipeline/trivial/utils.pcert1 : no_pcert = 0
-workshops/2000/manolios/pipeline/trivial/utils.pcert1 : workshops/2000/manolios/pipeline/trivial/utils.pcert0
-workshops/2000/manolios/pipeline/trivial/utils.cert : | workshops/2000/manolios/pipeline/trivial/utils.pcert1
-
-workshops/2000/medina/polynomials/addition.pcert0 : no_pcert = 0
-workshops/2000/medina/polynomials/addition.pcert0 : acl2x = 0
-workshops/2000/medina/polynomials/addition.pcert0 : \
- workshops/2000/medina/polynomials/normal-form.pcert0 \
- workshops/2000/medina/polynomials/addition.lisp \
- workshops/2000/medina/polynomials/addition.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-workshops/2000/medina/polynomials/addition.pcert1 : acl2x = 0
-workshops/2000/medina/polynomials/addition.pcert1 : no_pcert = 0
-workshops/2000/medina/polynomials/addition.pcert1 : workshops/2000/medina/polynomials/addition.pcert0
-workshops/2000/medina/polynomials/addition.cert : | workshops/2000/medina/polynomials/addition.pcert1
-
-workshops/2000/medina/polynomials/congruences-1.pcert0 : no_pcert = 0
-workshops/2000/medina/polynomials/congruences-1.pcert0 : acl2x = 0
-workshops/2000/medina/polynomials/congruences-1.pcert0 : \
- workshops/2000/medina/polynomials/negation.pcert0 \
- workshops/2000/medina/polynomials/congruences-1.lisp \
- workshops/2000/medina/polynomials/congruences-1.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-workshops/2000/medina/polynomials/congruences-1.pcert1 : acl2x = 0
-workshops/2000/medina/polynomials/congruences-1.pcert1 : no_pcert = 0
-workshops/2000/medina/polynomials/congruences-1.pcert1 : workshops/2000/medina/polynomials/congruences-1.pcert0
-workshops/2000/medina/polynomials/congruences-1.cert : | workshops/2000/medina/polynomials/congruences-1.pcert1
-
-workshops/2000/medina/polynomials/congruences-2.pcert0 : no_pcert = 0
-workshops/2000/medina/polynomials/congruences-2.pcert0 : acl2x = 0
-workshops/2000/medina/polynomials/congruences-2.pcert0 : \
- workshops/2000/medina/polynomials/multiplication.pcert0 \
- workshops/2000/medina/polynomials/congruences-2.lisp \
- workshops/2000/medina/polynomials/congruences-2.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-workshops/2000/medina/polynomials/congruences-2.pcert1 : acl2x = 0
-workshops/2000/medina/polynomials/congruences-2.pcert1 : no_pcert = 0
-workshops/2000/medina/polynomials/congruences-2.pcert1 : workshops/2000/medina/polynomials/congruences-2.pcert0
-workshops/2000/medina/polynomials/congruences-2.cert : | workshops/2000/medina/polynomials/congruences-2.pcert1
-
-workshops/2000/medina/polynomials/examples.pcert0 : no_pcert = 0
-workshops/2000/medina/polynomials/examples.pcert0 : acl2x = 0
-workshops/2000/medina/polynomials/examples.pcert0 : \
- workshops/2000/medina/polynomials/congruences-2.pcert0 \
- workshops/2000/medina/polynomials/examples.lisp \
- workshops/2000/medina/polynomials/examples.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-workshops/2000/medina/polynomials/examples.pcert1 : acl2x = 0
-workshops/2000/medina/polynomials/examples.pcert1 : no_pcert = 0
-workshops/2000/medina/polynomials/examples.pcert1 : workshops/2000/medina/polynomials/examples.pcert0
-workshops/2000/medina/polynomials/examples.cert : | workshops/2000/medina/polynomials/examples.pcert1
-
-workshops/2000/medina/polynomials/lexicographical-ordering.pcert0 : no_pcert = 0
-workshops/2000/medina/polynomials/lexicographical-ordering.pcert0 : acl2x = 0
-workshops/2000/medina/polynomials/lexicographical-ordering.pcert0 : \
- workshops/2000/medina/polynomials/term.pcert0 \
- ordinals/ordinals-without-arithmetic.pcert0 \
- workshops/2000/medina/polynomials/lexicographical-ordering.lisp \
- workshops/2000/medina/polynomials/lexicographical-ordering.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-workshops/2000/medina/polynomials/lexicographical-ordering.pcert1 : acl2x = 0
-workshops/2000/medina/polynomials/lexicographical-ordering.pcert1 : no_pcert = 0
-workshops/2000/medina/polynomials/lexicographical-ordering.pcert1 : workshops/2000/medina/polynomials/lexicographical-ordering.pcert0
-workshops/2000/medina/polynomials/lexicographical-ordering.cert : | workshops/2000/medina/polynomials/lexicographical-ordering.pcert1
-
-workshops/2000/medina/polynomials/monomial.pcert0 : no_pcert = 0
-workshops/2000/medina/polynomials/monomial.pcert0 : acl2x = 0
-workshops/2000/medina/polynomials/monomial.pcert0 : \
- workshops/2000/medina/polynomials/term.pcert0 \
- workshops/2000/medina/polynomials/monomial.lisp \
- workshops/2000/medina/polynomials/monomial.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-workshops/2000/medina/polynomials/monomial.pcert1 : acl2x = 0
-workshops/2000/medina/polynomials/monomial.pcert1 : no_pcert = 0
-workshops/2000/medina/polynomials/monomial.pcert1 : workshops/2000/medina/polynomials/monomial.pcert0
-workshops/2000/medina/polynomials/monomial.cert : | workshops/2000/medina/polynomials/monomial.pcert1
-
-workshops/2000/medina/polynomials/multiplication.pcert0 : no_pcert = 0
-workshops/2000/medina/polynomials/multiplication.pcert0 : acl2x = 0
-workshops/2000/medina/polynomials/multiplication.pcert0 : \
- workshops/2000/medina/polynomials/congruences-1.pcert0 \
- workshops/2000/medina/polynomials/multiplication.lisp \
- workshops/2000/medina/polynomials/multiplication.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-workshops/2000/medina/polynomials/multiplication.pcert1 : acl2x = 0
-workshops/2000/medina/polynomials/multiplication.pcert1 : no_pcert = 0
-workshops/2000/medina/polynomials/multiplication.pcert1 : workshops/2000/medina/polynomials/multiplication.pcert0
-workshops/2000/medina/polynomials/multiplication.cert : | workshops/2000/medina/polynomials/multiplication.pcert1
-
-workshops/2000/medina/polynomials/negation.pcert0 : no_pcert = 0
-workshops/2000/medina/polynomials/negation.pcert0 : acl2x = 0
-workshops/2000/medina/polynomials/negation.pcert0 : \
- workshops/2000/medina/polynomials/addition.pcert0 \
- workshops/2000/medina/polynomials/negation.lisp \
- workshops/2000/medina/polynomials/negation.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-workshops/2000/medina/polynomials/negation.pcert1 : acl2x = 0
-workshops/2000/medina/polynomials/negation.pcert1 : no_pcert = 0
-workshops/2000/medina/polynomials/negation.pcert1 : workshops/2000/medina/polynomials/negation.pcert0
-workshops/2000/medina/polynomials/negation.cert : | workshops/2000/medina/polynomials/negation.pcert1
-
-workshops/2000/medina/polynomials/normal-form.pcert0 : no_pcert = 0
-workshops/2000/medina/polynomials/normal-form.pcert0 : acl2x = 0
-workshops/2000/medina/polynomials/normal-form.pcert0 : \
- workshops/2000/medina/polynomials/polynomial.pcert0 \
- workshops/2000/medina/polynomials/lexicographical-ordering.pcert0 \
- workshops/2000/medina/polynomials/normal-form.lisp \
- workshops/2000/medina/polynomials/normal-form.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-workshops/2000/medina/polynomials/normal-form.pcert1 : acl2x = 0
-workshops/2000/medina/polynomials/normal-form.pcert1 : no_pcert = 0
-workshops/2000/medina/polynomials/normal-form.pcert1 : workshops/2000/medina/polynomials/normal-form.pcert0
-workshops/2000/medina/polynomials/normal-form.cert : | workshops/2000/medina/polynomials/normal-form.pcert1
-
-workshops/2000/medina/polynomials/polynomial.pcert0 : no_pcert = 0
-workshops/2000/medina/polynomials/polynomial.pcert0 : acl2x = 0
-workshops/2000/medina/polynomials/polynomial.pcert0 : \
- workshops/2000/medina/polynomials/monomial.pcert0 \
- workshops/2000/medina/polynomials/polynomial.lisp \
- workshops/2000/medina/polynomials/polynomial.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-workshops/2000/medina/polynomials/polynomial.pcert1 : acl2x = 0
-workshops/2000/medina/polynomials/polynomial.pcert1 : no_pcert = 0
-workshops/2000/medina/polynomials/polynomial.pcert1 : workshops/2000/medina/polynomials/polynomial.pcert0
-workshops/2000/medina/polynomials/polynomial.cert : | workshops/2000/medina/polynomials/polynomial.pcert1
-
-workshops/2000/medina/polynomials/term.pcert0 : no_pcert = 0
-workshops/2000/medina/polynomials/term.pcert0 : acl2x = 0
-workshops/2000/medina/polynomials/term.pcert0 : \
- workshops/2000/medina/polynomials/term.lisp \
- workshops/2000/medina/polynomials/term.acl2 \
- workshops/2000/medina/polynomials/certification.acl2
-workshops/2000/medina/polynomials/term.pcert1 : acl2x = 0
-workshops/2000/medina/polynomials/term.pcert1 : no_pcert = 0
-workshops/2000/medina/polynomials/term.pcert1 : workshops/2000/medina/polynomials/term.pcert0
-workshops/2000/medina/polynomials/term.cert : | workshops/2000/medina/polynomials/term.pcert1
-
-workshops/2000/moore-manolios/partial-functions/defpun-original.pcert0 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/defpun-original.pcert0 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/defpun-original.pcert0 : \
- workshops/2000/moore-manolios/partial-functions/defpun-original.lisp
-workshops/2000/moore-manolios/partial-functions/defpun-original.pcert1 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/defpun-original.pcert1 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/defpun-original.pcert1 : workshops/2000/moore-manolios/partial-functions/defpun-original.pcert0
-workshops/2000/moore-manolios/partial-functions/defpun-original.cert : | workshops/2000/moore-manolios/partial-functions/defpun-original.pcert1
-
-workshops/2000/moore-manolios/partial-functions/defpun.pcert0 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/defpun.pcert0 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/defpun.pcert0 : \
- misc/defpun.pcert0 \
- workshops/2000/moore-manolios/partial-functions/defpun.lisp
-workshops/2000/moore-manolios/partial-functions/defpun.pcert1 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/defpun.pcert1 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/defpun.pcert1 : workshops/2000/moore-manolios/partial-functions/defpun.pcert0
-workshops/2000/moore-manolios/partial-functions/defpun.cert : | workshops/2000/moore-manolios/partial-functions/defpun.pcert1
-
-workshops/2000/moore-manolios/partial-functions/examples.pcert0 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/examples.pcert0 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/examples.pcert0 : \
- workshops/2000/moore-manolios/partial-functions/tjvm.pcert0 \
- workshops/2000/moore-manolios/partial-functions/tjvm.pcert0 \
- workshops/2000/moore-manolios/partial-functions/examples.lisp \
- workshops/2000/moore-manolios/partial-functions/examples.acl2
-workshops/2000/moore-manolios/partial-functions/examples.pcert1 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/examples.pcert1 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/examples.pcert1 : workshops/2000/moore-manolios/partial-functions/examples.pcert0
-workshops/2000/moore-manolios/partial-functions/examples.cert : | workshops/2000/moore-manolios/partial-functions/examples.pcert1
-
-workshops/2000/moore-manolios/partial-functions/mod-1-property.pcert0 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/mod-1-property.pcert0 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/mod-1-property.pcert0 : \
- ihs/quotient-remainder-lemmas.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/2000/moore-manolios/partial-functions/mod-1-property.lisp
-workshops/2000/moore-manolios/partial-functions/mod-1-property.pcert1 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/mod-1-property.pcert1 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/mod-1-property.pcert1 : workshops/2000/moore-manolios/partial-functions/mod-1-property.pcert0
-workshops/2000/moore-manolios/partial-functions/mod-1-property.cert : | workshops/2000/moore-manolios/partial-functions/mod-1-property.pcert1
-
-workshops/2000/moore-manolios/partial-functions/report.pcert0 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/report.pcert0 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/report.pcert0 : \
- workshops/2000/moore-manolios/partial-functions/defpun.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/2000/moore-manolios/partial-functions/mod-1-property.pcert0 \
- workshops/2000/moore-manolios/partial-functions/tjvm-examples.pcert0 \
- workshops/2000/moore-manolios/partial-functions/report.lisp
-workshops/2000/moore-manolios/partial-functions/report.pcert1 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/report.pcert1 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/report.pcert1 : workshops/2000/moore-manolios/partial-functions/report.pcert0
-workshops/2000/moore-manolios/partial-functions/report.cert : | workshops/2000/moore-manolios/partial-functions/report.pcert1
-
-workshops/2000/moore-manolios/partial-functions/tjvm-examples.pcert0 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/tjvm-examples.pcert0 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/tjvm-examples.pcert0 : \
- workshops/2000/moore-manolios/partial-functions/defpun.pcert0 \
- workshops/2000/moore-manolios/partial-functions/examples.pcert0 \
- workshops/2000/moore-manolios/partial-functions/tjvm-examples.lisp \
- workshops/2000/moore-manolios/partial-functions/tjvm-examples.acl2
-workshops/2000/moore-manolios/partial-functions/tjvm-examples.pcert1 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/tjvm-examples.pcert1 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/tjvm-examples.pcert1 : workshops/2000/moore-manolios/partial-functions/tjvm-examples.pcert0
-workshops/2000/moore-manolios/partial-functions/tjvm-examples.cert : | workshops/2000/moore-manolios/partial-functions/tjvm-examples.pcert1
-
-workshops/2000/moore-manolios/partial-functions/tjvm.pcert0 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/tjvm.pcert0 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/tjvm.pcert0 : \
- workshops/2000/moore-manolios/partial-functions/tjvm.lisp \
- workshops/2000/moore-manolios/partial-functions/tjvm.acl2
-workshops/2000/moore-manolios/partial-functions/tjvm.pcert1 : acl2x = 0
-workshops/2000/moore-manolios/partial-functions/tjvm.pcert1 : no_pcert = 0
-workshops/2000/moore-manolios/partial-functions/tjvm.pcert1 : workshops/2000/moore-manolios/partial-functions/tjvm.pcert0
-workshops/2000/moore-manolios/partial-functions/tjvm.cert : | workshops/2000/moore-manolios/partial-functions/tjvm.pcert1
-
-workshops/2000/ruiz/multiset/defmul.pcert0 : no_pcert = 0
-workshops/2000/ruiz/multiset/defmul.pcert0 : acl2x = 0
-workshops/2000/ruiz/multiset/defmul.pcert0 : \
- workshops/2000/ruiz/multiset/multiset.pcert0 \
- workshops/2000/ruiz/multiset/defmul.lisp \
- workshops/2000/ruiz/multiset/defmul.acl2
-workshops/2000/ruiz/multiset/defmul.pcert1 : acl2x = 0
-workshops/2000/ruiz/multiset/defmul.pcert1 : no_pcert = 0
-workshops/2000/ruiz/multiset/defmul.pcert1 : workshops/2000/ruiz/multiset/defmul.pcert0
-workshops/2000/ruiz/multiset/defmul.cert : | workshops/2000/ruiz/multiset/defmul.pcert1
-
-workshops/2000/ruiz/multiset/examples/ackermann/ackermann.pcert0 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/ackermann/ackermann.pcert0 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/ackermann/ackermann.pcert0 : \
- workshops/2000/ruiz/multiset/defmul.pcert0 \
- workshops/2000/ruiz/multiset/examples/ackermann/ackermann.lisp
-workshops/2000/ruiz/multiset/examples/ackermann/ackermann.pcert1 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/ackermann/ackermann.pcert1 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/ackermann/ackermann.pcert1 : workshops/2000/ruiz/multiset/examples/ackermann/ackermann.pcert0
-workshops/2000/ruiz/multiset/examples/ackermann/ackermann.cert : | workshops/2000/ruiz/multiset/examples/ackermann/ackermann.pcert1
-
-workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.pcert0 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.pcert0 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.pcert0 : \
- workshops/2000/ruiz/multiset/defmul.pcert0 \
- workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.lisp
-workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.pcert1 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.pcert1 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.pcert1 : workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.pcert0
-workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.cert : | workshops/2000/ruiz/multiset/examples/mccarthy-91/mccarthy-91.pcert1
-
-workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.pcert0 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.pcert0 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.pcert0 : \
- data-structures/structures.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.lisp
-workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.pcert1 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.pcert1 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.pcert1 : workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.pcert0
-workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.cert : | workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.pcert1
-
-workshops/2000/ruiz/multiset/examples/newman/confluence-v0.pcert0 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/newman/confluence-v0.pcert0 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/confluence-v0.pcert0 : \
- workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.pcert0 \
- workshops/2000/ruiz/multiset/examples/newman/confluence-v0.lisp \
- workshops/2000/ruiz/multiset/examples/newman/confluence-v0.acl2
-workshops/2000/ruiz/multiset/examples/newman/confluence-v0.pcert1 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/confluence-v0.pcert1 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/newman/confluence-v0.pcert1 : workshops/2000/ruiz/multiset/examples/newman/confluence-v0.pcert0
-workshops/2000/ruiz/multiset/examples/newman/confluence-v0.cert : | workshops/2000/ruiz/multiset/examples/newman/confluence-v0.pcert1
-
-workshops/2000/ruiz/multiset/examples/newman/confluence.pcert0 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/newman/confluence.pcert0 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/confluence.pcert0 : \
- workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.pcert0 \
- workshops/2000/ruiz/multiset/examples/newman/confluence.lisp \
- workshops/2000/ruiz/multiset/examples/newman/confluence.acl2
-workshops/2000/ruiz/multiset/examples/newman/confluence.pcert1 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/confluence.pcert1 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/newman/confluence.pcert1 : workshops/2000/ruiz/multiset/examples/newman/confluence.pcert0
-workshops/2000/ruiz/multiset/examples/newman/confluence.cert : | workshops/2000/ruiz/multiset/examples/newman/confluence.pcert1
-
-workshops/2000/ruiz/multiset/examples/newman/local-confluence.pcert0 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/newman/local-confluence.pcert0 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/local-confluence.pcert0 : \
- workshops/2000/ruiz/multiset/examples/newman/confluence.pcert0 \
- workshops/2000/ruiz/multiset/examples/newman/newman.pcert0 \
- workshops/2000/ruiz/multiset/examples/newman/local-confluence.lisp \
- workshops/2000/ruiz/multiset/examples/newman/local-confluence.acl2
-workshops/2000/ruiz/multiset/examples/newman/local-confluence.pcert1 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/local-confluence.pcert1 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/newman/local-confluence.pcert1 : workshops/2000/ruiz/multiset/examples/newman/local-confluence.pcert0
-workshops/2000/ruiz/multiset/examples/newman/local-confluence.cert : | workshops/2000/ruiz/multiset/examples/newman/local-confluence.pcert1
-
-workshops/2000/ruiz/multiset/examples/newman/newman.pcert0 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/newman/newman.pcert0 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/newman.pcert0 : \
- workshops/2000/ruiz/multiset/defmul.pcert0 \
- ordinals/ordinals-without-arithmetic.pcert0 \
- workshops/2000/ruiz/multiset/examples/newman/abstract-proofs.pcert0 \
- workshops/2000/ruiz/multiset/examples/newman/newman.lisp \
- workshops/2000/ruiz/multiset/examples/newman/newman.acl2
-workshops/2000/ruiz/multiset/examples/newman/newman.pcert1 : acl2x = 0
-workshops/2000/ruiz/multiset/examples/newman/newman.pcert1 : no_pcert = 0
-workshops/2000/ruiz/multiset/examples/newman/newman.pcert1 : workshops/2000/ruiz/multiset/examples/newman/newman.pcert0
-workshops/2000/ruiz/multiset/examples/newman/newman.cert : | workshops/2000/ruiz/multiset/examples/newman/newman.pcert1
-
-workshops/2000/ruiz/multiset/multiset.pcert0 : no_pcert = 0
-workshops/2000/ruiz/multiset/multiset.pcert0 : acl2x = 0
-workshops/2000/ruiz/multiset/multiset.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- workshops/2000/ruiz/multiset/multiset.lisp \
- workshops/2000/ruiz/multiset/multiset.acl2
-workshops/2000/ruiz/multiset/multiset.pcert1 : acl2x = 0
-workshops/2000/ruiz/multiset/multiset.pcert1 : no_pcert = 0
-workshops/2000/ruiz/multiset/multiset.pcert1 : workshops/2000/ruiz/multiset/multiset.pcert0
-workshops/2000/ruiz/multiset/multiset.cert : | workshops/2000/ruiz/multiset/multiset.pcert1
-
-workshops/2000/russinoff-kaufmann/supporting-materials/constants.pcert0 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/constants.pcert0 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/constants.pcert0 : \
- workshops/2000/russinoff-kaufmann/supporting-materials/exec.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/declarations.pcert0 \
- rtl/rel1/lib3/top.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/constants.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/constants.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-workshops/2000/russinoff-kaufmann/supporting-materials/constants.pcert1 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/constants.pcert1 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/constants.pcert1 : workshops/2000/russinoff-kaufmann/supporting-materials/constants.pcert0
-workshops/2000/russinoff-kaufmann/supporting-materials/constants.cert : | workshops/2000/russinoff-kaufmann/supporting-materials/constants.pcert1
-
-workshops/2000/russinoff-kaufmann/supporting-materials/declarations.pcert0 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/declarations.pcert0 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/declarations.pcert0 : \
- rtl/rel1/lib3/top.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/declarations.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/declarations.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-workshops/2000/russinoff-kaufmann/supporting-materials/declarations.pcert1 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/declarations.pcert1 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/declarations.pcert1 : workshops/2000/russinoff-kaufmann/supporting-materials/declarations.pcert0
-workshops/2000/russinoff-kaufmann/supporting-materials/declarations.cert : | workshops/2000/russinoff-kaufmann/supporting-materials/declarations.pcert1
-
-workshops/2000/russinoff-kaufmann/supporting-materials/exec.pcert0 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/exec.pcert0 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/exec.pcert0 : \
- rtl/rel1/lib3/top.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/exec.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/exec.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-workshops/2000/russinoff-kaufmann/supporting-materials/exec.pcert1 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/exec.pcert1 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/exec.pcert1 : workshops/2000/russinoff-kaufmann/supporting-materials/exec.pcert0
-workshops/2000/russinoff-kaufmann/supporting-materials/exec.cert : | workshops/2000/russinoff-kaufmann/supporting-materials/exec.pcert1
-
-workshops/2000/russinoff-kaufmann/supporting-materials/inputs.pcert0 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/inputs.pcert0 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/inputs.pcert0 : \
- workshops/2000/russinoff-kaufmann/supporting-materials/model.pcert0 \
- rtl/rel1/lib3/top.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/inputs.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/inputs.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-workshops/2000/russinoff-kaufmann/supporting-materials/inputs.pcert1 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/inputs.pcert1 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/inputs.pcert1 : workshops/2000/russinoff-kaufmann/supporting-materials/inputs.pcert0
-workshops/2000/russinoff-kaufmann/supporting-materials/inputs.cert : | workshops/2000/russinoff-kaufmann/supporting-materials/inputs.pcert1
-
-workshops/2000/russinoff-kaufmann/supporting-materials/main.pcert0 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/main.pcert0 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/main.pcert0 : \
- workshops/2000/russinoff-kaufmann/supporting-materials/constants.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/inputs.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/pipe.pcert0 \
- rtl/rel1/lib3/top.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/main.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/main.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-workshops/2000/russinoff-kaufmann/supporting-materials/main.pcert1 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/main.pcert1 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/main.pcert1 : workshops/2000/russinoff-kaufmann/supporting-materials/main.pcert0
-workshops/2000/russinoff-kaufmann/supporting-materials/main.cert : | workshops/2000/russinoff-kaufmann/supporting-materials/main.pcert1
-
-workshops/2000/russinoff-kaufmann/supporting-materials/model.pcert0 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/model.pcert0 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/model.pcert0 : \
- rtl/rel1/lib3/top.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/model.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/model.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-workshops/2000/russinoff-kaufmann/supporting-materials/model.pcert1 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/model.pcert1 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/model.pcert1 : workshops/2000/russinoff-kaufmann/supporting-materials/model.pcert0
-workshops/2000/russinoff-kaufmann/supporting-materials/model.cert : | workshops/2000/russinoff-kaufmann/supporting-materials/model.pcert1
-
-workshops/2000/russinoff-kaufmann/supporting-materials/pipe.pcert0 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/pipe.pcert0 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/pipe.pcert0 : \
- workshops/2000/russinoff-kaufmann/supporting-materials/model.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/constants.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/inputs.pcert0 \
- rtl/rel1/lib3/top.pcert0 \
- workshops/2000/russinoff-kaufmann/supporting-materials/pipe.lisp \
- workshops/2000/russinoff-kaufmann/supporting-materials/pipe.acl2 \
- workshops/2000/russinoff-kaufmann/supporting-materials/packages.lsp
-workshops/2000/russinoff-kaufmann/supporting-materials/pipe.pcert1 : acl2x = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/pipe.pcert1 : no_pcert = 0
-workshops/2000/russinoff-kaufmann/supporting-materials/pipe.pcert1 : workshops/2000/russinoff-kaufmann/supporting-materials/pipe.pcert0
-workshops/2000/russinoff-kaufmann/supporting-materials/pipe.cert : | workshops/2000/russinoff-kaufmann/supporting-materials/pipe.pcert1
-
-workshops/2000/russinoff-short/crt.pcert0 : no_pcert = 0
-workshops/2000/russinoff-short/crt.pcert0 : acl2x = 0
-workshops/2000/russinoff-short/crt.pcert0 : \
- rtl/rel1/lib1/basic.pcert0 \
- rtl/rel1/support/fp.pcert0 \
- workshops/2000/russinoff-short/crt.lisp
-workshops/2000/russinoff-short/crt.pcert1 : acl2x = 0
-workshops/2000/russinoff-short/crt.pcert1 : no_pcert = 0
-workshops/2000/russinoff-short/crt.pcert1 : workshops/2000/russinoff-short/crt.pcert0
-workshops/2000/russinoff-short/crt.cert : | workshops/2000/russinoff-short/crt.pcert1
-
-workshops/2000/russinoff-short/summary.pcert0 : no_pcert = 0
-workshops/2000/russinoff-short/summary.pcert0 : acl2x = 0
-workshops/2000/russinoff-short/summary.pcert0 : \
- workshops/2000/russinoff-short/crt.pcert0 \
- workshops/2000/russinoff-short/summary.lisp
-workshops/2000/russinoff-short/summary.pcert1 : acl2x = 0
-workshops/2000/russinoff-short/summary.pcert1 : no_pcert = 0
-workshops/2000/russinoff-short/summary.pcert1 : workshops/2000/russinoff-short/summary.pcert0
-workshops/2000/russinoff-short/summary.cert : | workshops/2000/russinoff-short/summary.pcert1
-
-workshops/2000/sumners1/cdeq/cdeq-defs.pcert0 : no_pcert = 0
-workshops/2000/sumners1/cdeq/cdeq-defs.pcert0 : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-defs.pcert0 : \
- workshops/2000/sumners1/cdeq/records.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2000/sumners1/cdeq/cdeq-defs.lisp
-workshops/2000/sumners1/cdeq/cdeq-defs.pcert1 : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-defs.pcert1 : no_pcert = 0
-workshops/2000/sumners1/cdeq/cdeq-defs.pcert1 : workshops/2000/sumners1/cdeq/cdeq-defs.pcert0
-workshops/2000/sumners1/cdeq/cdeq-defs.cert : | workshops/2000/sumners1/cdeq/cdeq-defs.pcert1
-
-workshops/2000/sumners1/cdeq/cdeq-phase1.pcert0 : no_pcert = 0
-workshops/2000/sumners1/cdeq/cdeq-phase1.pcert0 : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase1.pcert0 : \
- workshops/2000/sumners1/cdeq/cdeq-defs.pcert0 \
- workshops/2000/sumners1/cdeq/cdeq-phase1.lisp
-workshops/2000/sumners1/cdeq/cdeq-phase1.pcert1 : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase1.pcert1 : no_pcert = 0
-workshops/2000/sumners1/cdeq/cdeq-phase1.pcert1 : workshops/2000/sumners1/cdeq/cdeq-phase1.pcert0
-workshops/2000/sumners1/cdeq/cdeq-phase1.cert : | workshops/2000/sumners1/cdeq/cdeq-phase1.pcert1
-
-workshops/2000/sumners1/cdeq/cdeq-phase2.pcert0 : no_pcert = 0
-workshops/2000/sumners1/cdeq/cdeq-phase2.pcert0 : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase2.pcert0 : \
- workshops/2000/sumners1/cdeq/cdeq-defs.pcert0 \
- workshops/2000/sumners1/cdeq/cdeq-phase2.lisp
-workshops/2000/sumners1/cdeq/cdeq-phase2.pcert1 : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase2.pcert1 : no_pcert = 0
-workshops/2000/sumners1/cdeq/cdeq-phase2.pcert1 : workshops/2000/sumners1/cdeq/cdeq-phase2.pcert0
-workshops/2000/sumners1/cdeq/cdeq-phase2.cert : | workshops/2000/sumners1/cdeq/cdeq-phase2.pcert1
-
-workshops/2000/sumners1/cdeq/cdeq-phase3.pcert0 : no_pcert = 0
-workshops/2000/sumners1/cdeq/cdeq-phase3.pcert0 : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase3.pcert0 : \
- workshops/2000/sumners1/cdeq/cdeq-defs.pcert0 \
- workshops/2000/sumners1/cdeq/cdeq-phase3.lisp
-workshops/2000/sumners1/cdeq/cdeq-phase3.pcert1 : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase3.pcert1 : no_pcert = 0
-workshops/2000/sumners1/cdeq/cdeq-phase3.pcert1 : workshops/2000/sumners1/cdeq/cdeq-phase3.pcert0
-workshops/2000/sumners1/cdeq/cdeq-phase3.cert : | workshops/2000/sumners1/cdeq/cdeq-phase3.pcert1
-
-workshops/2000/sumners1/cdeq/cdeq-phase4.pcert0 : no_pcert = 0
-workshops/2000/sumners1/cdeq/cdeq-phase4.pcert0 : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase4.pcert0 : \
- workshops/2000/sumners1/cdeq/cdeq-defs.pcert0 \
- workshops/2000/sumners1/cdeq/cdeq-phase4.lisp
-workshops/2000/sumners1/cdeq/cdeq-phase4.pcert1 : acl2x = 0
-workshops/2000/sumners1/cdeq/cdeq-phase4.pcert1 : no_pcert = 0
-workshops/2000/sumners1/cdeq/cdeq-phase4.pcert1 : workshops/2000/sumners1/cdeq/cdeq-phase4.pcert0
-workshops/2000/sumners1/cdeq/cdeq-phase4.cert : | workshops/2000/sumners1/cdeq/cdeq-phase4.pcert1
-
-workshops/2000/sumners1/cdeq/records.pcert0 : no_pcert = 0
-workshops/2000/sumners1/cdeq/records.pcert0 : acl2x = 0
-workshops/2000/sumners1/cdeq/records.pcert0 : \
- misc/total-order.pcert0 \
- workshops/2000/sumners1/cdeq/records.lisp
-workshops/2000/sumners1/cdeq/records.pcert1 : acl2x = 0
-workshops/2000/sumners1/cdeq/records.pcert1 : no_pcert = 0
-workshops/2000/sumners1/cdeq/records.pcert1 : workshops/2000/sumners1/cdeq/records.pcert0
-workshops/2000/sumners1/cdeq/records.cert : | workshops/2000/sumners1/cdeq/records.pcert1
-
-workshops/2000/sumners2/bdds/bdd-mgr.pcert0 : no_pcert = 0
-workshops/2000/sumners2/bdds/bdd-mgr.pcert0 : acl2x = 0
-workshops/2000/sumners2/bdds/bdd-mgr.pcert0 : \
- workshops/2000/sumners2/bdds/bdd-mgr.lisp
-workshops/2000/sumners2/bdds/bdd-mgr.pcert1 : acl2x = 0
-workshops/2000/sumners2/bdds/bdd-mgr.pcert1 : no_pcert = 0
-workshops/2000/sumners2/bdds/bdd-mgr.pcert1 : workshops/2000/sumners2/bdds/bdd-mgr.pcert0
-workshops/2000/sumners2/bdds/bdd-mgr.cert : | workshops/2000/sumners2/bdds/bdd-mgr.pcert1
-
-workshops/2000/sumners2/bdds/bdd-prf.pcert0 : no_pcert = 0
-workshops/2000/sumners2/bdds/bdd-prf.pcert0 : acl2x = 0
-workshops/2000/sumners2/bdds/bdd-prf.pcert0 : \
- workshops/2000/sumners2/bdds/bdd-spec.pcert0 \
- workshops/2000/sumners2/bdds/bdd-prf.lisp
-workshops/2000/sumners2/bdds/bdd-prf.pcert1 : acl2x = 0
-workshops/2000/sumners2/bdds/bdd-prf.pcert1 : no_pcert = 0
-workshops/2000/sumners2/bdds/bdd-prf.pcert1 : workshops/2000/sumners2/bdds/bdd-prf.pcert0
-workshops/2000/sumners2/bdds/bdd-prf.cert : | workshops/2000/sumners2/bdds/bdd-prf.pcert1
-
-workshops/2000/sumners2/bdds/bdd-spec.pcert0 : no_pcert = 0
-workshops/2000/sumners2/bdds/bdd-spec.pcert0 : acl2x = 0
-workshops/2000/sumners2/bdds/bdd-spec.pcert0 : \
- workshops/2000/sumners2/bdds/bdd-mgr.pcert0 \
- workshops/2000/sumners2/bdds/bdd-spec.lisp
-workshops/2000/sumners2/bdds/bdd-spec.pcert1 : acl2x = 0
-workshops/2000/sumners2/bdds/bdd-spec.pcert1 : no_pcert = 0
-workshops/2000/sumners2/bdds/bdd-spec.pcert1 : workshops/2000/sumners2/bdds/bdd-spec.pcert0
-workshops/2000/sumners2/bdds/bdd-spec.cert : | workshops/2000/sumners2/bdds/bdd-spec.pcert1
-
-workshops/2002/cowles-flat/support/flat-ackermann.pcert0 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-ackermann.pcert0 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-ackermann.pcert0 : \
- workshops/2002/cowles-flat/support/flat.pcert0 \
- workshops/2002/cowles-flat/support/flat-ackermann.lisp \
- workshops/2002/cowles-flat/support/flat-ackermann.acl2
-workshops/2002/cowles-flat/support/flat-ackermann.pcert1 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-ackermann.pcert1 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-ackermann.pcert1 : workshops/2002/cowles-flat/support/flat-ackermann.pcert0
-workshops/2002/cowles-flat/support/flat-ackermann.cert : | workshops/2002/cowles-flat/support/flat-ackermann.pcert1
-
-workshops/2002/cowles-flat/support/flat-nested.pcert0 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-nested.pcert0 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-nested.pcert0 : \
- workshops/2002/cowles-flat/support/flat.pcert0 \
- workshops/2002/cowles-flat/support/flat-nested.lisp \
- workshops/2002/cowles-flat/support/flat-nested.acl2
-workshops/2002/cowles-flat/support/flat-nested.pcert1 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-nested.pcert1 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-nested.pcert1 : workshops/2002/cowles-flat/support/flat-nested.pcert0
-workshops/2002/cowles-flat/support/flat-nested.cert : | workshops/2002/cowles-flat/support/flat-nested.pcert1
-
-workshops/2002/cowles-flat/support/flat-primitive.pcert0 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-primitive.pcert0 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-primitive.pcert0 : \
- workshops/2002/cowles-flat/support/flat.pcert0 \
- workshops/2002/cowles-flat/support/flat-primitive.lisp \
- workshops/2002/cowles-flat/support/flat-primitive.acl2
-workshops/2002/cowles-flat/support/flat-primitive.pcert1 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-primitive.pcert1 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-primitive.pcert1 : workshops/2002/cowles-flat/support/flat-primitive.pcert0
-workshops/2002/cowles-flat/support/flat-primitive.cert : | workshops/2002/cowles-flat/support/flat-primitive.pcert1
-
-workshops/2002/cowles-flat/support/flat-reverse.pcert0 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-reverse.pcert0 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-reverse.pcert0 : \
- workshops/2002/cowles-flat/support/flat.pcert0 \
- workshops/2002/cowles-flat/support/flat-reverse.lisp \
- workshops/2002/cowles-flat/support/flat-reverse.acl2
-workshops/2002/cowles-flat/support/flat-reverse.pcert1 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-reverse.pcert1 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-reverse.pcert1 : workshops/2002/cowles-flat/support/flat-reverse.pcert0
-workshops/2002/cowles-flat/support/flat-reverse.cert : | workshops/2002/cowles-flat/support/flat-reverse.pcert1
-
-workshops/2002/cowles-flat/support/flat-tail.pcert0 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-tail.pcert0 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-tail.pcert0 : \
- workshops/2002/cowles-flat/support/flat.pcert0 \
- workshops/2002/cowles-flat/support/flat-tail.lisp \
- workshops/2002/cowles-flat/support/flat-tail.acl2
-workshops/2002/cowles-flat/support/flat-tail.pcert1 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-tail.pcert1 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-tail.pcert1 : workshops/2002/cowles-flat/support/flat-tail.pcert0
-workshops/2002/cowles-flat/support/flat-tail.cert : | workshops/2002/cowles-flat/support/flat-tail.pcert1
-
-workshops/2002/cowles-flat/support/flat-z.pcert0 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-z.pcert0 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-z.pcert0 : \
- workshops/2002/cowles-flat/support/flat.pcert0 \
- workshops/2002/cowles-flat/support/flat-z.lisp \
- workshops/2002/cowles-flat/support/flat-z.acl2
-workshops/2002/cowles-flat/support/flat-z.pcert1 : acl2x = 0
-workshops/2002/cowles-flat/support/flat-z.pcert1 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat-z.pcert1 : workshops/2002/cowles-flat/support/flat-z.pcert0
-workshops/2002/cowles-flat/support/flat-z.cert : | workshops/2002/cowles-flat/support/flat-z.pcert1
-
-workshops/2002/cowles-flat/support/flat.pcert0 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat.pcert0 : acl2x = 0
-workshops/2002/cowles-flat/support/flat.pcert0 : \
- workshops/2002/cowles-flat/support/flat.lisp \
- workshops/2002/cowles-flat/support/flat.acl2
-workshops/2002/cowles-flat/support/flat.pcert1 : acl2x = 0
-workshops/2002/cowles-flat/support/flat.pcert1 : no_pcert = 0
-workshops/2002/cowles-flat/support/flat.pcert1 : workshops/2002/cowles-flat/support/flat.pcert0
-workshops/2002/cowles-flat/support/flat.cert : | workshops/2002/cowles-flat/support/flat.pcert1
-
-workshops/2002/cowles-primrec/support/bad-def.pcert0 : no_pcert = 0
-workshops/2002/cowles-primrec/support/bad-def.pcert0 : acl2x = 0
-workshops/2002/cowles-primrec/support/bad-def.pcert0 : \
- workshops/2002/cowles-primrec/support/bad-def.lisp \
- workshops/2002/cowles-primrec/support/bad-def.acl2
-workshops/2002/cowles-primrec/support/bad-def.pcert1 : acl2x = 0
-workshops/2002/cowles-primrec/support/bad-def.pcert1 : no_pcert = 0
-workshops/2002/cowles-primrec/support/bad-def.pcert1 : workshops/2002/cowles-primrec/support/bad-def.pcert0
-workshops/2002/cowles-primrec/support/bad-def.cert : | workshops/2002/cowles-primrec/support/bad-def.pcert1
-
-workshops/2002/cowles-primrec/support/bad-def1.pcert0 : no_pcert = 0
-workshops/2002/cowles-primrec/support/bad-def1.pcert0 : acl2x = 0
-workshops/2002/cowles-primrec/support/bad-def1.pcert0 : \
- workshops/2002/cowles-primrec/support/bad-def1.lisp \
- workshops/2002/cowles-primrec/support/bad-def1.acl2
-workshops/2002/cowles-primrec/support/bad-def1.pcert1 : acl2x = 0
-workshops/2002/cowles-primrec/support/bad-def1.pcert1 : no_pcert = 0
-workshops/2002/cowles-primrec/support/bad-def1.pcert1 : workshops/2002/cowles-primrec/support/bad-def1.pcert0
-workshops/2002/cowles-primrec/support/bad-def1.cert : | workshops/2002/cowles-primrec/support/bad-def1.pcert1
-
-workshops/2002/cowles-primrec/support/defpr.pcert0 : no_pcert = 0
-workshops/2002/cowles-primrec/support/defpr.pcert0 : acl2x = 0
-workshops/2002/cowles-primrec/support/defpr.pcert0 : \
- workshops/2002/cowles-primrec/support/defpr.lisp
-workshops/2002/cowles-primrec/support/defpr.pcert1 : acl2x = 0
-workshops/2002/cowles-primrec/support/defpr.pcert1 : no_pcert = 0
-workshops/2002/cowles-primrec/support/defpr.pcert1 : workshops/2002/cowles-primrec/support/defpr.pcert0
-workshops/2002/cowles-primrec/support/defpr.cert : | workshops/2002/cowles-primrec/support/defpr.pcert1
-
-workshops/2002/cowles-primrec/support/fix.pcert0 : no_pcert = 0
-workshops/2002/cowles-primrec/support/fix.pcert0 : acl2x = 0
-workshops/2002/cowles-primrec/support/fix.pcert0 : \
- workshops/2002/cowles-primrec/support/fix.lisp
-workshops/2002/cowles-primrec/support/fix.pcert1 : acl2x = 0
-workshops/2002/cowles-primrec/support/fix.pcert1 : no_pcert = 0
-workshops/2002/cowles-primrec/support/fix.pcert1 : workshops/2002/cowles-primrec/support/fix.pcert0
-workshops/2002/cowles-primrec/support/fix.cert : | workshops/2002/cowles-primrec/support/fix.pcert1
-
-workshops/2002/cowles-primrec/support/primitive.pcert0 : no_pcert = 0
-workshops/2002/cowles-primrec/support/primitive.pcert0 : acl2x = 0
-workshops/2002/cowles-primrec/support/primitive.pcert0 : \
- workshops/2002/cowles-primrec/support/primitive.lisp
-workshops/2002/cowles-primrec/support/primitive.pcert1 : acl2x = 0
-workshops/2002/cowles-primrec/support/primitive.pcert1 : no_pcert = 0
-workshops/2002/cowles-primrec/support/primitive.pcert1 : workshops/2002/cowles-primrec/support/primitive.pcert0
-workshops/2002/cowles-primrec/support/primitive.cert : | workshops/2002/cowles-primrec/support/primitive.pcert1
-
-workshops/2002/cowles-primrec/support/tail.pcert0 : no_pcert = 0
-workshops/2002/cowles-primrec/support/tail.pcert0 : acl2x = 0
-workshops/2002/cowles-primrec/support/tail.pcert0 : \
- workshops/2002/cowles-primrec/support/tail.lisp
-workshops/2002/cowles-primrec/support/tail.pcert1 : acl2x = 0
-workshops/2002/cowles-primrec/support/tail.pcert1 : no_pcert = 0
-workshops/2002/cowles-primrec/support/tail.pcert1 : workshops/2002/cowles-primrec/support/tail.pcert0
-workshops/2002/cowles-primrec/support/tail.cert : | workshops/2002/cowles-primrec/support/tail.pcert1
-
-workshops/2002/georgelin-borrione-ostier/support/acl2-transl.pcert0 : no_pcert = 0
-workshops/2002/georgelin-borrione-ostier/support/acl2-transl.pcert0 : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/acl2-transl.pcert0 : \
- workshops/2002/georgelin-borrione-ostier/support/utils.pcert0 \
- workshops/2002/georgelin-borrione-ostier/support/generates-functions.pcert0 \
- workshops/2002/georgelin-borrione-ostier/support/generates-theorems.pcert0 \
- workshops/2002/georgelin-borrione-ostier/support/acl2-transl.lisp
-workshops/2002/georgelin-borrione-ostier/support/acl2-transl.pcert1 : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/acl2-transl.pcert1 : no_pcert = 0
-workshops/2002/georgelin-borrione-ostier/support/acl2-transl.pcert1 : workshops/2002/georgelin-borrione-ostier/support/acl2-transl.pcert0
-workshops/2002/georgelin-borrione-ostier/support/acl2-transl.cert : | workshops/2002/georgelin-borrione-ostier/support/acl2-transl.pcert1
-
-workshops/2002/georgelin-borrione-ostier/support/generates-functions.pcert0 : no_pcert = 0
-workshops/2002/georgelin-borrione-ostier/support/generates-functions.pcert0 : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/generates-functions.pcert0 : \
- workshops/2002/georgelin-borrione-ostier/support/utils.pcert0 \
- workshops/2002/georgelin-borrione-ostier/support/generates-functions.lisp
-workshops/2002/georgelin-borrione-ostier/support/generates-functions.pcert1 : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/generates-functions.pcert1 : no_pcert = 0
-workshops/2002/georgelin-borrione-ostier/support/generates-functions.pcert1 : workshops/2002/georgelin-borrione-ostier/support/generates-functions.pcert0
-workshops/2002/georgelin-borrione-ostier/support/generates-functions.cert : | workshops/2002/georgelin-borrione-ostier/support/generates-functions.pcert1
-
-workshops/2002/georgelin-borrione-ostier/support/generates-theorems.pcert0 : no_pcert = 0
-workshops/2002/georgelin-borrione-ostier/support/generates-theorems.pcert0 : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/generates-theorems.pcert0 : \
- workshops/2002/georgelin-borrione-ostier/support/utils.pcert0 \
- workshops/2002/georgelin-borrione-ostier/support/generates-theorems.lisp
-workshops/2002/georgelin-borrione-ostier/support/generates-theorems.pcert1 : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/generates-theorems.pcert1 : no_pcert = 0
-workshops/2002/georgelin-borrione-ostier/support/generates-theorems.pcert1 : workshops/2002/georgelin-borrione-ostier/support/generates-theorems.pcert0
-workshops/2002/georgelin-borrione-ostier/support/generates-theorems.cert : | workshops/2002/georgelin-borrione-ostier/support/generates-theorems.pcert1
-
-workshops/2002/georgelin-borrione-ostier/support/utils.pcert0 : no_pcert = 0
-workshops/2002/georgelin-borrione-ostier/support/utils.pcert0 : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/utils.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- misc/expander.pcert0 \
- workshops/2002/georgelin-borrione-ostier/support/utils.lisp
-workshops/2002/georgelin-borrione-ostier/support/utils.pcert1 : acl2x = 0
-workshops/2002/georgelin-borrione-ostier/support/utils.pcert1 : no_pcert = 0
-workshops/2002/georgelin-borrione-ostier/support/utils.pcert1 : workshops/2002/georgelin-borrione-ostier/support/utils.pcert0
-workshops/2002/georgelin-borrione-ostier/support/utils.cert : | workshops/2002/georgelin-borrione-ostier/support/utils.pcert1
-
-workshops/2002/kaufmann-sumners/support/records.pcert0 : no_pcert = 0
-workshops/2002/kaufmann-sumners/support/records.pcert0 : acl2x = 0
-workshops/2002/kaufmann-sumners/support/records.pcert0 : \
- misc/total-order.pcert0 \
- workshops/2002/kaufmann-sumners/support/records.lisp
-workshops/2002/kaufmann-sumners/support/records.pcert1 : acl2x = 0
-workshops/2002/kaufmann-sumners/support/records.pcert1 : no_pcert = 0
-workshops/2002/kaufmann-sumners/support/records.pcert1 : workshops/2002/kaufmann-sumners/support/records.pcert0
-workshops/2002/kaufmann-sumners/support/records.cert : | workshops/2002/kaufmann-sumners/support/records.pcert1
-
-workshops/2002/kaufmann-sumners/support/records0.pcert0 : no_pcert = 0
-workshops/2002/kaufmann-sumners/support/records0.pcert0 : acl2x = 0
-workshops/2002/kaufmann-sumners/support/records0.pcert0 : \
- misc/total-order.pcert0 \
- workshops/2002/kaufmann-sumners/support/records0.lisp
-workshops/2002/kaufmann-sumners/support/records0.pcert1 : acl2x = 0
-workshops/2002/kaufmann-sumners/support/records0.pcert1 : no_pcert = 0
-workshops/2002/kaufmann-sumners/support/records0.pcert1 : workshops/2002/kaufmann-sumners/support/records0.pcert0
-workshops/2002/kaufmann-sumners/support/records0.cert : | workshops/2002/kaufmann-sumners/support/records0.pcert1
-
-workshops/2002/kaufmann-sumners/support/sets.pcert0 : no_pcert = 0
-workshops/2002/kaufmann-sumners/support/sets.pcert0 : acl2x = 0
-workshops/2002/kaufmann-sumners/support/sets.pcert0 : \
- misc/total-order.pcert0 \
- workshops/2002/kaufmann-sumners/support/sets.lisp
-workshops/2002/kaufmann-sumners/support/sets.pcert1 : acl2x = 0
-workshops/2002/kaufmann-sumners/support/sets.pcert1 : no_pcert = 0
-workshops/2002/kaufmann-sumners/support/sets.pcert1 : workshops/2002/kaufmann-sumners/support/sets.pcert0
-workshops/2002/kaufmann-sumners/support/sets.cert : | workshops/2002/kaufmann-sumners/support/sets.pcert1
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.pcert0 : \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.lisp \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.acl2
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.pcert1 : workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.pcert0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.cert : | workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory-original.pcert1
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.pcert0 : \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.lisp \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.acl2
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.pcert1 : workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.pcert0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.cert : | workshops/2002/manolios-kaufmann/support/finite-set-theory/set-theory.pcert1
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.pcert0 : \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.lisp
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.pcert1 : workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.pcert0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.cert : | workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering-original.pcert1
-
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.pcert0 : \
- workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.lisp
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.pcert1 : workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.pcert0
-workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.cert : | workshops/2002/manolios-kaufmann/support/finite-set-theory/total-ordering.pcert1
-
-workshops/2002/manolios-kaufmann/support/records/records-original.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/records/records-original.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/records/records-original.pcert0 : \
- workshops/2002/manolios-kaufmann/support/records/records-original.lisp
-workshops/2002/manolios-kaufmann/support/records/records-original.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/records/records-original.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/records/records-original.pcert1 : workshops/2002/manolios-kaufmann/support/records/records-original.pcert0
-workshops/2002/manolios-kaufmann/support/records/records-original.cert : | workshops/2002/manolios-kaufmann/support/records/records-original.pcert1
-
-workshops/2002/manolios-kaufmann/support/records/records.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/records/records.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/records/records.pcert0 : \
- workshops/2002/manolios-kaufmann/support/records/total-order.pcert0 \
- workshops/2002/manolios-kaufmann/support/records/records.lisp
-workshops/2002/manolios-kaufmann/support/records/records.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/records/records.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/records/records.pcert1 : workshops/2002/manolios-kaufmann/support/records/records.pcert0
-workshops/2002/manolios-kaufmann/support/records/records.cert : | workshops/2002/manolios-kaufmann/support/records/records.pcert1
-
-workshops/2002/manolios-kaufmann/support/records/total-order.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/records/total-order.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/records/total-order.pcert0 : \
- misc/total-order.pcert0 \
- workshops/2002/manolios-kaufmann/support/records/total-order.lisp
-workshops/2002/manolios-kaufmann/support/records/total-order.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/records/total-order.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/records/total-order.pcert1 : workshops/2002/manolios-kaufmann/support/records/total-order.pcert0
-workshops/2002/manolios-kaufmann/support/records/total-order.cert : | workshops/2002/manolios-kaufmann/support/records/total-order.pcert1
-
-workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.pcert0 : \
- workshops/2002/manolios-kaufmann/support/sorting/perm-order.pcert0 \
- workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.lisp
-workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.pcert1 : workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.pcert0
-workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.cert : | workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.pcert1
-
-workshops/2002/manolios-kaufmann/support/sorting/perm-order.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/sorting/perm-order.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/perm-order.pcert0 : \
- workshops/2002/manolios-kaufmann/support/sorting/perm.pcert0 \
- workshops/2002/manolios-kaufmann/support/sorting/total-order.pcert0 \
- workshops/2002/manolios-kaufmann/support/sorting/perm-order.lisp
-workshops/2002/manolios-kaufmann/support/sorting/perm-order.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/perm-order.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/sorting/perm-order.pcert1 : workshops/2002/manolios-kaufmann/support/sorting/perm-order.pcert0
-workshops/2002/manolios-kaufmann/support/sorting/perm-order.cert : | workshops/2002/manolios-kaufmann/support/sorting/perm-order.pcert1
-
-workshops/2002/manolios-kaufmann/support/sorting/perm.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/sorting/perm.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/perm.pcert0 : \
- workshops/2002/manolios-kaufmann/support/sorting/perm.lisp
-workshops/2002/manolios-kaufmann/support/sorting/perm.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/perm.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/sorting/perm.pcert1 : workshops/2002/manolios-kaufmann/support/sorting/perm.pcert0
-workshops/2002/manolios-kaufmann/support/sorting/perm.cert : | workshops/2002/manolios-kaufmann/support/sorting/perm.pcert1
-
-workshops/2002/manolios-kaufmann/support/sorting/quicksort.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/sorting/quicksort.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/quicksort.pcert0 : \
- workshops/2002/manolios-kaufmann/support/sorting/insertion-sort.pcert0 \
- workshops/2002/manolios-kaufmann/support/sorting/quicksort.lisp
-workshops/2002/manolios-kaufmann/support/sorting/quicksort.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/quicksort.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/sorting/quicksort.pcert1 : workshops/2002/manolios-kaufmann/support/sorting/quicksort.pcert0
-workshops/2002/manolios-kaufmann/support/sorting/quicksort.cert : | workshops/2002/manolios-kaufmann/support/sorting/quicksort.pcert1
-
-workshops/2002/manolios-kaufmann/support/sorting/total-order.pcert0 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/sorting/total-order.pcert0 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/total-order.pcert0 : \
- misc/total-order.pcert0 \
- workshops/2002/manolios-kaufmann/support/sorting/total-order.lisp
-workshops/2002/manolios-kaufmann/support/sorting/total-order.pcert1 : acl2x = 0
-workshops/2002/manolios-kaufmann/support/sorting/total-order.pcert1 : no_pcert = 0
-workshops/2002/manolios-kaufmann/support/sorting/total-order.pcert1 : workshops/2002/manolios-kaufmann/support/sorting/total-order.pcert0
-workshops/2002/manolios-kaufmann/support/sorting/total-order.cert : | workshops/2002/manolios-kaufmann/support/sorting/total-order.pcert1
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.pcert0 : no_pcert = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.pcert0 : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.pcert0 : \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.pcert0 \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.lisp
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.pcert1 : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.pcert1 : no_pcert = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.pcert1 : workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.pcert0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.cert : | workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.pcert1
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.pcert0 : no_pcert = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.pcert0 : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.pcert0 : \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.lisp
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.pcert1 : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.pcert1 : no_pcert = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.pcert1 : workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.pcert0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.cert : | workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-theory.pcert1
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.pcert0 : no_pcert = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.pcert0 : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.pcert0 : \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.pcert0 \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.lisp
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.pcert1 : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.pcert1 : no_pcert = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.pcert1 : workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.pcert0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.cert : | workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-assoc.pcert1
-
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.pcert0 : no_pcert = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.pcert0 : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.pcert0 : \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/generic-multiset.pcert0 \
- workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.lisp
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.pcert1 : acl2x = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.pcert1 : no_pcert = 0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.pcert1 : workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.pcert0
-workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.cert : | workshops/2002/martin-alonso-hidalgo-ruiz/support/multiset-list.pcert1
-
-workshops/2002/martin-alonso-perez-sancho/support/Adleman.pcert0 : no_pcert = 0
-workshops/2002/martin-alonso-perez-sancho/support/Adleman.pcert0 : acl2x = 0
-workshops/2002/martin-alonso-perez-sancho/support/Adleman.pcert0 : \
- workshops/2002/martin-alonso-perez-sancho/support/Adleman.lisp
-workshops/2002/martin-alonso-perez-sancho/support/Adleman.pcert1 : acl2x = 0
-workshops/2002/martin-alonso-perez-sancho/support/Adleman.pcert1 : no_pcert = 0
-workshops/2002/martin-alonso-perez-sancho/support/Adleman.pcert1 : workshops/2002/martin-alonso-perez-sancho/support/Adleman.pcert0
-workshops/2002/martin-alonso-perez-sancho/support/Adleman.cert : | workshops/2002/martin-alonso-perez-sancho/support/Adleman.pcert1
-
-workshops/2002/medina-palomo-alonso/support/section-2/npol.pcert0 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-2/npol.pcert0 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-2/npol.pcert0 : \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-2.pcert0 \
- workshops/2002/medina-palomo-alonso/support/section-2/npol.lisp \
- workshops/2002/medina-palomo-alonso/support/section-2/npol.acl2
-workshops/2002/medina-palomo-alonso/support/section-2/npol.pcert1 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-2/npol.pcert1 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-2/npol.pcert1 : workshops/2002/medina-palomo-alonso/support/section-2/npol.pcert0
-workshops/2002/medina-palomo-alonso/support/section-2/npol.cert : | workshops/2002/medina-palomo-alonso/support/section-2/npol.pcert1
-
-workshops/2002/medina-palomo-alonso/support/section-2/upol-1.pcert0 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-1.pcert0 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-1.pcert0 : \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-1.lisp \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-1.acl2
-workshops/2002/medina-palomo-alonso/support/section-2/upol-1.pcert1 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-1.pcert1 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-1.pcert1 : workshops/2002/medina-palomo-alonso/support/section-2/upol-1.pcert0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-1.cert : | workshops/2002/medina-palomo-alonso/support/section-2/upol-1.pcert1
-
-workshops/2002/medina-palomo-alonso/support/section-2/upol-2.pcert0 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-2.pcert0 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-2.pcert0 : \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-2.lisp \
- workshops/2002/medina-palomo-alonso/support/section-2/upol-2.acl2
-workshops/2002/medina-palomo-alonso/support/section-2/upol-2.pcert1 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-2.pcert1 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-2.pcert1 : workshops/2002/medina-palomo-alonso/support/section-2/upol-2.pcert0
-workshops/2002/medina-palomo-alonso/support/section-2/upol-2.cert : | workshops/2002/medina-palomo-alonso/support/section-2/upol-2.pcert1
-
-workshops/2002/medina-palomo-alonso/support/section-3/monomial.pcert0 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/monomial.pcert0 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/monomial.pcert0 : \
- workshops/2002/medina-palomo-alonso/support/section-3/term.pcert0 \
- workshops/2002/medina-palomo-alonso/support/section-3/monomial.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/monomial.acl2
-workshops/2002/medina-palomo-alonso/support/section-3/monomial.pcert1 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/monomial.pcert1 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/monomial.pcert1 : workshops/2002/medina-palomo-alonso/support/section-3/monomial.pcert0
-workshops/2002/medina-palomo-alonso/support/section-3/monomial.cert : | workshops/2002/medina-palomo-alonso/support/section-3/monomial.pcert1
-
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.pcert0 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.pcert0 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.pcert0 : \
- workshops/2002/medina-palomo-alonso/support/section-3/upol.pcert0 \
- workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.pcert0 \
- ordinals/ordinals-without-arithmetic.pcert0 \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.acl2
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.pcert1 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.pcert1 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.pcert1 : workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.pcert0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.cert : | workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-1.pcert1
-
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.pcert0 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.pcert0 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.pcert0 : \
- workshops/2002/medina-palomo-alonso/support/section-3/upol.pcert0 \
- workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.pcert0 \
- ordinals/ordinals-without-arithmetic.pcert0 \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.acl2
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.pcert1 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.pcert1 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.pcert1 : workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.pcert0
-workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.cert : | workshops/2002/medina-palomo-alonso/support/section-3/npol-ordering-2.pcert1
-
-workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.pcert0 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.pcert0 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.pcert0 : \
- workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.acl2
-workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.pcert1 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.pcert1 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.pcert1 : workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.pcert0
-workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.cert : | workshops/2002/medina-palomo-alonso/support/section-3/ordinal-ordering.pcert1
-
-workshops/2002/medina-palomo-alonso/support/section-3/term.pcert0 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/term.pcert0 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/term.pcert0 : \
- workshops/2002/medina-palomo-alonso/support/section-3/term.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/term.acl2
-workshops/2002/medina-palomo-alonso/support/section-3/term.pcert1 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/term.pcert1 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/term.pcert1 : workshops/2002/medina-palomo-alonso/support/section-3/term.pcert0
-workshops/2002/medina-palomo-alonso/support/section-3/term.cert : | workshops/2002/medina-palomo-alonso/support/section-3/term.pcert1
-
-workshops/2002/medina-palomo-alonso/support/section-3/upol.pcert0 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/upol.pcert0 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/upol.pcert0 : \
- workshops/2002/medina-palomo-alonso/support/section-3/monomial.pcert0 \
- workshops/2002/medina-palomo-alonso/support/section-3/upol.lisp \
- workshops/2002/medina-palomo-alonso/support/section-3/upol.acl2
-workshops/2002/medina-palomo-alonso/support/section-3/upol.pcert1 : acl2x = 0
-workshops/2002/medina-palomo-alonso/support/section-3/upol.pcert1 : no_pcert = 0
-workshops/2002/medina-palomo-alonso/support/section-3/upol.pcert1 : workshops/2002/medina-palomo-alonso/support/section-3/upol.pcert0
-workshops/2002/medina-palomo-alonso/support/section-3/upol.cert : | workshops/2002/medina-palomo-alonso/support/section-3/upol.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dag-unification.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/dags.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/defpun.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/basic.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-dags/support/terms.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/anti-unification.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/lattice-of-terms.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/mg-instance.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-definition-v0.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/renamings.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert0 \
- ordinals/ordinals-without-arithmetic.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-well-founded.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/matching.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/basic.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/terms.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.pcert1
-
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.pcert0 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.pcert0 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.pcert0 : \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/subsumption-subst.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification-pattern.pcert0 \
- workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.lisp
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.pcert1 : acl2x = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.pcert1 : no_pcert = 0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.pcert1 : workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.pcert0
-workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.cert : | workshops/2002/ruiz-alonso-hidalgo-martin-theory-terms/support/unification.pcert1
-
-workshops/2003/austel/support/abs-type.pcert0 : no_pcert = 0
-workshops/2003/austel/support/abs-type.pcert0 : acl2x = 0
-workshops/2003/austel/support/abs-type.pcert0 : \
- workshops/2003/austel/support/abs-type.lisp
-workshops/2003/austel/support/abs-type.pcert1 : acl2x = 0
-workshops/2003/austel/support/abs-type.pcert1 : no_pcert = 0
-workshops/2003/austel/support/abs-type.pcert1 : workshops/2003/austel/support/abs-type.pcert0
-workshops/2003/austel/support/abs-type.cert : | workshops/2003/austel/support/abs-type.pcert1
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.pcert0 : no_pcert = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.pcert0 : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.pcert0 : \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.lisp
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.pcert1 : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.pcert1 : no_pcert = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.pcert1 : workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.pcert0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.cert : | workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.pcert1
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.pcert0 : no_pcert = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.pcert0 : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.pcert0 : \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.lisp
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.pcert1 : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.pcert1 : no_pcert = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.pcert1 : workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.pcert0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.cert : | workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.pcert1
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.pcert0 : no_pcert = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.pcert0 : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.pcert0 : \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.pcert0 \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.pcert0 \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.lisp
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.pcert1 : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.pcert1 : no_pcert = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.pcert1 : workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.pcert0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.cert : | workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.pcert1
-
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.pcert0 : no_pcert = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.pcert0 : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.pcert0 : \
- arithmetic/top.pcert0 \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/array2.pcert0 \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/alist2.pcert0 \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.lisp
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.pcert1 : acl2x = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.pcert1 : no_pcert = 0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.pcert1 : workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.pcert0
-workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.cert : | workshops/2003/cowles-gamboa-van-baalen_matrix/support/matrix.pcert1
-
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.pcert0 : no_pcert = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.pcert0 : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.pcert0 : \
- workshops/2003/gamboa-cowles-van-baalen/support/linalg.pcert0 \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.lisp \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.acl2 \
- workshops/2003/gamboa-cowles-van-baalen/support/defpkg.lsp
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.pcert1 : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.pcert1 : no_pcert = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.pcert1 : workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.pcert0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.cert : | workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.pcert1
-
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.pcert0 : no_pcert = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.pcert0 : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.pcert0 : \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.pcert0 \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.lisp \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.acl2 \
- workshops/2003/gamboa-cowles-van-baalen/support/defpkg.lsp
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.pcert1 : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.pcert1 : no_pcert = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.pcert1 : workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.pcert0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.cert : | workshops/2003/gamboa-cowles-van-baalen/support/kalman-demo.pcert1
-
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.pcert0 : no_pcert = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.pcert0 : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.pcert0 : \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-defs.pcert0 \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.lisp \
- workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.acl2 \
- workshops/2003/gamboa-cowles-van-baalen/support/defpkg.lsp
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.pcert1 : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.pcert1 : no_pcert = 0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.pcert1 : workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.pcert0
-workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.cert : | workshops/2003/gamboa-cowles-van-baalen/support/kalman-proof.pcert1
-
-workshops/2003/gamboa-cowles-van-baalen/support/linalg.pcert0 : no_pcert = 0
-workshops/2003/gamboa-cowles-van-baalen/support/linalg.pcert0 : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/linalg.pcert0 : \
- arithmetic/top.pcert0 \
- workshops/2003/cowles-gamboa-van-baalen_matrix/support/matalg.pcert0 \
- workshops/2003/gamboa-cowles-van-baalen/support/linalg.lisp
-workshops/2003/gamboa-cowles-van-baalen/support/linalg.pcert1 : acl2x = 0
-workshops/2003/gamboa-cowles-van-baalen/support/linalg.pcert1 : no_pcert = 0
-workshops/2003/gamboa-cowles-van-baalen/support/linalg.pcert1 : workshops/2003/gamboa-cowles-van-baalen/support/linalg.pcert0
-workshops/2003/gamboa-cowles-van-baalen/support/linalg.cert : | workshops/2003/gamboa-cowles-van-baalen/support/linalg.pcert1
-
-workshops/2003/greve-wilding_defrecord/support/defrecord.pcert0 : no_pcert = 0
-workshops/2003/greve-wilding_defrecord/support/defrecord.pcert0 : acl2x = 0
-workshops/2003/greve-wilding_defrecord/support/defrecord.pcert0 : \
- misc/records.pcert0 \
- workshops/2003/greve-wilding_defrecord/support/defrecord.lisp
-workshops/2003/greve-wilding_defrecord/support/defrecord.pcert1 : acl2x = 0
-workshops/2003/greve-wilding_defrecord/support/defrecord.pcert1 : no_pcert = 0
-workshops/2003/greve-wilding_defrecord/support/defrecord.pcert1 : workshops/2003/greve-wilding_defrecord/support/defrecord.pcert0
-workshops/2003/greve-wilding_defrecord/support/defrecord.cert : | workshops/2003/greve-wilding_defrecord/support/defrecord.pcert1
-
-workshops/2003/greve-wilding_mbe/support/fpst.pcert0 : no_pcert = 0
-workshops/2003/greve-wilding_mbe/support/fpst.pcert0 : acl2x = 0
-workshops/2003/greve-wilding_mbe/support/fpst.pcert0 : \
- workshops/1999/graph/linear-find-path.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2003/greve-wilding_mbe/support/fpst.lisp
-workshops/2003/greve-wilding_mbe/support/fpst.pcert1 : acl2x = 0
-workshops/2003/greve-wilding_mbe/support/fpst.pcert1 : no_pcert = 0
-workshops/2003/greve-wilding_mbe/support/fpst.pcert1 : workshops/2003/greve-wilding_mbe/support/fpst.pcert0
-workshops/2003/greve-wilding_mbe/support/fpst.cert : | workshops/2003/greve-wilding_mbe/support/fpst.pcert1
-
-workshops/2003/greve-wilding_mbe/support/run-fpst.pcert0 : no_pcert = 0
-workshops/2003/greve-wilding_mbe/support/run-fpst.pcert0 : acl2x = 0
-workshops/2003/greve-wilding_mbe/support/run-fpst.pcert0 : \
- workshops/2003/greve-wilding_mbe/support/fpst.pcert0 \
- workshops/2003/greve-wilding_mbe/support/run-fpst.lisp
-workshops/2003/greve-wilding_mbe/support/run-fpst.pcert1 : acl2x = 0
-workshops/2003/greve-wilding_mbe/support/run-fpst.pcert1 : no_pcert = 0
-workshops/2003/greve-wilding_mbe/support/run-fpst.pcert1 : workshops/2003/greve-wilding_mbe/support/run-fpst.pcert0
-workshops/2003/greve-wilding_mbe/support/run-fpst.cert : | workshops/2003/greve-wilding_mbe/support/run-fpst.pcert1
-
-workshops/2003/hbl/support/sol1.pcert0 : no_pcert = 0
-workshops/2003/hbl/support/sol1.pcert0 : acl2x = 0
-workshops/2003/hbl/support/sol1.pcert0 : \
- misc/records.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/2003/hbl/support/sol1.lisp
-workshops/2003/hbl/support/sol1.pcert1 : acl2x = 0
-workshops/2003/hbl/support/sol1.pcert1 : no_pcert = 0
-workshops/2003/hbl/support/sol1.pcert1 : workshops/2003/hbl/support/sol1.pcert0
-workshops/2003/hbl/support/sol1.cert : | workshops/2003/hbl/support/sol1.pcert1
-
-workshops/2003/hbl/support/sol2.pcert0 : no_pcert = 0
-workshops/2003/hbl/support/sol2.pcert0 : acl2x = 0
-workshops/2003/hbl/support/sol2.pcert0 : \
- misc/records.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2003/hbl/support/sol2.lisp
-workshops/2003/hbl/support/sol2.pcert1 : acl2x = 0
-workshops/2003/hbl/support/sol2.pcert1 : no_pcert = 0
-workshops/2003/hbl/support/sol2.pcert1 : workshops/2003/hbl/support/sol2.pcert0
-workshops/2003/hbl/support/sol2.cert : | workshops/2003/hbl/support/sol2.pcert1
-
-workshops/2003/hendrix/support/madd.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/madd.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/madd.pcert0 : \
- workshops/2003/hendrix/support/mdefthms.pcert0 \
- workshops/2003/hendrix/support/mzero.pcert0 \
- workshops/2003/hendrix/support/mentry.pcert0 \
- workshops/2003/hendrix/support/madd.lisp
-workshops/2003/hendrix/support/madd.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/madd.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/madd.pcert1 : workshops/2003/hendrix/support/madd.pcert0
-workshops/2003/hendrix/support/madd.cert : | workshops/2003/hendrix/support/madd.pcert1
-
-workshops/2003/hendrix/support/matrices.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/matrices.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/matrices.pcert0 : \
- workshops/2003/hendrix/support/vector.pcert0 \
- workshops/2003/hendrix/support/mdefuns.pcert0 \
- workshops/2003/hendrix/support/mdefthms.pcert0 \
- workshops/2003/hendrix/support/mentry.pcert0 \
- workshops/2003/hendrix/support/mzero.pcert0 \
- workshops/2003/hendrix/support/madd.pcert0 \
- workshops/2003/hendrix/support/mscal.pcert0 \
- workshops/2003/hendrix/support/msub.pcert0 \
- workshops/2003/hendrix/support/mid.pcert0 \
- workshops/2003/hendrix/support/mmult.pcert0 \
- workshops/2003/hendrix/support/mtrans.pcert0 \
- workshops/2003/hendrix/support/matrices.lisp
-workshops/2003/hendrix/support/matrices.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/matrices.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/matrices.pcert1 : workshops/2003/hendrix/support/matrices.pcert0
-workshops/2003/hendrix/support/matrices.cert : | workshops/2003/hendrix/support/matrices.pcert1
-
-workshops/2003/hendrix/support/mdefthms.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/mdefthms.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/mdefthms.pcert0 : \
- workshops/2003/hendrix/support/mdefuns.pcert0 \
- workshops/2003/hendrix/support/mdefthms.lisp
-workshops/2003/hendrix/support/mdefthms.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/mdefthms.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/mdefthms.pcert1 : workshops/2003/hendrix/support/mdefthms.pcert0
-workshops/2003/hendrix/support/mdefthms.cert : | workshops/2003/hendrix/support/mdefthms.pcert1
-
-workshops/2003/hendrix/support/mdefuns.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/mdefuns.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/mdefuns.pcert0 : \
- workshops/2003/hendrix/support/vector.pcert0 \
- workshops/2003/hendrix/support/mdefuns.lisp
-workshops/2003/hendrix/support/mdefuns.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/mdefuns.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/mdefuns.pcert1 : workshops/2003/hendrix/support/mdefuns.pcert0
-workshops/2003/hendrix/support/mdefuns.cert : | workshops/2003/hendrix/support/mdefuns.pcert1
-
-workshops/2003/hendrix/support/mentry.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/mentry.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/mentry.pcert0 : \
- workshops/2003/hendrix/support/mdefthms.pcert0 \
- workshops/2003/hendrix/support/mentry.lisp
-workshops/2003/hendrix/support/mentry.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/mentry.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/mentry.pcert1 : workshops/2003/hendrix/support/mentry.pcert0
-workshops/2003/hendrix/support/mentry.cert : | workshops/2003/hendrix/support/mentry.pcert1
-
-workshops/2003/hendrix/support/mid.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/mid.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/mid.pcert0 : \
- workshops/2003/hendrix/support/mdefthms.pcert0 \
- workshops/2003/hendrix/support/mid.lisp
-workshops/2003/hendrix/support/mid.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/mid.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/mid.pcert1 : workshops/2003/hendrix/support/mid.pcert0
-workshops/2003/hendrix/support/mid.cert : | workshops/2003/hendrix/support/mid.pcert1
-
-workshops/2003/hendrix/support/mmult.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/mmult.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/mmult.pcert0 : \
- workshops/2003/hendrix/support/mdefthms.pcert0 \
- workshops/2003/hendrix/support/mzero.pcert0 \
- workshops/2003/hendrix/support/madd.pcert0 \
- workshops/2003/hendrix/support/mscal.pcert0 \
- workshops/2003/hendrix/support/mid.pcert0 \
- workshops/2003/hendrix/support/mentry.pcert0 \
- workshops/2003/hendrix/support/mmult.lisp
-workshops/2003/hendrix/support/mmult.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/mmult.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/mmult.pcert1 : workshops/2003/hendrix/support/mmult.pcert0
-workshops/2003/hendrix/support/mmult.cert : | workshops/2003/hendrix/support/mmult.pcert1
-
-workshops/2003/hendrix/support/mscal.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/mscal.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/mscal.pcert0 : \
- workshops/2003/hendrix/support/mdefthms.pcert0 \
- workshops/2003/hendrix/support/mzero.pcert0 \
- workshops/2003/hendrix/support/madd.pcert0 \
- workshops/2003/hendrix/support/mentry.pcert0 \
- workshops/2003/hendrix/support/mscal.lisp
-workshops/2003/hendrix/support/mscal.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/mscal.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/mscal.pcert1 : workshops/2003/hendrix/support/mscal.pcert0
-workshops/2003/hendrix/support/mscal.cert : | workshops/2003/hendrix/support/mscal.pcert1
-
-workshops/2003/hendrix/support/msub.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/msub.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/msub.pcert0 : \
- workshops/2003/hendrix/support/mdefthms.pcert0 \
- workshops/2003/hendrix/support/madd.pcert0 \
- workshops/2003/hendrix/support/mscal.pcert0 \
- workshops/2003/hendrix/support/msub.lisp
-workshops/2003/hendrix/support/msub.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/msub.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/msub.pcert1 : workshops/2003/hendrix/support/msub.pcert0
-workshops/2003/hendrix/support/msub.cert : | workshops/2003/hendrix/support/msub.pcert1
-
-workshops/2003/hendrix/support/mtrans.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/mtrans.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/mtrans.pcert0 : \
- workshops/2003/hendrix/support/mdefthms.pcert0 \
- workshops/2003/hendrix/support/mzero.pcert0 \
- workshops/2003/hendrix/support/madd.pcert0 \
- workshops/2003/hendrix/support/mid.pcert0 \
- workshops/2003/hendrix/support/mscal.pcert0 \
- workshops/2003/hendrix/support/mmult.pcert0 \
- workshops/2003/hendrix/support/mentry.pcert0 \
- workshops/2003/hendrix/support/mtrans.lisp
-workshops/2003/hendrix/support/mtrans.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/mtrans.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/mtrans.pcert1 : workshops/2003/hendrix/support/mtrans.pcert0
-workshops/2003/hendrix/support/mtrans.cert : | workshops/2003/hendrix/support/mtrans.pcert1
-
-workshops/2003/hendrix/support/mzero.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/mzero.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/mzero.pcert0 : \
- workshops/2003/hendrix/support/mdefthms.pcert0 \
- workshops/2003/hendrix/support/mzero.lisp
-workshops/2003/hendrix/support/mzero.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/mzero.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/mzero.pcert1 : workshops/2003/hendrix/support/mzero.pcert0
-workshops/2003/hendrix/support/mzero.cert : | workshops/2003/hendrix/support/mzero.pcert1
-
-workshops/2003/hendrix/support/vector.pcert0 : no_pcert = 0
-workshops/2003/hendrix/support/vector.pcert0 : acl2x = 0
-workshops/2003/hendrix/support/vector.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- workshops/2003/hendrix/support/vector.lisp
-workshops/2003/hendrix/support/vector.pcert1 : acl2x = 0
-workshops/2003/hendrix/support/vector.pcert1 : no_pcert = 0
-workshops/2003/hendrix/support/vector.pcert1 : workshops/2003/hendrix/support/vector.pcert0
-workshops/2003/hendrix/support/vector.cert : | workshops/2003/hendrix/support/vector.pcert1
-
-workshops/2003/matlin-mccune/support/simp.pcert0 : no_pcert = 0
-workshops/2003/matlin-mccune/support/simp.pcert0 : acl2x = 0
-workshops/2003/matlin-mccune/support/simp.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/2003/matlin-mccune/support/simp.lisp
-workshops/2003/matlin-mccune/support/simp.pcert1 : acl2x = 0
-workshops/2003/matlin-mccune/support/simp.pcert1 : no_pcert = 0
-workshops/2003/matlin-mccune/support/simp.pcert1 : workshops/2003/matlin-mccune/support/simp.pcert0
-workshops/2003/matlin-mccune/support/simp.cert : | workshops/2003/matlin-mccune/support/simp.pcert1
-
-workshops/2003/moore_rockwell/support/memory-taggings.pcert0 : no_pcert = 0
-workshops/2003/moore_rockwell/support/memory-taggings.pcert0 : acl2x = 0
-workshops/2003/moore_rockwell/support/memory-taggings.pcert0 : \
- misc/records.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2003/moore_rockwell/support/memory-taggings.lisp
-workshops/2003/moore_rockwell/support/memory-taggings.pcert1 : acl2x = 0
-workshops/2003/moore_rockwell/support/memory-taggings.pcert1 : no_pcert = 0
-workshops/2003/moore_rockwell/support/memory-taggings.pcert1 : workshops/2003/moore_rockwell/support/memory-taggings.pcert0
-workshops/2003/moore_rockwell/support/memory-taggings.cert : | workshops/2003/moore_rockwell/support/memory-taggings.pcert1
-
-workshops/2003/moore_vcg/support/demo.pcert0 : no_pcert = 0
-workshops/2003/moore_vcg/support/demo.pcert0 : acl2x = 0
-workshops/2003/moore_vcg/support/demo.pcert0 : \
- workshops/2003/moore_vcg/support/utilities.pcert0 \
- workshops/2003/moore_vcg/support/demo.lisp \
- workshops/2003/moore_vcg/support/demo.acl2
-workshops/2003/moore_vcg/support/demo.pcert1 : acl2x = 0
-workshops/2003/moore_vcg/support/demo.pcert1 : no_pcert = 0
-workshops/2003/moore_vcg/support/demo.pcert1 : workshops/2003/moore_vcg/support/demo.pcert0
-workshops/2003/moore_vcg/support/demo.cert : | workshops/2003/moore_vcg/support/demo.pcert1
-
-workshops/2003/moore_vcg/support/m5.pcert0 : no_pcert = 0
-workshops/2003/moore_vcg/support/m5.pcert0 : acl2x = 0
-workshops/2003/moore_vcg/support/m5.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- workshops/2003/moore_vcg/support/m5.lisp \
- workshops/2003/moore_vcg/support/m5.acl2
-workshops/2003/moore_vcg/support/m5.pcert1 : acl2x = 0
-workshops/2003/moore_vcg/support/m5.pcert1 : no_pcert = 0
-workshops/2003/moore_vcg/support/m5.pcert1 : workshops/2003/moore_vcg/support/m5.pcert0
-workshops/2003/moore_vcg/support/m5.cert : | workshops/2003/moore_vcg/support/m5.pcert1
-
-workshops/2003/moore_vcg/support/utilities.pcert0 : no_pcert = 0
-workshops/2003/moore_vcg/support/utilities.pcert0 : acl2x = 0
-workshops/2003/moore_vcg/support/utilities.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2003/moore_vcg/support/m5.pcert0 \
- workshops/2003/moore_vcg/support/utilities.lisp \
- workshops/2003/moore_vcg/support/utilities.acl2
-workshops/2003/moore_vcg/support/utilities.pcert1 : acl2x = 0
-workshops/2003/moore_vcg/support/utilities.pcert1 : no_pcert = 0
-workshops/2003/moore_vcg/support/utilities.pcert1 : workshops/2003/moore_vcg/support/utilities.pcert0
-workshops/2003/moore_vcg/support/utilities.cert : | workshops/2003/moore_vcg/support/utilities.pcert1
-
-workshops/2003/moore_vcg/support/vcg-examples.pcert0 : no_pcert = 0
-workshops/2003/moore_vcg/support/vcg-examples.pcert0 : acl2x = 0
-workshops/2003/moore_vcg/support/vcg-examples.pcert0 : \
- misc/defpun.pcert0 \
- workshops/2003/moore_vcg/support/demo.pcert0 \
- workshops/2003/moore_vcg/support/utilities.pcert0 \
- workshops/2003/moore_vcg/support/vcg-examples.lisp \
- workshops/2003/moore_vcg/support/vcg-examples.acl2
-workshops/2003/moore_vcg/support/vcg-examples.pcert1 : acl2x = 0
-workshops/2003/moore_vcg/support/vcg-examples.pcert1 : no_pcert = 0
-workshops/2003/moore_vcg/support/vcg-examples.pcert1 : workshops/2003/moore_vcg/support/vcg-examples.pcert0
-workshops/2003/moore_vcg/support/vcg-examples.cert : | workshops/2003/moore_vcg/support/vcg-examples.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/apply-total-order.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/apply-total-order.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/apply-total-order.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/total-order.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/apply-total-order.lisp
-workshops/2003/ray-matthews-tuttle/support/apply-total-order.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/apply-total-order.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/apply-total-order.pcert1 : workshops/2003/ray-matthews-tuttle/support/apply-total-order.pcert0
-workshops/2003/ray-matthews-tuttle/support/apply-total-order.cert : | workshops/2003/ray-matthews-tuttle/support/apply-total-order.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/bisimilarity.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/bisimilarity.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/bisimilarity.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/ltl.pcert0 \
- arithmetic-2/meta/top.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/bisimilarity.lisp
-workshops/2003/ray-matthews-tuttle/support/bisimilarity.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/bisimilarity.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/bisimilarity.pcert1 : workshops/2003/ray-matthews-tuttle/support/bisimilarity.pcert0
-workshops/2003/ray-matthews-tuttle/support/bisimilarity.cert : | workshops/2003/ray-matthews-tuttle/support/bisimilarity.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/circuit-bisim.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/circuit-bisim.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/circuit-bisim.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/ltl.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/bisimilarity.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/circuit-bisim.lisp
-workshops/2003/ray-matthews-tuttle/support/circuit-bisim.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/circuit-bisim.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/circuit-bisim.pcert1 : workshops/2003/ray-matthews-tuttle/support/circuit-bisim.pcert0
-workshops/2003/ray-matthews-tuttle/support/circuit-bisim.cert : | workshops/2003/ray-matthews-tuttle/support/circuit-bisim.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/circuits.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/circuits.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/circuits.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/circuit-bisim.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/circuits.lisp
-workshops/2003/ray-matthews-tuttle/support/circuits.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/circuits.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/circuits.pcert1 : workshops/2003/ray-matthews-tuttle/support/circuits.pcert0
-workshops/2003/ray-matthews-tuttle/support/circuits.cert : | workshops/2003/ray-matthews-tuttle/support/circuits.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/concrete-ltl.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/concrete-ltl.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/concrete-ltl.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/ltl.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/concrete-ltl.lisp
-workshops/2003/ray-matthews-tuttle/support/concrete-ltl.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/concrete-ltl.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/concrete-ltl.pcert1 : workshops/2003/ray-matthews-tuttle/support/concrete-ltl.pcert0
-workshops/2003/ray-matthews-tuttle/support/concrete-ltl.cert : | workshops/2003/ray-matthews-tuttle/support/concrete-ltl.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/cone-of-influence.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/cone-of-influence.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/cone-of-influence.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/circuits.pcert0 \
- arithmetic-2/meta/top.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/cone-of-influence.lisp
-workshops/2003/ray-matthews-tuttle/support/cone-of-influence.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/cone-of-influence.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/cone-of-influence.pcert1 : workshops/2003/ray-matthews-tuttle/support/cone-of-influence.pcert0
-workshops/2003/ray-matthews-tuttle/support/cone-of-influence.cert : | workshops/2003/ray-matthews-tuttle/support/cone-of-influence.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/conjunction.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/conjunction.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/conjunction.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/ltl.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/conjunction.lisp
-workshops/2003/ray-matthews-tuttle/support/conjunction.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/conjunction.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/conjunction.pcert1 : workshops/2003/ray-matthews-tuttle/support/conjunction.pcert0
-workshops/2003/ray-matthews-tuttle/support/conjunction.cert : | workshops/2003/ray-matthews-tuttle/support/conjunction.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/impl-hack.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/impl-hack.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/impl-hack.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/reductions.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/impl-hack.lisp \
- workshops/2003/ray-matthews-tuttle/support/impl-hack.acl2
-workshops/2003/ray-matthews-tuttle/support/impl-hack.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/impl-hack.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/impl-hack.pcert1 : workshops/2003/ray-matthews-tuttle/support/impl-hack.pcert0
-workshops/2003/ray-matthews-tuttle/support/impl-hack.cert : | workshops/2003/ray-matthews-tuttle/support/impl-hack.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/ltl.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/ltl.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/ltl.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/sets.pcert0 \
- arithmetic-2/meta/top.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/ltl.lisp
-workshops/2003/ray-matthews-tuttle/support/ltl.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/ltl.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/ltl.pcert1 : workshops/2003/ray-matthews-tuttle/support/ltl.pcert0
-workshops/2003/ray-matthews-tuttle/support/ltl.cert : | workshops/2003/ray-matthews-tuttle/support/ltl.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/records.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/records.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/records.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/apply-total-order.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/records.lisp
-workshops/2003/ray-matthews-tuttle/support/records.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/records.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/records.pcert1 : workshops/2003/ray-matthews-tuttle/support/records.pcert0
-workshops/2003/ray-matthews-tuttle/support/records.cert : | workshops/2003/ray-matthews-tuttle/support/records.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/reductions.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/reductions.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/reductions.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/conjunction.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/cone-of-influence.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/reductions.lisp
-workshops/2003/ray-matthews-tuttle/support/reductions.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/reductions.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/reductions.pcert1 : workshops/2003/ray-matthews-tuttle/support/reductions.pcert0
-workshops/2003/ray-matthews-tuttle/support/reductions.cert : | workshops/2003/ray-matthews-tuttle/support/reductions.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/sets.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/sets.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/sets.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/records.pcert0 \
- workshops/2003/ray-matthews-tuttle/support/sets.lisp
-workshops/2003/ray-matthews-tuttle/support/sets.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/sets.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/sets.pcert1 : workshops/2003/ray-matthews-tuttle/support/sets.pcert0
-workshops/2003/ray-matthews-tuttle/support/sets.cert : | workshops/2003/ray-matthews-tuttle/support/sets.pcert1
-
-workshops/2003/ray-matthews-tuttle/support/total-order.pcert0 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/total-order.pcert0 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/total-order.pcert0 : \
- workshops/2003/ray-matthews-tuttle/support/total-order.lisp
-workshops/2003/ray-matthews-tuttle/support/total-order.pcert1 : acl2x = 0
-workshops/2003/ray-matthews-tuttle/support/total-order.pcert1 : no_pcert = 0
-workshops/2003/ray-matthews-tuttle/support/total-order.pcert1 : workshops/2003/ray-matthews-tuttle/support/total-order.pcert0
-workshops/2003/ray-matthews-tuttle/support/total-order.cert : | workshops/2003/ray-matthews-tuttle/support/total-order.pcert1
-
-workshops/2003/schmaltz-al-sammane-et-al/support/consistency.pcert0 : no_pcert = 0
-workshops/2003/schmaltz-al-sammane-et-al/support/consistency.pcert0 : acl2x = 0
-workshops/2003/schmaltz-al-sammane-et-al/support/consistency.pcert0 : \
- misc/expander.pcert0 \
- workshops/2003/schmaltz-al-sammane-et-al/support/consistency.lisp
-workshops/2003/schmaltz-al-sammane-et-al/support/consistency.pcert1 : acl2x = 0
-workshops/2003/schmaltz-al-sammane-et-al/support/consistency.pcert1 : no_pcert = 0
-workshops/2003/schmaltz-al-sammane-et-al/support/consistency.pcert1 : workshops/2003/schmaltz-al-sammane-et-al/support/consistency.pcert0
-workshops/2003/schmaltz-al-sammane-et-al/support/consistency.cert : | workshops/2003/schmaltz-al-sammane-et-al/support/consistency.pcert1
-
-workshops/2003/schmaltz-borrione/support/arbiter.pcert0 : no_pcert = 0
-workshops/2003/schmaltz-borrione/support/arbiter.pcert0 : acl2x = 0
-workshops/2003/schmaltz-borrione/support/arbiter.pcert0 : \
- workshops/2003/schmaltz-borrione/support/inequalities.pcert0 \
- workshops/2003/schmaltz-borrione/support/decoder.pcert0 \
- workshops/2003/schmaltz-borrione/support/predicates.pcert0 \
- workshops/2003/schmaltz-borrione/support/arbiter.lisp
-workshops/2003/schmaltz-borrione/support/arbiter.pcert1 : acl2x = 0
-workshops/2003/schmaltz-borrione/support/arbiter.pcert1 : no_pcert = 0
-workshops/2003/schmaltz-borrione/support/arbiter.pcert1 : workshops/2003/schmaltz-borrione/support/arbiter.pcert0
-workshops/2003/schmaltz-borrione/support/arbiter.cert : | workshops/2003/schmaltz-borrione/support/arbiter.pcert1
-
-workshops/2003/schmaltz-borrione/support/decoder.pcert0 : no_pcert = 0
-workshops/2003/schmaltz-borrione/support/decoder.pcert0 : acl2x = 0
-workshops/2003/schmaltz-borrione/support/decoder.pcert0 : \
- arithmetic/top.pcert0 \
- arithmetic-2/floor-mod/floor-mod.pcert0 \
- workshops/2003/schmaltz-borrione/support/decoder.lisp
-workshops/2003/schmaltz-borrione/support/decoder.pcert1 : acl2x = 0
-workshops/2003/schmaltz-borrione/support/decoder.pcert1 : no_pcert = 0
-workshops/2003/schmaltz-borrione/support/decoder.pcert1 : workshops/2003/schmaltz-borrione/support/decoder.pcert0
-workshops/2003/schmaltz-borrione/support/decoder.cert : | workshops/2003/schmaltz-borrione/support/decoder.pcert1
-
-workshops/2003/schmaltz-borrione/support/inequalities.pcert0 : no_pcert = 0
-workshops/2003/schmaltz-borrione/support/inequalities.pcert0 : acl2x = 0
-workshops/2003/schmaltz-borrione/support/inequalities.pcert0 : \
- arithmetic/top.pcert0 \
- workshops/2003/schmaltz-borrione/support/inequalities.lisp
-workshops/2003/schmaltz-borrione/support/inequalities.pcert1 : acl2x = 0
-workshops/2003/schmaltz-borrione/support/inequalities.pcert1 : no_pcert = 0
-workshops/2003/schmaltz-borrione/support/inequalities.pcert1 : workshops/2003/schmaltz-borrione/support/inequalities.pcert0
-workshops/2003/schmaltz-borrione/support/inequalities.cert : | workshops/2003/schmaltz-borrione/support/inequalities.pcert1
-
-workshops/2003/schmaltz-borrione/support/predicates.pcert0 : no_pcert = 0
-workshops/2003/schmaltz-borrione/support/predicates.pcert0 : acl2x = 0
-workshops/2003/schmaltz-borrione/support/predicates.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- workshops/2003/schmaltz-borrione/support/predicates.lisp
-workshops/2003/schmaltz-borrione/support/predicates.pcert1 : acl2x = 0
-workshops/2003/schmaltz-borrione/support/predicates.pcert1 : no_pcert = 0
-workshops/2003/schmaltz-borrione/support/predicates.pcert1 : workshops/2003/schmaltz-borrione/support/predicates.pcert0
-workshops/2003/schmaltz-borrione/support/predicates.cert : | workshops/2003/schmaltz-borrione/support/predicates.pcert1
-
-workshops/2003/schmaltz-borrione/support/transfers.pcert0 : no_pcert = 0
-workshops/2003/schmaltz-borrione/support/transfers.pcert0 : acl2x = 0
-workshops/2003/schmaltz-borrione/support/transfers.pcert0 : \
- workshops/2003/schmaltz-borrione/support/decoder.pcert0 \
- workshops/2003/schmaltz-borrione/support/arbiter.pcert0 \
- workshops/2003/schmaltz-borrione/support/transfers.lisp
-workshops/2003/schmaltz-borrione/support/transfers.pcert1 : acl2x = 0
-workshops/2003/schmaltz-borrione/support/transfers.pcert1 : no_pcert = 0
-workshops/2003/schmaltz-borrione/support/transfers.pcert1 : workshops/2003/schmaltz-borrione/support/transfers.pcert0
-workshops/2003/schmaltz-borrione/support/transfers.cert : | workshops/2003/schmaltz-borrione/support/transfers.pcert1
-
-workshops/2003/sumners/support/cfair.pcert0 : no_pcert = 0
-workshops/2003/sumners/support/cfair.pcert0 : acl2x = 0
-workshops/2003/sumners/support/cfair.pcert0 : \
- workshops/2003/sumners/support/n2n.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2003/sumners/support/cfair.lisp
-workshops/2003/sumners/support/cfair.pcert1 : acl2x = 0
-workshops/2003/sumners/support/cfair.pcert1 : no_pcert = 0
-workshops/2003/sumners/support/cfair.pcert1 : workshops/2003/sumners/support/cfair.pcert0
-workshops/2003/sumners/support/cfair.cert : | workshops/2003/sumners/support/cfair.pcert1
-
-workshops/2003/sumners/support/example1.pcert0 : no_pcert = 0
-workshops/2003/sumners/support/example1.pcert0 : acl2x = 0
-workshops/2003/sumners/support/example1.pcert0 : \
- workshops/2003/sumners/support/fair1.pcert0 \
- workshops/2003/sumners/support/example1.lisp
-workshops/2003/sumners/support/example1.pcert1 : acl2x = 0
-workshops/2003/sumners/support/example1.pcert1 : no_pcert = 0
-workshops/2003/sumners/support/example1.pcert1 : workshops/2003/sumners/support/example1.pcert0
-workshops/2003/sumners/support/example1.cert : | workshops/2003/sumners/support/example1.pcert1
-
-workshops/2003/sumners/support/example2.pcert0 : no_pcert = 0
-workshops/2003/sumners/support/example2.pcert0 : acl2x = 0
-workshops/2003/sumners/support/example2.pcert0 : \
- workshops/2003/sumners/support/fair2.pcert0 \
- workshops/2003/sumners/support/example2.lisp
-workshops/2003/sumners/support/example2.pcert1 : acl2x = 0
-workshops/2003/sumners/support/example2.pcert1 : no_pcert = 0
-workshops/2003/sumners/support/example2.pcert1 : workshops/2003/sumners/support/example2.pcert0
-workshops/2003/sumners/support/example2.cert : | workshops/2003/sumners/support/example2.pcert1
-
-workshops/2003/sumners/support/example3.pcert0 : no_pcert = 0
-workshops/2003/sumners/support/example3.pcert0 : acl2x = 0
-workshops/2003/sumners/support/example3.pcert0 : \
- workshops/2003/sumners/support/fair2.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2003/sumners/support/example3.lisp
-workshops/2003/sumners/support/example3.pcert1 : acl2x = 0
-workshops/2003/sumners/support/example3.pcert1 : no_pcert = 0
-workshops/2003/sumners/support/example3.pcert1 : workshops/2003/sumners/support/example3.pcert0
-workshops/2003/sumners/support/example3.cert : | workshops/2003/sumners/support/example3.pcert1
-
-workshops/2003/sumners/support/fair1.pcert0 : no_pcert = 0
-workshops/2003/sumners/support/fair1.pcert0 : acl2x = 0
-workshops/2003/sumners/support/fair1.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- workshops/2003/sumners/support/fair1.lisp
-workshops/2003/sumners/support/fair1.pcert1 : acl2x = 0
-workshops/2003/sumners/support/fair1.pcert1 : no_pcert = 0
-workshops/2003/sumners/support/fair1.pcert1 : workshops/2003/sumners/support/fair1.pcert0
-workshops/2003/sumners/support/fair1.cert : | workshops/2003/sumners/support/fair1.pcert1
-
-workshops/2003/sumners/support/fair2.pcert0 : no_pcert = 0
-workshops/2003/sumners/support/fair2.pcert0 : acl2x = 0
-workshops/2003/sumners/support/fair2.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- workshops/2003/sumners/support/n2n.pcert0 \
- workshops/2003/sumners/support/fair2.lisp
-workshops/2003/sumners/support/fair2.pcert1 : acl2x = 0
-workshops/2003/sumners/support/fair2.pcert1 : no_pcert = 0
-workshops/2003/sumners/support/fair2.pcert1 : workshops/2003/sumners/support/fair2.pcert0
-workshops/2003/sumners/support/fair2.cert : | workshops/2003/sumners/support/fair2.pcert1
-
-workshops/2003/sumners/support/n2n.pcert0 : no_pcert = 0
-workshops/2003/sumners/support/n2n.pcert0 : acl2x = 0
-workshops/2003/sumners/support/n2n.pcert0 : \
- workshops/2003/sumners/support/n2n.lisp
-workshops/2003/sumners/support/n2n.pcert1 : acl2x = 0
-workshops/2003/sumners/support/n2n.pcert1 : no_pcert = 0
-workshops/2003/sumners/support/n2n.pcert1 : workshops/2003/sumners/support/n2n.pcert0
-workshops/2003/sumners/support/n2n.cert : | workshops/2003/sumners/support/n2n.pcert1
-
-workshops/2003/sumners/support/simple.pcert0 : no_pcert = 0
-workshops/2003/sumners/support/simple.pcert0 : acl2x = 0
-workshops/2003/sumners/support/simple.pcert0 : \
- workshops/2003/sumners/support/simple.lisp
-workshops/2003/sumners/support/simple.pcert1 : acl2x = 0
-workshops/2003/sumners/support/simple.pcert1 : no_pcert = 0
-workshops/2003/sumners/support/simple.pcert1 : workshops/2003/sumners/support/simple.pcert0
-workshops/2003/sumners/support/simple.cert : | workshops/2003/sumners/support/simple.pcert1
-
-workshops/2003/sustik/support/dickson.pcert0 : no_pcert = 0
-workshops/2003/sustik/support/dickson.pcert0 : acl2x = 0
-workshops/2003/sustik/support/dickson.pcert0 : \
- ordinals/ordinals.pcert0 \
- workshops/2003/sustik/support/dickson.lisp
-workshops/2003/sustik/support/dickson.pcert1 : acl2x = 0
-workshops/2003/sustik/support/dickson.pcert1 : no_pcert = 0
-workshops/2003/sustik/support/dickson.pcert1 : workshops/2003/sustik/support/dickson.pcert0
-workshops/2003/sustik/support/dickson.cert : | workshops/2003/sustik/support/dickson.pcert1
-
-workshops/2003/toma-borrione/support/bv-op-defthms.pcert0 : no_pcert = 0
-workshops/2003/toma-borrione/support/bv-op-defthms.pcert0 : acl2x = 0
-workshops/2003/toma-borrione/support/bv-op-defthms.pcert0 : \
- workshops/2003/toma-borrione/support/bv-op-defuns.pcert0 \
- workshops/2003/toma-borrione/support/bv-op-defthms.lisp
-workshops/2003/toma-borrione/support/bv-op-defthms.pcert1 : acl2x = 0
-workshops/2003/toma-borrione/support/bv-op-defthms.pcert1 : no_pcert = 0
-workshops/2003/toma-borrione/support/bv-op-defthms.pcert1 : workshops/2003/toma-borrione/support/bv-op-defthms.pcert0
-workshops/2003/toma-borrione/support/bv-op-defthms.cert : | workshops/2003/toma-borrione/support/bv-op-defthms.pcert1
-
-workshops/2003/toma-borrione/support/bv-op-defuns.pcert0 : no_pcert = 0
-workshops/2003/toma-borrione/support/bv-op-defuns.pcert0 : acl2x = 0
-workshops/2003/toma-borrione/support/bv-op-defuns.pcert0 : \
- workshops/2003/toma-borrione/support/misc.pcert0 \
- workshops/2003/toma-borrione/support/bv-op-defuns.lisp
-workshops/2003/toma-borrione/support/bv-op-defuns.pcert1 : acl2x = 0
-workshops/2003/toma-borrione/support/bv-op-defuns.pcert1 : no_pcert = 0
-workshops/2003/toma-borrione/support/bv-op-defuns.pcert1 : workshops/2003/toma-borrione/support/bv-op-defuns.pcert0
-workshops/2003/toma-borrione/support/bv-op-defuns.cert : | workshops/2003/toma-borrione/support/bv-op-defuns.pcert1
-
-workshops/2003/toma-borrione/support/misc.pcert0 : no_pcert = 0
-workshops/2003/toma-borrione/support/misc.pcert0 : acl2x = 0
-workshops/2003/toma-borrione/support/misc.pcert0 : \
- arithmetic/equalities.pcert0 \
- arithmetic/inequalities.pcert0 \
- arithmetic-2/floor-mod/floor-mod.pcert0 \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- workshops/2003/toma-borrione/support/misc.lisp
-workshops/2003/toma-borrione/support/misc.pcert1 : acl2x = 0
-workshops/2003/toma-borrione/support/misc.pcert1 : no_pcert = 0
-workshops/2003/toma-borrione/support/misc.pcert1 : workshops/2003/toma-borrione/support/misc.pcert0
-workshops/2003/toma-borrione/support/misc.cert : | workshops/2003/toma-borrione/support/misc.pcert1
-
-workshops/2003/toma-borrione/support/padding-1-256.pcert0 : no_pcert = 0
-workshops/2003/toma-borrione/support/padding-1-256.pcert0 : acl2x = 0
-workshops/2003/toma-borrione/support/padding-1-256.pcert0 : \
- workshops/2003/toma-borrione/support/bv-op-defthms.pcert0 \
- workshops/2003/toma-borrione/support/padding-1-256.lisp
-workshops/2003/toma-borrione/support/padding-1-256.pcert1 : acl2x = 0
-workshops/2003/toma-borrione/support/padding-1-256.pcert1 : no_pcert = 0
-workshops/2003/toma-borrione/support/padding-1-256.pcert1 : workshops/2003/toma-borrione/support/padding-1-256.pcert0
-workshops/2003/toma-borrione/support/padding-1-256.cert : | workshops/2003/toma-borrione/support/padding-1-256.pcert1
-
-workshops/2003/toma-borrione/support/padding-384-512.pcert0 : no_pcert = 0
-workshops/2003/toma-borrione/support/padding-384-512.pcert0 : acl2x = 0
-workshops/2003/toma-borrione/support/padding-384-512.pcert0 : \
- workshops/2003/toma-borrione/support/bv-op-defthms.pcert0 \
- workshops/2003/toma-borrione/support/padding-384-512.lisp
-workshops/2003/toma-borrione/support/padding-384-512.pcert1 : acl2x = 0
-workshops/2003/toma-borrione/support/padding-384-512.pcert1 : no_pcert = 0
-workshops/2003/toma-borrione/support/padding-384-512.pcert1 : workshops/2003/toma-borrione/support/padding-384-512.pcert0
-workshops/2003/toma-borrione/support/padding-384-512.cert : | workshops/2003/toma-borrione/support/padding-384-512.pcert1
-
-workshops/2003/toma-borrione/support/parsing.pcert0 : no_pcert = 0
-workshops/2003/toma-borrione/support/parsing.pcert0 : acl2x = 0
-workshops/2003/toma-borrione/support/parsing.pcert0 : \
- workshops/2003/toma-borrione/support/padding-1-256.pcert0 \
- workshops/2003/toma-borrione/support/padding-384-512.pcert0 \
- workshops/2003/toma-borrione/support/parsing.lisp
-workshops/2003/toma-borrione/support/parsing.pcert1 : acl2x = 0
-workshops/2003/toma-borrione/support/parsing.pcert1 : no_pcert = 0
-workshops/2003/toma-borrione/support/parsing.pcert1 : workshops/2003/toma-borrione/support/parsing.pcert0
-workshops/2003/toma-borrione/support/parsing.cert : | workshops/2003/toma-borrione/support/parsing.pcert1
-
-workshops/2003/toma-borrione/support/sha-1.pcert0 : no_pcert = 0
-workshops/2003/toma-borrione/support/sha-1.pcert0 : acl2x = 0
-workshops/2003/toma-borrione/support/sha-1.pcert0 : \
- workshops/2003/toma-borrione/support/parsing.pcert0 \
- workshops/2003/toma-borrione/support/sha-functions.pcert0 \
- workshops/2003/toma-borrione/support/sha-1.lisp
-workshops/2003/toma-borrione/support/sha-1.pcert1 : acl2x = 0
-workshops/2003/toma-borrione/support/sha-1.pcert1 : no_pcert = 0
-workshops/2003/toma-borrione/support/sha-1.pcert1 : workshops/2003/toma-borrione/support/sha-1.pcert0
-workshops/2003/toma-borrione/support/sha-1.cert : | workshops/2003/toma-borrione/support/sha-1.pcert1
-
-workshops/2003/toma-borrione/support/sha-256.pcert0 : no_pcert = 0
-workshops/2003/toma-borrione/support/sha-256.pcert0 : acl2x = 0
-workshops/2003/toma-borrione/support/sha-256.pcert0 : \
- workshops/2003/toma-borrione/support/parsing.pcert0 \
- workshops/2003/toma-borrione/support/sha-functions.pcert0 \
- workshops/2003/toma-borrione/support/sha-256.lisp
-workshops/2003/toma-borrione/support/sha-256.pcert1 : acl2x = 0
-workshops/2003/toma-borrione/support/sha-256.pcert1 : no_pcert = 0
-workshops/2003/toma-borrione/support/sha-256.pcert1 : workshops/2003/toma-borrione/support/sha-256.pcert0
-workshops/2003/toma-borrione/support/sha-256.cert : | workshops/2003/toma-borrione/support/sha-256.pcert1
-
-workshops/2003/toma-borrione/support/sha-384-512.pcert0 : no_pcert = 0
-workshops/2003/toma-borrione/support/sha-384-512.pcert0 : acl2x = 0
-workshops/2003/toma-borrione/support/sha-384-512.pcert0 : \
- workshops/2003/toma-borrione/support/parsing.pcert0 \
- workshops/2003/toma-borrione/support/sha-functions.pcert0 \
- workshops/2003/toma-borrione/support/sha-384-512.lisp
-workshops/2003/toma-borrione/support/sha-384-512.pcert1 : acl2x = 0
-workshops/2003/toma-borrione/support/sha-384-512.pcert1 : no_pcert = 0
-workshops/2003/toma-borrione/support/sha-384-512.pcert1 : workshops/2003/toma-borrione/support/sha-384-512.pcert0
-workshops/2003/toma-borrione/support/sha-384-512.cert : | workshops/2003/toma-borrione/support/sha-384-512.pcert1
-
-workshops/2003/toma-borrione/support/sha-functions.pcert0 : no_pcert = 0
-workshops/2003/toma-borrione/support/sha-functions.pcert0 : acl2x = 0
-workshops/2003/toma-borrione/support/sha-functions.pcert0 : \
- workshops/2003/toma-borrione/support/bv-op-defthms.pcert0 \
- workshops/2003/toma-borrione/support/sha-functions.lisp
-workshops/2003/toma-borrione/support/sha-functions.pcert1 : acl2x = 0
-workshops/2003/toma-borrione/support/sha-functions.pcert1 : no_pcert = 0
-workshops/2003/toma-borrione/support/sha-functions.pcert1 : workshops/2003/toma-borrione/support/sha-functions.pcert0
-workshops/2003/toma-borrione/support/sha-functions.cert : | workshops/2003/toma-borrione/support/sha-functions.pcert1
-
-workshops/2003/tsong/support/shim.pcert0 : no_pcert = 0
-workshops/2003/tsong/support/shim.pcert0 : acl2x = 0
-workshops/2003/tsong/support/shim.pcert0 : \
- data-structures/structures.pcert0 \
- workshops/2003/tsong/support/shim.lisp
-workshops/2003/tsong/support/shim.pcert1 : acl2x = 0
-workshops/2003/tsong/support/shim.pcert1 : no_pcert = 0
-workshops/2003/tsong/support/shim.pcert1 : workshops/2003/tsong/support/shim.pcert0
-workshops/2003/tsong/support/shim.cert : | workshops/2003/tsong/support/shim.pcert1
-
-workshops/2004/cowles-gamboa/support/WyoM1-correct.pcert0 : no_pcert = 0
-workshops/2004/cowles-gamboa/support/WyoM1-correct.pcert0 : acl2x = 0
-workshops/2004/cowles-gamboa/support/WyoM1-correct.pcert0 : \
- workshops/2004/cowles-gamboa/support/WyoM1-utilities.pcert0 \
- misc/defpun.pcert0 \
- workshops/2004/cowles-gamboa/support/WyoM1-utilities.pcert0 \
- workshops/2004/cowles-gamboa/support/WyoM1-correct.lisp \
- workshops/2004/cowles-gamboa/support/WyoM1-correct.acl2
-workshops/2004/cowles-gamboa/support/WyoM1-correct.pcert1 : acl2x = 0
-workshops/2004/cowles-gamboa/support/WyoM1-correct.pcert1 : no_pcert = 0
-workshops/2004/cowles-gamboa/support/WyoM1-correct.pcert1 : workshops/2004/cowles-gamboa/support/WyoM1-correct.pcert0
-workshops/2004/cowles-gamboa/support/WyoM1-correct.cert : | workshops/2004/cowles-gamboa/support/WyoM1-correct.pcert1
-
-workshops/2004/cowles-gamboa/support/WyoM1-utilities.pcert0 : no_pcert = 0
-workshops/2004/cowles-gamboa/support/WyoM1-utilities.pcert0 : acl2x = 0
-workshops/2004/cowles-gamboa/support/WyoM1-utilities.pcert0 : \
- workshops/2004/cowles-gamboa/support/WyoM1.pcert0 \
- arithmetic/top.pcert0 \
- workshops/2004/cowles-gamboa/support/WyoM1.pcert0 \
- workshops/2004/cowles-gamboa/support/WyoM1-utilities.lisp \
- workshops/2004/cowles-gamboa/support/WyoM1-utilities.acl2
-workshops/2004/cowles-gamboa/support/WyoM1-utilities.pcert1 : acl2x = 0
-workshops/2004/cowles-gamboa/support/WyoM1-utilities.pcert1 : no_pcert = 0
-workshops/2004/cowles-gamboa/support/WyoM1-utilities.pcert1 : workshops/2004/cowles-gamboa/support/WyoM1-utilities.pcert0
-workshops/2004/cowles-gamboa/support/WyoM1-utilities.cert : | workshops/2004/cowles-gamboa/support/WyoM1-utilities.pcert1
-
-workshops/2004/cowles-gamboa/support/WyoM1.pcert0 : no_pcert = 0
-workshops/2004/cowles-gamboa/support/WyoM1.pcert0 : acl2x = 0
-workshops/2004/cowles-gamboa/support/WyoM1.pcert0 : \
- workshops/2004/cowles-gamboa/support/WyoM1.lisp \
- workshops/2004/cowles-gamboa/support/WyoM1.acl2
-workshops/2004/cowles-gamboa/support/WyoM1.pcert1 : acl2x = 0
-workshops/2004/cowles-gamboa/support/WyoM1.pcert1 : no_pcert = 0
-workshops/2004/cowles-gamboa/support/WyoM1.pcert1 : workshops/2004/cowles-gamboa/support/WyoM1.pcert0
-workshops/2004/cowles-gamboa/support/WyoM1.cert : | workshops/2004/cowles-gamboa/support/WyoM1.pcert1
-
-workshops/2004/cowles-gamboa/support/knuth.pcert0 : no_pcert = 0
-workshops/2004/cowles-gamboa/support/knuth.pcert0 : acl2x = 0
-workshops/2004/cowles-gamboa/support/knuth.pcert0 : \
- arithmetic/top.pcert0 \
- workshops/2004/cowles-gamboa/support/knuth.lisp
-workshops/2004/cowles-gamboa/support/knuth.pcert1 : acl2x = 0
-workshops/2004/cowles-gamboa/support/knuth.pcert1 : no_pcert = 0
-workshops/2004/cowles-gamboa/support/knuth.pcert1 : workshops/2004/cowles-gamboa/support/knuth.pcert0
-workshops/2004/cowles-gamboa/support/knuth.cert : | workshops/2004/cowles-gamboa/support/knuth.pcert1
-
-workshops/2004/cowles-gamboa/support/tail-rec.pcert0 : no_pcert = 0
-workshops/2004/cowles-gamboa/support/tail-rec.pcert0 : acl2x = 0
-workshops/2004/cowles-gamboa/support/tail-rec.pcert0 : \
- misc/defpun.pcert0 \
- workshops/2004/cowles-gamboa/support/tail-rec.lisp \
- workshops/2004/cowles-gamboa/support/tail-rec.acl2
-workshops/2004/cowles-gamboa/support/tail-rec.pcert1 : acl2x = 0
-workshops/2004/cowles-gamboa/support/tail-rec.pcert1 : no_pcert = 0
-workshops/2004/cowles-gamboa/support/tail-rec.pcert1 : workshops/2004/cowles-gamboa/support/tail-rec.pcert0
-workshops/2004/cowles-gamboa/support/tail-rec.cert : | workshops/2004/cowles-gamboa/support/tail-rec.pcert1
-
-workshops/2004/davis/support/computed-hints.pcert0 : no_pcert = 0
-workshops/2004/davis/support/computed-hints.pcert0 : acl2x = 0
-workshops/2004/davis/support/computed-hints.pcert0 : \
- workshops/2004/davis/support/instance.pcert0 \
- workshops/2004/davis/support/computed-hints.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-workshops/2004/davis/support/computed-hints.pcert1 : acl2x = 0
-workshops/2004/davis/support/computed-hints.pcert1 : no_pcert = 0
-workshops/2004/davis/support/computed-hints.pcert1 : workshops/2004/davis/support/computed-hints.pcert0
-workshops/2004/davis/support/computed-hints.cert : | workshops/2004/davis/support/computed-hints.pcert1
-
-workshops/2004/davis/support/fast.pcert0 : no_pcert = 0
-workshops/2004/davis/support/fast.pcert0 : acl2x = 0
-workshops/2004/davis/support/fast.pcert0 : \
- workshops/2004/davis/support/membership.pcert0 \
- workshops/2004/davis/support/fast.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-workshops/2004/davis/support/fast.pcert1 : acl2x = 0
-workshops/2004/davis/support/fast.pcert1 : no_pcert = 0
-workshops/2004/davis/support/fast.pcert1 : workshops/2004/davis/support/fast.pcert0
-workshops/2004/davis/support/fast.cert : | workshops/2004/davis/support/fast.pcert1
-
-workshops/2004/davis/support/instance.pcert0 : no_pcert = 0
-workshops/2004/davis/support/instance.pcert0 : acl2x = 0
-workshops/2004/davis/support/instance.pcert0 : \
- workshops/2004/davis/support/instance.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-workshops/2004/davis/support/instance.pcert1 : acl2x = 0
-workshops/2004/davis/support/instance.pcert1 : no_pcert = 0
-workshops/2004/davis/support/instance.pcert1 : workshops/2004/davis/support/instance.pcert0
-workshops/2004/davis/support/instance.cert : | workshops/2004/davis/support/instance.pcert1
-
-workshops/2004/davis/support/map.pcert0 : no_pcert = 0
-workshops/2004/davis/support/map.pcert0 : acl2x = 0
-workshops/2004/davis/support/map.pcert0 : \
- workshops/2004/davis/support/quantify.pcert0 \
- workshops/2004/davis/support/map.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-workshops/2004/davis/support/map.pcert1 : acl2x = 0
-workshops/2004/davis/support/map.pcert1 : no_pcert = 0
-workshops/2004/davis/support/map.pcert1 : workshops/2004/davis/support/map.pcert0
-workshops/2004/davis/support/map.cert : | workshops/2004/davis/support/map.pcert1
-
-workshops/2004/davis/support/membership.pcert0 : no_pcert = 0
-workshops/2004/davis/support/membership.pcert0 : acl2x = 0
-workshops/2004/davis/support/membership.pcert0 : \
- workshops/2004/davis/support/primitives.pcert0 \
- workshops/2004/davis/support/computed-hints.pcert0 \
- workshops/2004/davis/support/membership.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-workshops/2004/davis/support/membership.pcert1 : acl2x = 0
-workshops/2004/davis/support/membership.pcert1 : no_pcert = 0
-workshops/2004/davis/support/membership.pcert1 : workshops/2004/davis/support/membership.pcert0
-workshops/2004/davis/support/membership.cert : | workshops/2004/davis/support/membership.pcert1
-
-workshops/2004/davis/support/outer.pcert0 : no_pcert = 0
-workshops/2004/davis/support/outer.pcert0 : acl2x = 0
-workshops/2004/davis/support/outer.pcert0 : \
- workshops/2004/davis/support/fast.pcert0 \
- workshops/2004/davis/support/outer.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-workshops/2004/davis/support/outer.pcert1 : acl2x = 0
-workshops/2004/davis/support/outer.pcert1 : no_pcert = 0
-workshops/2004/davis/support/outer.pcert1 : workshops/2004/davis/support/outer.pcert0
-workshops/2004/davis/support/outer.cert : | workshops/2004/davis/support/outer.pcert1
-
-workshops/2004/davis/support/primitives.pcert0 : no_pcert = 0
-workshops/2004/davis/support/primitives.pcert0 : acl2x = 0
-workshops/2004/davis/support/primitives.pcert0 : \
- workshops/2004/davis/support/primitives.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-workshops/2004/davis/support/primitives.pcert1 : acl2x = 0
-workshops/2004/davis/support/primitives.pcert1 : no_pcert = 0
-workshops/2004/davis/support/primitives.pcert1 : workshops/2004/davis/support/primitives.pcert0
-workshops/2004/davis/support/primitives.cert : | workshops/2004/davis/support/primitives.pcert1
-
-workshops/2004/davis/support/quantify.pcert0 : no_pcert = 0
-workshops/2004/davis/support/quantify.pcert0 : acl2x = 0
-workshops/2004/davis/support/quantify.pcert0 : \
- workshops/2004/davis/support/sets.pcert0 \
- workshops/2004/davis/support/sets.pcert0 \
- workshops/2004/davis/support/quantify.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-workshops/2004/davis/support/quantify.pcert1 : acl2x = 0
-workshops/2004/davis/support/quantify.pcert1 : no_pcert = 0
-workshops/2004/davis/support/quantify.pcert1 : workshops/2004/davis/support/quantify.pcert0
-workshops/2004/davis/support/quantify.cert : | workshops/2004/davis/support/quantify.pcert1
-
-workshops/2004/davis/support/set-order.pcert0 : no_pcert = 0
-workshops/2004/davis/support/set-order.pcert0 : acl2x = 0
-workshops/2004/davis/support/set-order.pcert0 : \
- workshops/2004/davis/support/primitives.pcert0 \
- workshops/2004/davis/support/membership.pcert0 \
- workshops/2004/davis/support/fast.pcert0 \
- workshops/2004/davis/support/sets.pcert0 \
- workshops/2004/davis/support/set-order.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-workshops/2004/davis/support/set-order.pcert1 : acl2x = 0
-workshops/2004/davis/support/set-order.pcert1 : no_pcert = 0
-workshops/2004/davis/support/set-order.pcert1 : workshops/2004/davis/support/set-order.pcert0
-workshops/2004/davis/support/set-order.cert : | workshops/2004/davis/support/set-order.pcert1
-
-workshops/2004/davis/support/sets.pcert0 : no_pcert = 0
-workshops/2004/davis/support/sets.pcert0 : acl2x = 0
-workshops/2004/davis/support/sets.pcert0 : \
- workshops/2004/davis/support/computed-hints.pcert0 \
- workshops/2004/davis/support/primitives.pcert0 \
- workshops/2004/davis/support/membership.pcert0 \
- workshops/2004/davis/support/fast.pcert0 \
- workshops/2004/davis/support/outer.pcert0 \
- workshops/2004/davis/support/sort.pcert0 \
- workshops/2004/davis/support/sets.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-workshops/2004/davis/support/sets.pcert1 : acl2x = 0
-workshops/2004/davis/support/sets.pcert1 : no_pcert = 0
-workshops/2004/davis/support/sets.pcert1 : workshops/2004/davis/support/sets.pcert0
-workshops/2004/davis/support/sets.cert : | workshops/2004/davis/support/sets.pcert1
-
-workshops/2004/davis/support/sort.pcert0 : no_pcert = 0
-workshops/2004/davis/support/sort.pcert0 : acl2x = 0
-workshops/2004/davis/support/sort.pcert0 : \
- workshops/2004/davis/support/outer.pcert0 \
- workshops/2004/davis/support/sort.lisp \
- workshops/2004/davis/support/cert.acl2 \
- workshops/2004/davis/support/package.lsp
-workshops/2004/davis/support/sort.pcert1 : acl2x = 0
-workshops/2004/davis/support/sort.pcert1 : no_pcert = 0
-workshops/2004/davis/support/sort.pcert1 : workshops/2004/davis/support/sort.pcert0
-workshops/2004/davis/support/sort.cert : | workshops/2004/davis/support/sort.pcert1
-
-workshops/2004/gameiro-manolios/support/interval.pcert0 : no_pcert = 0
-workshops/2004/gameiro-manolios/support/interval.pcert0 : acl2x = 0
-workshops/2004/gameiro-manolios/support/interval.pcert0 : \
- workshops/2004/gameiro-manolios/support/top-with-meta.pcert0 \
- workshops/2004/gameiro-manolios/support/nth-thms.pcert0 \
- workshops/2004/gameiro-manolios/support/interval.lisp
-workshops/2004/gameiro-manolios/support/interval.pcert1 : acl2x = 0
-workshops/2004/gameiro-manolios/support/interval.pcert1 : no_pcert = 0
-workshops/2004/gameiro-manolios/support/interval.pcert1 : workshops/2004/gameiro-manolios/support/interval.pcert0
-workshops/2004/gameiro-manolios/support/interval.cert : | workshops/2004/gameiro-manolios/support/interval.pcert1
-
-workshops/2004/gameiro-manolios/support/nth-thms.pcert0 : no_pcert = 0
-workshops/2004/gameiro-manolios/support/nth-thms.pcert0 : acl2x = 0
-workshops/2004/gameiro-manolios/support/nth-thms.pcert0 : \
- workshops/2004/gameiro-manolios/support/nth-thms.lisp
-workshops/2004/gameiro-manolios/support/nth-thms.pcert1 : acl2x = 0
-workshops/2004/gameiro-manolios/support/nth-thms.pcert1 : no_pcert = 0
-workshops/2004/gameiro-manolios/support/nth-thms.pcert1 : workshops/2004/gameiro-manolios/support/nth-thms.pcert0
-workshops/2004/gameiro-manolios/support/nth-thms.cert : | workshops/2004/gameiro-manolios/support/nth-thms.pcert1
-
-workshops/2004/gameiro-manolios/support/top-with-meta.pcert0 : no_pcert = 0
-workshops/2004/gameiro-manolios/support/top-with-meta.pcert0 : acl2x = 0
-workshops/2004/gameiro-manolios/support/top-with-meta.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- workshops/2004/gameiro-manolios/support/top-with-meta.lisp
-workshops/2004/gameiro-manolios/support/top-with-meta.pcert1 : acl2x = 0
-workshops/2004/gameiro-manolios/support/top-with-meta.pcert1 : no_pcert = 0
-workshops/2004/gameiro-manolios/support/top-with-meta.pcert1 : workshops/2004/gameiro-manolios/support/top-with-meta.pcert0
-workshops/2004/gameiro-manolios/support/top-with-meta.cert : | workshops/2004/gameiro-manolios/support/top-with-meta.pcert1
-
-workshops/2004/gameiro-manolios/support/transversality.pcert0 : no_pcert = 0
-workshops/2004/gameiro-manolios/support/transversality.pcert0 : acl2x = 0
-workshops/2004/gameiro-manolios/support/transversality.pcert0 : \
- workshops/2004/gameiro-manolios/support/interval.pcert0 \
- workshops/2004/gameiro-manolios/support/transversality.lisp
-workshops/2004/gameiro-manolios/support/transversality.pcert1 : acl2x = 0
-workshops/2004/gameiro-manolios/support/transversality.pcert1 : no_pcert = 0
-workshops/2004/gameiro-manolios/support/transversality.pcert1 : workshops/2004/gameiro-manolios/support/transversality.pcert0
-workshops/2004/gameiro-manolios/support/transversality.cert : | workshops/2004/gameiro-manolios/support/transversality.pcert1
-
-workshops/2004/greve/support/defrecord.pcert0 : no_pcert = 0
-workshops/2004/greve/support/defrecord.pcert0 : acl2x = 0
-workshops/2004/greve/support/defrecord.pcert0 : \
- misc/records.pcert0 \
- workshops/2004/greve/support/defrecord.lisp
-workshops/2004/greve/support/defrecord.pcert1 : acl2x = 0
-workshops/2004/greve/support/defrecord.pcert1 : no_pcert = 0
-workshops/2004/greve/support/defrecord.pcert1 : workshops/2004/greve/support/defrecord.pcert0
-workshops/2004/greve/support/defrecord.cert : | workshops/2004/greve/support/defrecord.pcert1
-
-workshops/2004/greve/support/mark.pcert0 : no_pcert = 0
-workshops/2004/greve/support/mark.pcert0 : acl2x = 0
-workshops/2004/greve/support/mark.pcert0 : \
- workshops/2004/greve/support/defrecord.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/2004/greve/support/mark.lisp
-workshops/2004/greve/support/mark.pcert1 : acl2x = 0
-workshops/2004/greve/support/mark.pcert1 : no_pcert = 0
-workshops/2004/greve/support/mark.pcert1 : workshops/2004/greve/support/mark.pcert0
-workshops/2004/greve/support/mark.cert : | workshops/2004/greve/support/mark.pcert1
-
-workshops/2004/legato/support/generic-theories.pcert0 : no_pcert = 0
-workshops/2004/legato/support/generic-theories.pcert0 : acl2x = 0
-workshops/2004/legato/support/generic-theories.pcert0 : \
- workshops/2004/legato/support/generic-theories.lisp
-workshops/2004/legato/support/generic-theories.pcert1 : acl2x = 0
-workshops/2004/legato/support/generic-theories.pcert1 : no_pcert = 0
-workshops/2004/legato/support/generic-theories.pcert1 : workshops/2004/legato/support/generic-theories.pcert0
-workshops/2004/legato/support/generic-theories.cert : | workshops/2004/legato/support/generic-theories.pcert1
-
-workshops/2004/legato/support/generic-theory-alternative-induction-mult.pcert0 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-alternative-induction-mult.pcert0 : acl2x = 0
-workshops/2004/legato/support/generic-theory-alternative-induction-mult.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/legato/support/generic-theories.pcert0 \
- workshops/2004/legato/support/generic-theory-alternative-induction-mult.lisp
-workshops/2004/legato/support/generic-theory-alternative-induction-mult.pcert1 : acl2x = 0
-workshops/2004/legato/support/generic-theory-alternative-induction-mult.pcert1 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-alternative-induction-mult.pcert1 : workshops/2004/legato/support/generic-theory-alternative-induction-mult.pcert0
-workshops/2004/legato/support/generic-theory-alternative-induction-mult.cert : | workshops/2004/legato/support/generic-theory-alternative-induction-mult.pcert1
-
-workshops/2004/legato/support/generic-theory-alternative-induction-sum.pcert0 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-alternative-induction-sum.pcert0 : acl2x = 0
-workshops/2004/legato/support/generic-theory-alternative-induction-sum.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/legato/support/generic-theories.pcert0 \
- workshops/2004/legato/support/generic-theory-alternative-induction-sum.lisp
-workshops/2004/legato/support/generic-theory-alternative-induction-sum.pcert1 : acl2x = 0
-workshops/2004/legato/support/generic-theory-alternative-induction-sum.pcert1 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-alternative-induction-sum.pcert1 : workshops/2004/legato/support/generic-theory-alternative-induction-sum.pcert0
-workshops/2004/legato/support/generic-theory-alternative-induction-sum.cert : | workshops/2004/legato/support/generic-theory-alternative-induction-sum.pcert1
-
-workshops/2004/legato/support/generic-theory-loop-invariant-mult.pcert0 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-loop-invariant-mult.pcert0 : acl2x = 0
-workshops/2004/legato/support/generic-theory-loop-invariant-mult.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/legato/support/generic-theories.pcert0 \
- workshops/2004/legato/support/generic-theory-loop-invariant-mult.lisp
-workshops/2004/legato/support/generic-theory-loop-invariant-mult.pcert1 : acl2x = 0
-workshops/2004/legato/support/generic-theory-loop-invariant-mult.pcert1 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-loop-invariant-mult.pcert1 : workshops/2004/legato/support/generic-theory-loop-invariant-mult.pcert0
-workshops/2004/legato/support/generic-theory-loop-invariant-mult.cert : | workshops/2004/legato/support/generic-theory-loop-invariant-mult.pcert1
-
-workshops/2004/legato/support/generic-theory-loop-invariant-sum.pcert0 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-loop-invariant-sum.pcert0 : acl2x = 0
-workshops/2004/legato/support/generic-theory-loop-invariant-sum.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/legato/support/generic-theories.pcert0 \
- workshops/2004/legato/support/generic-theory-loop-invariant-sum.lisp
-workshops/2004/legato/support/generic-theory-loop-invariant-sum.pcert1 : acl2x = 0
-workshops/2004/legato/support/generic-theory-loop-invariant-sum.pcert1 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-loop-invariant-sum.pcert1 : workshops/2004/legato/support/generic-theory-loop-invariant-sum.pcert0
-workshops/2004/legato/support/generic-theory-loop-invariant-sum.cert : | workshops/2004/legato/support/generic-theory-loop-invariant-sum.pcert1
-
-workshops/2004/legato/support/generic-theory-tail-recursion-mult.pcert0 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-tail-recursion-mult.pcert0 : acl2x = 0
-workshops/2004/legato/support/generic-theory-tail-recursion-mult.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/legato/support/generic-theories.pcert0 \
- workshops/2004/legato/support/generic-theory-tail-recursion-mult.lisp
-workshops/2004/legato/support/generic-theory-tail-recursion-mult.pcert1 : acl2x = 0
-workshops/2004/legato/support/generic-theory-tail-recursion-mult.pcert1 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-tail-recursion-mult.pcert1 : workshops/2004/legato/support/generic-theory-tail-recursion-mult.pcert0
-workshops/2004/legato/support/generic-theory-tail-recursion-mult.cert : | workshops/2004/legato/support/generic-theory-tail-recursion-mult.pcert1
-
-workshops/2004/legato/support/generic-theory-tail-recursion-sum.pcert0 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-tail-recursion-sum.pcert0 : acl2x = 0
-workshops/2004/legato/support/generic-theory-tail-recursion-sum.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/legato/support/generic-theories.pcert0 \
- workshops/2004/legato/support/generic-theory-tail-recursion-sum.lisp
-workshops/2004/legato/support/generic-theory-tail-recursion-sum.pcert1 : acl2x = 0
-workshops/2004/legato/support/generic-theory-tail-recursion-sum.pcert1 : no_pcert = 0
-workshops/2004/legato/support/generic-theory-tail-recursion-sum.pcert1 : workshops/2004/legato/support/generic-theory-tail-recursion-sum.pcert0
-workshops/2004/legato/support/generic-theory-tail-recursion-sum.cert : | workshops/2004/legato/support/generic-theory-tail-recursion-sum.pcert1
-
-workshops/2004/legato/support/proof-by-generalization-mult.pcert0 : no_pcert = 0
-workshops/2004/legato/support/proof-by-generalization-mult.pcert0 : acl2x = 0
-workshops/2004/legato/support/proof-by-generalization-mult.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/legato/support/proof-by-generalization-mult.lisp
-workshops/2004/legato/support/proof-by-generalization-mult.pcert1 : acl2x = 0
-workshops/2004/legato/support/proof-by-generalization-mult.pcert1 : no_pcert = 0
-workshops/2004/legato/support/proof-by-generalization-mult.pcert1 : workshops/2004/legato/support/proof-by-generalization-mult.pcert0
-workshops/2004/legato/support/proof-by-generalization-mult.cert : | workshops/2004/legato/support/proof-by-generalization-mult.pcert1
-
-workshops/2004/legato/support/proof-by-generalization-sum.pcert0 : no_pcert = 0
-workshops/2004/legato/support/proof-by-generalization-sum.pcert0 : acl2x = 0
-workshops/2004/legato/support/proof-by-generalization-sum.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/legato/support/proof-by-generalization-sum.lisp
-workshops/2004/legato/support/proof-by-generalization-sum.pcert1 : acl2x = 0
-workshops/2004/legato/support/proof-by-generalization-sum.pcert1 : no_pcert = 0
-workshops/2004/legato/support/proof-by-generalization-sum.pcert1 : workshops/2004/legato/support/proof-by-generalization-sum.pcert0
-workshops/2004/legato/support/proof-by-generalization-sum.cert : | workshops/2004/legato/support/proof-by-generalization-sum.pcert1
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.pcert0 : no_pcert = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.pcert0 : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.pcert0 : \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.lisp
-workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.pcert1 : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.pcert1 : no_pcert = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.pcert1 : workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.pcert0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.cert : | workshops/2004/manolios-srinivasan/support/Supporting-Books/det-macros.pcert1
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.pcert0 : no_pcert = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.pcert0 : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.lisp
-workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.pcert1 : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.pcert1 : no_pcert = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.pcert1 : workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.pcert0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.cert : | workshops/2004/manolios-srinivasan/support/Supporting-Books/meta.pcert1
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/records.pcert0 : no_pcert = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/records.pcert0 : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/records.pcert0 : \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.pcert0 \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/records.lisp
-workshops/2004/manolios-srinivasan/support/Supporting-Books/records.pcert1 : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/records.pcert1 : no_pcert = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/records.pcert1 : workshops/2004/manolios-srinivasan/support/Supporting-Books/records.pcert0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/records.cert : | workshops/2004/manolios-srinivasan/support/Supporting-Books/records.pcert1
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.pcert0 : no_pcert = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.pcert0 : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.pcert0 : \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.lisp
-workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.pcert1 : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.pcert1 : no_pcert = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.pcert1 : workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.pcert0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.cert : | workshops/2004/manolios-srinivasan/support/Supporting-Books/seq.pcert1
-
-workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.pcert0 : no_pcert = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.pcert0 : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.pcert0 : \
- workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.lisp
-workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.pcert1 : acl2x = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.pcert1 : no_pcert = 0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.pcert1 : workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.pcert0
-workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.cert : | workshops/2004/manolios-srinivasan/support/Supporting-Books/total-order.pcert1
-
-workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.pcert0 : no_pcert = 0
-workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.pcert0 : acl2x = 0
-workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.pcert0 : \
- workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.pcert0 \
- workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.lisp
-workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.pcert1 : acl2x = 0
-workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.pcert1 : no_pcert = 0
-workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.pcert1 : workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.pcert0
-workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.cert : | workshops/2004/matthews-vroon/support/partial-clock-functions/efficient-simulator.pcert1
-
-workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.pcert0 : no_pcert = 0
-workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.pcert0 : acl2x = 0
-workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.pcert0 : \
- workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.pcert0 \
- rtl/rel4/arithmetic/top.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- misc/defpun.pcert0 \
- ordinals/ordinals.pcert0 \
- workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.lisp
-workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.pcert1 : acl2x = 0
-workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.pcert1 : no_pcert = 0
-workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.pcert1 : workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.pcert0
-workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.cert : | workshops/2004/matthews-vroon/support/partial-clock-functions/partial-clock-functions.pcert1
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.pcert0 : no_pcert = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.pcert0 : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.pcert0 : \
- arithmetic-2/meta/top.pcert0 \
- workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.lisp
-workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.pcert1 : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.pcert1 : no_pcert = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.pcert1 : workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.pcert0
-workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.cert : | workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.pcert1
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.pcert0 : no_pcert = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.pcert0 : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.pcert0 : \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.pcert0 \
- workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.lisp
-workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.pcert1 : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.pcert1 : no_pcert = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.pcert1 : workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.pcert0
-workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.cert : | workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.pcert1
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.pcert0 : no_pcert = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.pcert0 : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.pcert0 : \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.pcert0 \
- workshops/2004/matthews-vroon/support/tiny-fib-example/fib-def.pcert0 \
- misc/defpun.pcert0 \
- ordinals/ordinals.pcert0 \
- workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.lisp
-workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.pcert1 : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.pcert1 : no_pcert = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.pcert1 : workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.pcert0
-workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.cert : | workshops/2004/matthews-vroon/support/tiny-fib-example/partial-clock-functions.pcert1
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.pcert0 : no_pcert = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.pcert0 : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.pcert0 : \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.lisp
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.pcert1 : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.pcert1 : no_pcert = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.pcert1 : workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.pcert0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.cert : | workshops/2004/matthews-vroon/support/tiny-fib-example/tiny-rewrites.pcert1
-
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.pcert0 : no_pcert = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.pcert0 : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.pcert0 : \
- workshops/2004/matthews-vroon/support/tiny-fib-example/defstobj+.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- data-structures/list-defthms.pcert0 \
- ihs/logops-lemmas.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.lisp
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.pcert1 : acl2x = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.pcert1 : no_pcert = 0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.pcert1 : workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.pcert0
-workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.cert : | workshops/2004/matthews-vroon/support/tiny-fib-example/tiny.pcert1
-
-workshops/2004/ray/support/defcoerce.pcert0 : no_pcert = 0
-workshops/2004/ray/support/defcoerce.pcert0 : acl2x = 0
-workshops/2004/ray/support/defcoerce.pcert0 : \
- arithmetic-2/meta/top.pcert0 \
- workshops/2004/ray/support/generic.pcert0 \
- workshops/2004/ray/support/defcoerce.lisp
-workshops/2004/ray/support/defcoerce.pcert1 : acl2x = 0
-workshops/2004/ray/support/defcoerce.pcert1 : no_pcert = 0
-workshops/2004/ray/support/defcoerce.pcert1 : workshops/2004/ray/support/defcoerce.pcert0
-workshops/2004/ray/support/defcoerce.cert : | workshops/2004/ray/support/defcoerce.pcert1
-
-workshops/2004/ray/support/defpun-exec.pcert0 : no_pcert = 0
-workshops/2004/ray/support/defpun-exec.pcert0 : acl2x = 0
-workshops/2004/ray/support/defpun-exec.pcert0 : \
- misc/defpun.pcert0 \
- workshops/2004/ray/support/defpun-exec.lisp
-workshops/2004/ray/support/defpun-exec.pcert1 : acl2x = 0
-workshops/2004/ray/support/defpun-exec.pcert1 : no_pcert = 0
-workshops/2004/ray/support/defpun-exec.pcert1 : workshops/2004/ray/support/defpun-exec.pcert0
-workshops/2004/ray/support/defpun-exec.cert : | workshops/2004/ray/support/defpun-exec.pcert1
-
-workshops/2004/ray/support/generic.pcert0 : no_pcert = 0
-workshops/2004/ray/support/generic.pcert0 : acl2x = 0
-workshops/2004/ray/support/generic.pcert0 : \
- arithmetic-2/meta/top.pcert0 \
- workshops/2004/ray/support/generic.lisp
-workshops/2004/ray/support/generic.pcert1 : acl2x = 0
-workshops/2004/ray/support/generic.pcert1 : no_pcert = 0
-workshops/2004/ray/support/generic.pcert1 : workshops/2004/ray/support/generic.pcert0
-workshops/2004/ray/support/generic.cert : | workshops/2004/ray/support/generic.pcert1
-
-workshops/2004/roach-fraij/support/roach-fraij-script.pcert0 : no_pcert = 0
-workshops/2004/roach-fraij/support/roach-fraij-script.pcert0 : acl2x = 0
-workshops/2004/roach-fraij/support/roach-fraij-script.pcert0 : \
- workshops/2004/roach-fraij/support/roach-fraij-script.lisp
-workshops/2004/roach-fraij/support/roach-fraij-script.pcert1 : acl2x = 0
-workshops/2004/roach-fraij/support/roach-fraij-script.pcert1 : no_pcert = 0
-workshops/2004/roach-fraij/support/roach-fraij-script.pcert1 : workshops/2004/roach-fraij/support/roach-fraij-script.pcert0
-workshops/2004/roach-fraij/support/roach-fraij-script.cert : | workshops/2004/roach-fraij/support/roach-fraij-script.pcert1
-
-workshops/2004/ruiz-et-al/support/basic.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/basic.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/basic.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- workshops/2004/ruiz-et-al/support/basic.lisp
-workshops/2004/ruiz-et-al/support/basic.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/basic.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/basic.pcert1 : workshops/2004/ruiz-et-al/support/basic.pcert0
-workshops/2004/ruiz-et-al/support/basic.cert : | workshops/2004/ruiz-et-al/support/basic.pcert1
-
-workshops/2004/ruiz-et-al/support/dag-unification-rules.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/dag-unification-rules.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/dag-unification-rules.pcert0 : \
- workshops/2004/ruiz-et-al/support/dags.pcert0 \
- workshops/2004/ruiz-et-al/support/prefix-unification-rules.pcert0 \
- workshops/2004/ruiz-et-al/support/dag-unification-rules.lisp
-workshops/2004/ruiz-et-al/support/dag-unification-rules.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/dag-unification-rules.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/dag-unification-rules.pcert1 : workshops/2004/ruiz-et-al/support/dag-unification-rules.pcert0
-workshops/2004/ruiz-et-al/support/dag-unification-rules.cert : | workshops/2004/ruiz-et-al/support/dag-unification-rules.pcert1
-
-workshops/2004/ruiz-et-al/support/dags.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/dags.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/dags.pcert0 : \
- workshops/2004/ruiz-et-al/support/basic.pcert0 \
- workshops/2004/ruiz-et-al/support/lists.pcert0 \
- workshops/2004/ruiz-et-al/support/dags.lisp
-workshops/2004/ruiz-et-al/support/dags.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/dags.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/dags.pcert1 : workshops/2004/ruiz-et-al/support/dags.pcert0
-workshops/2004/ruiz-et-al/support/dags.cert : | workshops/2004/ruiz-et-al/support/dags.pcert1
-
-workshops/2004/ruiz-et-al/support/lists.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/lists.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/lists.pcert0 : \
- workshops/2004/ruiz-et-al/support/lists.lisp
-workshops/2004/ruiz-et-al/support/lists.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/lists.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/lists.pcert1 : workshops/2004/ruiz-et-al/support/lists.pcert0
-workshops/2004/ruiz-et-al/support/lists.cert : | workshops/2004/ruiz-et-al/support/lists.pcert1
-
-workshops/2004/ruiz-et-al/support/matching.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/matching.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/matching.pcert0 : \
- workshops/2004/ruiz-et-al/support/terms.pcert0 \
- workshops/2004/ruiz-et-al/support/matching.lisp
-workshops/2004/ruiz-et-al/support/matching.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/matching.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/matching.pcert1 : workshops/2004/ruiz-et-al/support/matching.pcert0
-workshops/2004/ruiz-et-al/support/matching.cert : | workshops/2004/ruiz-et-al/support/matching.pcert1
-
-workshops/2004/ruiz-et-al/support/prefix-unification-rules.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/prefix-unification-rules.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/prefix-unification-rules.pcert0 : \
- workshops/2004/ruiz-et-al/support/subsumption-subst.pcert0 \
- workshops/2004/ruiz-et-al/support/prefix-unification-rules.lisp
-workshops/2004/ruiz-et-al/support/prefix-unification-rules.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/prefix-unification-rules.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/prefix-unification-rules.pcert1 : workshops/2004/ruiz-et-al/support/prefix-unification-rules.pcert0
-workshops/2004/ruiz-et-al/support/prefix-unification-rules.cert : | workshops/2004/ruiz-et-al/support/prefix-unification-rules.pcert1
-
-workshops/2004/ruiz-et-al/support/q-dag-unification-rules.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification-rules.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification-rules.pcert0 : \
- workshops/2004/ruiz-et-al/support/dag-unification-rules.pcert0 \
- workshops/2004/ruiz-et-al/support/q-dag-unification-rules.lisp
-workshops/2004/ruiz-et-al/support/q-dag-unification-rules.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification-rules.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification-rules.pcert1 : workshops/2004/ruiz-et-al/support/q-dag-unification-rules.pcert0
-workshops/2004/ruiz-et-al/support/q-dag-unification-rules.cert : | workshops/2004/ruiz-et-al/support/q-dag-unification-rules.pcert1
-
-workshops/2004/ruiz-et-al/support/q-dag-unification-st.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification-st.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification-st.pcert0 : \
- workshops/2004/ruiz-et-al/support/q-dag-unification.pcert0 \
- workshops/2004/ruiz-et-al/support/q-dag-unification-st.lisp
-workshops/2004/ruiz-et-al/support/q-dag-unification-st.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification-st.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification-st.pcert1 : workshops/2004/ruiz-et-al/support/q-dag-unification-st.pcert0
-workshops/2004/ruiz-et-al/support/q-dag-unification-st.cert : | workshops/2004/ruiz-et-al/support/q-dag-unification-st.pcert1
-
-workshops/2004/ruiz-et-al/support/q-dag-unification.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification.pcert0 : \
- workshops/2004/ruiz-et-al/support/q-dag-unification-rules.pcert0 \
- workshops/2004/ruiz-et-al/support/terms-as-dag.pcert0 \
- workshops/2004/ruiz-et-al/support/q-dag-unification.lisp
-workshops/2004/ruiz-et-al/support/q-dag-unification.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/q-dag-unification.pcert1 : workshops/2004/ruiz-et-al/support/q-dag-unification.pcert0
-workshops/2004/ruiz-et-al/support/q-dag-unification.cert : | workshops/2004/ruiz-et-al/support/q-dag-unification.pcert1
-
-workshops/2004/ruiz-et-al/support/subsumption-subst.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/subsumption-subst.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/subsumption-subst.pcert0 : \
- workshops/2004/ruiz-et-al/support/subsumption.pcert0 \
- workshops/2004/ruiz-et-al/support/subsumption-subst.lisp
-workshops/2004/ruiz-et-al/support/subsumption-subst.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/subsumption-subst.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/subsumption-subst.pcert1 : workshops/2004/ruiz-et-al/support/subsumption-subst.pcert0
-workshops/2004/ruiz-et-al/support/subsumption-subst.cert : | workshops/2004/ruiz-et-al/support/subsumption-subst.pcert1
-
-workshops/2004/ruiz-et-al/support/subsumption.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/subsumption.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/subsumption.pcert0 : \
- workshops/2004/ruiz-et-al/support/matching.pcert0 \
- workshops/2004/ruiz-et-al/support/terms.pcert0 \
- workshops/2004/ruiz-et-al/support/subsumption.lisp
-workshops/2004/ruiz-et-al/support/subsumption.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/subsumption.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/subsumption.pcert1 : workshops/2004/ruiz-et-al/support/subsumption.pcert0
-workshops/2004/ruiz-et-al/support/subsumption.cert : | workshops/2004/ruiz-et-al/support/subsumption.pcert1
-
-workshops/2004/ruiz-et-al/support/terms-as-dag.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/terms-as-dag.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/terms-as-dag.pcert0 : \
- workshops/2004/ruiz-et-al/support/dag-unification-rules.pcert0 \
- workshops/2004/ruiz-et-al/support/terms-as-dag.lisp
-workshops/2004/ruiz-et-al/support/terms-as-dag.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/terms-as-dag.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/terms-as-dag.pcert1 : workshops/2004/ruiz-et-al/support/terms-as-dag.pcert0
-workshops/2004/ruiz-et-al/support/terms-as-dag.cert : | workshops/2004/ruiz-et-al/support/terms-as-dag.pcert1
-
-workshops/2004/ruiz-et-al/support/terms.pcert0 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/terms.pcert0 : acl2x = 0
-workshops/2004/ruiz-et-al/support/terms.pcert0 : \
- workshops/2004/ruiz-et-al/support/basic.pcert0 \
- workshops/2004/ruiz-et-al/support/terms.lisp
-workshops/2004/ruiz-et-al/support/terms.pcert1 : acl2x = 0
-workshops/2004/ruiz-et-al/support/terms.pcert1 : no_pcert = 0
-workshops/2004/ruiz-et-al/support/terms.pcert1 : workshops/2004/ruiz-et-al/support/terms.pcert0
-workshops/2004/ruiz-et-al/support/terms.cert : | workshops/2004/ruiz-et-al/support/terms.pcert1
-
-workshops/2004/sawada/support/bv.pcert0 : no_pcert = 0
-workshops/2004/sawada/support/bv.pcert0 : acl2x = 0
-workshops/2004/sawada/support/bv.pcert0 : \
- workshops/2004/sawada/support/ihs.pcert0 \
- arithmetic-2/pass1/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2004/sawada/support/bv.lisp \
- workshops/2004/sawada/support/bv.acl2 \
- workshops/2004/sawada/support/defpkg.lsp
-workshops/2004/sawada/support/bv.pcert1 : acl2x = 0
-workshops/2004/sawada/support/bv.pcert1 : no_pcert = 0
-workshops/2004/sawada/support/bv.pcert1 : workshops/2004/sawada/support/bv.pcert0
-workshops/2004/sawada/support/bv.cert : | workshops/2004/sawada/support/bv.pcert1
-
-workshops/2004/sawada/support/ihs.pcert0 : no_pcert = 0
-workshops/2004/sawada/support/ihs.pcert0 : acl2x = 0
-workshops/2004/sawada/support/ihs.pcert0 : \
- ihs/ihs-definitions.pcert0 \
- ihs/logops-lemmas.pcert0 \
- workshops/2004/sawada/support/ihs.lisp
-workshops/2004/sawada/support/ihs.pcert1 : acl2x = 0
-workshops/2004/sawada/support/ihs.pcert1 : no_pcert = 0
-workshops/2004/sawada/support/ihs.pcert1 : workshops/2004/sawada/support/ihs.pcert0
-workshops/2004/sawada/support/ihs.cert : | workshops/2004/sawada/support/ihs.pcert1
-
-workshops/2004/schmaltz-borrione/support/collect_msg_book.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/collect_msg_book.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/collect_msg_book.pcert0 : \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert0 \
- workshops/2004/schmaltz-borrione/support/node.pcert0 \
- workshops/2004/schmaltz-borrione/support/collect_msg_book.lisp
-workshops/2004/schmaltz-borrione/support/collect_msg_book.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/collect_msg_book.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/collect_msg_book.pcert1 : workshops/2004/schmaltz-borrione/support/collect_msg_book.pcert0
-workshops/2004/schmaltz-borrione/support/collect_msg_book.cert : | workshops/2004/schmaltz-borrione/support/collect_msg_book.pcert1
-
-workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.pcert0 : \
- workshops/2004/schmaltz-borrione/support/routing_defuns.pcert0 \
- workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.lisp
-workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.pcert1 : workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.pcert0
-workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.cert : | workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.pcert1
-
-workshops/2004/schmaltz-borrione/support/intersect.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/intersect.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/intersect.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert0 \
- workshops/2004/schmaltz-borrione/support/intersect.lisp
-workshops/2004/schmaltz-borrione/support/intersect.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/intersect.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/intersect.pcert1 : workshops/2004/schmaltz-borrione/support/intersect.pcert0
-workshops/2004/schmaltz-borrione/support/intersect.cert : | workshops/2004/schmaltz-borrione/support/intersect.pcert1
-
-workshops/2004/schmaltz-borrione/support/local_trip_book.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/local_trip_book.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/local_trip_book.pcert0 : \
- workshops/2004/schmaltz-borrione/support/trip_book.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/schmaltz-borrione/support/local_trip_book.lisp
-workshops/2004/schmaltz-borrione/support/local_trip_book.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/local_trip_book.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/local_trip_book.pcert1 : workshops/2004/schmaltz-borrione/support/local_trip_book.pcert0
-workshops/2004/schmaltz-borrione/support/local_trip_book.cert : | workshops/2004/schmaltz-borrione/support/local_trip_book.pcert1
-
-workshops/2004/schmaltz-borrione/support/make_travel_list_book.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/make_travel_list_book.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/make_travel_list_book.pcert0 : \
- workshops/2004/schmaltz-borrione/support/routing_main.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/schmaltz-borrione/support/make_travel_list_book.lisp
-workshops/2004/schmaltz-borrione/support/make_travel_list_book.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/make_travel_list_book.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/make_travel_list_book.pcert1 : workshops/2004/schmaltz-borrione/support/make_travel_list_book.pcert0
-workshops/2004/schmaltz-borrione/support/make_travel_list_book.cert : | workshops/2004/schmaltz-borrione/support/make_travel_list_book.pcert1
-
-workshops/2004/schmaltz-borrione/support/mod_lemmas.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/mod_lemmas.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/mod_lemmas.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/schmaltz-borrione/support/mod_lemmas.lisp
-workshops/2004/schmaltz-borrione/support/mod_lemmas.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/mod_lemmas.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/mod_lemmas.pcert1 : workshops/2004/schmaltz-borrione/support/mod_lemmas.pcert0
-workshops/2004/schmaltz-borrione/support/mod_lemmas.cert : | workshops/2004/schmaltz-borrione/support/mod_lemmas.pcert1
-
-workshops/2004/schmaltz-borrione/support/node.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/node.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/node.pcert0 : \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert0 \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2004/schmaltz-borrione/support/node.lisp
-workshops/2004/schmaltz-borrione/support/node.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/node.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/node.pcert1 : workshops/2004/schmaltz-borrione/support/node.pcert0
-workshops/2004/schmaltz-borrione/support/node.cert : | workshops/2004/schmaltz-borrione/support/node.pcert1
-
-workshops/2004/schmaltz-borrione/support/octagon_book.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/octagon_book.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/octagon_book.pcert0 : \
- workshops/2004/schmaltz-borrione/support/collect_msg_book.pcert0 \
- workshops/2004/schmaltz-borrione/support/make_travel_list_book.pcert0 \
- workshops/2004/schmaltz-borrione/support/scheduler_book.pcert0 \
- workshops/2004/schmaltz-borrione/support/trip_thms.pcert0 \
- workshops/2004/schmaltz-borrione/support/octagon_book.lisp
-workshops/2004/schmaltz-borrione/support/octagon_book.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/octagon_book.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/octagon_book.pcert1 : workshops/2004/schmaltz-borrione/support/octagon_book.pcert0
-workshops/2004/schmaltz-borrione/support/octagon_book.cert : | workshops/2004/schmaltz-borrione/support/octagon_book.pcert1
-
-workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert0 : \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.lisp
-workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert1 : workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert0
-workshops/2004/schmaltz-borrione/support/predicatesNCie.cert : | workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert1
-
-workshops/2004/schmaltz-borrione/support/routing_defuns.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/routing_defuns.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/routing_defuns.pcert0 : \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert0 \
- workshops/2004/schmaltz-borrione/support/mod_lemmas.pcert0 \
- workshops/2004/schmaltz-borrione/support/routing_defuns.lisp
-workshops/2004/schmaltz-borrione/support/routing_defuns.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/routing_defuns.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/routing_defuns.pcert1 : workshops/2004/schmaltz-borrione/support/routing_defuns.pcert0
-workshops/2004/schmaltz-borrione/support/routing_defuns.cert : | workshops/2004/schmaltz-borrione/support/routing_defuns.pcert1
-
-workshops/2004/schmaltz-borrione/support/routing_local_lemmas.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/routing_local_lemmas.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/routing_local_lemmas.pcert0 : \
- workshops/2004/schmaltz-borrione/support/getting_rid_of_mod.pcert0 \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- workshops/2004/schmaltz-borrione/support/routing_local_lemmas.lisp
-workshops/2004/schmaltz-borrione/support/routing_local_lemmas.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/routing_local_lemmas.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/routing_local_lemmas.pcert1 : workshops/2004/schmaltz-borrione/support/routing_local_lemmas.pcert0
-workshops/2004/schmaltz-borrione/support/routing_local_lemmas.cert : | workshops/2004/schmaltz-borrione/support/routing_local_lemmas.pcert1
-
-workshops/2004/schmaltz-borrione/support/routing_main.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/routing_main.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/routing_main.pcert0 : \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert0 \
- workshops/2004/schmaltz-borrione/support/routing_local_lemmas.pcert0 \
- workshops/2004/schmaltz-borrione/support/routing_main.lisp
-workshops/2004/schmaltz-borrione/support/routing_main.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/routing_main.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/routing_main.pcert1 : workshops/2004/schmaltz-borrione/support/routing_main.pcert0
-workshops/2004/schmaltz-borrione/support/routing_main.cert : | workshops/2004/schmaltz-borrione/support/routing_main.pcert1
-
-workshops/2004/schmaltz-borrione/support/scheduler_book.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/scheduler_book.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/scheduler_book.pcert0 : \
- workshops/2004/schmaltz-borrione/support/intersect.pcert0 \
- workshops/2004/schmaltz-borrione/support/scheduler_book.lisp
-workshops/2004/schmaltz-borrione/support/scheduler_book.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/scheduler_book.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/scheduler_book.pcert1 : workshops/2004/schmaltz-borrione/support/scheduler_book.pcert0
-workshops/2004/schmaltz-borrione/support/scheduler_book.cert : | workshops/2004/schmaltz-borrione/support/scheduler_book.pcert1
-
-workshops/2004/schmaltz-borrione/support/switch.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/switch.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/switch.pcert0 : \
- workshops/2004/schmaltz-borrione/support/switch.lisp
-workshops/2004/schmaltz-borrione/support/switch.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/switch.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/switch.pcert1 : workshops/2004/schmaltz-borrione/support/switch.pcert0
-workshops/2004/schmaltz-borrione/support/switch.cert : | workshops/2004/schmaltz-borrione/support/switch.pcert1
-
-workshops/2004/schmaltz-borrione/support/trip_book.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/trip_book.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/trip_book.pcert0 : \
- workshops/2004/schmaltz-borrione/support/switch.pcert0 \
- workshops/2004/schmaltz-borrione/support/predicatesNCie.pcert0 \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- workshops/2004/schmaltz-borrione/support/trip_book.lisp
-workshops/2004/schmaltz-borrione/support/trip_book.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/trip_book.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/trip_book.pcert1 : workshops/2004/schmaltz-borrione/support/trip_book.pcert0
-workshops/2004/schmaltz-borrione/support/trip_book.cert : | workshops/2004/schmaltz-borrione/support/trip_book.pcert1
-
-workshops/2004/schmaltz-borrione/support/trip_thms.pcert0 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/trip_thms.pcert0 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/trip_thms.pcert0 : \
- workshops/2004/schmaltz-borrione/support/local_trip_book.pcert0 \
- workshops/2004/schmaltz-borrione/support/trip_thms.lisp
-workshops/2004/schmaltz-borrione/support/trip_thms.pcert1 : acl2x = 0
-workshops/2004/schmaltz-borrione/support/trip_thms.pcert1 : no_pcert = 0
-workshops/2004/schmaltz-borrione/support/trip_thms.pcert1 : workshops/2004/schmaltz-borrione/support/trip_thms.pcert0
-workshops/2004/schmaltz-borrione/support/trip_thms.cert : | workshops/2004/schmaltz-borrione/support/trip_thms.pcert1
-
-workshops/2004/smith-et-al/support/bags/bag-exports.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/bag-exports.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/bag-exports.pcert0 : \
- workshops/2004/smith-et-al/support/bags/bag-pkg.pcert0 \
- workshops/2004/smith-et-al/support/bags/bag-exports.lisp \
- workshops/2004/smith-et-al/support/bags/bag-exports.acl2
-workshops/2004/smith-et-al/support/bags/bag-exports.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/bag-exports.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/bag-exports.pcert1 : workshops/2004/smith-et-al/support/bags/bag-exports.pcert0
-workshops/2004/smith-et-al/support/bags/bag-exports.cert : | workshops/2004/smith-et-al/support/bags/bag-exports.pcert1
-
-workshops/2004/smith-et-al/support/bags/bag-pkg.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/bag-pkg.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/bag-pkg.pcert0 : \
- workshops/2004/smith-et-al/support/lists/list-exports.pcert0 \
- workshops/2004/smith-et-al/support/syntax/syn-pkg.pcert0 \
- workshops/2004/smith-et-al/support/bags/bag-pkg.lisp \
- workshops/2004/smith-et-al/support/bags/bag-pkg.acl2
-workshops/2004/smith-et-al/support/bags/bag-pkg.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/bag-pkg.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/bag-pkg.pcert1 : workshops/2004/smith-et-al/support/bags/bag-pkg.pcert0
-workshops/2004/smith-et-al/support/bags/bag-pkg.cert : | workshops/2004/smith-et-al/support/bags/bag-pkg.pcert1
-
-workshops/2004/smith-et-al/support/bags/basic.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/basic.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/basic.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- workshops/2004/smith-et-al/support/lists/lists.pcert0 \
- workshops/2004/smith-et-al/support/bags/bag-exports.pcert0 \
- workshops/2004/smith-et-al/support/bags/basic.lisp \
- workshops/2004/smith-et-al/support/bags/basic.acl2
-workshops/2004/smith-et-al/support/bags/basic.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/basic.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/basic.pcert1 : workshops/2004/smith-et-al/support/bags/basic.pcert0
-workshops/2004/smith-et-al/support/bags/basic.cert : | workshops/2004/smith-et-al/support/bags/basic.pcert1
-
-workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert0 : \
- workshops/2004/smith-et-al/support/bags/meta.pcert0 \
- workshops/2004/smith-et-al/support/bags/bag-exports.pcert0 \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.lisp \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.acl2
-workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert1 : workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert0
-workshops/2004/smith-et-al/support/bags/bind-free-rules.cert : | workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert1
-
-workshops/2004/smith-et-al/support/bags/cons.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/cons.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/cons.pcert0 : \
- workshops/2004/smith-et-al/support/bags/cons.lisp
-workshops/2004/smith-et-al/support/bags/cons.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/cons.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/cons.pcert1 : workshops/2004/smith-et-al/support/bags/cons.pcert0
-workshops/2004/smith-et-al/support/bags/cons.cert : | workshops/2004/smith-et-al/support/bags/cons.pcert1
-
-workshops/2004/smith-et-al/support/bags/eric-meta.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/eric-meta.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/eric-meta.pcert0 : \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert0 \
- rtl/rel4/support/logand.pcert0 \
- workshops/2004/smith-et-al/support/bags/bag-exports.pcert0 \
- workshops/2004/smith-et-al/support/bags/eric-meta.lisp \
- workshops/2004/smith-et-al/support/bags/eric-meta.acl2
-workshops/2004/smith-et-al/support/bags/eric-meta.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/eric-meta.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/eric-meta.pcert1 : workshops/2004/smith-et-al/support/bags/eric-meta.pcert0
-workshops/2004/smith-et-al/support/bags/eric-meta.cert : | workshops/2004/smith-et-al/support/bags/eric-meta.pcert1
-
-workshops/2004/smith-et-al/support/bags/meta.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/meta.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/meta.pcert0 : \
- workshops/2004/smith-et-al/support/bags/basic.pcert0 \
- ordinals/e0-ordinal.pcert0 \
- workshops/2004/smith-et-al/support/bags/bag-exports.pcert0 \
- workshops/2004/smith-et-al/support/lists/mv-nth.pcert0 \
- workshops/2004/smith-et-al/support/syntax/syntax.pcert0 \
- workshops/2004/smith-et-al/support/bags/meta.lisp \
- workshops/2004/smith-et-al/support/bags/meta.acl2
-workshops/2004/smith-et-al/support/bags/meta.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/meta.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/meta.pcert1 : workshops/2004/smith-et-al/support/bags/meta.pcert0
-workshops/2004/smith-et-al/support/bags/meta.cert : | workshops/2004/smith-et-al/support/bags/meta.pcert1
-
-workshops/2004/smith-et-al/support/bags/neq.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/neq.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/neq.pcert0 : \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert0 \
- workshops/2004/smith-et-al/support/bags/bag-exports.pcert0 \
- workshops/2004/smith-et-al/support/bags/neq.lisp \
- workshops/2004/smith-et-al/support/bags/neq.acl2
-workshops/2004/smith-et-al/support/bags/neq.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/neq.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/neq.pcert1 : workshops/2004/smith-et-al/support/bags/neq.pcert0
-workshops/2004/smith-et-al/support/bags/neq.cert : | workshops/2004/smith-et-al/support/bags/neq.pcert1
-
-workshops/2004/smith-et-al/support/bags/top.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/top.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/top.pcert0 : \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert0 \
- workshops/2004/smith-et-al/support/bags/cons.pcert0 \
- workshops/2004/smith-et-al/support/bags/neq.pcert0 \
- workshops/2004/smith-et-al/support/bags/eric-meta.pcert0 \
- workshops/2004/smith-et-al/support/bags/bag-exports.pcert0 \
- workshops/2004/smith-et-al/support/bags/top.lisp \
- workshops/2004/smith-et-al/support/bags/top.acl2
-workshops/2004/smith-et-al/support/bags/top.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/top.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/top.pcert1 : workshops/2004/smith-et-al/support/bags/top.pcert0
-workshops/2004/smith-et-al/support/bags/top.cert : | workshops/2004/smith-et-al/support/bags/top.pcert1
-
-workshops/2004/smith-et-al/support/bags/two-level-meta.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/two-level-meta.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/two-level-meta.pcert0 : \
- workshops/2004/smith-et-al/support/bags/two-level.pcert0 \
- workshops/2004/smith-et-al/support/bags/bag-exports.pcert0 \
- workshops/2004/smith-et-al/support/bags/two-level-meta.lisp \
- workshops/2004/smith-et-al/support/bags/two-level-meta.acl2
-workshops/2004/smith-et-al/support/bags/two-level-meta.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/two-level-meta.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/two-level-meta.pcert1 : workshops/2004/smith-et-al/support/bags/two-level-meta.pcert0
-workshops/2004/smith-et-al/support/bags/two-level-meta.cert : | workshops/2004/smith-et-al/support/bags/two-level-meta.pcert1
-
-workshops/2004/smith-et-al/support/bags/two-level.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/two-level.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/two-level.pcert0 : \
- workshops/2004/smith-et-al/support/bags/bind-free-rules.pcert0 \
- workshops/2004/smith-et-al/support/bags/bag-exports.pcert0 \
- workshops/2004/smith-et-al/support/bags/two-level.lisp \
- workshops/2004/smith-et-al/support/bags/two-level.acl2
-workshops/2004/smith-et-al/support/bags/two-level.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/bags/two-level.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/bags/two-level.pcert1 : workshops/2004/smith-et-al/support/bags/two-level.pcert0
-workshops/2004/smith-et-al/support/bags/two-level.cert : | workshops/2004/smith-et-al/support/bags/two-level.pcert1
-
-workshops/2004/smith-et-al/support/lists/list-exports.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/lists/list-exports.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/lists/list-exports.pcert0 : \
- workshops/2004/smith-et-al/support/lists/list-exports.lisp \
- workshops/2004/smith-et-al/support/lists/cert.acl2
-workshops/2004/smith-et-al/support/lists/list-exports.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/lists/list-exports.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/lists/list-exports.pcert1 : workshops/2004/smith-et-al/support/lists/list-exports.pcert0
-workshops/2004/smith-et-al/support/lists/list-exports.cert : | workshops/2004/smith-et-al/support/lists/list-exports.pcert1
-
-workshops/2004/smith-et-al/support/lists/list-top.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/lists/list-top.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/lists/list-top.pcert0 : \
- workshops/2004/smith-et-al/support/lists/lists.pcert0 \
- workshops/2004/smith-et-al/support/lists/list-exports.pcert0 \
- workshops/2004/smith-et-al/support/lists/mv-nth.pcert0 \
- workshops/2004/smith-et-al/support/lists/list-top.lisp \
- workshops/2004/smith-et-al/support/lists/list-top.acl2
-workshops/2004/smith-et-al/support/lists/list-top.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/lists/list-top.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/lists/list-top.pcert1 : workshops/2004/smith-et-al/support/lists/list-top.pcert0
-workshops/2004/smith-et-al/support/lists/list-top.cert : | workshops/2004/smith-et-al/support/lists/list-top.pcert1
-
-workshops/2004/smith-et-al/support/lists/lists.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/lists/lists.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/lists/lists.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- workshops/2004/smith-et-al/support/lists/lists.lisp \
- workshops/2004/smith-et-al/support/lists/cert.acl2
-workshops/2004/smith-et-al/support/lists/lists.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/lists/lists.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/lists/lists.pcert1 : workshops/2004/smith-et-al/support/lists/lists.pcert0
-workshops/2004/smith-et-al/support/lists/lists.cert : | workshops/2004/smith-et-al/support/lists/lists.pcert1
-
-workshops/2004/smith-et-al/support/lists/mv-nth.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/lists/mv-nth.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/lists/mv-nth.pcert0 : \
- workshops/2004/smith-et-al/support/lists/mv-nth.lisp \
- workshops/2004/smith-et-al/support/lists/cert.acl2
-workshops/2004/smith-et-al/support/lists/mv-nth.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/lists/mv-nth.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/lists/mv-nth.pcert1 : workshops/2004/smith-et-al/support/lists/mv-nth.pcert0
-workshops/2004/smith-et-al/support/lists/mv-nth.cert : | workshops/2004/smith-et-al/support/lists/mv-nth.pcert1
-
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.pcert0 : \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.lisp \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.acl2
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.pcert1 : workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.pcert0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.cert : | workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.pcert1
-
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.pcert0 : \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns-exports.pcert0 \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.lisp \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.acl2
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.pcert1 : workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.pcert0
-workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.cert : | workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.pcert1
-
-workshops/2004/smith-et-al/support/syntax/auxilary.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/syntax/auxilary.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/auxilary.pcert0 : \
- workshops/2004/smith-et-al/support/symbol-fns/symbol-fns.pcert0 \
- workshops/2004/smith-et-al/support/syntax/auxilary.lisp \
- workshops/2004/smith-et-al/support/syntax/auxilary.acl2
-workshops/2004/smith-et-al/support/syntax/auxilary.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/auxilary.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/syntax/auxilary.pcert1 : workshops/2004/smith-et-al/support/syntax/auxilary.pcert0
-workshops/2004/smith-et-al/support/syntax/auxilary.cert : | workshops/2004/smith-et-al/support/syntax/auxilary.pcert1
-
-workshops/2004/smith-et-al/support/syntax/syn-pkg.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/syntax/syn-pkg.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/syn-pkg.pcert0 : \
- workshops/2004/smith-et-al/support/syntax/syn-pkg.lisp \
- workshops/2004/smith-et-al/support/syntax/syn-pkg.acl2
-workshops/2004/smith-et-al/support/syntax/syn-pkg.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/syn-pkg.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/syntax/syn-pkg.pcert1 : workshops/2004/smith-et-al/support/syntax/syn-pkg.pcert0
-workshops/2004/smith-et-al/support/syntax/syn-pkg.cert : | workshops/2004/smith-et-al/support/syntax/syn-pkg.pcert1
-
-workshops/2004/smith-et-al/support/syntax/syntax-extensions.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/syntax/syntax-extensions.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/syntax-extensions.pcert0 : \
- workshops/2004/smith-et-al/support/syntax/auxilary.pcert0 \
- workshops/2004/smith-et-al/support/syntax/syn-pkg.pcert0 \
- workshops/2004/smith-et-al/support/lists/list-top.pcert0 \
- workshops/2004/smith-et-al/support/syntax/syntax-extensions.lisp \
- workshops/2004/smith-et-al/support/syntax/syntax-extensions.acl2
-workshops/2004/smith-et-al/support/syntax/syntax-extensions.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/syntax-extensions.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/syntax/syntax-extensions.pcert1 : workshops/2004/smith-et-al/support/syntax/syntax-extensions.pcert0
-workshops/2004/smith-et-al/support/syntax/syntax-extensions.cert : | workshops/2004/smith-et-al/support/syntax/syntax-extensions.pcert1
-
-workshops/2004/smith-et-al/support/syntax/syntax.pcert0 : no_pcert = 0
-workshops/2004/smith-et-al/support/syntax/syntax.pcert0 : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/syntax.pcert0 : \
- workshops/2004/smith-et-al/support/syntax/syntax-extensions.pcert0 \
- workshops/2004/smith-et-al/support/syntax/syntax.lisp \
- workshops/2004/smith-et-al/support/syntax/syntax.acl2
-workshops/2004/smith-et-al/support/syntax/syntax.pcert1 : acl2x = 0
-workshops/2004/smith-et-al/support/syntax/syntax.pcert1 : no_pcert = 0
-workshops/2004/smith-et-al/support/syntax/syntax.pcert1 : workshops/2004/smith-et-al/support/syntax/syntax.pcert0
-workshops/2004/smith-et-al/support/syntax/syntax.cert : | workshops/2004/smith-et-al/support/syntax/syntax.pcert1
-
-workshops/2004/sumners-ray/support/basis.pcert0 : no_pcert = 0
-workshops/2004/sumners-ray/support/basis.pcert0 : acl2x = 0
-workshops/2004/sumners-ray/support/basis.pcert0 : \
- workshops/2004/sumners-ray/support/basis.lisp
-workshops/2004/sumners-ray/support/basis.pcert1 : acl2x = 0
-workshops/2004/sumners-ray/support/basis.pcert1 : no_pcert = 0
-workshops/2004/sumners-ray/support/basis.pcert1 : workshops/2004/sumners-ray/support/basis.pcert0
-workshops/2004/sumners-ray/support/basis.cert : | workshops/2004/sumners-ray/support/basis.pcert1
-
-workshops/2004/sumners-ray/support/crit.pcert0 : no_pcert = 0
-workshops/2004/sumners-ray/support/crit.pcert0 : acl2x = 0
-workshops/2004/sumners-ray/support/crit.pcert0 : \
- workshops/2004/sumners-ray/support/basis.pcert0 \
- workshops/2004/sumners-ray/support/crit.lisp
-workshops/2004/sumners-ray/support/crit.pcert1 : acl2x = 0
-workshops/2004/sumners-ray/support/crit.pcert1 : no_pcert = 0
-workshops/2004/sumners-ray/support/crit.pcert1 : workshops/2004/sumners-ray/support/crit.pcert0
-workshops/2004/sumners-ray/support/crit.cert : | workshops/2004/sumners-ray/support/crit.pcert1
-
-workshops/2004/sumners-ray/support/mesi.pcert0 : no_pcert = 0
-workshops/2004/sumners-ray/support/mesi.pcert0 : acl2x = 0
-workshops/2004/sumners-ray/support/mesi.pcert0 : \
- workshops/2004/sumners-ray/support/basis.pcert0 \
- workshops/2004/sumners-ray/support/records.pcert0 \
- workshops/2004/sumners-ray/support/mesi.lisp
-workshops/2004/sumners-ray/support/mesi.pcert1 : acl2x = 0
-workshops/2004/sumners-ray/support/mesi.pcert1 : no_pcert = 0
-workshops/2004/sumners-ray/support/mesi.pcert1 : workshops/2004/sumners-ray/support/mesi.pcert0
-workshops/2004/sumners-ray/support/mesi.cert : | workshops/2004/sumners-ray/support/mesi.pcert1
-
-workshops/2004/sumners-ray/support/records.pcert0 : no_pcert = 0
-workshops/2004/sumners-ray/support/records.pcert0 : acl2x = 0
-workshops/2004/sumners-ray/support/records.pcert0 : \
- workshops/2004/sumners-ray/support/sets.pcert0 \
- workshops/2004/sumners-ray/support/records.lisp
-workshops/2004/sumners-ray/support/records.pcert1 : acl2x = 0
-workshops/2004/sumners-ray/support/records.pcert1 : no_pcert = 0
-workshops/2004/sumners-ray/support/records.pcert1 : workshops/2004/sumners-ray/support/records.pcert0
-workshops/2004/sumners-ray/support/records.cert : | workshops/2004/sumners-ray/support/records.pcert1
-
-workshops/2004/sumners-ray/support/sets.pcert0 : no_pcert = 0
-workshops/2004/sumners-ray/support/sets.pcert0 : acl2x = 0
-workshops/2004/sumners-ray/support/sets.pcert0 : \
- workshops/2004/sumners-ray/support/total-order.pcert0 \
- workshops/2004/sumners-ray/support/sets.lisp
-workshops/2004/sumners-ray/support/sets.pcert1 : acl2x = 0
-workshops/2004/sumners-ray/support/sets.pcert1 : no_pcert = 0
-workshops/2004/sumners-ray/support/sets.pcert1 : workshops/2004/sumners-ray/support/sets.pcert0
-workshops/2004/sumners-ray/support/sets.cert : | workshops/2004/sumners-ray/support/sets.pcert1
-
-workshops/2004/sumners-ray/support/total-order.pcert0 : no_pcert = 0
-workshops/2004/sumners-ray/support/total-order.pcert0 : acl2x = 0
-workshops/2004/sumners-ray/support/total-order.pcert0 : \
- workshops/2004/sumners-ray/support/total-order.lisp
-workshops/2004/sumners-ray/support/total-order.pcert1 : acl2x = 0
-workshops/2004/sumners-ray/support/total-order.pcert1 : no_pcert = 0
-workshops/2004/sumners-ray/support/total-order.pcert1 : workshops/2004/sumners-ray/support/total-order.pcert0
-workshops/2004/sumners-ray/support/total-order.cert : | workshops/2004/sumners-ray/support/total-order.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed1.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed1.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed1.pcert0 : \
- arithmetic/top.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed1.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed1.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed1.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed1.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed1.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed1.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed1.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed1.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.pcert0 : \
- arithmetic/top.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.lisp
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed2a.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.lisp
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed2b.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 : \
- arithmetic/top.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed3.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed4aa.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed4ab.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed4ba.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed4bb.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed4ca.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed4cb.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed4da.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed4db.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.pcert0 : \
- arithmetic/top.pcert0 \
- ihs/quotient-remainder-lemmas.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed5aa.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed3.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/ed6a.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/coe-fld.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-suma.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fucongruencias-producto.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fumonomio.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuopuesto.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuproducto.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fupolinomio-normalizado.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuquot-rem.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fuforma-normal.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/fusuma.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.pcert0 : \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/fld-u-poly/futermino.pcert1
-
-workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.pcert0 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.pcert0 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- arithmetic/mod-gcd.pcert0 \
- workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.lisp \
- workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.acl2
-workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.pcert1 : acl2x = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.pcert1 : no_pcert = 0
-workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.pcert1 : workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.pcert0
-workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.cert : | workshops/2006/cowles-gamboa-euclid/Euclid/prime-fac.pcert1
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.pcert0 : no_pcert = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.pcert0 : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.pcert0 : \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.pcert0 \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.lisp
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.pcert1 : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.pcert1 : no_pcert = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.pcert1 : workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.pcert0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.cert : | workshops/2006/gordon-hunt-kaufmann-reynolds/support/basic.pcert1
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.pcert0 : no_pcert = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.pcert0 : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.pcert0 : \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.lisp
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.pcert1 : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.pcert1 : no_pcert = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.pcert1 : workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.pcert0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.cert : | workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.pcert1
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.pcert0 : no_pcert = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.pcert0 : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.pcert0 : \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.pcert0 \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.lisp
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.pcert1 : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.pcert1 : no_pcert = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.pcert1 : workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.pcert0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.cert : | workshops/2006/gordon-hunt-kaufmann-reynolds/support/guarded.pcert1
-
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.pcert0 : no_pcert = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.pcert0 : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.pcert0 : \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/data.pcert0 \
- workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.lisp
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.pcert1 : acl2x = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.pcert1 : no_pcert = 0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.pcert1 : workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.pcert0
-workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.cert : | workshops/2006/gordon-hunt-kaufmann-reynolds/support/stobjs.pcert1
-
-workshops/2006/greve/nary/example.pcert0 : no_pcert = 0
-workshops/2006/greve/nary/example.pcert0 : acl2x = 0
-workshops/2006/greve/nary/example.pcert0 : \
- workshops/2006/greve/nary/nary.pcert0 \
- ihs/ihs-definitions.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- workshops/2006/greve/nary/nth-rules.pcert0 \
- workshops/2006/greve/nary/example.lisp
-workshops/2006/greve/nary/example.pcert1 : acl2x = 0
-workshops/2006/greve/nary/example.pcert1 : no_pcert = 0
-workshops/2006/greve/nary/example.pcert1 : workshops/2006/greve/nary/example.pcert0
-workshops/2006/greve/nary/example.cert : | workshops/2006/greve/nary/example.pcert1
-
-workshops/2006/greve/nary/nary.pcert0 : no_pcert = 0
-workshops/2006/greve/nary/nary.pcert0 : acl2x = 0
-workshops/2006/greve/nary/nary.pcert0 : \
- workshops/2006/greve/nary/nary.lisp
-workshops/2006/greve/nary/nary.pcert1 : acl2x = 0
-workshops/2006/greve/nary/nary.pcert1 : no_pcert = 0
-workshops/2006/greve/nary/nary.pcert1 : workshops/2006/greve/nary/nary.pcert0
-workshops/2006/greve/nary/nary.cert : | workshops/2006/greve/nary/nary.pcert1
-
-workshops/2006/greve/nary/nth-rules.pcert0 : no_pcert = 0
-workshops/2006/greve/nary/nth-rules.pcert0 : acl2x = 0
-workshops/2006/greve/nary/nth-rules.pcert0 : \
- workshops/2006/greve/nary/nth-rules.lisp
-workshops/2006/greve/nary/nth-rules.pcert1 : acl2x = 0
-workshops/2006/greve/nary/nth-rules.pcert1 : no_pcert = 0
-workshops/2006/greve/nary/nth-rules.pcert1 : workshops/2006/greve/nary/nth-rules.pcert0
-workshops/2006/greve/nary/nth-rules.cert : | workshops/2006/greve/nary/nth-rules.pcert1
-
-workshops/2006/hunt-reeber/support/acl2.pcert0 : no_pcert = 0
-workshops/2006/hunt-reeber/support/acl2.pcert0 : acl2x = 0
-workshops/2006/hunt-reeber/support/acl2.pcert0 : \
- workshops/2006/hunt-reeber/support/acl2.lisp
-workshops/2006/hunt-reeber/support/acl2.pcert1 : acl2x = 0
-workshops/2006/hunt-reeber/support/acl2.pcert1 : no_pcert = 0
-workshops/2006/hunt-reeber/support/acl2.pcert1 : workshops/2006/hunt-reeber/support/acl2.pcert0
-workshops/2006/hunt-reeber/support/acl2.cert : | workshops/2006/hunt-reeber/support/acl2.pcert1
-
-workshops/2006/hunt-reeber/support/bdd.pcert0 : no_pcert = 0
-workshops/2006/hunt-reeber/support/bdd.pcert0 : acl2x = 0
-workshops/2006/hunt-reeber/support/bdd.pcert0 : \
- workshops/2006/hunt-reeber/support/bdd.lisp
-workshops/2006/hunt-reeber/support/bdd.pcert1 : acl2x = 0
-workshops/2006/hunt-reeber/support/bdd.pcert1 : no_pcert = 0
-workshops/2006/hunt-reeber/support/bdd.pcert1 : workshops/2006/hunt-reeber/support/bdd.pcert0
-workshops/2006/hunt-reeber/support/bdd.cert : | workshops/2006/hunt-reeber/support/bdd.pcert1
-
-workshops/2006/hunt-reeber/support/sat.pcert0 : no_pcert = 0
-workshops/2006/hunt-reeber/support/sat.pcert0 : acl2x = 0
-workshops/2006/hunt-reeber/support/sat.pcert0 : \
- workshops/2006/hunt-reeber/support/sat.lisp
-workshops/2006/hunt-reeber/support/sat.pcert1 : acl2x = 0
-workshops/2006/hunt-reeber/support/sat.pcert1 : no_pcert = 0
-workshops/2006/hunt-reeber/support/sat.pcert1 : workshops/2006/hunt-reeber/support/sat.pcert0
-workshops/2006/hunt-reeber/support/sat.cert : | workshops/2006/hunt-reeber/support/sat.pcert1
-
-workshops/2006/kaufmann-moore/support/austel.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/austel.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/austel.pcert0 : \
- workshops/2006/kaufmann-moore/support/austel.lisp
-workshops/2006/kaufmann-moore/support/austel.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/austel.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/austel.pcert1 : workshops/2006/kaufmann-moore/support/austel.pcert0
-workshops/2006/kaufmann-moore/support/austel.cert : | workshops/2006/kaufmann-moore/support/austel.pcert1
-
-workshops/2006/kaufmann-moore/support/greve1.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/greve1.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/greve1.pcert0 : \
- workshops/2006/kaufmann-moore/support/greve1.lisp
-workshops/2006/kaufmann-moore/support/greve1.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/greve1.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/greve1.pcert1 : workshops/2006/kaufmann-moore/support/greve1.pcert0
-workshops/2006/kaufmann-moore/support/greve1.cert : | workshops/2006/kaufmann-moore/support/greve1.pcert1
-
-workshops/2006/kaufmann-moore/support/greve2.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/greve2.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/greve2.pcert0 : \
- workshops/2006/kaufmann-moore/support/greve2.lisp
-workshops/2006/kaufmann-moore/support/greve2.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/greve2.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/greve2.pcert1 : workshops/2006/kaufmann-moore/support/greve2.pcert0
-workshops/2006/kaufmann-moore/support/greve2.cert : | workshops/2006/kaufmann-moore/support/greve2.pcert1
-
-workshops/2006/kaufmann-moore/support/greve3.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/greve3.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/greve3.pcert0 : \
- workshops/2006/kaufmann-moore/support/greve3.lisp
-workshops/2006/kaufmann-moore/support/greve3.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/greve3.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/greve3.pcert1 : workshops/2006/kaufmann-moore/support/greve3.pcert0
-workshops/2006/kaufmann-moore/support/greve3.cert : | workshops/2006/kaufmann-moore/support/greve3.pcert1
-
-workshops/2006/kaufmann-moore/support/mini-proveall-plus.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/mini-proveall-plus.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/mini-proveall-plus.pcert0 : \
- workshops/2006/kaufmann-moore/support/mini-proveall.pcert0 \
- workshops/2006/kaufmann-moore/support/mini-proveall-plus.lisp
-workshops/2006/kaufmann-moore/support/mini-proveall-plus.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/mini-proveall-plus.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/mini-proveall-plus.pcert1 : workshops/2006/kaufmann-moore/support/mini-proveall-plus.pcert0
-workshops/2006/kaufmann-moore/support/mini-proveall-plus.cert : | workshops/2006/kaufmann-moore/support/mini-proveall-plus.pcert1
-
-workshops/2006/kaufmann-moore/support/mini-proveall.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/mini-proveall.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/mini-proveall.pcert0 : \
- workshops/2006/kaufmann-moore/support/mini-proveall.lisp
-workshops/2006/kaufmann-moore/support/mini-proveall.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/mini-proveall.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/mini-proveall.pcert1 : workshops/2006/kaufmann-moore/support/mini-proveall.pcert0
-workshops/2006/kaufmann-moore/support/mini-proveall.cert : | workshops/2006/kaufmann-moore/support/mini-proveall.pcert1
-
-workshops/2006/kaufmann-moore/support/rhs1-iff.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/rhs1-iff.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/rhs1-iff.pcert0 : \
- workshops/2006/kaufmann-moore/support/rhs1-iff.lisp \
- workshops/2006/kaufmann-moore/support/rhs1-iff.acl2
-workshops/2006/kaufmann-moore/support/rhs1-iff.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/rhs1-iff.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/rhs1-iff.pcert1 : workshops/2006/kaufmann-moore/support/rhs1-iff.pcert0
-workshops/2006/kaufmann-moore/support/rhs1-iff.cert : | workshops/2006/kaufmann-moore/support/rhs1-iff.pcert1
-
-workshops/2006/kaufmann-moore/support/rhs1.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/rhs1.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/rhs1.pcert0 : \
- workshops/2006/kaufmann-moore/support/rhs1.lisp \
- workshops/2006/kaufmann-moore/support/rhs1.acl2
-workshops/2006/kaufmann-moore/support/rhs1.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/rhs1.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/rhs1.pcert1 : workshops/2006/kaufmann-moore/support/rhs1.pcert0
-workshops/2006/kaufmann-moore/support/rhs1.cert : | workshops/2006/kaufmann-moore/support/rhs1.pcert1
-
-workshops/2006/kaufmann-moore/support/rhs2.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/rhs2.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/rhs2.pcert0 : \
- workshops/2006/kaufmann-moore/support/rhs2.lisp \
- workshops/2006/kaufmann-moore/support/rhs2.acl2
-workshops/2006/kaufmann-moore/support/rhs2.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/rhs2.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/rhs2.pcert1 : workshops/2006/kaufmann-moore/support/rhs2.pcert0
-workshops/2006/kaufmann-moore/support/rhs2.cert : | workshops/2006/kaufmann-moore/support/rhs2.pcert1
-
-workshops/2006/kaufmann-moore/support/smith1.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/smith1.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/smith1.pcert0 : \
- workshops/2006/kaufmann-moore/support/smith1.lisp
-workshops/2006/kaufmann-moore/support/smith1.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/smith1.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/smith1.pcert1 : workshops/2006/kaufmann-moore/support/smith1.pcert0
-workshops/2006/kaufmann-moore/support/smith1.cert : | workshops/2006/kaufmann-moore/support/smith1.pcert1
-
-workshops/2006/kaufmann-moore/support/sumners1.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/sumners1.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/sumners1.pcert0 : \
- workshops/2006/kaufmann-moore/support/sumners1.lisp
-workshops/2006/kaufmann-moore/support/sumners1.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/sumners1.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/sumners1.pcert1 : workshops/2006/kaufmann-moore/support/sumners1.pcert0
-workshops/2006/kaufmann-moore/support/sumners1.cert : | workshops/2006/kaufmann-moore/support/sumners1.pcert1
-
-workshops/2006/kaufmann-moore/support/warnings.pcert0 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/warnings.pcert0 : acl2x = 0
-workshops/2006/kaufmann-moore/support/warnings.pcert0 : \
- workshops/2006/kaufmann-moore/support/warnings.lisp \
- workshops/2006/kaufmann-moore/support/warnings.acl2
-workshops/2006/kaufmann-moore/support/warnings.pcert1 : acl2x = 0
-workshops/2006/kaufmann-moore/support/warnings.pcert1 : no_pcert = 0
-workshops/2006/kaufmann-moore/support/warnings.pcert1 : workshops/2006/kaufmann-moore/support/warnings.pcert0
-workshops/2006/kaufmann-moore/support/warnings.cert : | workshops/2006/kaufmann-moore/support/warnings.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/AES/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.cert : | workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/AES/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.cert : | workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-canon.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/AES/AES-source-shallow-flatten.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/AES/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.cert : | workshops/2006/pike-shields-matthews/core_verifier/AES/proof-AES.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.cert : | workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.cert : | workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-canon.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/fibs-source-shallow-flatten.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.cert : | workshops/2006/pike-shields-matthews/core_verifier/Fibonacci/proof-fibs.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.cert : | workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.cert : | workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-canon.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/RC6-source-shallow-flatten.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/RC6/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.cert : | workshops/2006/pike-shields-matthews/core_verifier/RC6/proof-RC6.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.cert : | workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.cert : | workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-canon.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/TEA-source-shallow-flatten.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/TEA/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.cert : | workshops/2006/pike-shields-matthews/core_verifier/TEA/proof-TEA.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.cert : | workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- misc/priorities.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.cert : | workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- coi/super-ihs/super-ihs.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.cert : | workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.pcert0 : \
- data-structures/list-defthms.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.cert : | workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/list-defthms-help.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/ihs-defthms-help.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/append-defthms-help.pcert0 \
- data-structures/list-defthms.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 \
- coi/super-ihs/super-ihs.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.cert : | workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 : \
- arithmetic/mod-gcd.pcert0 \
- ordinals/ordinals.pcert0 \
- ihs/ihs-definitions.pcert0 \
- ihs/ihs-lemmas.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.cert : | workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.cert : | workshops/2006/pike-shields-matthews/core_verifier/books/symbol-manip.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.pcert0 : \
- data-structures/number-list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/books/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.cert : | workshops/2006/pike-shields-matthews/core_verifier/books/vector-comp-canon.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.cert : | workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/source_shallow.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/books/computed-hints.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.cert : | workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.pcert1
-
-workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.pcert0 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.pcert0 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.pcert0 : \
- workshops/2006/pike-shields-matthews/core_verifier/books/make-theorems.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-canon.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/fac-source-shallow-flatten.pcert0 \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.lisp \
- workshops/2006/pike-shields-matthews/core_verifier/factorial/cert.acl2
-workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.pcert1 : acl2x = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.pcert1 : no_pcert = 0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.pcert1 : workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.pcert0
-workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.cert : | workshops/2006/pike-shields-matthews/core_verifier/factorial/proof-fac.pcert1
-
-workshops/2006/rager/support/ptest-fib.pcert0 : no_pcert = 0
-workshops/2006/rager/support/ptest-fib.pcert0 : acl2x = 0
-workshops/2006/rager/support/ptest-fib.pcert0 : \
- workshops/2006/rager/support/ptest-fib.lisp
-workshops/2006/rager/support/ptest-fib.pcert1 : acl2x = 0
-workshops/2006/rager/support/ptest-fib.pcert1 : no_pcert = 0
-workshops/2006/rager/support/ptest-fib.pcert1 : workshops/2006/rager/support/ptest-fib.pcert0
-workshops/2006/rager/support/ptest-fib.cert : | workshops/2006/rager/support/ptest-fib.pcert1
-
-workshops/2006/rager/support/ptest-if-normalization.pcert0 : no_pcert = 0
-workshops/2006/rager/support/ptest-if-normalization.pcert0 : acl2x = 0
-workshops/2006/rager/support/ptest-if-normalization.pcert0 : \
- workshops/2006/rager/support/ptest-if-normalization.lisp
-workshops/2006/rager/support/ptest-if-normalization.pcert1 : acl2x = 0
-workshops/2006/rager/support/ptest-if-normalization.pcert1 : no_pcert = 0
-workshops/2006/rager/support/ptest-if-normalization.pcert1 : workshops/2006/rager/support/ptest-if-normalization.pcert0
-workshops/2006/rager/support/ptest-if-normalization.cert : | workshops/2006/rager/support/ptest-if-normalization.pcert1
-
-workshops/2006/rager/support/ptest-mergesort.pcert0 : no_pcert = 0
-workshops/2006/rager/support/ptest-mergesort.pcert0 : acl2x = 0
-workshops/2006/rager/support/ptest-mergesort.pcert0 : \
- finite-set-theory/osets/sets.pcert0 \
- workshops/2006/rager/support/ptest-mergesort.lisp \
- workshops/2006/rager/support/ptest-mergesort.acl2 \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-workshops/2006/rager/support/ptest-mergesort.pcert1 : acl2x = 0
-workshops/2006/rager/support/ptest-mergesort.pcert1 : no_pcert = 0
-workshops/2006/rager/support/ptest-mergesort.pcert1 : workshops/2006/rager/support/ptest-mergesort.pcert0
-workshops/2006/rager/support/ptest-mergesort.cert : | workshops/2006/rager/support/ptest-mergesort.pcert1
-
-workshops/2006/ray/tail/exists.pcert0 : no_pcert = 0
-workshops/2006/ray/tail/exists.pcert0 : acl2x = 0
-workshops/2006/ray/tail/exists.pcert0 : \
- workshops/2006/ray/tail/exists.lisp
-workshops/2006/ray/tail/exists.pcert1 : acl2x = 0
-workshops/2006/ray/tail/exists.pcert1 : no_pcert = 0
-workshops/2006/ray/tail/exists.pcert1 : workshops/2006/ray/tail/exists.pcert0
-workshops/2006/ray/tail/exists.cert : | workshops/2006/ray/tail/exists.pcert1
-
-workshops/2006/ray/tail/forall.pcert0 : no_pcert = 0
-workshops/2006/ray/tail/forall.pcert0 : acl2x = 0
-workshops/2006/ray/tail/forall.pcert0 : \
- workshops/2006/ray/tail/forall.lisp
-workshops/2006/ray/tail/forall.pcert1 : acl2x = 0
-workshops/2006/ray/tail/forall.pcert1 : no_pcert = 0
-workshops/2006/ray/tail/forall.pcert1 : workshops/2006/ray/tail/forall.pcert0
-workshops/2006/ray/tail/forall.cert : | workshops/2006/ray/tail/forall.pcert1
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.pcert0 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.pcert0 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.pcert0 : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.lisp
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.pcert1 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.pcert1 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.pcert1 : workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.pcert0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.cert : | workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.pcert1
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.pcert0 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.pcert0 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.pcert0 : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.pcert0 \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.lisp
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.pcert1 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.pcert1 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.pcert1 : workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.pcert0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.cert : | workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.pcert1
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.pcert0 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.pcert0 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.pcert0 : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.lisp
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.pcert1 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.pcert1 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.pcert1 : workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.pcert0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.cert : | workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.pcert1
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.pcert0 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.pcert0 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.pcert0 : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.pcert0 \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.pcert0 \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.lisp
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.pcert1 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.pcert1 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.pcert1 : workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.pcert0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.cert : | workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.pcert1
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.pcert0 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.pcert0 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.pcert0 : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-nodeset.pcert0 \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-misc.pcert0 \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.lisp
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.pcert1 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.pcert1 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.pcert1 : workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.pcert0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.cert : | workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.pcert1
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.pcert0 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.pcert0 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- textbook/chap11/qsort.pcert0 \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.lisp
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.pcert1 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.pcert1 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.pcert1 : workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.pcert0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.cert : | workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-types.pcert1
-
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.pcert0 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.pcert0 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.pcert0 : \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-scheduling.pcert0 \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-routing.pcert0 \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC-interfaces.pcert0 \
- workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.lisp
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.pcert1 : acl2x = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.pcert1 : no_pcert = 0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.pcert1 : workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.pcert0
-workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.cert : | workshops/2006/schmaltz-borrione/GeNoC-support/GeNoC.pcert1
-
-workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.pcert0 : no_pcert = 0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.pcert0 : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.pcert0 : \
- data-structures/list-theory.pcert0 \
- workshops/2006/swords-cook/lcsoundness/defsum.pcert0 \
- workshops/2006/swords-cook/lcsoundness/defsum-thms.pcert0 \
- workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.lisp
-workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.pcert1 : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.pcert1 : no_pcert = 0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.pcert1 : workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.pcert0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.cert : | workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.pcert1
-
-workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.pcert0 : no_pcert = 0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.pcert0 : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.pcert0 : \
- workshops/2006/swords-cook/lcsoundness/LambdaCalcBasis.pcert0 \
- workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.lisp
-workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.pcert1 : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.pcert1 : no_pcert = 0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.pcert1 : workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.pcert0
-workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.cert : | workshops/2006/swords-cook/lcsoundness/LambdaCalcSoundness.pcert1
-
-workshops/2006/swords-cook/lcsoundness/defsum-thms.pcert0 : no_pcert = 0
-workshops/2006/swords-cook/lcsoundness/defsum-thms.pcert0 : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/defsum-thms.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- workshops/2006/swords-cook/lcsoundness/defsum-thms.lisp
-workshops/2006/swords-cook/lcsoundness/defsum-thms.pcert1 : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/defsum-thms.pcert1 : no_pcert = 0
-workshops/2006/swords-cook/lcsoundness/defsum-thms.pcert1 : workshops/2006/swords-cook/lcsoundness/defsum-thms.pcert0
-workshops/2006/swords-cook/lcsoundness/defsum-thms.cert : | workshops/2006/swords-cook/lcsoundness/defsum-thms.pcert1
-
-workshops/2006/swords-cook/lcsoundness/defsum.pcert0 : no_pcert = 0
-workshops/2006/swords-cook/lcsoundness/defsum.pcert0 : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/defsum.pcert0 : \
- workshops/2006/swords-cook/lcsoundness/pattern-match.pcert0 \
- workshops/2006/swords-cook/lcsoundness/defsum.lisp
-workshops/2006/swords-cook/lcsoundness/defsum.pcert1 : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/defsum.pcert1 : no_pcert = 0
-workshops/2006/swords-cook/lcsoundness/defsum.pcert1 : workshops/2006/swords-cook/lcsoundness/defsum.pcert0
-workshops/2006/swords-cook/lcsoundness/defsum.cert : | workshops/2006/swords-cook/lcsoundness/defsum.pcert1
-
-workshops/2006/swords-cook/lcsoundness/pattern-match.pcert0 : no_pcert = 0
-workshops/2006/swords-cook/lcsoundness/pattern-match.pcert0 : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/pattern-match.pcert0 : \
- workshops/2006/swords-cook/lcsoundness/pattern-match.lisp
-workshops/2006/swords-cook/lcsoundness/pattern-match.pcert1 : acl2x = 0
-workshops/2006/swords-cook/lcsoundness/pattern-match.pcert1 : no_pcert = 0
-workshops/2006/swords-cook/lcsoundness/pattern-match.pcert1 : workshops/2006/swords-cook/lcsoundness/pattern-match.pcert0
-workshops/2006/swords-cook/lcsoundness/pattern-match.cert : | workshops/2006/swords-cook/lcsoundness/pattern-match.pcert1
-
-workshops/2007/cowles-et-al/support/cowles/while-loop.pcert0 : no_pcert = 0
-workshops/2007/cowles-et-al/support/cowles/while-loop.pcert0 : acl2x = 0
-workshops/2007/cowles-et-al/support/cowles/while-loop.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- workshops/2007/cowles-et-al/support/cowles/while-loop.lisp
-workshops/2007/cowles-et-al/support/cowles/while-loop.pcert1 : acl2x = 0
-workshops/2007/cowles-et-al/support/cowles/while-loop.pcert1 : no_pcert = 0
-workshops/2007/cowles-et-al/support/cowles/while-loop.pcert1 : workshops/2007/cowles-et-al/support/cowles/while-loop.pcert0
-workshops/2007/cowles-et-al/support/cowles/while-loop.cert : | workshops/2007/cowles-et-al/support/cowles/while-loop.pcert1
-
-workshops/2007/cowles-et-al/support/greve/ack.pcert0 : no_pcert = 0
-workshops/2007/cowles-et-al/support/greve/ack.pcert0 : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/ack.pcert0 : \
- workshops/2007/cowles-et-al/support/greve/defminterm.pcert0 \
- workshops/2007/cowles-et-al/support/greve/ack.lisp
-workshops/2007/cowles-et-al/support/greve/ack.pcert1 : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/ack.pcert1 : no_pcert = 0
-workshops/2007/cowles-et-al/support/greve/ack.pcert1 : workshops/2007/cowles-et-al/support/greve/ack.pcert0
-workshops/2007/cowles-et-al/support/greve/ack.cert : | workshops/2007/cowles-et-al/support/greve/ack.pcert1
-
-workshops/2007/cowles-et-al/support/greve/defminterm.pcert0 : no_pcert = 0
-workshops/2007/cowles-et-al/support/greve/defminterm.pcert0 : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/defminterm.pcert0 : \
- workshops/2007/cowles-et-al/support/greve/defxch.pcert0 \
- workshops/2007/cowles-et-al/support/greve/defpun.pcert0 \
- workshops/2007/cowles-et-al/support/greve/defminterm.lisp
-workshops/2007/cowles-et-al/support/greve/defminterm.pcert1 : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/defminterm.pcert1 : no_pcert = 0
-workshops/2007/cowles-et-al/support/greve/defminterm.pcert1 : workshops/2007/cowles-et-al/support/greve/defminterm.pcert0
-workshops/2007/cowles-et-al/support/greve/defminterm.cert : | workshops/2007/cowles-et-al/support/greve/defminterm.pcert1
-
-workshops/2007/cowles-et-al/support/greve/defpun.pcert0 : no_pcert = 0
-workshops/2007/cowles-et-al/support/greve/defpun.pcert0 : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/defpun.pcert0 : \
- workshops/2007/cowles-et-al/support/greve/defpun.lisp
-workshops/2007/cowles-et-al/support/greve/defpun.pcert1 : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/defpun.pcert1 : no_pcert = 0
-workshops/2007/cowles-et-al/support/greve/defpun.pcert1 : workshops/2007/cowles-et-al/support/greve/defpun.pcert0
-workshops/2007/cowles-et-al/support/greve/defpun.cert : | workshops/2007/cowles-et-al/support/greve/defpun.pcert1
-
-workshops/2007/cowles-et-al/support/greve/defxch.pcert0 : no_pcert = 0
-workshops/2007/cowles-et-al/support/greve/defxch.pcert0 : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/defxch.pcert0 : \
- arithmetic-2/meta/top.pcert0 \
- misc/defpun.pcert0 \
- workshops/2007/cowles-et-al/support/greve/defxch.lisp
-workshops/2007/cowles-et-al/support/greve/defxch.pcert1 : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/defxch.pcert1 : no_pcert = 0
-workshops/2007/cowles-et-al/support/greve/defxch.pcert1 : workshops/2007/cowles-et-al/support/greve/defxch.pcert0
-workshops/2007/cowles-et-al/support/greve/defxch.cert : | workshops/2007/cowles-et-al/support/greve/defxch.pcert1
-
-workshops/2007/cowles-et-al/support/greve/while.pcert0 : no_pcert = 0
-workshops/2007/cowles-et-al/support/greve/while.pcert0 : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/while.pcert0 : \
- workshops/2007/cowles-et-al/support/greve/defminterm.pcert0 \
- workshops/2007/cowles-et-al/support/greve/ack.pcert0 \
- workshops/2007/cowles-et-al/support/greve/while.lisp
-workshops/2007/cowles-et-al/support/greve/while.pcert1 : acl2x = 0
-workshops/2007/cowles-et-al/support/greve/while.pcert1 : no_pcert = 0
-workshops/2007/cowles-et-al/support/greve/while.pcert1 : workshops/2007/cowles-et-al/support/greve/while.pcert0
-workshops/2007/cowles-et-al/support/greve/while.cert : | workshops/2007/cowles-et-al/support/greve/while.pcert1
-
-workshops/2007/cowles-et-al/support/ray/reflexive-macros.pcert0 : no_pcert = 0
-workshops/2007/cowles-et-al/support/ray/reflexive-macros.pcert0 : acl2x = 0
-workshops/2007/cowles-et-al/support/ray/reflexive-macros.pcert0 : \
- workshops/2007/cowles-et-al/support/ray/reflexive.pcert0 \
- workshops/2007/cowles-et-al/support/ray/reflexive-macros.lisp
-workshops/2007/cowles-et-al/support/ray/reflexive-macros.pcert1 : acl2x = 0
-workshops/2007/cowles-et-al/support/ray/reflexive-macros.pcert1 : no_pcert = 0
-workshops/2007/cowles-et-al/support/ray/reflexive-macros.pcert1 : workshops/2007/cowles-et-al/support/ray/reflexive-macros.pcert0
-workshops/2007/cowles-et-al/support/ray/reflexive-macros.cert : | workshops/2007/cowles-et-al/support/ray/reflexive-macros.pcert1
-
-workshops/2007/cowles-et-al/support/ray/reflexive.pcert0 : no_pcert = 0
-workshops/2007/cowles-et-al/support/ray/reflexive.pcert0 : acl2x = 0
-workshops/2007/cowles-et-al/support/ray/reflexive.pcert0 : \
- arithmetic/top-with-meta.pcert0 \
- workshops/2007/cowles-et-al/support/ray/reflexive.lisp
-workshops/2007/cowles-et-al/support/ray/reflexive.pcert1 : acl2x = 0
-workshops/2007/cowles-et-al/support/ray/reflexive.pcert1 : no_pcert = 0
-workshops/2007/cowles-et-al/support/ray/reflexive.pcert1 : workshops/2007/cowles-et-al/support/ray/reflexive.pcert0
-workshops/2007/cowles-et-al/support/ray/reflexive.cert : | workshops/2007/cowles-et-al/support/ray/reflexive.pcert1
-
-workshops/2007/dillinger-et-al/code/all.pcert0 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/all.pcert0 : acl2x = 0
-workshops/2007/dillinger-et-al/code/all.pcert0 : \
- workshops/2007/dillinger-et-al/code/hacker.pcert0 \
- workshops/2007/dillinger-et-al/code/defcode-macro.pcert0 \
- workshops/2007/dillinger-et-al/code/defcode.pcert0 \
- workshops/2007/dillinger-et-al/code/defstruct-parsing.pcert0 \
- workshops/2007/dillinger-et-al/code/raw.pcert0 \
- workshops/2007/dillinger-et-al/code/rewrite-code.pcert0 \
- workshops/2007/dillinger-et-al/code/redefun.pcert0 \
- workshops/2007/dillinger-et-al/code/bridge.pcert0 \
- workshops/2007/dillinger-et-al/code/subsumption.pcert0 \
- workshops/2007/dillinger-et-al/code/table-guard.pcert0 \
- workshops/2007/dillinger-et-al/code/all.lisp \
- workshops/2007/dillinger-et-al/code/all.acl2
-workshops/2007/dillinger-et-al/code/all.pcert1 : acl2x = 0
-workshops/2007/dillinger-et-al/code/all.pcert1 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/all.pcert1 : workshops/2007/dillinger-et-al/code/all.pcert0
-workshops/2007/dillinger-et-al/code/all.cert : | workshops/2007/dillinger-et-al/code/all.pcert1
-
-workshops/2007/dillinger-et-al/code/bridge.pcert0 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/bridge.pcert0 : acl2x = 0
-workshops/2007/dillinger-et-al/code/bridge.pcert0 : \
- workshops/2007/dillinger-et-al/code/defcode.pcert0 \
- workshops/2007/dillinger-et-al/code/bridge.lisp \
- workshops/2007/dillinger-et-al/code/bridge.acl2 \
- workshops/2007/dillinger-et-al/code/hacker-pkg.lsp
-workshops/2007/dillinger-et-al/code/bridge.pcert1 : acl2x = 0
-workshops/2007/dillinger-et-al/code/bridge.pcert1 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/bridge.pcert1 : workshops/2007/dillinger-et-al/code/bridge.pcert0
-workshops/2007/dillinger-et-al/code/bridge.cert : | workshops/2007/dillinger-et-al/code/bridge.pcert1
-
-workshops/2007/dillinger-et-al/code/defcode-macro.pcert0 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/defcode-macro.pcert0 : acl2x = 0
-workshops/2007/dillinger-et-al/code/defcode-macro.pcert0 : \
- workshops/2007/dillinger-et-al/code/hacker.pcert0 \
- workshops/2007/dillinger-et-al/code/hacker.pcert0 \
- workshops/2007/dillinger-et-al/code/defcode-macro.lisp \
- workshops/2007/dillinger-et-al/code/defcode-macro.acl2
-workshops/2007/dillinger-et-al/code/defcode-macro.pcert1 : acl2x = 0
-workshops/2007/dillinger-et-al/code/defcode-macro.pcert1 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/defcode-macro.pcert1 : workshops/2007/dillinger-et-al/code/defcode-macro.pcert0
-workshops/2007/dillinger-et-al/code/defcode-macro.cert : | workshops/2007/dillinger-et-al/code/defcode-macro.pcert1
-
-workshops/2007/dillinger-et-al/code/defcode.pcert0 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/defcode.pcert0 : acl2x = 0
-workshops/2007/dillinger-et-al/code/defcode.pcert0 : \
- workshops/2007/dillinger-et-al/code/hacker.pcert0 \
- workshops/2007/dillinger-et-al/code/defcode-macro.pcert0 \
- workshops/2007/dillinger-et-al/code/hacker.pcert0 \
- workshops/2007/dillinger-et-al/code/defcode.lisp \
- workshops/2007/dillinger-et-al/code/defcode.acl2
-workshops/2007/dillinger-et-al/code/defcode.pcert1 : acl2x = 0
-workshops/2007/dillinger-et-al/code/defcode.pcert1 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/defcode.pcert1 : workshops/2007/dillinger-et-al/code/defcode.pcert0
-workshops/2007/dillinger-et-al/code/defcode.cert : | workshops/2007/dillinger-et-al/code/defcode.pcert1
-
-workshops/2007/dillinger-et-al/code/defstruct-parsing.pcert0 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/defstruct-parsing.pcert0 : acl2x = 0
-workshops/2007/dillinger-et-al/code/defstruct-parsing.pcert0 : \
- workshops/2007/dillinger-et-al/code/defstruct-parsing.lisp \
- workshops/2007/dillinger-et-al/code/defstruct-parsing.acl2 \
- workshops/2007/dillinger-et-al/code/hacker-pkg.lsp
-workshops/2007/dillinger-et-al/code/defstruct-parsing.pcert1 : acl2x = 0
-workshops/2007/dillinger-et-al/code/defstruct-parsing.pcert1 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/defstruct-parsing.pcert1 : workshops/2007/dillinger-et-al/code/defstruct-parsing.pcert0
-workshops/2007/dillinger-et-al/code/defstruct-parsing.cert : | workshops/2007/dillinger-et-al/code/defstruct-parsing.pcert1
-
-workshops/2007/dillinger-et-al/code/hacker.pcert0 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/hacker.pcert0 : acl2x = 0
-workshops/2007/dillinger-et-al/code/hacker.pcert0 : \
- workshops/2007/dillinger-et-al/code/hacker.lisp \
- workshops/2007/dillinger-et-al/code/hacker.acl2 \
- workshops/2007/dillinger-et-al/code/hacker-pkg.lsp
-workshops/2007/dillinger-et-al/code/hacker.pcert1 : acl2x = 0
-workshops/2007/dillinger-et-al/code/hacker.pcert1 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/hacker.pcert1 : workshops/2007/dillinger-et-al/code/hacker.pcert0
-workshops/2007/dillinger-et-al/code/hacker.cert : | workshops/2007/dillinger-et-al/code/hacker.pcert1
-
-workshops/2007/dillinger-et-al/code/raw.pcert0 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/raw.pcert0 : acl2x = 0
-workshops/2007/dillinger-et-al/code/raw.pcert0 : \
- workshops/2007/dillinger-et-al/code/defstruct-parsing.pcert0 \
- workshops/2007/dillinger-et-al/code/defcode.pcert0 \
- workshops/2007/dillinger-et-al/code/raw.lisp \
- workshops/2007/dillinger-et-al/code/raw.acl2 \
- workshops/2007/dillinger-et-al/code/hacker-pkg.lsp
-workshops/2007/dillinger-et-al/code/raw.pcert1 : acl2x = 0
-workshops/2007/dillinger-et-al/code/raw.pcert1 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/raw.pcert1 : workshops/2007/dillinger-et-al/code/raw.pcert0
-workshops/2007/dillinger-et-al/code/raw.cert : | workshops/2007/dillinger-et-al/code/raw.pcert1
-
-workshops/2007/dillinger-et-al/code/redefun.pcert0 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/redefun.pcert0 : acl2x = 0
-workshops/2007/dillinger-et-al/code/redefun.pcert0 : \
- workshops/2007/dillinger-et-al/code/defcode.pcert0 \
- workshops/2007/dillinger-et-al/code/rewrite-code.pcert0 \
- workshops/2007/dillinger-et-al/code/defcode.pcert0 \
- workshops/2007/dillinger-et-al/code/redefun.lisp \
- workshops/2007/dillinger-et-al/code/redefun.acl2
-workshops/2007/dillinger-et-al/code/redefun.pcert1 : acl2x = 0
-workshops/2007/dillinger-et-al/code/redefun.pcert1 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/redefun.pcert1 : workshops/2007/dillinger-et-al/code/redefun.pcert0
-workshops/2007/dillinger-et-al/code/redefun.cert : | workshops/2007/dillinger-et-al/code/redefun.pcert1
-
-workshops/2007/dillinger-et-al/code/rewrite-code.pcert0 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/rewrite-code.pcert0 : acl2x = 0
-workshops/2007/dillinger-et-al/code/rewrite-code.pcert0 : \
- workshops/2007/dillinger-et-al/code/rewrite-code.lisp \
- workshops/2007/dillinger-et-al/code/rewrite-code.acl2
-workshops/2007/dillinger-et-al/code/rewrite-code.pcert1 : acl2x = 0
-workshops/2007/dillinger-et-al/code/rewrite-code.pcert1 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/rewrite-code.pcert1 : workshops/2007/dillinger-et-al/code/rewrite-code.pcert0
-workshops/2007/dillinger-et-al/code/rewrite-code.cert : | workshops/2007/dillinger-et-al/code/rewrite-code.pcert1
-
-workshops/2007/dillinger-et-al/code/subsumption.pcert0 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/subsumption.pcert0 : acl2x = 0
-workshops/2007/dillinger-et-al/code/subsumption.pcert0 : \
- workshops/2007/dillinger-et-al/code/defcode.pcert0 \
- workshops/2007/dillinger-et-al/code/subsumption.lisp \
- workshops/2007/dillinger-et-al/code/subsumption.acl2 \
- workshops/2007/dillinger-et-al/code/hacker-pkg.lsp
-workshops/2007/dillinger-et-al/code/subsumption.pcert1 : acl2x = 0
-workshops/2007/dillinger-et-al/code/subsumption.pcert1 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/subsumption.pcert1 : workshops/2007/dillinger-et-al/code/subsumption.pcert0
-workshops/2007/dillinger-et-al/code/subsumption.cert : | workshops/2007/dillinger-et-al/code/subsumption.pcert1
-
-workshops/2007/dillinger-et-al/code/table-guard.pcert0 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/table-guard.pcert0 : acl2x = 0
-workshops/2007/dillinger-et-al/code/table-guard.pcert0 : \
- workshops/2007/dillinger-et-al/code/defcode.pcert0 \
- workshops/2007/dillinger-et-al/code/redefun.pcert0 \
- workshops/2007/dillinger-et-al/code/defcode.pcert0 \
- workshops/2007/dillinger-et-al/code/redefun.pcert0 \
- workshops/2007/dillinger-et-al/code/table-guard.lisp \
- workshops/2007/dillinger-et-al/code/table-guard.acl2
-workshops/2007/dillinger-et-al/code/table-guard.pcert1 : acl2x = 0
-workshops/2007/dillinger-et-al/code/table-guard.pcert1 : no_pcert = 0
-workshops/2007/dillinger-et-al/code/table-guard.pcert1 : workshops/2007/dillinger-et-al/code/table-guard.pcert0
-workshops/2007/dillinger-et-al/code/table-guard.cert : | workshops/2007/dillinger-et-al/code/table-guard.pcert1
-
-workshops/2007/erickson/bprove/bash.pcert0 : no_pcert = 0
-workshops/2007/erickson/bprove/bash.pcert0 : acl2x = 0
-workshops/2007/erickson/bprove/bash.pcert0 : \
- workshops/2007/erickson/bprove/bash.lisp
-workshops/2007/erickson/bprove/bash.pcert1 : acl2x = 0
-workshops/2007/erickson/bprove/bash.pcert1 : no_pcert = 0
-workshops/2007/erickson/bprove/bash.pcert1 : workshops/2007/erickson/bprove/bash.pcert0
-workshops/2007/erickson/bprove/bash.cert : | workshops/2007/erickson/bprove/bash.pcert1
-
-workshops/2007/erickson/bprove/exdefs.pcert0 : no_pcert = 0
-workshops/2007/erickson/bprove/exdefs.pcert0 : acl2x = 0
-workshops/2007/erickson/bprove/exdefs.pcert0 : \
- workshops/2007/erickson/bprove/lemgen.pcert0 \
- workshops/2007/erickson/bprove/exdefs.lisp
-workshops/2007/erickson/bprove/exdefs.pcert1 : acl2x = 0
-workshops/2007/erickson/bprove/exdefs.pcert1 : no_pcert = 0
-workshops/2007/erickson/bprove/exdefs.pcert1 : workshops/2007/erickson/bprove/exdefs.pcert0
-workshops/2007/erickson/bprove/exdefs.cert : | workshops/2007/erickson/bprove/exdefs.pcert1
-
-workshops/2007/erickson/bprove/gen.pcert0 : no_pcert = 0
-workshops/2007/erickson/bprove/gen.pcert0 : acl2x = 0
-workshops/2007/erickson/bprove/gen.pcert0 : \
- workshops/2007/erickson/bprove/gen.lisp
-workshops/2007/erickson/bprove/gen.pcert1 : acl2x = 0
-workshops/2007/erickson/bprove/gen.pcert1 : no_pcert = 0
-workshops/2007/erickson/bprove/gen.pcert1 : workshops/2007/erickson/bprove/gen.pcert0
-workshops/2007/erickson/bprove/gen.cert : | workshops/2007/erickson/bprove/gen.pcert1
-
-workshops/2007/erickson/bprove/lemgen.pcert0 : no_pcert = 0
-workshops/2007/erickson/bprove/lemgen.pcert0 : acl2x = 0
-workshops/2007/erickson/bprove/lemgen.pcert0 : \
- workshops/2007/erickson/bprove/refute.pcert0 \
- workshops/2007/erickson/bprove/gen.pcert0 \
- workshops/2007/erickson/bprove/lemgen.lisp
-workshops/2007/erickson/bprove/lemgen.pcert1 : acl2x = 0
-workshops/2007/erickson/bprove/lemgen.pcert1 : no_pcert = 0
-workshops/2007/erickson/bprove/lemgen.pcert1 : workshops/2007/erickson/bprove/lemgen.pcert0
-workshops/2007/erickson/bprove/lemgen.cert : | workshops/2007/erickson/bprove/lemgen.pcert1
-
-workshops/2007/erickson/bprove/refute.pcert0 : no_pcert = 0
-workshops/2007/erickson/bprove/refute.pcert0 : acl2x = 0
-workshops/2007/erickson/bprove/refute.pcert0 : \
- workshops/2007/erickson/bprove/bash.pcert0 \
- workshops/2007/erickson/bprove/refute.lisp
-workshops/2007/erickson/bprove/refute.pcert1 : acl2x = 0
-workshops/2007/erickson/bprove/refute.pcert1 : no_pcert = 0
-workshops/2007/erickson/bprove/refute.pcert1 : workshops/2007/erickson/bprove/refute.pcert0
-workshops/2007/erickson/bprove/refute.cert : | workshops/2007/erickson/bprove/refute.pcert1
-
-workshops/2007/rimlinger/support/Rimlinger.pcert0 : no_pcert = 0
-workshops/2007/rimlinger/support/Rimlinger.pcert0 : acl2x = 0
-workshops/2007/rimlinger/support/Rimlinger.pcert0 : \
- workshops/2007/rimlinger/support/Rimlinger.lisp
-workshops/2007/rimlinger/support/Rimlinger.pcert1 : acl2x = 0
-workshops/2007/rimlinger/support/Rimlinger.pcert1 : no_pcert = 0
-workshops/2007/rimlinger/support/Rimlinger.pcert1 : workshops/2007/rimlinger/support/Rimlinger.pcert0
-workshops/2007/rimlinger/support/Rimlinger.cert : | workshops/2007/rimlinger/support/Rimlinger.pcert1
-
-workshops/2007/rubio/support/abstract-reductions/abstract-proofs.pcert0 : no_pcert = 0
-workshops/2007/rubio/support/abstract-reductions/abstract-proofs.pcert0 : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/abstract-proofs.pcert0 : \
- data-structures/structures.pcert0 \
- workshops/2007/rubio/support/abstract-reductions/abstract-proofs.lisp
-workshops/2007/rubio/support/abstract-reductions/abstract-proofs.pcert1 : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/abstract-proofs.pcert1 : no_pcert = 0
-workshops/2007/rubio/support/abstract-reductions/abstract-proofs.pcert1 : workshops/2007/rubio/support/abstract-reductions/abstract-proofs.pcert0
-workshops/2007/rubio/support/abstract-reductions/abstract-proofs.cert : | workshops/2007/rubio/support/abstract-reductions/abstract-proofs.pcert1
-
-workshops/2007/rubio/support/abstract-reductions/confluence.pcert0 : no_pcert = 0
-workshops/2007/rubio/support/abstract-reductions/confluence.pcert0 : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/confluence.pcert0 : \
- workshops/2007/rubio/support/abstract-reductions/abstract-proofs.pcert0 \
- workshops/2007/rubio/support/abstract-reductions/confluence.lisp \
- workshops/2007/rubio/support/abstract-reductions/confluence.acl2
-workshops/2007/rubio/support/abstract-reductions/confluence.pcert1 : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/confluence.pcert1 : no_pcert = 0
-workshops/2007/rubio/support/abstract-reductions/confluence.pcert1 : workshops/2007/rubio/support/abstract-reductions/confluence.pcert0
-workshops/2007/rubio/support/abstract-reductions/confluence.cert : | workshops/2007/rubio/support/abstract-reductions/confluence.pcert1
-
-workshops/2007/rubio/support/abstract-reductions/convergent.pcert0 : no_pcert = 0
-workshops/2007/rubio/support/abstract-reductions/convergent.pcert0 : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/convergent.pcert0 : \
- workshops/2007/rubio/support/abstract-reductions/confluence.pcert0 \
- workshops/2007/rubio/support/abstract-reductions/newman.pcert0 \
- workshops/2007/rubio/support/abstract-reductions/convergent.lisp \
- workshops/2007/rubio/support/abstract-reductions/convergent.acl2
-workshops/2007/rubio/support/abstract-reductions/convergent.pcert1 : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/convergent.pcert1 : no_pcert = 0
-workshops/2007/rubio/support/abstract-reductions/convergent.pcert1 : workshops/2007/rubio/support/abstract-reductions/convergent.pcert0
-workshops/2007/rubio/support/abstract-reductions/convergent.cert : | workshops/2007/rubio/support/abstract-reductions/convergent.pcert1
-
-workshops/2007/rubio/support/abstract-reductions/newman.pcert0 : no_pcert = 0
-workshops/2007/rubio/support/abstract-reductions/newman.pcert0 : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/newman.pcert0 : \
- workshops/2007/rubio/support/multisets/defmul.pcert0 \
- workshops/2007/rubio/support/abstract-reductions/abstract-proofs.pcert0 \
- workshops/2007/rubio/support/abstract-reductions/newman.lisp \
- workshops/2007/rubio/support/abstract-reductions/newman.acl2
-workshops/2007/rubio/support/abstract-reductions/newman.pcert1 : acl2x = 0
-workshops/2007/rubio/support/abstract-reductions/newman.pcert1 : no_pcert = 0
-workshops/2007/rubio/support/abstract-reductions/newman.pcert1 : workshops/2007/rubio/support/abstract-reductions/newman.pcert0
-workshops/2007/rubio/support/abstract-reductions/newman.cert : | workshops/2007/rubio/support/abstract-reductions/newman.pcert1
-
-workshops/2007/rubio/support/multisets/defmul.pcert0 : no_pcert = 0
-workshops/2007/rubio/support/multisets/defmul.pcert0 : acl2x = 0
-workshops/2007/rubio/support/multisets/defmul.pcert0 : \
- workshops/2007/rubio/support/multisets/multiset.pcert0 \
- workshops/2007/rubio/support/multisets/defmul.lisp \
- workshops/2007/rubio/support/multisets/defmul.acl2
-workshops/2007/rubio/support/multisets/defmul.pcert1 : acl2x = 0
-workshops/2007/rubio/support/multisets/defmul.pcert1 : no_pcert = 0
-workshops/2007/rubio/support/multisets/defmul.pcert1 : workshops/2007/rubio/support/multisets/defmul.pcert0
-workshops/2007/rubio/support/multisets/defmul.cert : | workshops/2007/rubio/support/multisets/defmul.pcert1
-
-workshops/2007/rubio/support/multisets/multiset.pcert0 : no_pcert = 0
-workshops/2007/rubio/support/multisets/multiset.pcert0 : acl2x = 0
-workshops/2007/rubio/support/multisets/multiset.pcert0 : \
- ordinals/e0-ordinal.pcert0 \
- workshops/2007/rubio/support/multisets/multiset.lisp \
- workshops/2007/rubio/support/multisets/multiset.acl2
-workshops/2007/rubio/support/multisets/multiset.pcert1 : acl2x = 0
-workshops/2007/rubio/support/multisets/multiset.pcert1 : no_pcert = 0
-workshops/2007/rubio/support/multisets/multiset.pcert1 : workshops/2007/rubio/support/multisets/multiset.pcert0
-workshops/2007/rubio/support/multisets/multiset.cert : | workshops/2007/rubio/support/multisets/multiset.pcert1
-
-workshops/2007/rubio/support/simplicial-topology/generate-degenerate.pcert0 : no_pcert = 0
-workshops/2007/rubio/support/simplicial-topology/generate-degenerate.pcert0 : acl2x = 0
-workshops/2007/rubio/support/simplicial-topology/generate-degenerate.pcert0 : \
- workshops/2007/rubio/support/abstract-reductions/convergent.pcert0 \
- arithmetic/top-with-meta.pcert0 \
- workshops/2007/rubio/support/simplicial-topology/generate-degenerate.lisp \
- workshops/2007/rubio/support/simplicial-topology/generate-degenerate.acl2
-workshops/2007/rubio/support/simplicial-topology/generate-degenerate.pcert1 : acl2x = 0
-workshops/2007/rubio/support/simplicial-topology/generate-degenerate.pcert1 : no_pcert = 0
-workshops/2007/rubio/support/simplicial-topology/generate-degenerate.pcert1 : workshops/2007/rubio/support/simplicial-topology/generate-degenerate.pcert0
-workshops/2007/rubio/support/simplicial-topology/generate-degenerate.cert : | workshops/2007/rubio/support/simplicial-topology/generate-degenerate.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.lisp
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.pcert1 : workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.pcert0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.cert : | workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.lisp
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.pcert1 : workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.pcert0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.cert : | workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.lisp
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert1 : workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.cert : | workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.lisp
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.pcert1 : workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.pcert0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.cert : | workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-misc.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.lisp
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.pcert1 : workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.pcert0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.cert : | workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- textbook/chap11/qsort.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.lisp
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.pcert1 : workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.pcert0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.cert : | workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-types.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-interfaces.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.lisp
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.pcert1 : workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.pcert0
-workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.cert : | workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/interfaces/bi-phi-m.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-nodeset.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/doubleY-routing/doubleY-routing.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.pcert0 : \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/mod_lemmas.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_defuns.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/getting_rid_of_mod.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/octagon-nodeset.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_local_lemmas.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/octagon-routing/routing_main.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-routing.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/nodeset/2D-mesh-nodeset.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/routing/xy-routing/xy-routing.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/circuit-scheduling.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.pcert1
-
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.pcert0 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.pcert0 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.pcert0 : \
- workshops/2007/schmaltz/genoc-v1.0/generic-modules/GeNoC-scheduling.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/intersect.pcert0 \
- workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.lisp
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.pcert1 : acl2x = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.pcert1 : no_pcert = 0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.pcert1 : workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.pcert0
-workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.cert : | workshops/2007/schmaltz/genoc-v1.0/instantiations/scheduling/packet-scheduling.pcert1
-
-workshops/2009/fraij-roach/support/functions.pcert0 : no_pcert = 0
-workshops/2009/fraij-roach/support/functions.pcert0 : acl2x = 0
-workshops/2009/fraij-roach/support/functions.pcert0 : \
- ordinals/lexicographic-ordering.pcert0 \
- workshops/2009/fraij-roach/support/functions.lisp
-workshops/2009/fraij-roach/support/functions.pcert1 : acl2x = 0
-workshops/2009/fraij-roach/support/functions.pcert1 : no_pcert = 0
-workshops/2009/fraij-roach/support/functions.pcert1 : workshops/2009/fraij-roach/support/functions.pcert0
-workshops/2009/fraij-roach/support/functions.cert : | workshops/2009/fraij-roach/support/functions.pcert1
-
-workshops/2009/fraij-roach/support/theorems.pcert0 : no_pcert = 0
-workshops/2009/fraij-roach/support/theorems.pcert0 : acl2x = 0
-workshops/2009/fraij-roach/support/theorems.pcert0 : \
- workshops/2009/fraij-roach/support/functions.pcert0 \
- workshops/2009/fraij-roach/support/theorems.lisp
-workshops/2009/fraij-roach/support/theorems.pcert1 : acl2x = 0
-workshops/2009/fraij-roach/support/theorems.pcert1 : no_pcert = 0
-workshops/2009/fraij-roach/support/theorems.pcert1 : workshops/2009/fraij-roach/support/theorems.pcert0
-workshops/2009/fraij-roach/support/theorems.cert : | workshops/2009/fraij-roach/support/theorems.pcert1
-
-workshops/2009/hardin/deque-stobj/deque-stobj.pcert0 : no_pcert = 0
-workshops/2009/hardin/deque-stobj/deque-stobj.pcert0 : acl2x = 0
-workshops/2009/hardin/deque-stobj/deque-stobj.pcert0 : \
- workshops/2009/hardin/deque-stobj/deque-stobj.lisp
-workshops/2009/hardin/deque-stobj/deque-stobj.pcert1 : acl2x = 0
-workshops/2009/hardin/deque-stobj/deque-stobj.pcert1 : no_pcert = 0
-workshops/2009/hardin/deque-stobj/deque-stobj.pcert1 : workshops/2009/hardin/deque-stobj/deque-stobj.pcert0
-workshops/2009/hardin/deque-stobj/deque-stobj.cert : | workshops/2009/hardin/deque-stobj/deque-stobj.pcert1
-
-workshops/2009/hardin/deque-stobj/deque-thms.pcert0 : no_pcert = 0
-workshops/2009/hardin/deque-stobj/deque-thms.pcert0 : acl2x = 0
-workshops/2009/hardin/deque-stobj/deque-thms.pcert0 : \
- workshops/2009/hardin/deque-stobj/deque-stobj.pcert0 \
- arithmetic-5/top.pcert0 \
- workshops/2009/hardin/deque-stobj/deque-thms.lisp
-workshops/2009/hardin/deque-stobj/deque-thms.pcert1 : acl2x = 0
-workshops/2009/hardin/deque-stobj/deque-thms.pcert1 : no_pcert = 0
-workshops/2009/hardin/deque-stobj/deque-thms.pcert1 : workshops/2009/hardin/deque-stobj/deque-thms.pcert0
-workshops/2009/hardin/deque-stobj/deque-thms.cert : | workshops/2009/hardin/deque-stobj/deque-thms.pcert1
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.pcert0 : no_pcert = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.pcert0 : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.pcert0 : \
- workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.pcert0 \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.lisp \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.acl2
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.pcert1 : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.pcert1 : no_pcert = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.pcert1 : workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.pcert0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.cert : | workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.pcert1
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.pcert0 : no_pcert = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.pcert0 : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.pcert0 : \
- workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.pcert0 \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.pcert0 \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.lisp \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.acl2
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.pcert1 : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.pcert1 : no_pcert = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.pcert1 : workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.pcert0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.cert : | workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.pcert1
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.pcert0 : no_pcert = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.pcert0 : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.pcert0 : \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-fns.pcert0 \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss-work.pcert0 \
- workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.lisp
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.pcert1 : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.pcert1 : no_pcert = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.pcert1 : workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.pcert0
-workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.cert : | workshops/2009/kaufmann-kornerup-reitblatt/support/gauss.pcert1
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.pcert0 : no_pcert = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.pcert0 : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.pcert0 : \
- defexec/other-apps/records/records.pcert0 \
- workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.lisp
-workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.pcert1 : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.pcert1 : no_pcert = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.pcert1 : workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.pcert0
-workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.cert : | workshops/2009/kaufmann-kornerup-reitblatt/support/generic-loop-inv.pcert1
-
-workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.pcert0 : no_pcert = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.pcert0 : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.pcert0 : \
- defexec/other-apps/records/records.pcert0 \
- defexec/other-apps/records/records.pcert0 \
- workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.lisp \
- workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.acl2
-workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.pcert1 : acl2x = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.pcert1 : no_pcert = 0
-workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.pcert1 : workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.pcert0
-workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.cert : | workshops/2009/kaufmann-kornerup-reitblatt/support/preliminaries.pcert1
-
-workshops/2009/liu/support/error-analysis-tool3.pcert0 : no_pcert = 0
-workshops/2009/liu/support/error-analysis-tool3.pcert0 : acl2x = 0
-workshops/2009/liu/support/error-analysis-tool3.pcert0 : \
- rtl/rel8/arithmetic/top.pcert0 \
- workshops/2009/liu/support/mylet.pcert0 \
- workshops/2009/liu/support/error-analysis-tool3.lisp
-workshops/2009/liu/support/error-analysis-tool3.pcert1 : acl2x = 0
-workshops/2009/liu/support/error-analysis-tool3.pcert1 : no_pcert = 0
-workshops/2009/liu/support/error-analysis-tool3.pcert1 : workshops/2009/liu/support/error-analysis-tool3.pcert0
-workshops/2009/liu/support/error-analysis-tool3.cert : | workshops/2009/liu/support/error-analysis-tool3.pcert1
-
-workshops/2009/liu/support/mylet.pcert0 : no_pcert = 0
-workshops/2009/liu/support/mylet.pcert0 : acl2x = 0
-workshops/2009/liu/support/mylet.pcert0 : \
- workshops/2009/liu/support/mylet.lisp
-workshops/2009/liu/support/mylet.pcert1 : acl2x = 0
-workshops/2009/liu/support/mylet.pcert1 : no_pcert = 0
-workshops/2009/liu/support/mylet.pcert1 : workshops/2009/liu/support/mylet.pcert0
-workshops/2009/liu/support/mylet.cert : | workshops/2009/liu/support/mylet.pcert1
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.pcert0 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.pcert0 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.pcert0 : \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.pcert0 \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.lisp
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.pcert1 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.pcert1 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.pcert1 : workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.pcert0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.cert : | workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-TMR.pcert1
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.pcert0 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.pcert0 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.pcert0 : \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.pcert0 \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.lisp
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.pcert1 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.pcert1 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.pcert1 : workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.pcert0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.cert : | workshops/2009/pierre-clavel-leveugle/Fault-tolerance/ATM-det.pcert1
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.pcert0 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.pcert0 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.pcert0 : \
- arithmetic-3/top.pcert0 \
- make-event/defspec.pcert0 \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.lisp
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.pcert1 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.pcert1 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.pcert1 : workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.pcert0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.cert : | workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.pcert1
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.pcert0 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.pcert0 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.pcert0 : \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.pcert0 \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.lisp
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.pcert1 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.pcert1 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.pcert1 : workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.pcert0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.cert : | workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-TMR.pcert1
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.pcert0 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.pcert0 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.pcert0 : \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.pcert0 \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.lisp
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.pcert1 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.pcert1 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.pcert1 : workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.pcert0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.cert : | workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register-det.pcert1
-
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.pcert0 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.pcert0 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.pcert0 : \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/error-model.pcert0 \
- workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.lisp
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.pcert1 : acl2x = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.pcert1 : no_pcert = 0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.pcert1 : workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.pcert0
-workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.cert : | workshops/2009/pierre-clavel-leveugle/Fault-tolerance/register.pcert1
-
-workshops/2009/sumners/support/kas.pcert0 : no_pcert = 0
-workshops/2009/sumners/support/kas.pcert0 : acl2x = 0
-workshops/2009/sumners/support/kas.pcert0 : \
- workshops/2009/sumners/support/kas.lisp \
- workshops/2009/sumners/support/kas.acl2
-workshops/2009/sumners/support/kas.pcert1 : acl2x = 0
-workshops/2009/sumners/support/kas.pcert1 : no_pcert = 0
-workshops/2009/sumners/support/kas.pcert1 : workshops/2009/sumners/support/kas.pcert0
-workshops/2009/sumners/support/kas.cert : | workshops/2009/sumners/support/kas.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.pcert0 : \
- make-event/defspec.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.pcert0 : \
- make-event/defspec.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert0 : \
- make-event/defspec.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert0 : \
- make-event/defspec.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.pcert0 : \
- make-event/defspec.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert0 : \
- make-event/defspec.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/datalink.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/departure.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/flowcontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/circuit-XY-2Dmesh/GeNoC.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/packet-XY-2Dmesh/GeNoC.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/spidergon/GeNoC.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/GeNoC.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/departure/simple/departure.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/genoc/wormhole-XY-2Dmesh/GeNoC.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/2Dmesh/network.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/ring/network.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/network.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/types.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/network/spidergon/network.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/routecontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/circuit/flowcontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-circuit/router.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/packet/flowcontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-packet/router.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/xy/routecontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/XY-wormhole/router.pcert1
-
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.pcert0 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.pcert0 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.pcert0 : \
- workshops/2009/vandenbroek-schmaltz/GeNoC/generic-modules/router.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/datalink/simple/datalink.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/routecontrol/spidergon/routecontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/flowcontrol/wormhole/flowcontrol.pcert0 \
- workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.lisp
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.pcert1 : acl2x = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.pcert1 : no_pcert = 0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.pcert1 : workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.pcert0
-workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.cert : | workshops/2009/vandenbroek-schmaltz/GeNoC/instantiations/router/spidergon/router.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.pcert0 : \
- make-event/defspec.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.pcert0 \
- make-event/defspec.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert0 : \
- make-event/defspec.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.pcert0 \
- make-event/defspec.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-priority.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.pcert0 : \
- make-event/defspec.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-types.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-interfaces.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.pcert0 : \
- ordinals/lexicographic-ordering.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.lisp
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.cert : | workshops/2009/verbeek-schmaltz/verbeek/generic-modules/own-perm.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.pcert0 : \
- make-event/defspec.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-departure.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.pcert0 : \
- make-event/defspec.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/departure/simple/simple-R4D.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.pcert0 \
- ordinals/lexicographic-ordering.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/sets.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/simple.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.pcert0 : \
- ordinals/lexicographic-ordering.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-misc.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/interfaces-computes.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/interfaces/dummy-interfaces/interfaces-computes.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-nodeset.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-ntkstate.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-routing.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/nodeset/2DMesh-no-ports/2DMesh.pcert0 \
- arithmetic-3/bind-free/top.pcert0 \
- arithmetic-3/floor-mod/floor-mod.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/routing/XY/XYRouting.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-scheduling.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/genoc/simple-ct-global/trlst-equal.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/circuit.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.pcert0 : \
- data-structures/list-defuns.pcert0 \
- data-structures/list-defthms.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/scheduling/circuit-switching-global/intersect.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-simulation.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/simulation/simple/simple.pcert1
-
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.pcert0 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.pcert0 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.pcert0 : \
- workshops/2009/verbeek-schmaltz/verbeek/generic-modules/GeNoC-synchronization.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/ntkstate/simple/simple.pcert0 \
- workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.lisp
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.pcert1 : acl2x = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.pcert1 : no_pcert = 0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.pcert1 : workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.pcert0
-workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.cert : | workshops/2009/verbeek-schmaltz/verbeek/instantiations/synchronization/circuit-global/circuit.pcert1
-
-workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.pcert0 : no_pcert = 0
-workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.pcert0 : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.pcert0 : \
- arithmetic-3/top.pcert0 \
- workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.lisp
-workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.pcert1 : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.pcert1 : no_pcert = 0
-workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.pcert1 : workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.pcert0
-workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.cert : | workshops/2011/cowles-gamboa-sierpinski/support/r-no-cover.pcert1
-
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.pcert0 : no_pcert = 0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.pcert0 : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.pcert0 : \
- arithmetic-3/top.pcert0 \
- workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.lisp
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.pcert1 : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.pcert1 : no_pcert = 0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.pcert1 : workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.pcert0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.cert : | workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover.pcert1
-
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.pcert0 : no_pcert = 0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.pcert0 : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.pcert0 : \
- arithmetic-3/top.pcert0 \
- workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.lisp
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.pcert1 : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.pcert1 : no_pcert = 0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.pcert1 : workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.pcert0
-workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.cert : | workshops/2011/cowles-gamboa-sierpinski/support/s-no-cover1.pcert1
-
-workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.pcert0 : no_pcert = 0
-workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.pcert0 : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.pcert0 : \
- arithmetic-3/top.pcert0 \
- data-structures/utilities.pcert0 \
- workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.lisp \
- workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.acl2
-workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.pcert1 : acl2x = 0
-workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.pcert1 : no_pcert = 0
-workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.pcert1 : workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.pcert0
-workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.cert : | workshops/2011/cowles-gamboa-sierpinski/support/verifying-macros.pcert1
-
-wp-gen/mutrec/mutrec.pcert0 : no_pcert = 0
-wp-gen/mutrec/mutrec.pcert0 : acl2x = 0
-wp-gen/mutrec/mutrec.pcert0 : \
- ordinals/lexicographic-ordering.pcert0 \
- wp-gen/mutrec/mutrec.lisp
-wp-gen/mutrec/mutrec.pcert1 : acl2x = 0
-wp-gen/mutrec/mutrec.pcert1 : no_pcert = 0
-wp-gen/mutrec/mutrec.pcert1 : wp-gen/mutrec/mutrec.pcert0
-wp-gen/mutrec/mutrec.cert : | wp-gen/mutrec/mutrec.pcert1
-
-wp-gen/shared.pcert0 : no_pcert = 0
-wp-gen/shared.pcert0 : acl2x = 0
-wp-gen/shared.pcert0 : \
- wp-gen/shared.lisp
-wp-gen/shared.pcert1 : acl2x = 0
-wp-gen/shared.pcert1 : no_pcert = 0
-wp-gen/shared.pcert1 : wp-gen/shared.pcert0
-wp-gen/shared.cert : | wp-gen/shared.pcert1
-
-wp-gen/wp-gen.pcert0 : no_pcert = 0
-wp-gen/wp-gen.pcert0 : acl2x = 0
-wp-gen/wp-gen.pcert0 : \
- wp-gen/shared.pcert0 \
- wp-gen/mutrec/mutrec.pcert0 \
- wp-gen/wp-gen.lisp \
- wp-gen/wp-gen.acl2
-wp-gen/wp-gen.pcert1 : acl2x = 0
-wp-gen/wp-gen.pcert1 : no_pcert = 0
-wp-gen/wp-gen.pcert1 : wp-gen/wp-gen.pcert0
-wp-gen/wp-gen.cert : | wp-gen/wp-gen.pcert1
-
-xdoc-impl/autolink.pcert0 : no_pcert = 0
-xdoc-impl/autolink.pcert0 : acl2x = 0
-xdoc-impl/autolink.pcert0 : \
- xdoc-impl/fmt-to-str.pcert0 \
- xdoc/names.pcert0 \
- misc/assert.pcert0 \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/autolink.lisp \
- xdoc-impl/cert.acl2
-xdoc-impl/autolink.pcert1 : acl2x = 0
-xdoc-impl/autolink.pcert1 : no_pcert = 0
-xdoc-impl/autolink.pcert1 : xdoc-impl/autolink.pcert0
-xdoc-impl/autolink.cert : | xdoc-impl/autolink.pcert1
-
-xdoc-impl/extra-packages.pcert0 : no_pcert = 0
-xdoc-impl/extra-packages.pcert0 : acl2x = 0
-xdoc-impl/extra-packages.pcert0 : \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/extra-packages.lisp \
- xdoc-impl/extra-packages.acl2 \
- xdoc-impl/cert.acl2 \
- cowles/packages.lsp \
- clause-processors/SULFA/books/sat/sat-package.acl2 \
- data-structures/define-u-package.lsp \
- data-structures/define-structures-package.lsp \
- data-structures/memories/package.lsp \
- hacking/hacker-pkg.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- tools/flag-package.lsp \
- oslib/package.lsp \
- cutil/package.lsp \
- str/package.lsp \
- xdoc/package.lsp \
- xdoc/package.lsp \
- finite-set-theory/osets/sets.defpkg \
- xdoc/package.lsp
-xdoc-impl/extra-packages.pcert1 : acl2x = 0
-xdoc-impl/extra-packages.pcert1 : no_pcert = 0
-xdoc-impl/extra-packages.pcert1 : xdoc-impl/extra-packages.pcert0
-xdoc-impl/extra-packages.cert : | xdoc-impl/extra-packages.pcert1
-
-xdoc-impl/fmt-to-str.pcert0 : no_pcert = 0
-xdoc-impl/fmt-to-str.pcert0 : acl2x = 0
-xdoc-impl/fmt-to-str.pcert0 : \
- tools/bstar.pcert0 \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/fmt-to-str.lisp \
- xdoc-impl/cert.acl2
-xdoc-impl/fmt-to-str.pcert1 : acl2x = 0
-xdoc-impl/fmt-to-str.pcert1 : no_pcert = 0
-xdoc-impl/fmt-to-str.pcert1 : xdoc-impl/fmt-to-str.pcert0
-xdoc-impl/fmt-to-str.cert : | xdoc-impl/fmt-to-str.pcert1
-
-xdoc-impl/import-acl2doc.pcert0 : no_pcert = 0
-xdoc-impl/import-acl2doc.pcert0 : acl2x = 0
-xdoc-impl/import-acl2doc.pcert0 : \
- xdoc-impl/write-acl2-xdoc.pcert0 \
- xdoc/base.pcert0 \
- tools/bstar.pcert0 \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/import-acl2doc.lisp \
- xdoc-impl/cert.acl2
-xdoc-impl/import-acl2doc.pcert1 : acl2x = 0
-xdoc-impl/import-acl2doc.pcert1 : no_pcert = 0
-xdoc-impl/import-acl2doc.pcert1 : xdoc-impl/import-acl2doc.pcert0
-xdoc-impl/import-acl2doc.cert : | xdoc-impl/import-acl2doc.pcert1
-
-xdoc-impl/mkdir-raw.pcert0 : no_pcert = 0
-xdoc-impl/mkdir-raw.pcert0 : acl2x = 0
-xdoc-impl/mkdir-raw.pcert0 : \
- xdoc-impl/mkdir.pcert0 \
- tools/bstar.pcert0 \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/mkdir-raw.lisp \
- xdoc-impl/mkdir-raw.acl2 \
- xdoc-impl/cert.acl2
-xdoc-impl/mkdir-raw.pcert1 : acl2x = 0
-xdoc-impl/mkdir-raw.pcert1 : no_pcert = 0
-xdoc-impl/mkdir-raw.pcert1 : xdoc-impl/mkdir-raw.pcert0
-xdoc-impl/mkdir-raw.cert : | xdoc-impl/mkdir-raw.pcert1
-
-xdoc-impl/mkdir.pcert0 : no_pcert = 0
-xdoc-impl/mkdir.pcert0 : acl2x = 0
-xdoc-impl/mkdir.pcert0 : \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/mkdir.lisp \
- xdoc-impl/cert.acl2
-xdoc-impl/mkdir.pcert1 : acl2x = 0
-xdoc-impl/mkdir.pcert1 : no_pcert = 0
-xdoc-impl/mkdir.pcert1 : xdoc-impl/mkdir.pcert0
-xdoc-impl/mkdir.cert : | xdoc-impl/mkdir.pcert1
-
-xdoc-impl/parse-xml.pcert0 : no_pcert = 0
-xdoc-impl/parse-xml.pcert0 : acl2x = 0
-xdoc-impl/parse-xml.pcert0 : \
- xdoc-impl/preprocess.pcert0 \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/parse-xml.lisp \
- xdoc-impl/cert.acl2
-xdoc-impl/parse-xml.pcert1 : acl2x = 0
-xdoc-impl/parse-xml.pcert1 : no_pcert = 0
-xdoc-impl/parse-xml.pcert1 : xdoc-impl/parse-xml.pcert0
-xdoc-impl/parse-xml.cert : | xdoc-impl/parse-xml.pcert1
-
-xdoc-impl/portcullis.pcert0 : no_pcert = 0
-xdoc-impl/portcullis.pcert0 : acl2x = 0
-xdoc-impl/portcullis.pcert0 : \
- xdoc-impl/portcullis.lisp \
- xdoc-impl/portcullis.acl2 \
- xdoc/package.lsp \
- str/package.lsp \
- xdoc/package.lsp
-xdoc-impl/portcullis.pcert1 : acl2x = 0
-xdoc-impl/portcullis.pcert1 : no_pcert = 0
-xdoc-impl/portcullis.pcert1 : xdoc-impl/portcullis.pcert0
-xdoc-impl/portcullis.cert : | xdoc-impl/portcullis.pcert1
-
-xdoc-impl/preprocess.pcert0 : no_pcert = 0
-xdoc-impl/preprocess.pcert0 : acl2x = 0
-xdoc-impl/preprocess.pcert0 : \
- xdoc-impl/autolink.pcert0 \
- str/top.pcert0 \
- misc/assert.pcert0 \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/preprocess.lisp \
- xdoc-impl/cert.acl2
-xdoc-impl/preprocess.pcert1 : acl2x = 0
-xdoc-impl/preprocess.pcert1 : no_pcert = 0
-xdoc-impl/preprocess.pcert1 : xdoc-impl/preprocess.pcert0
-xdoc-impl/preprocess.cert : | xdoc-impl/preprocess.pcert1
-
-xdoc-impl/save.pcert0 : no_pcert = 0
-xdoc-impl/save.pcert0 : acl2x = 0
-xdoc-impl/save.pcert0 : \
- xdoc-impl/mkdir.pcert0 \
- xdoc/base.pcert0 \
- xdoc-impl/preprocess.pcert0 \
- xdoc-impl/parse-xml.pcert0 \
- xdoc-impl/sort.pcert0 \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/save.lisp \
- xdoc-impl/cert.acl2
-xdoc-impl/save.pcert1 : acl2x = 0
-xdoc-impl/save.pcert1 : no_pcert = 0
-xdoc-impl/save.pcert1 : xdoc-impl/save.pcert0
-xdoc-impl/save.cert : | xdoc-impl/save.pcert1
-
-xdoc-impl/sort.pcert0 : no_pcert = 0
-xdoc-impl/sort.pcert0 : acl2x = 0
-xdoc-impl/sort.pcert0 : \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/sort.lisp \
- xdoc-impl/cert.acl2
-xdoc-impl/sort.pcert1 : acl2x = 0
-xdoc-impl/sort.pcert1 : no_pcert = 0
-xdoc-impl/sort.pcert1 : xdoc-impl/sort.pcert0
-xdoc-impl/sort.cert : | xdoc-impl/sort.pcert1
-
-xdoc-impl/topics.pcert0 : no_pcert = 0
-xdoc-impl/topics.pcert0 : acl2x = 0
-xdoc-impl/topics.pcert0 : \
- xdoc-impl/import-acl2doc.pcert0 \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/topics.lisp \
- xdoc-impl/cert.acl2
-xdoc-impl/topics.pcert1 : acl2x = 0
-xdoc-impl/topics.pcert1 : no_pcert = 0
-xdoc-impl/topics.pcert1 : xdoc-impl/topics.pcert0
-xdoc-impl/topics.cert : | xdoc-impl/topics.pcert1
-
-xdoc-impl/write-acl2-xdoc.pcert0 : no_pcert = 0
-xdoc-impl/write-acl2-xdoc.pcert0 : acl2x = 0
-xdoc-impl/write-acl2-xdoc.pcert0 : \
- xdoc-impl/portcullis.pcert0 \
- xdoc-impl/write-acl2-xdoc.lisp \
- xdoc-impl/cert.acl2
-xdoc-impl/write-acl2-xdoc.pcert1 : acl2x = 0
-xdoc-impl/write-acl2-xdoc.pcert1 : no_pcert = 0
-xdoc-impl/write-acl2-xdoc.pcert1 : xdoc-impl/write-acl2-xdoc.pcert0
-xdoc-impl/write-acl2-xdoc.cert : | xdoc-impl/write-acl2-xdoc.pcert1
-
-xdoc/base.pcert0 : no_pcert = 0
-xdoc/base.pcert0 : acl2x = 0
-xdoc/base.pcert0 : \
- xdoc/portcullis.pcert0 \
- xdoc/base.lisp \
- xdoc/cert.acl2
-xdoc/base.pcert1 : acl2x = 0
-xdoc/base.pcert1 : no_pcert = 0
-xdoc/base.pcert1 : xdoc/base.pcert0
-xdoc/base.cert : | xdoc/base.pcert1
-
-xdoc/book-thms.pcert0 : no_pcert = 0
-xdoc/book-thms.pcert0 : acl2x = 0
-xdoc/book-thms.pcert0 : \
- xdoc/portcullis.pcert0 \
- xdoc/book-thms.lisp \
- xdoc/cert.acl2
-xdoc/book-thms.pcert1 : acl2x = 0
-xdoc/book-thms.pcert1 : no_pcert = 0
-xdoc/book-thms.pcert1 : xdoc/book-thms.pcert0
-xdoc/book-thms.cert : | xdoc/book-thms.pcert1
-
-xdoc/defxdoc-raw.pcert0 : no_pcert = 0
-xdoc/defxdoc-raw.pcert0 : acl2x = 0
-xdoc/defxdoc-raw.pcert0 : \
- xdoc/base.pcert0 \
- xdoc/portcullis.pcert0 \
- xdoc/defxdoc-raw.lisp \
- xdoc/defxdoc-raw.acl2
-xdoc/defxdoc-raw.pcert1 : acl2x = 0
-xdoc/defxdoc-raw.pcert1 : no_pcert = 0
-xdoc/defxdoc-raw.pcert1 : xdoc/defxdoc-raw.pcert0
-xdoc/defxdoc-raw.cert : | xdoc/defxdoc-raw.pcert1
-
-xdoc/names.pcert0 : no_pcert = 0
-xdoc/names.pcert0 : acl2x = 0
-xdoc/names.pcert0 : \
- xdoc/base.pcert0 \
- xdoc/portcullis.pcert0 \
- xdoc/names.lisp \
- xdoc/cert.acl2
-xdoc/names.pcert1 : acl2x = 0
-xdoc/names.pcert1 : no_pcert = 0
-xdoc/names.pcert1 : xdoc/names.pcert0
-xdoc/names.cert : | xdoc/names.pcert1
-
-xdoc/portcullis.pcert0 : no_pcert = 0
-xdoc/portcullis.pcert0 : acl2x = 0
-xdoc/portcullis.pcert0 : \
- xdoc/portcullis.lisp \
- xdoc/portcullis.acl2 \
- xdoc/package.lsp
-xdoc/portcullis.pcert1 : acl2x = 0
-xdoc/portcullis.pcert1 : no_pcert = 0
-xdoc/portcullis.pcert1 : xdoc/portcullis.pcert0
-xdoc/portcullis.cert : | xdoc/portcullis.pcert1
-
-xdoc/top.pcert0 : no_pcert = 0
-xdoc/top.pcert0 : acl2x = 0
-xdoc/top.pcert0 : \
- xdoc/base.pcert0 \
- xdoc/book-thms.pcert0 \
- xdoc/portcullis.pcert0 \
- xdoc/top.lisp \
- xdoc/cert.acl2
-xdoc/top.pcert1 : acl2x = 0
-xdoc/top.pcert1 : no_pcert = 0
-xdoc/top.pcert1 : xdoc/top.pcert0
-xdoc/top.cert : | xdoc/top.pcert1
-
-
-endif
-
diff -Nru acl2-6.2/books/Makefile-generic acl2-6.3/books/Makefile-generic
--- acl2-6.2/books/Makefile-generic 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/Makefile-generic 2013-09-30 17:53:32.000000000 +0000
@@ -1,4 +1,4 @@
-#; Support for Community Books to Go with ACL2 Version 6.2
+#; Support for ACL2 Community Books
#; Copyright (C) 2013, Regents of the University of Texas
#; This program is free software; you can redistribute it and/or
@@ -153,6 +153,7 @@
BOOKS_DX64FSL = $(patsubst %, %.dx64fsl, $(BOOKS_COMP))
BOOKS_LX64FSL = $(patsubst %, %.lx64fsl, $(BOOKS_COMP))
BOOKS_LX32FSL = $(patsubst %, %.lx32fsl, $(BOOKS_COMP))
+BOOKS_SSE2F = $(patsubst %, %.sse2f, $(BOOKS_COMP))
BOOKS_X86F = $(patsubst %, %.x86f, $(BOOKS_COMP))
BOOKS_O = $(patsubst %, %.o, $(BOOKS_COMP))
@@ -439,6 +440,15 @@
@echo "Making $$PWD/$@"
echo '(acl2::value :q) (acl2::lp) (ld `((include-book "$(patsubst %.lx32fsl,%,$(@))" :load-compiled-file :comp :ttags :all))) (acl2::value :q) (acl2::exit-lisp)' | $(ACL2)
+.PHONY: sse2f
+sse2f:
+ @echo 'Using ACL2=$(ACL2)'
+ $(MAKE) -s -f $(ACL2_BOOKS_MAKEFILE) $(BOOKS_SSE2F) INHIBIT='$(INHIBIT)' ACL2='$(ACL2)'
+
+%.sse2f: %.cert
+ @echo "Making $$PWD/$@"
+ echo '(acl2::value :q) (acl2::lp) (ld `((include-book "$(patsubst %.sse2f,%,$(@))" :load-compiled-file :comp :ttags :all))) (acl2::value :q) (acl2::exit-lisp)' | $(ACL2)
+
.PHONY: nothing
nothing:
@echo "There\'s a good reason to do this here."
diff -Nru acl2-6.2/books/Makefile-psubdirs acl2-6.3/books/Makefile-psubdirs
--- acl2-6.2/books/Makefile-psubdirs 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/Makefile-psubdirs 2013-09-30 17:53:32.000000000 +0000
@@ -1,4 +1,4 @@
-#; Support for Community Books to Go with ACL2 Version 6.2
+#; Support for ACL2 Community Books
#; Copyright (C) 2013, Regents of the University of Texas
#; This program is free software; you can redistribute it and/or
diff -Nru acl2-6.2/books/Makefile-subdirs acl2-6.3/books/Makefile-subdirs
--- acl2-6.2/books/Makefile-subdirs 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/Makefile-subdirs 2013-09-30 17:53:32.000000000 +0000
@@ -1,4 +1,4 @@
-#; Support for Community Books to Go with ACL2 Version 6.2
+#; Support for ACL2 Community Books
#; Copyright (C) 2013, Regents of the University of Texas
#; This program is free software; you can redistribute it and/or
diff -Nru acl2-6.2/books/Makefile.legacy acl2-6.3/books/Makefile.legacy
--- acl2-6.2/books/Makefile.legacy 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/Makefile.legacy 1970-01-01 00:00:00.000000000 +0000
@@ -1,1010 +0,0 @@
-#; Support for Community Books to Go with ACL2 Version 6.2
-#; Copyright (C) 2013, Regents of the University of Texas
-
-#; This program is free software; you can redistribute it and/or
-#; modify it under the terms of Version 2 of the GNU General Public
-#; License as published by the Free Software Foundation.
-
-#; This program is distributed in the hope that it will be useful,
-#; but WITHOUT ANY WARRANTY; without even the implied warranty of
-#; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-#; GNU General Public License for more details.
-
-#; You should have received a copy of the GNU General Public License
-#; along with this program; if not, write to the Free Software
-#; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-#; Written by: Matt Kaufmann and J Strother Moore
-#; email: Kaufmann@cs.utexas.edu and Moore@cs.utexas.edu
-#; Department of Computer Sciences
-#; University of Texas at Austin
-#; Austin, TX 78712-1188 U.S.A.
-
-# This file certifies books by directing appropriate subdirectories to
-# certify their books. The subsidiary Makefiles take advantage of a
-# makefile, Makefile-generic, in this directory, which is derived from
-# one written by Bishop Brock.
-
-# For example, to clean and time book certification (including workshops):
-# make clean all-plus
-
-# To see how one can certify the books in the regression suite using
-# waterfall parallelism (requires the experimental extension ACL2(p)
-# of ACL2), see file acl2-sources/acl2-customization-files/README.
-
-# We do not set variable ACL2 here, because the value here would be
-# overriden anyhow by the values in the subsidiary Makefiles, which get their
-# value from file Makefile-generic. However, ACL2 can be set on the command
-# line, e.g.:
-# make ACL2=acl2
-# make ACL2=/usr/local/bin/acl2 TIME=/usr/bin/time
-# make ACL2=/u/acl2/v2-9/acl2-sources/saved_acl2
-
-TIME = time
-
-# Avoid loading customization file unless environment variable is already set.
-# (This is also done in Makefile-generic, but we do it here in support of the
-# hons target.)
-export ACL2_CUSTOMIZATION ?= NONE
-
-# Directories go here; first those before certifying arithmetic/top-with-meta,
-# then those afterwards.
-
-# NOTE! This does *not* touch directory nonstd.
-
-# Note: arithmetic-4 could be added in analogy to arithmetic-5.
-
-DIRS1 = cowles arithmetic meta xdoc
-DIRS2_EXCEPT_WK_COI = ordinals data-structures bdd ihs arithmetic-2 arithmetic-3 arithmetic-5 \
- misc models/jvm/m1-original models/jvm/m1 models/jvm/m5 \
- proofstyles rtl arithmetic-3/extra sorting make-event parallel hints \
- fix-cert finite-set-theory finite-set-theory/osets powerlists textbook \
- defexec symbolic \
- data-structures/memories unicode str concurrent-programs/bakery \
- concurrent-programs/german-protocol deduction/passmore clause-processors \
- quadratic-reciprocity tools paco hacking security regex \
- defsort serialize wp-gen xdoc-impl system tutorial-problems \
- cutil cutil/tools countereg-gen demos leftist-trees taspi \
- std std/ks std/lists std/io std/alists std/typed-lists std/misc \
- oslib tau add-ons
-# Add directories other than centaur that depend on hons, say, for performance:
-HONS_ONLY_DIRS = models/y86 security/des
-ifdef ACL2_HONS_REGRESSION
-DIRS2_EXCEPT_WK_COI += $(HONS_ONLY_DIRS)
-endif
-DIRS2_EXCEPT_WK = $(DIRS2_EXCEPT_WK_COI) coi misc/misc2
-DIRS2 = $(DIRS2_EXCEPT_WK) workshops
-SHORTDIRS2 = ordinals data-structures bdd
-
-# If ACL2_CENTAUR is already set then we leave it alone. Otherwise
-# we set ACL2_CENTAUR to `before' to obtain extra parallelism via the
-# centaur/ books unless specific directories are specified, in which
-# case we set ACL2_CENTAUR to `skip' to avoid certifying the centaur
-# books needlessly. (If a books directory depends on the centaur
-# books, then its dependency should be recorded among the long list of
-# dependencies below.)
-ifdef ACL2_BOOK_DIRS
-ifndef ACL2_CENTAUR
-ACL2_CENTAUR ?= skip
-endif
-else
-ACL2_CENTAUR ?= before
-# The following can be any subset of DIRS2, and can be set by the user
-# on the command line, e.g., from the ACL2 sources directory:
-# make -j 8 regression ACL2_BOOK_DIRS='symbolic paco'
-# The directory dependencies (below) should guarantee that all
-# necessary supporting directories are made before the ones specified
-# explicitly in ACL2_BOOK_DIRS.
-ACL2_BOOK_DIRS := $(DIRS2)
-endif
-
-ALL_PLUS_DIRS = $(DIRS1) $(ACL2_BOOK_DIRS)
-
-ifdef ACL2
- ACL2_FOR_HONS ?= $(ACL2)
- ACL2_FOR_CENTAUR ?= $(ACL2)
-else
- ACL2_FOR_HONS ?= $(shell cd .. ; pwd)/saved_acl2h
- ACL2_FOR_CENTAUR ?= $(shell cd .. ; pwd)/saved_acl2
-ifdef ACL2_HONS_REGRESSION
-# and ACL2 not defined
- export ACL2 = $(shell cd .. ; pwd)/saved_acl2h
-endif
-endif
-
-# Since we have specified that ACL2_BOOK_DIRS is to be a subset of
-# DIRS2, we don't need to add it explicitly on the next line.
-.PHONY: $(DIRS1) $(DIRS2)
-
-# Same as all-plus below, using DIRS2_EXCEPT_WK instead of DIRS2. Much faster! Omits
-# books less likely to be needed, in particular, under workshops/.
-all:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-aux
-
-
-# Next, specify all of the directory dependencies. At this point we do this
-# manually by inspecting the Makefiles.
-
-arithmetic: cowles
-data-structures: arithmetic
-meta: arithmetic
-ordinals: top-with-meta-cert
-ihs: arithmetic data-structures
-misc: data-structures top-with-meta-cert ordinals arithmetic ihs arithmetic-2 arithmetic-3 std/lists
-make-event: misc arithmetic-3 arithmetic rtl
-arithmetic-2: ihs
-rtl: arithmetic meta top-with-meta-cert ordinals ihs misc arithmetic-2
-# arithmetic-3 has no dependencies (but see arithmetic-3/extra)
-arithmetic-3/extra: arithmetic-3 ihs rtl arithmetic-2 arithmetic-3
-# arithmetic-5 has no dependencies
-finite-set-theory: arithmetic ordinals
-finite-set-theory/osets: unicode tools
-powerlists: arithmetic ordinals data-structures
-textbook: arithmetic top-with-meta-cert ordinals ihs
-defexec: arithmetic misc ordinals
-symbolic: arithmetic arithmetic-2 data-structures ihs misc ordinals models/jvm/m5
-data-structures/memories: arithmetic-3 misc
-unicode: arithmetic arithmetic-3 ihs ordinals tools misc system std/io std/lists std/ks
-proofstyles: arithmetic-2 ordinals misc top-with-meta-cert
-concurrent-programs/bakery: misc ordinals
-concurrent-programs/german-protocol: misc
-deduction/passmore:
-serialize: tools
-clause-processors: top-with-meta-cert arithmetic-3 textbook arithmetic \
- misc tools data-structures arithmetic-5 system parallel system
-quadratic-reciprocity: rtl
-misc/misc2: rtl coi top-with-meta-cert
-hints: misc
-models/jvm/m1-original: arithmetic-3/extra
-models/jvm/m1: arithmetic-5
-models/jvm/m5: top-with-meta-cert ordinals misc ihs
-# models/jvm/m5 is needed for paco/books, not paco
-models/X86: tools arithmetic-5 arithmetic misc rtl defexec
-paco: ihs ordinals top-with-meta-cert
-hacking: misc
-parallel: make-event tools
-security: misc arithmetic-3 arithmetic-5
-security/des: security misc centaur
-sorting: arithmetic-3/extra
-tools: arithmetic-5 misc xdoc
-regex: tools cutil str misc
-defsort: misc tools std/lists
-str: arithmetic defsort tools xdoc misc std/ks
-coi: arithmetic arithmetic-2 arithmetic-3 data-structures ihs make-event \
- misc ordinals rtl
-wp-gen: ordinals
-# xdoc has no dependencies
-xdoc-impl: xdoc str tools finite-set-theory/osets
-system: tools arithmetic arithmetic-5 misc
-std/lists: arithmetic top-with-meta-cert xdoc
-std/alists: std/lists tools
-std/typed-lists: std/lists cutil arithmetic
-std/ks: std/lists ihs arithmetic xdoc std/misc
-std/io: tools xdoc system std/lists std/ks arithmetic ihs arithmetic-3
-std/misc: std/lists ihs top-with-meta-cert xdoc
-cutil: xdoc xdoc-impl tools str misc finite-set-theory/osets \
- defsort unicode clause-processors system top-with-meta-cert
-cutil/tools: cutil tools
-countereg-gen: xdoc arithmetic-5 tools defexec finite-set-theory/osets \
- arithmetic-3 arithmetic ordinals
-leftist-trees: arithmetic-5 sorting
-demos: make-event cutil misc tools arithmetic
-taspi: misc arithmetic-3
-models/y86: tools centaur misc arithmetic-5 rtl arithmetic defexec
-oslib: cutil str tools misc
-tau: arithmetic-5
-add-ons: arithmetic misc hacking
-
-# Let us wait for everything else before workshops. Starting after
-# Version_4.3 we include the coi books, because of
-# workshops/2006/pike-shields-matthews/.
-workshops: $(DIRS1) $(DIRS2_EXCEPT_WK)
-
-$(DIRS1):
- @if [ -f $@/Makefile ]; then cd $@ ; $(MAKE) ; fi
-
-$(DIRS2): top-with-meta-cert
- @if [ -f $@/Makefile ]; then cd $@ ; $(MAKE) ; fi
-
-.PHONY: all-aux
-all-aux: $(DIRS1) $(DIRS2_EXCEPT_WK)
-
-# Certify all books that need certification. If you want to get a
-# total time for certifying all books, then first do "make clean". By
-# default we do the centaur books first, because one of them might
-# support a non-centaur book. This is quite a commitment: henceforth,
-# the regression could in theory fail if we remove the centaur books
-# (say, because someone has a problem with Perl). We'll face that
-# problem if it occurs; for example, we could remove the "offending"
-# directory from DIRS2_EXCEPT_WK_COI, or we could use
-# ACL2_CENTAUR=skip on the command line.
-
-.PHONY: all-plus centaur
-
-ifeq ($(ACL2_CENTAUR),before)
-all-plus: $(ALL_PLUS_DIRS)
-$(ALL_PLUS_DIRS): centaur
-else
-ifeq ($(ACL2_CENTAUR),after)
-all-plus: centaur
-centaur: $(ALL_PLUS_DIRS)
-else
-all-plus: $(ALL_PLUS_DIRS)
-endif
-endif
-
-.PHONY: hons clean-hons
-# For a parallel "make hons", use e.g.:
-# make hons ACL2_HONS_OPT="-j4"
-# In general, ACL2_HONS_OPT is passed to the cert.pl command in centaur/.
-# Note that this variable is set automatically in ../GNUmakefile using
-# ACL2_JOBS.
-hons:
- ./cert.pl --targets regression-hons-targets \
- $(ACL2_HONS_OPT) \
- --acl2-books "`pwd`" \
- --acl2 $(ACL2_FOR_HONS)
-
-# WARNING: clean-hons will clean everywhere relevant to books/centaur/ under
-# the books/ directory, not merely under books/centaur/.
-clean-hons:
- rm -rf centaur/manual
- ./cert.pl -c centaur/doc.lisp \
- $(ACL2_HONS_OPT) \
- --acl2-books "`pwd`" \
- -q
- cd taspi/ ; make clean
-
-# Clean all books, not only the "basic" ones.
-.PHONY: clean
-clean:
- @for dir in $(DIRS1) $(DIRS2) $(HONS_ONLY_DIRS) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) FAST_DEPS_FOR_CLEAN=1 clean ; \
- cd ..) ; \
- fi \
- done
-
-# See instructions for hons above -- except we expect to use the
-# centaur target with vanilla ACL2, as opposed to ACL2(h).
-centaur:
- ./cert.pl --targets regression-centaur-targets \
- $(ACL2_HONS_OPT) \
- --acl2-books "`pwd`" \
- --acl2 $(ACL2_FOR_CENTAUR)
-
-# WARNING: clean-centaur will clean everywhere relevant to books/centaur/ under
-# the books/ directory, not merely under books/centaur/.
-.PHONY: clean-centaur
-ifeq ($(ACL2_CENTAUR),skip)
-clean-centaur:
- @echo "Skipping actions for clean-centaur."
-else
-clean-centaur:
- rm -rf centaur/manual
- ./cert.pl -c centaur/doc.lisp \
- $(ACL2_HONS_OPT) \
- --acl2-books "`pwd`" \
- -q
-endif
-
-.PHONY: clean
-clean: clean-centaur
-
-# Tar up books and support, not including workshops or nonstd stuff.
-.PHONY: tar
-tar:
- tar cvf books.tar Makefile Makefile-generic Makefile-subdirs README README.html certify-numbers.lsp $(DIRS1) $(DIRS2_EXCEPT_WK)
-
-# The following "short" targets allow for a relatively short test, in response
-# to a request from GCL maintainer Camm Maguire.
-
-.PHONY: short-clean
-short-clean:
- @rm -f short-test.log
- @for dir in $(DIRS1) $(SHORTDIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) clean ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: short-test-aux
-short-test-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) all ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-cert
- @for dir in $(SHORTDIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) all ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: short-test
-short-test:
- @rm -f short-test.log
- $(MAKE) -f Makefile.legacy short-clean
- $(MAKE) -f Makefile.legacy short-test-aux > short-test.log 2> short-test.log
- @if [ ! -f short-test.log ] || (fgrep '**' short-test.log > /dev/null) ; then \
- (echo 'Short test failed!' ; exit 1) ; else \
- echo 'Short test passed.' ; fi
-
-# The following target is primarily for developers to be able to check
-# well-formedness of the ACL2 world after including each book.
-# WARNING: Be sure to run "make regression" first!
-# The explicit make of top-with-meta.cert is there in order to avoid
-# removing that file after the .bkchk.out file is made (which
-# otherwise happens, somehow!).
-
-.PHONY: chk-include-book-worlds-top
-chk-include-book-worlds-top:
- @(cd system ; $(MAKE) ; cd ..)
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) chk-include-book-worlds ; \
- cd ..) ; \
- fi \
- done
- @(cd arithmetic/ ; $(MAKE) -f ../Makefile-generic top-with-meta.cert ; cd ..)
- @(cd arithmetic/ ; $(MAKE) -f ../Makefile-generic top-with-meta.bkchk.out ; cd ..)
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) chk-include-book-worlds ; \
- cd ..) ; \
- fi \
- done
-
-# The targets below create compiled files for books that may have
-# already been certified in another lisp (.fasl files for all-fasl,
-# etc.). Of course, the underlying lisp of the ACL2 that is run
-# should agree with the desired compiled file extension.
-# IMPORTANT: In order to use the targets below, you will first need to
-# have certified saving expansion files, e.g. with the following 'make'
-# argument.
-# ACL2_SAVE_EXPANSION=t
-
-.PHONY: fasl
-fasl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy fasl-aux ; date
-
-.PHONY: fasl-aux
-fasl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) fasl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-fasl
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) fasl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: fas
-fas:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy fas-aux ; date
-
-.PHONY: fas-aux
-fas-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) fas ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-fas
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) fas ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: sparcf
-sparcf:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy sparcf-aux ; date
-
-.PHONY: sparcf-aux
-sparcf-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) sparcf ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-sparcf
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) sparcf ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: ufsl
-ufsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy ufsl-aux ; date
-
-.PHONY: ufsl-aux
-ufsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) ufsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-ufsl
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) ufsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: 64ufasl
-64ufasl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy 64ufasl-aux ; date
-
-.PHONY: 64ufasl-aux
-64ufasl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) 64ufasl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-64ufasl
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) 64ufasl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: x86f
-x86f:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy x86f-aux ; date
-
-.PHONY: x86f-aux
-x86f-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) x86f ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-x86f
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) x86f ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: o
-o:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy o-aux ; date
-
-.PHONY: o-aux
-o-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) o ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-o
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) o ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: dfsl
-dfsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy dfsl-aux ; date
-
-.PHONY: dfsl-aux
-dfsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) dfsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-dfsl
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) dfsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: d64fsl
-d64fsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy d64fsl-aux ; date
-
-.PHONY: d64fsl-aux
-d64fsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) d64fsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-d64fsl
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) d64fsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: dx64fsl
-dx64fsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy dx64fsl-aux ; date
-
-.PHONY: dx64fsl-aux
-dx64fsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) dx64fsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-dx64fsl
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) dx64fsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: lx64fsl
-lx64fsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy lx64fsl-aux ; date
-
-.PHONY: lx64fsl-aux
-lx64fsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) lx64fsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-lx64fsl
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) lx64fsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: lx32fsl
-lx32fsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy lx32fsl-aux ; date
-
-.PHONY: lx32fsl-aux
-lx32fsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) lx32fsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-lx32fsl
- @for dir in $(DIRS2_EXCEPT_WK) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) lx32fsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-fasl
-all-fasl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-fasl-aux ; date
-
-.PHONY: all-fasl-aux
-all-fasl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) fasl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-fasl
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) fasl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-fas
-all-fas:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-fas-aux ; date
-
-.PHONY: all-fas-aux
-all-fas-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) fas ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-fas
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) fas ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-sparcf
-all-sparcf:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-sparcf-aux ; date
-
-.PHONY: all-sparcf-aux
-all-sparcf-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) sparcf ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-sparcf
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) sparcf ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-ufsl
-all-ufsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-ufsl-aux ; date
-
-.PHONY: all-ufsl-aux
-all-ufsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) ufsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-ufsl
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) ufsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-64ufasl
-all-64ufasl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-64ufasl-aux ; date
-
-.PHONY: all-64ufasl-aux
-all-64ufasl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) 64ufasl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-64ufasl
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) 64ufasl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-x86f
-all-x86f:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-x86f-aux ; date
-
-.PHONY: all-x86f-aux
-all-x86f-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) x86f ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-x86f
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) x86f ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-dfsl
-all-dfsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-dfsl-aux ; date
-
-.PHONY: all-dfsl-aux
-all-dfsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) dfsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-dfsl
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) dfsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-d64fsl
-all-d64fsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-d64fsl-aux ; date
-
-.PHONY: all-d64fsl-aux
-all-d64fsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) d64fsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-d64fsl
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) d64fsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-dx64fsl
-all-dx64fsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-dx64fsl-aux ; date
-
-.PHONY: all-dx64fsl-aux
-all-dx64fsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) dx64fsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-dx64fsl
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) dx64fsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-lx64fsl
-all-lx64fsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-lx64fsl-aux ; date
-
-.PHONY: all-lx64fsl-aux
-all-lx64fsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) lx64fsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-lx64fsl
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) lx64fsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-lx32fsl
-all-lx32fsl:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-lx32fsl-aux ; date
-
-.PHONY: all-lx32fsl-aux
-all-lx32fsl-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) lx32fsl ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-lx32fsl
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) lx32fsl ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: all-o
-all-o:
- @date ; $(TIME) $(MAKE) -f Makefile.legacy all-o-aux ; date
-
-.PHONY: all-o-aux
-all-o-aux:
- @for dir in $(DIRS1) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) o ; \
- cd ..) ; \
- fi \
- done
- @$(MAKE) -f Makefile.legacy top-with-meta-o
- @for dir in $(DIRS2) ; \
- do \
- if [ -f $$dir/Makefile ]; then \
- (cd $$dir ; \
- $(MAKE) o ; \
- cd ..) ; \
- fi \
- done
-
-.PHONY: top-with-meta-cert
-top-with-meta-cert: $(DIRS1)
- @echo "Using ACL2=$(ACL2)"
- cd arithmetic ; $(MAKE) top-with-meta.cert
-
-.PHONY: top-with-meta-o
-top-with-meta-o:
- cd arithmetic ; $(MAKE) top-with-meta.o
-
-.PHONY: top-with-meta-fasl
-top-with-meta-fasl:
- cd arithmetic ; $(MAKE) top-with-meta.fasl
-
-.PHONY: top-with-meta-fas
-top-with-meta-fas:
- cd arithmetic ; $(MAKE) top-with-meta.fas
-
-.PHONY: top-with-meta-sparcf
-top-with-meta-sparcf:
- cd arithmetic ; $(MAKE) top-with-meta.sparcf
-
-.PHONY: top-with-meta-ufsl
-top-with-meta-ufsl:
- cd arithmetic ; $(MAKE) top-with-meta.ufsl
-
-.PHONY: top-with-meta-64ufasl
-top-with-meta-64ufasl:
- cd arithmetic ; $(MAKE) top-with-meta.64ufasl
-
-.PHONY: top-with-meta-x86f
-top-with-meta-x86f:
- cd arithmetic ; $(MAKE) top-with-meta.x86f
-
-.PHONY: top-with-meta-dfsl
-top-with-meta-dfsl:
- cd arithmetic ; $(MAKE) top-with-meta.dfsl
-
-.PHONY: top-with-meta-d64fsl
-top-with-meta-d64fsl:
- cd arithmetic ; $(MAKE) top-with-meta.d64fsl
-
-.PHONY: top-with-meta-dx64fsl
-top-with-meta-dx64fsl:
- cd arithmetic ; $(MAKE) top-with-meta.dx64fsl
-
-.PHONY: top-with-meta-lx64fsl
-top-with-meta-lx64fsl:
- cd arithmetic ; $(MAKE) top-with-meta.lx64fsl
-
-.PHONY: top-with-meta-lx32fsl
-top-with-meta-lx32fsl:
- cd arithmetic ; $(MAKE) top-with-meta.lx32fsl
diff -Nru acl2-6.2/books/README acl2-6.3/books/README
--- acl2-6.2/books/README 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/README 2013-09-30 17:53:32.000000000 +0000
@@ -1 +1,2 @@
Please point your browser at Readme.html in this directory.
+
diff -Nru acl2-6.2/books/README-svn acl2-6.3/books/README-svn
--- acl2-6.2/books/README-svn 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/README-svn 2013-09-30 17:53:32.000000000 +0000
@@ -91,9 +91,9 @@
To create a branch from the trunk:
-svn copy -m 'Make initial release branch for Version 6.2.' \
+svn copy -m 'Make initial release branch for Version 6.3.' \
https://acl2-books.googlecode.com/svn/trunk \
- https://acl2-books.googlecode.com/svn/branches/6.2
+ https://acl2-books.googlecode.com/svn/branches/6.3
To create a tag is the same operation (note from Matt K.: Not sure we
ever need to create a tag); the only difference is the convention that
@@ -101,35 +101,35 @@
directories under tags are treated as write-once "markers" for a
certain revision.
-svn copy -m 'Release branch corresponding to actual ACL2 6.2 release.' \
- https://acl2-books.googlecode.com/svn/branches/6.2 \
- https://acl2-books.googlecode.com/svn/tags/6.2
+svn copy -m 'Release branch corresponding to actual ACL2 6.3 release.' \
+ https://acl2-books.googlecode.com/svn/branches/6.3 \
+ https://acl2-books.googlecode.com/svn/tags/6.3
If ever you want to make a branch/tag from a specific revision (i.e.
not the latest), you can do something like (note the @660):
-svn copy -m 'Release branch corresponding to actual ACL2 6.2 release.' \
- https://acl2-books.googlecode.com/svn/branches/6.2@660 \
- https://acl2-books.googlecode.com/svn/tags/6.2
+svn copy -m 'Release branch corresponding to actual ACL2 6.3 release.' \
+ https://acl2-books.googlecode.com/svn/branches/6.3@660 \
+ https://acl2-books.googlecode.com/svn/tags/6.3
For an ACL2 developer, the next step is to remember the current
version number for the books -- below, we assume it is 663.
cd /projects/acl2/devel/books/
-svn switch https://acl2-books.googlecode.com/svn/branches/6.2
+svn switch https://acl2-books.googlecode.com/svn/branches/6.3
Now switch back to the trunk AFTER the release is complete,
substituting "663" below by the number saved above (where "663" is
mentioned):
cd /projects/acl2/devel/books/
-# While still in 6.2:
-svn commit -m "Updates made for release committed to 6.2 branch"
+# While still in 6.3:
+svn commit -m "Updates made for release committed to 6.3 branch"
# Now switch over to trunk
svn switch https://acl2-books.googlecode.com/svn/trunk
svn update
-svn merge -r 663:HEAD https://acl2-books.googlecode.com/svn/branches/6.2 .
+svn merge -r 663:HEAD https://acl2-books.googlecode.com/svn/branches/6.3 .
svn commit -m "Updates made for release committed to trunk"
Then resolve any conflicts.
@@ -161,9 +161,9 @@
working copy directory, run the following command, with appropriately
chosen revision numbers:
- svn merge -r 663:HEAD https://acl2-books.googlecode.com/svn/branches/6.2 .
+ svn merge -r 663:HEAD https://acl2-books.googlecode.com/svn/branches/6.3 .
- This takes the diff between revisions 663 and HEAD of the 6.2 branch
+ This takes the diff between revisions 663 and HEAD of the 6.3 branch
and applies it to your current working copy (no change is committed to
the repository yet.) Again, it will notify you of conflicts if it
encounters any. Note to ACL2 developers: Resolve those, if any, and
@@ -174,6 +174,6 @@
Note that if desired, you can check out a working copy of the branch
in the usual way:
-svn checkout https://acl2-books.googlecode.com/svn/branches/6.2 my-new-books-dir
+svn checkout https://acl2-books.googlecode.com/svn/branches/6.3 my-new-books-dir
============================================================
diff -Nru acl2-6.2/books/Readme.html acl2-6.3/books/Readme.html
--- acl2-6.2/books/Readme.html 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/Readme.html 2013-09-30 17:53:32.000000000 +0000
@@ -57,6 +57,7 @@
arithmetic-3 .
bdd : books that exercise ACL2's BDD mechanism.
+ccg : automated termination analyisis.
centaur : books contributed by Centaur formal
verification folks;
see centaur/README
@@ -65,6 +66,7 @@
certify the cowles
and arithmetic
books when
not using make, e.g., for example, when using a Macintosh.
+cgen : support for counterexample generation
clause-processors : examples of the use of
clause processors (e.g., external tools)
coi : The coi books comprise a "shelf" of ACL2
@@ -73,7 +75,6 @@
concurrent-programs : contributions by
Sandip Ray (see Readme.lsp files in subdirectories)
-countereg-gen : support for counterexample generation
cowles : support for arithmetic books
cutil : Centaur Basic Utilities
data-structures : books for common data
@@ -89,10 +90,6 @@
trust tags to modify or extend core ACL2 behavior
hints : tests of hints, especially :or
and
:custom
hints
-hons-archive : Implements Hons Archives
-(HARs), which are a way to write ACL2 objects to disk so they can be
-loaded in other ACL2 sessions.
-
ihs : ``integer hardware specification'', integer
arithmetic appropriate for hardware modeling
interface : utilities providing Emacs support for
@@ -102,6 +99,8 @@
make-event
, which implements the idea of macros that can take state
memoize : a descendant of the memoization scheme developed by Bob Boyer and Warren A. Hunt, Jr., which was incorporated into ACL2(h)
meta : metafunctions for arithmetic
+milawa : a "self-verifying" theorem prover for an ACL2-like logic, developed
+by Jared Davis for his Ph.D. dissertation.
misc : a grab-bag of useful books and
utilities
models : models, especially of digital systems, with associated proofs
@@ -117,6 +116,7 @@
pedagogical use.
parallel : example use of primitives for
parallelism (with speed-up only in experimental extension that supports parallel evaluation)
+parsers : parsers
powerlists : a data-structure suited to the analysis of recursive,
data-parallel algorithms.
proofstyles : Soundness and completeness of
@@ -149,6 +149,7 @@
HREF="http://www.cs.utexas.edu/users/moore/publications/acl2-books/car/index.html">Computer-Aided
Reasoning: An Approach
tools : macros and tools designed to make common constructs easier and less verbose to write
+translators : translators to and from ACL2
tutorial-problems : solutions to
exercises of a tutorial nature
unicode : help for reading input from files
@@ -189,24 +190,14 @@
-The instructions below assume that you are standing in subdirectory
-books
of the ACL2 distribution.
+Instructions for certifying the ACL2 community books may be found in
+the folllowing ACL2 documentation topic: BOOKS-CERTIFICATION .
-
+
-To certify the ACL2 community books, execute a command such as one of
-the following. In the first case, we assume that if environment
-variable named "ACL2
" is defined then it specifies your
-ACL2 executable, and otherwise the command "acl2
" invokes
-your ACL2 executable. In the second and third cases, we define such
-an environment variable on the command line, where in the second case
-we assume that my_acl2
is on your path.
-
-make
-make ACL2=my_acl2
-make ACL2=/u/smith/bin/my_acl2
-
-To certify more books,
+If you obtained your books from a gzipped tarfile (typically
+named books-*.tar.gz
), as opposed to svn, then you don't
+yet have the workshops books. If you want them, simply
download
workshops.tar.gz to your acl2-sources/books/ directory, and
then gunzip and extract it there.
diff -Nru acl2-6.2/books/april-fools.txt acl2-6.3/books/april-fools.txt
--- acl2-6.2/books/april-fools.txt 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/april-fools.txt 1970-01-01 00:00:00.000000000 +0000
@@ -1 +0,0 @@
-5
diff -Nru acl2-6.2/books/arithmetic/nat-listp.lisp acl2-6.3/books/arithmetic/nat-listp.lisp
--- acl2-6.2/books/arithmetic/nat-listp.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic/nat-listp.lisp 2013-09-30 17:52:17.000000000 +0000
@@ -20,51 +20,55 @@
;; symbol-listp, etc, in that it implies true-listp.
(in-package "ACL2")
+(include-book "xdoc/top" :dir :system)
+(in-theory (disable nat-listp))
-(defund nat-listp (l)
- (declare (xargs :guard t))
- (cond ((atom l)
- (eq l nil))
- (t (and (natp (car l))
- (nat-listp (cdr l))))))
-
-(local (in-theory (enable nat-listp)))
-
-(defthm nat-listp-implies-true-listp
- (implies (nat-listp x)
- (true-listp x))
- :rule-classes (:rewrite :compound-recognizer))
-
-(in-theory (disable (:rewrite nat-listp-implies-true-listp)))
-
-(defthm nat-listp-when-not-consp
- (implies (not (consp x))
- (equal (nat-listp x)
- (not x)))
- :hints(("Goal" :in-theory (enable nat-listp))))
-
-(defthm nat-listp-of-cons
- (equal (nat-listp (cons a x))
- (and (natp a)
- (nat-listp x)))
- :hints(("Goal" :in-theory (enable nat-listp))))
-
-(defthm nat-listp-of-append-weak
- ;; [Jared] added "weak" in support of std/typed-lists/nat-listp
- (implies (true-listp x)
- (equal (nat-listp (append x y))
- (and (nat-listp x)
- (nat-listp y)))))
-
-(defthm car-nat-listp
- (implies (and (nat-listp x)
- x)
- (natp (car x)))
- :rule-classes :forward-chaining)
-
-(defthm nat-listp-of-cdr-when-nat-listp
- ;; [Jared] added double-rewrite in support of std/typed-lists/nat-listp
- (implies (nat-listp (double-rewrite x))
- (equal (nat-listp (cdr x))
- t)))
+(defsection arithmetic/nat-listp
+ :parents (nat-listp)
+ :short "Lemmas about @(see nat-listp) available in the @('arithmetic/nat-listp')
+book."
+
+ :long "BOZO additional lemmas about @('nat-listp') are available in the
+book @(see std/typed-list/nat-listp), which subsumes this one. Should we get
+rid of this book?
"
+
+ (local (in-theory (enable nat-listp)))
+
+ (defthm nat-listp-implies-true-listp
+ (implies (nat-listp x)
+ (true-listp x))
+ :rule-classes (:rewrite :compound-recognizer))
+
+ (in-theory (disable (:rewrite nat-listp-implies-true-listp)))
+
+ (defthm nat-listp-when-not-consp
+ (implies (not (consp x))
+ (equal (nat-listp x)
+ (not x)))
+ :hints(("Goal" :in-theory (enable nat-listp))))
+
+ (defthm nat-listp-of-cons
+ (equal (nat-listp (cons a x))
+ (and (natp a)
+ (nat-listp x)))
+ :hints(("Goal" :in-theory (enable nat-listp))))
+
+ (defthm nat-listp-of-append-weak
+ ;; [Jared] added "weak" in support of std/typed-lists/nat-listp
+ (implies (true-listp x)
+ (equal (nat-listp (append x y))
+ (and (nat-listp x)
+ (nat-listp y)))))
+
+ (defthm car-nat-listp
+ (implies (and (nat-listp x)
+ x)
+ (natp (car x)))
+ :rule-classes :forward-chaining)
+
+ (defthm nat-listp-of-cdr-when-nat-listp
+ ;; [Jared] added double-rewrite in support of std/typed-lists/nat-listp
+ (implies (nat-listp (double-rewrite x))
+ (equal (nat-listp (cdr x))
+ t))))
diff -Nru acl2-6.2/books/arithmetic-3/bind-free/collect.lisp acl2-6.3/books/arithmetic-3/bind-free/collect.lisp
--- acl2-6.2/books/arithmetic-3/bind-free/collect.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-3/bind-free/collect.lisp 2013-09-30 17:52:17.000000000 +0000
@@ -320,12 +320,24 @@
(t
(- (expt x (- m n))))))))
-(defthm |(* (expt c n) (expt d n))|
- (implies (and (integerp n)
- (syntaxp (quotep c))
- (syntaxp (quotep d)))
- (equal (collect-* (expt c n) (expt d n))
- (expt (* c d) n))))
+
+
+;; [Jared]: removing this rule:
+;;
+;; (defthm |(* (expt c n) (expt d n))|
+;; (implies (and (integerp n)
+;; (syntaxp (quotep c))
+;; (syntaxp (quotep d)))
+;; (equal (collect-* (expt c n) (expt d n))
+;; (expt (* c d) n))))
+;;
+;; Because above we have the same thing without syntaxp hyps, except with
+;; slightly different names:
+;;
+;; (defthm |(* (expt x n) (expt y n))|
+;; (implies (integerp n)
+;; (equal (collect-* (expt x n) (expt y n))
+;; (expt (* x y) n))))
(defthm |(collect-* y x)|
(equal (collect-* y x)
diff -Nru acl2-6.2/books/arithmetic-3/bind-free/normalize.lisp acl2-6.3/books/arithmetic-3/bind-free/normalize.lisp
--- acl2-6.2/books/arithmetic-3/bind-free/normalize.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-3/bind-free/normalize.lisp 2013-09-30 17:52:17.000000000 +0000
@@ -186,37 +186,43 @@
(t
nil)))
-(defthm test381
- (implies (and (true-list-listp x)
- (true-list-listp y))
- (true-list-listp (revappend x y))))
-
-(defthm test382
- (implies (true-listp x)
- (true-listp (append a x))))
-
-(defthm test392
- (implies (and (pseudo-termp denominator)
- (true-listp factors)
- (true-list-listp to-be-found))
- (true-list-listp (to-be-found denominator
- saved-denominator
- factors
- to-be-found))))
-
-(defthm test-302
- (implies (and (not (equal (car denominator) 'quote))
- (consp denominator)
- (pseudo-termp denominator))
- (pseudo-termp (cadr denominator)))
- :hints (("goal" :expand (pseudo-termp denominator))))
-
-(defthm test-303
- (implies (and (not (equal (car denominator) 'quote))
- (consp denominator)
- (pseudo-termp denominator))
- (pseudo-termp (caddr denominator)))
- :hints (("goal" :expand (pseudo-termp denominator))))
+
+;; [Jared] localizing since this seems like it should be local
+(local (defthm test381
+ (implies (and (true-list-listp x)
+ (true-list-listp y))
+ (true-list-listp (revappend x y)))))
+
+;; [Jared] localizing since this seems like it should be local
+(local (defthm test382
+ (implies (true-listp x)
+ (true-listp (append a x)))))
+
+;; [Jared] localizing since this seems like it should be local
+(local (defthm test392
+ (implies (and (pseudo-termp denominator)
+ (true-listp factors)
+ (true-list-listp to-be-found))
+ (true-list-listp (to-be-found denominator
+ saved-denominator
+ factors
+ to-be-found)))))
+
+;; [Jared] localizing since this seems like it should be local
+(local (defthm test-302
+ (implies (and (not (equal (car denominator) 'quote))
+ (consp denominator)
+ (pseudo-termp denominator))
+ (pseudo-termp (cadr denominator)))
+ :hints (("goal" :expand (pseudo-termp denominator)))))
+
+;; [Jared] localizing since this seems like it should be local
+(local (defthm test-303
+ (implies (and (not (equal (car denominator) 'quote))
+ (consp denominator)
+ (pseudo-termp denominator))
+ (pseudo-termp (caddr denominator)))
+ :hints (("goal" :expand (pseudo-termp denominator)))))
(defun denominatorp (denominator)
(declare (xargs :guard t))
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/arithmetic-theory.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/arithmetic-theory.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/arithmetic-theory.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/arithmetic-theory.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/banner.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/banner.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/banner.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/banner.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/basic.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/basic.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/basic.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/basic.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/building-blocks-helper.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/building-blocks-helper.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/building-blocks-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/building-blocks-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/building-blocks.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/building-blocks.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/building-blocks.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/building-blocks.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/collect.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/collect.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/collect.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/collect.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/common.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/common.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/common.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/common.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/default-hint.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/default-hint.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/default-hint.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/default-hint.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/distributivity.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/distributivity.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/distributivity.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/distributivity.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/dynamic-e-d.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/dynamic-e-d.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/dynamic-e-d.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/dynamic-e-d.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/elim-hint.acl2 acl2-6.3/books/arithmetic-5/lib/basic-ops/elim-hint.acl2
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/elim-hint.acl2 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/elim-hint.acl2 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
(in-package "ACL2")
; cert-flags: ? t :ttags (the-ultimate-clause-processor-ttag)
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/elim-hint.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/elim-hint.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/elim-hint.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/elim-hint.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/expt-helper.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/expt-helper.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/expt-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/expt-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/expt.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/expt.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/expt.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/expt.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/forcing-types.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/forcing-types.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/forcing-types.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/forcing-types.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/if-normalization.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/if-normalization.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/if-normalization.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/if-normalization.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/integerp-helper.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/integerp-helper.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/integerp-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/integerp-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/integerp-meta.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/integerp-meta.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/integerp-meta.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/integerp-meta.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/integerp.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/integerp.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/integerp.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/integerp.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/mini-theories.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/mini-theories.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/mini-theories.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/mini-theories.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/natp-posp.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/natp-posp.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/natp-posp.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/natp-posp.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/normalize.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/normalize.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/normalize.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/normalize.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/numerator-and-denominator.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/numerator-and-denominator.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/numerator-and-denominator.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/numerator-and-denominator.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/remove-weak-inequalities.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/remove-weak-inequalities.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/remove-weak-inequalities.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/remove-weak-inequalities.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/simple-equalities-and-inequalities.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/simplify-helper.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/simplify-helper.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/simplify-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/simplify-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/simplify.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/simplify.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/simplify.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/simplify.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/top.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/top.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/top.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/top.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/types-helper.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/types-helper.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/types-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/types-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/types.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/types.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/types.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/types.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/basic-ops/we-are-here.lisp acl2-6.3/books/arithmetic-5/lib/basic-ops/we-are-here.lisp
--- acl2-6.2/books/arithmetic-5/lib/basic-ops/we-are-here.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/basic-ops/we-are-here.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/floor-mod-basic-helper.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/floor-mod-basic-helper.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/floor-mod-basic-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/floor-mod-basic-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/floor-mod-basic.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/floor-mod-basic.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/floor-mod-basic.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/floor-mod-basic.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/floor-mod-helper.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/floor-mod-helper.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/floor-mod-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/floor-mod-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/floor-mod.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/floor-mod.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/floor-mod.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/floor-mod.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/forcing-types.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/forcing-types.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/forcing-types.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/forcing-types.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/if-normalization.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/if-normalization.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/if-normalization.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/if-normalization.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/logand-helper.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/logand-helper.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/logand-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/logand-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/logand.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/logand.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/logand.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/logand.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/mod-expt-fast.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/mod-expt-fast.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/mod-expt-fast.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/mod-expt-fast.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/more-floor-mod.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/more-floor-mod.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/more-floor-mod.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/more-floor-mod.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/top.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/top.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/top.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/top.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/lib/floor-mod/truncate-rem.lisp acl2-6.3/books/arithmetic-5/lib/floor-mod/truncate-rem.lisp
--- acl2-6.2/books/arithmetic-5/lib/floor-mod/truncate-rem.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/lib/floor-mod/truncate-rem.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/arithmetic-5/support/basic-arithmetic-helper.lisp acl2-6.3/books/arithmetic-5/support/basic-arithmetic-helper.lisp
--- acl2-6.2/books/arithmetic-5/support/basic-arithmetic-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/support/basic-arithmetic-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;
;; basic-arithmetic-helper.lisp
@@ -21,6 +9,9 @@
;; RK 3/15/99 The following is copied from the books of Cowles
;; and adapted to the needs at hand.
+;; (Note from Matt Kaufmann: While this appears to be fair use,
+;; John Cowles has granted explicit permission for this in an
+;; email to me on 8/5/2013.)
(in-package "ACL2")
diff -Nru acl2-6.2/books/arithmetic-5/support/basic-arithmetic.lisp acl2-6.3/books/arithmetic-5/support/basic-arithmetic.lisp
--- acl2-6.2/books/arithmetic-5/support/basic-arithmetic.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/support/basic-arithmetic.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;
;; basic-arithmetic.lisp
diff -Nru acl2-6.2/books/arithmetic-5/support/expt-helper.lisp acl2-6.3/books/arithmetic-5/support/expt-helper.lisp
--- acl2-6.2/books/arithmetic-5/support/expt-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/support/expt-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;
;; expt-helper.lisp
diff -Nru acl2-6.2/books/arithmetic-5/support/expt.lisp acl2-6.3/books/arithmetic-5/support/expt.lisp
--- acl2-6.2/books/arithmetic-5/support/expt.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/support/expt.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;
;; expt.lisp
@@ -32,6 +20,9 @@
; Much of this is adapted from John Cowles's acl2-exp.lisp book.
; There are various modifications, however.
+; (Note from Matt Kaufmann: While this appears to be fair use,
+; John Cowles has granted explicit permission for this in an
+; email to me on 8/5/2013.)
(defthm expt-type-prescription-rationalp
(implies (real/rationalp r)
diff -Nru acl2-6.2/books/arithmetic-5/support/inequalities.lisp acl2-6.3/books/arithmetic-5/support/inequalities.lisp
--- acl2-6.2/books/arithmetic-5/support/inequalities.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/support/inequalities.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,20 +1,7 @@
-
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;
;; inequalities.lisp
diff -Nru acl2-6.2/books/arithmetic-5/support/mini-theories.lisp acl2-6.3/books/arithmetic-5/support/mini-theories.lisp
--- acl2-6.2/books/arithmetic-5/support/mini-theories.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/support/mini-theories.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;
;; mini-theories.lisp
diff -Nru acl2-6.2/books/arithmetic-5/support/non-linear.lisp acl2-6.3/books/arithmetic-5/support/non-linear.lisp
--- acl2-6.2/books/arithmetic-5/support/non-linear.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/support/non-linear.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
diff -Nru acl2-6.2/books/arithmetic-5/support/num-and-denom-helper.lisp acl2-6.3/books/arithmetic-5/support/num-and-denom-helper.lisp
--- acl2-6.2/books/arithmetic-5/support/num-and-denom-helper.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/support/num-and-denom-helper.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,13 @@
-; ACL2 Arithmetic Nonnegative Integer Mod and Gcd book.
-; Copyright (C) 1998 John R. Cowles, University of Wyoming
+; Arithmetic-5 Library, Robert Krug
+; This file Copyright (C) 1998 John R. Cowles, University of Wyoming
+; License:
+; As described in the LICENSE file at the top level of the arithmetic-5
+; library.
+; (Note from Matt Kaufmann:
+; John Cowles has granted explicit permission for this license in an
+; email to me on 8/5/2013.)
-; This book is free software; you can redistribute it and/or modify
-; it under the terms of the GNU General Public License as published by
-; the Free Software Foundation; either version 2 of the License, or
-; (at your option) any later version.
-
-; This book is distributed in the hope that it will be useful,
-; but WITHOUT ANY WARRANTY; without even the implied warranty of
-; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-; GNU General Public License for more details.
-
-; You should have received a copy of the GNU General Public License
-; along with this book; if not, write to the Free Software
-; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+; ACL2 Arithmetic Nonnegative Integer Mod and Gcd book.
; Written by:
; John Cowles
diff -Nru acl2-6.2/books/arithmetic-5/support/numerator-and-denominator.lisp acl2-6.3/books/arithmetic-5/support/numerator-and-denominator.lisp
--- acl2-6.2/books/arithmetic-5/support/numerator-and-denominator.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/support/numerator-and-denominator.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;
;; numerator-and-denominator.lisp
diff -Nru acl2-6.2/books/arithmetic-5/support/prefer-times.lisp acl2-6.3/books/arithmetic-5/support/prefer-times.lisp
--- acl2-6.2/books/arithmetic-5/support/prefer-times.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/support/prefer-times.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;
;; prefer-times.lisp
diff -Nru acl2-6.2/books/arithmetic-5/support/top.lisp acl2-6.3/books/arithmetic-5/support/top.lisp
--- acl2-6.2/books/arithmetic-5/support/top.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/support/top.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;
;; top.lisp
diff -Nru acl2-6.2/books/arithmetic-5/top.lisp acl2-6.3/books/arithmetic-5/top.lisp
--- acl2-6.2/books/arithmetic-5/top.lisp 2013-06-06 17:11:05.000000000 +0000
+++ acl2-6.3/books/arithmetic-5/top.lisp 2013-09-30 17:52:18.000000000 +0000
@@ -1,19 +1,7 @@
; Arithmetic-5 Library
-; Copyright (C) 2009 Robert Krug
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version.
-;
-; This program is distributed in the hope that it will be useful but WITHOUT
-; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
-; details.
-;
-; You should have received a copy of the GNU General Public License along with
-; this program; if not, write to the Free Software Foundation, Inc., 51
-; Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+; Written by Robert Krug
+; Copyright/License:
+; See the LICENSE file at the top level of the arithmetic-5 library.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
diff -Nru acl2-6.2/books/ccg/Makefile acl2-6.3/books/ccg/Makefile
--- acl2-6.2/books/ccg/Makefile 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/ccg/Makefile 2013-09-30 17:53:20.000000000 +0000
@@ -0,0 +1,2 @@
+include ../Makefile-generic
+-include Makefile-deps
diff -Nru acl2-6.2/books/ccg/README acl2-6.3/books/ccg/README
--- acl2-6.2/books/ccg/README 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/ccg/README 2013-09-30 17:53:20.000000000 +0000
@@ -0,0 +1,16 @@
+Book: CCG - Automated termination analysis
+Author: Daron Vroon
+
+To certify the books use the standard procedure i.e. make
+or use ../cert.pl ccg.cert ccg-settings-dependencies.cert
+
+To get CCG to do termination proofs, use the following two commands.
+
+(include-book "ccg" :ttags ((:ccg)) :load-compiled-file nil)
+(ld "ccg-settings.lsp")
+
+Documentation - :doc ccg
+
+See Readme.lsp for licensing and other information.
+
+
diff -Nru acl2-6.2/books/ccg/Readme.lsp acl2-6.3/books/ccg/Readme.lsp
--- acl2-6.2/books/ccg/Readme.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/ccg/Readme.lsp 2013-09-30 17:53:20.000000000 +0000
@@ -0,0 +1,53 @@
+((:FILES "
+.:
+ccg.lisp
+"
+)
+ (:TITLE "CCG Termination Analysis")
+ (:AUTHOR/S "Daron Vroon and Pete Manolios")
+ (:KEYWORDS ; non-empty list of keywords, case-insensitive
+ "book contributions" "contributed books"
+ "termination" "termination analysis"
+ "automated termination proofs"
+ )
+ (:ABSTRACT
+"Automated termination analysis based on Calling Context Graphs,
+developed as part of ACL2 Sedan.
+
+To use this book, use the event form shown at the bottom.
+CCG is configured by calling set-termination-method with a single
+parameter, which must be one of these:
+
+ :ccg - CCG analysis only (no measure-based proof attempt)
+ :measure - no CCG analysis (measure-based proofs only)
+
+Regardless of this or other settings, ACL2's built-in method will be
+used if an explicit measure is specified.
+
+Of course, any termination analysis is necessarily incomplete and
+eventually users may come across terminating functions that CCG
+analysis cannot prove terminating. When that happens, CCG analysis
+will construct a function that is as simple as possible, includes a
+subset of the looping behavior of the submitted function, and which
+CCG analysis cannot prove terminating. This function, along with
+several suggestions of how to help CCG analysis prove termination,
+will be presented to the user.
+
+Our CCG termination analysis is highly customizable and includes many
+features not mentioned here. For detailed documentation please refer
+to :doc ccg from inside a session.
+
+")
+ (:PERMISSION ; author/s permission for distribution and copying:
+"Copyright (C) 2010 Daron Vroon, Pete Manolios.
+License: A 3-clause BSD license.
+See the LICENSE file distributed with ACL2.
+"))
+
+#|
+(duplicated here from README)
+To enable CCG termination analysis:
+(include-book "ccg" :ttags ((:ccg)) :load-compiled-file nil)
+(ld "ccg-settings.lsp")
+
+|#
\ No newline at end of file
diff -Nru acl2-6.2/books/ccg/ccg-settings-dependencies.lisp acl2-6.3/books/ccg/ccg-settings-dependencies.lisp
--- acl2-6.2/books/ccg/ccg-settings-dependencies.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/ccg/ccg-settings-dependencies.lisp 2013-09-30 17:53:20.000000000 +0000
@@ -0,0 +1,7 @@
+
+(in-package "ACL2")
+
+(include-book "ordinals/lexicographic-ordering-without-arithmetic" :dir :system)
+
+
+
diff -Nru acl2-6.2/books/ccg/ccg-settings.lsp acl2-6.3/books/ccg/ccg-settings.lsp
--- acl2-6.2/books/ccg/ccg-settings.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/ccg/ccg-settings.lsp 2013-09-30 17:53:20.000000000 +0000
@@ -0,0 +1,26 @@
+
+
+;; Common events (found in ACL2s session modes)
+(include-book "ordinals/lexicographic-ordering-without-arithmetic" :dir :system)
+(set-well-founded-relation l<)
+(make-event ; use ruler-extenders if available
+ (if (member-eq 'ruler-extenders-lst
+ (getprop 'put-induction-info 'formals nil
+ 'current-acl2-world (w state)))
+ (value '(set-ruler-extenders :all))
+ (value '(value-triple :invisible))))
+
+
+;; CCG settings
+
+; dont be too verbose
+ (set-ccg-print-proofs nil)
+ (set-ccg-inhibit-output-lst
+ '(QUERY BASICS PERFORMANCE BUILD/REFINE SIZE-CHANGE))
+;remove any time limit on ccg termination proofs
+ (set-ccg-time-limit nil)
+
+
+
+; Use CCG to do termination proofs.
+(set-termination-method :ccg)
diff -Nru acl2-6.2/books/ccg/ccg.acl2 acl2-6.3/books/ccg/ccg.acl2
--- acl2-6.2/books/ccg/ccg.acl2 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/ccg/ccg.acl2 2013-09-30 17:53:20.000000000 +0000
@@ -0,0 +1,24 @@
+; cert-flags: ? nil :ttags (:ccg)
+
+; Here is a low-level explanation of the change by Matt Kaufmann, 8/4/2013, of
+; the third argument of certify-book (below) from t to nil:
+
+; We avoid compiling this book in order to avoid certification errors in some
+; Lisps (in particular, we have seen one in an ACL2(h) regression with
+; Lispworks), and to avoid errors when attempting to include this book in
+; perhaps every Lisp. It appears that the problem is with the use of
+; defmacro-raw, which calls assert-unbound to cause an error when such a
+; macro's definition is attempted while the macro is already defined. If you
+; save the expansion file (ccg@expansion.lsp) when attempting to certify this
+; book, using (assign save-expansion-file t), then you'll see that the macro
+; context-fn, defined by defmacro-raw, isn't mentioned in *hcomp-macro-alist*,
+; and hence isn't made undefined after an early load of the compiled file.
+; Indeed, if we look at the definition of defmacro-raw in hacking/raw.lisp,
+; we'll see that while there is some attempt to maintain the undo-stack
+; appropriately, there appears to be nothing that addresses the problem
+; mentioned above of failing to unbind the definition after early load of the
+; compiled file. I'm not sufficiently familiar with the hacking/ stuff to know
+; how best to fix this, but since trust tags are used, that's the
+; responsibility of whomever is maintaining these books.
+
+(certify-book "ccg" ? nil :ttags (:ccg))
diff -Nru acl2-6.2/books/ccg/ccg.lisp acl2-6.3/books/ccg/ccg.lisp
--- acl2-6.2/books/ccg/ccg.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/ccg/ccg.lisp 2013-09-30 17:53:20.000000000 +0000
@@ -0,0 +1,7670 @@
+#|$ACL2s-Preamble$;
+
+(begin-book t :ttags ((:ccg)));$ACL2s-Preamble$|#
+
+(in-package "ACL2")
+
+(defttag :ccg)
+
+; load in the expander book.
+
+(include-book "misc/expander" :dir :system)
+
+
+; load in Peter's hacker stuff. we use at least three things from this:
+; - add several keys to the acl2-defaults-table
+; - make raw Lisp definitions from an acl2 book, i.e. defstruct-raw,
+; defmacro-raw, and defun-raw
+; - bridge raw lisp and ACL2 so that we can access the raw Lisp code
+;
+(include-book "hacking/hacker" :dir :system)
+(progn+all-ttags-allowed
+ (include-book "hacking/all" :dir :system :ttags :all))
+(subsume-ttags-since-defttag)
+
+
+(defdoc CCG
+ ":Doc-Section CCG
+
+ a powerful automated termination prover for ACL2~/~/
+
+ In order to see how the CCG analysis works, consider the following
+ definition of Ackermann's function from exercise 6.15 in the ACL2 textbook:
+ ~bv[]
+ (defun ack (x y)
+ (if (zp x)
+ 1
+ (if (zp y)
+ (if (equal x 1) 2 (+ x 2))
+ (ack (ack (1- x) y) (1- y)))))
+ ~ev[]
+ ACL2 cannot automatically prove the termination of ~c[ack] using its
+ measure-based termination proof. In order to admit the function, the user
+ must supply a measure. An example measure is
+ ~c[(make-ord 1 (1+ (acl2-count y)) (acl2-count x))], which is equivalent to the ordinal
+ ~c[w * (1+ (acl2-count y)) + (acl2-count x)], where ~c[w] is the first infinite
+ ordinal.
+
+ The CCG analysis, on the other hand, automatically proves termination as
+ follows. Note that there are two recursive calls. These calls, along with
+ their rulers (i.e. the conditions under which the recursive call is reached)
+ are called ~em[calling contexts], or sometimes just ~em[contexts] (for more
+ on rulers, see ~il[ruler-extenders]). For
+ ~c[ack], these are:
+ ~bv[]
+ 1. (ack (1- x) y) with ruler ((not (zp x)) (not (zp y))).
+ 2. (ack (ack (1- x) y) (1- y)) with ruler ((not (zp x)) (not (zp y))).
+ ~ev[]
+ These calling contexts are used to build a ~em[calling context graph (CCG)],
+ from which our analysis derives its name. This graph has an edge from
+ context ~c[c1] to context ~c[c2] when it is possible that execution can move
+ from context ~c[c1] to context ~c[c2] in one ``step'' (i.e. without visiting
+ any other contexts). For our example, we get the complete graph, with edges
+ from each context to both contexts.
+
+ The analysis next attempts to guess ~em[calling context measures (CCMs)], or
+ just ~em[measures], for each function. These are similar to ACL2 measures,
+ in that they are ACL2 terms that must provably be able to evaluate to an
+ ordinal value (unlike ACL2 measures, CCG currently ignores the current
+ well-founded relation setting). However, functions may have multiple CCMs,
+ instead of one, like ACL2, and the CCG analysis has some more sophisticated
+ heuristics for guessing appropriate measures. However, there is a mechanism
+ for supplying measures to the CCG analysis if you need to ~pl[CCG-XARGS]. In
+ our example, the CCG analysis will guess the measures ~c[(acl2-count x)],
+ ~c[(acl2-count y)], and ~c[(+ (acl2-count x) (acl2-count y))]. This last one
+ turns out to be unimportant for the termination proof. However, note that
+ the first two of these measures are components of the ordinal measure that
+ we gave ACL2 to prove termination earlier. As one might guess, these are
+ important for the success of our CCG analysis.
+
+ Like ACL2's measure analysis, we are concerned with what happens to these
+ values when a recursive call is made. However, we are concerned not just
+ with decreasing measures, but also non-increasing measures. Thus, we
+ construct ~em[Calling Context Measure Functions (CCMFs)], which tell us how
+ one measure compares to another across recursive calls.
+
+ In our example, note that when the recursive call of the context 1 is made,
+ the new value of ~c[(acl2-count x)] is less than the original value of
+ ~c[(acl2-count x)]. More formally, we can prove the following:
+ ~bv[]
+ (implies (and (not (zp x))
+ (not (zp y)))
+ (o< (acl2-count (1- x))
+ (acl2-count x)))
+ ~ev[]
+ For those of you that are familiar with measure-based termination proofs in
+ ACL2, this should look familiar, as it has the same structure as such a
+ termination proof. However, we also note the following trivial observation:
+ ~bv[]
+ (implies (and (not (zp x))
+ (not (zp y)))
+ (o<= (acl2-count y)
+ (acl2-count y)))
+ ~ev[]
+ That is, ~c[y] stays the same across this recursive call. For the other
+ context, we similarly note that ~c[(acl2-count y)] is decreasing. However,
+ we can say nothing about the value of ~c[(acl2-count x)]. The CCG algorithm
+ does this analysis using queries to the theorem prover that are carefully
+ restricted to limit prover time.
+
+ Finally, the CCG analysis uses this local information to do a global
+ analysis of what happens to values. This analysis asks the question, for
+ every infinite path through our CCG, ~c[c_1], ~c[c_2], ~c[c_3], ..., is
+ there a natural number ~c[N] such that there is an infinite sequence of
+ measures ~c[m_N], ~c[m_(N+1)], ~c[m_(N+2)], ... such that each ~c[m_i] is a
+ measure for the context ~c[c_i] (i.e. a measure for the function containing
+ ~c[ci]), we have proven that the ~c[m_(i+1)] is never larger than ~c[m_i],
+ and for infinitely many ~c[i], it is the case that we have proven that
+ ~c[m_i] is always larger than ~c[m_(i+)]. That's a bit of a mouthful, but
+ what we are essentially saying is that, for every possible infinite sequence
+ of recursions it is the case that after some finite number of steps, we can
+ start picking out measures such that they never increase and infinitely
+ often they decrease. Since these measures return ordinal values, we then
+ know that there can be no infinite recursions, and we are done.
+
+ For our example, consider two kinds of infinite paths through our CCG: those
+ that visit context 2 infinitely often, and those that don't. In the first
+ case, we know that ~c[(acl2-count y)] is never increasing, since a visit to
+ context 1 does not change the value of ~c[y], and a visit to context 2
+ decreases the value of ~c[(acl2-count y)]. Furthermore, since we visit
+ context 2 infinitely often, we know that ~c[(acl2-count y)] is infinitely
+ decreasing along this path. Therefore, we have met the criteria for proving
+ no such path is a valid computation. In the case in which we do not visit
+ context 2 infinitely often, there must be a value ~c[N] such that we do not
+ visit context 2 any more after the ~c[N]th context in the path. After this,
+ we must only visit context 1, which always decreases the value of
+ ~c[(acl2-count x)]. Therefore, no such path can be a valid
+ computation. Since all infinite paths through our CCG either visit context 2
+ infinitely often or not, we have proven termination. This analysis of the
+ local data in the global context is done automatically by a decision
+ procedure.
+
+ That is a brief overview of the CCG analysis. Note that, can it prove many
+ functions terminating that ACL2 cannot. It also does so using simpler
+ measures. In the ~c[ack] example, we did not require any infinite ordinal
+ measures to prove termination using CCG. Intuitively, CCG is in a way
+ putting together the measures for you so you don't have to think about the
+ ordinal structure. Thus, even when the CCG analysis to prove termination, it
+ is often easier to give it multiple simple measures and allow it to put
+ together the global termination argument than to give ACL2 the entire
+ measure so it can prove that it decreases every single step.
+
+ To find out more about interacting and controlling the CCG analysis, see the
+ topics included in this section.")
+
+; BEGIN public configuration interface
+
+; add :termination-method key to acl2-defaults-table
+;
+; add-acl2-defaults-table-key is provided by my hacker stuff. -Peter
+
+(add-acl2-defaults-table-key :termination-method
+ (member-eq val '(:measure :ccg)))
+
+(defdoc set-termination-method
+ ":Doc-Section CCG
+
+ Set the default means of proving termination.~/
+ ~bv[]
+ Examples:
+ (set-termination-method :ccg)
+ (set-termination-method :measure)
+ ~ev[]
+
+ Introduced by the CCG analysis book, this macro sets the default
+ means by which ACL2 will prove termination. Note: This is an event!
+ It does not print the usual event summary but nevertheless changes
+ the ACL2 logical ~il[world] and is so recorded.~/
+
+ ~bv[] General Form:
+ (set-termination-method tm)
+ ~ev[]
+
+ where ~c[tm] is ~c[:CCG] or ~c[:MEASURE]. The default is ~c[:MEASURE] (chosen
+ to assure compatibility with books created without CCG). The recommended
+ setting is ~c[:CCG]. This macro is equivalent to
+ ~c[(table acl2-defaults-table :termination-method 'tm)], and hence is ~ilc[local] to
+ any ~il[books] and ~ilc[encapsulate] ~il[events] in which it occurs;
+ ~pl[acl2-defaults-table].
+
+ When the termination-method is set to ~c[:CCG], a termination proof is
+ attempted using the the hierarchical CCG algorithm ~url[CCG-hierarchy].
+
+ When the termination-method is set to ~c[:MEASURE], ACL2 attempts to
+ prove termination using its default measure-based method. Thus, in
+ this setting, ACL2's behavior is identical to that when the CCG book
+ is not included at all.
+
+ To see what the current termination method setting is, use
+ ~ilc[get-termination-method].~/")
+
+(defun get-termination-method (wrld)
+ ":Doc-Section CCG
+
+ Returns the current default termination method.~/
+
+ ~bv[]
+ Examples:
+ (get-termination-method (w state))
+ ~ev[]
+
+ This will return the termination-method as specified by the current world. ~/
+
+ ~bv[]
+ General Form:
+ (get-termination-method wrld)
+ ~ev[]
+
+ where ~c[wrld] is a ~il[world]. For information on the settings and
+ their meaning, ~pl[set-termination-method].~/"
+
+ (declare (xargs :guard (and (plist-worldp wrld)
+ (alistp (table-alist 'acl2-defaults-table wrld)))))
+ (let ((entry (assoc :termination-method (table-alist 'acl2-defaults-table wrld))))
+ (or (and entry (cdr entry)) :measure)))
+
+(verify-guards get-termination-method)
+
+(defmacro hlevel-proof-technique (hlevel)
+ `(car ,hlevel))
+
+(defmacro hlevel-ccm-comparison-scheme (hlevel)
+ `(cadr ,hlevel))
+
+(defmacro hlevel-ccmfs-per-nodep (hlevel)
+ `(caddr ,hlevel))
+
+(defmacro make-hlevel (pt ccm-cs cpn)
+ `(list ,pt ,ccm-cs ,cpn))
+
+(defun proof-techniquep (pt)
+
+; checks whether pt is a valid "proof technique" as described in the
+; documentation for the set-ccg-hierarchy. That is, this function returns true
+; if pt is :built-in-clauses or of the form (:induction-depth n) for some
+; natural number n.
+
+ (declare (xargs :guard t))
+ (or (and (keywordp pt)
+ (eq pt :built-in-clauses))
+ (and (consp pt)
+ (keywordp (car pt))
+ (eq (car pt) :induction-depth)
+ (consp (cdr pt))
+ (natp (cadr pt))
+ (null (cddr pt)))))
+
+(defun hlevelp (hlevel)
+ (declare (xargs :guard t))
+
+; returns non-nil if hlevel is a valid level of a CCG hierarchy. That is,
+; the result is non-nil if it is of the form (:measure pt) or (pt ccm-cs cpn)
+; where pt satisfies proof-techniquep, ccm-cs is one of :EQUAL, :ALL, :SOME, or
+; :NONE, and cpn is a boolean.
+
+ (and (consp hlevel)
+ (or (and (keywordp (car hlevel))
+ (eq (car hlevel) :measure)
+ (consp (cdr hlevel))
+ (proof-techniquep (cadr hlevel))
+ (null (cddr hlevel)))
+ (and (proof-techniquep (car hlevel))
+ (consp (cdr hlevel))
+ (member-eq (cadr hlevel) '(:EQUAL :ALL :SOME :NONE))
+ (consp (cddr hlevel))
+ (booleanp (caddr hlevel))
+ (null (cdddr hlevel))))))
+
+(defun hlevel-listp (lst)
+ (declare (xargs :guard t))
+
+; returns non-nil iff lst is a true-list of elements satisfying hlevelp.
+
+ (if (consp lst)
+ (and (hlevelp (car lst))
+ (hlevel-listp (cdr lst)))
+ (null lst)))
+
+(defun non-empty-hlevel-listp (lst)
+ (declare (xargs :guard t))
+ (and (consp lst)
+ (hlevel-listp lst)))
+
+(defun hlevel< (hlevel0 hlevel1)
+
+; a non-transitive comparison function for arguments that are non-measure
+; levels of a CCG hierarchy. The definition is designed to return t if the CCG
+; analysis, using the techniques described in hlevel1 could possibly further
+; refine an annotated CCG that had already been refined using the techniques
+; described in hlevel0. That is, hlevel< returns t if hlevel0 does *not*
+; subsume hlevel1.
+
+ (declare (xargs :guard (and (hlevelp hlevel0)
+ (not (equal (car hlevel0)
+ :measure))
+ (hlevelp hlevel1)
+ (not (equal (car hlevel1)
+ :measure)))))
+ (let ((pt0 (hlevel-proof-technique hlevel0))
+ (ccm-cs0 (hlevel-ccm-comparison-scheme hlevel0))
+ (cpn0 (hlevel-ccmfs-per-nodep hlevel0))
+ (pt1 (hlevel-proof-technique hlevel1))
+ (ccm-cs1 (hlevel-ccm-comparison-scheme hlevel1))
+ (cpn1 (hlevel-ccmfs-per-nodep hlevel1)))
+
+; if cpn0 is t and cpn1 is nil (hlevel0 calculates CCMFs on a per-node basis,
+; and hlevel1 on a per-edge basis), then we return t.
+
+ (or (and cpn0 (not cpn1))
+
+; if hlevel1 has a stronger proof technique than hlevel0, then return t.
+
+ (and (not (equal pt1 :built-in-clauses))
+ (or (equal pt0 :built-in-clauses)
+ (< (cadr pt0) (cadr pt1))))
+
+; if hlevel1 has a more comprehensive CCM comparison scheme, then return t.
+
+ (let ((ccm-cs-vals '((:EQUAL . 0)
+ (:ALL . 1)
+ (:SOME . 2)
+ (:NONE . 3))))
+ (< (cdr (assoc ccm-cs0 ccm-cs-vals))
+ (cdr (assoc ccm-cs1 ccm-cs-vals)))))))
+
+(rewrite-table-guard
+ acl2-defaults-table
+ (:carpat %body%
+ :vars %body%
+ :repl (if (eq key :ccg-hierarchy)
+ (non-empty-hlevel-listp val)
+ %body%)))
+
+
+(defun fix-ccg-hierarchy (hierarchy)
+ (declare (xargs :guard (or (consp hierarchy)
+ (and (symbolp hierarchy)
+ (member-eq hierarchy
+ '(:CCG-ONLY
+ :CCG-ONLY-CPN
+ :HYBRID
+ :HYBRID-CPN))))))
+
+
+; if hierarchy is a symbol designating one of the pre-defined hierarchies,
+; return the hierarchy that it represents. Otherwise, return hierarchy.
+
+ (if (consp hierarchy)
+ hierarchy
+ (case hierarchy
+ (:CCG-ONLY
+ '((:built-in-clauses :equal t)
+ ((:induction-depth 0) :EQUAL t)
+ ((:induction-depth 1) :EQUAL t)
+ ((:induction-depth 1) :ALL t)
+ ((:induction-depth 1) :SOME t)
+ ((:induction-depth 1) :NONE t)
+ ((:induction-depth 1) :EQUAL nil)
+ ((:induction-depth 1) :ALL nil)
+ ((:induction-depth 1) :SOME nil)
+ ((:induction-depth 1) :NONE nil)))
+ (:CCG-ONLY-CPN
+ '((:built-in-clauses :equal t)
+ ((:induction-depth 0) :EQUAL t)
+ ((:induction-depth 1) :EQUAL t)
+ ((:induction-depth 1) :ALL t)
+ ((:induction-depth 1) :SOME t)
+ ((:induction-depth 1) :NONE t)))
+ (:HYBRID
+ '((:built-in-clauses :equal t)
+ (:measure (:induction-depth 1))
+ ((:induction-depth 0) :EQUAL t)
+ ((:induction-depth 1) :EQUAL t)
+ ((:induction-depth 1) :ALL t)
+ ((:induction-depth 1) :SOME t)
+ ((:induction-depth 1) :NONE t)
+ ((:induction-depth 1) :EQUAL nil)
+ ((:induction-depth 1) :ALL nil)
+ ((:induction-depth 1) :SOME nil)
+ ((:induction-depth 1) :NONE nil)))
+ (:HYBRID-CPN
+ '((:built-in-clauses :equal t)
+ (:measure (:induction-depth 1))
+ ((:induction-depth 0) :EQUAL t)
+ ((:induction-depth 1) :EQUAL t)
+ ((:induction-depth 1) :ALL t)
+ ((:induction-depth 1) :SOME t)
+ ((:induction-depth 1) :NONE t)))
+ (otherwise
+ nil))))
+
+(defun get-ccg-hierarchy (wrld)
+ (declare (xargs :guard (and (plist-worldp wrld)
+ (alistp (table-alist 'acl2-defaults-table
+ wrld)))))
+
+; gets the default ccg hierarchy from the acl2-defaults-table. the default is
+; :CCG-ONLY.
+
+ (let ((entry (assoc :ccg-hierarchy (table-alist 'acl2-defaults-table wrld))))
+ (if (null entry)
+ (fix-ccg-hierarchy :CCG-ONLY)
+ (cdr entry))))
+
+(set-state-ok t)
+(program)
+
+(defun chk-ccg-hierarchy1 (hierarchy cpn ctx state)
+
+; checks the given hierarchy to assure that it conforms to the proper form.
+; if cpn is nil, all levels of the hierarchy must have a cpn of nil. Otherwise,
+; this function checks that there are no levels of the hierarchy with cpn t
+; that come after levels with a cpn of nil (once you switch from CCMFs per-node
+; to CCMFs per-edge, you cannot go back). The ctx and state are there to enable
+; error reporting. This function returns an error triple whose value is nil if
+; everything checks out.
+
+ (cond ((endp hierarchy)
+ (value nil))
+ ((not (hlevelp (car hierarchy)))
+ (er soft ctx
+ "Each element of a CCG-HIERARCHY must either have the form (PT ~
+ CCM-CS CPN) or (:MEASURE PT), where PT is either ~
+ :BUILT-IN-CLAUSES or (:INDUCTION-DEPTH N) for some natural ~
+ number, N, CCM-CS is one of :EQUAL, :ALL, :SOME, :NONE, and CPN ~
+ is either T or NIL. ~x0 does not match this form."
+ (car hierarchy)))
+ ((and (not cpn)
+ (not (equal (caar hierarchy) :MEASURE))
+ (hlevel-ccmfs-per-nodep (car hierarchy)))
+ (er soft ctx
+ "It is not permitted that a level of a CCG-HIERARCHY have a ~
+ CCCMFs-per-nodep of T when a previous level had a ~
+ CCMFs-per-nodep of NIL. But this is the case with level ~x0."
+ (car hierarchy)))
+ (t
+ (chk-ccg-hierarchy1 (cdr hierarchy)
+ (if (equal (caar hierarchy) :measure)
+ cpn
+ (hlevel-ccmfs-per-nodep (car hierarchy)))
+ ctx state))))
+
+(defun chk-measure-hlevel<-all (hlevel0 hierarchy ctx state)
+
+; ensures that none of the measure levels of hierarchy are subsumed by hlevel0.
+
+ (cond ((endp hierarchy)
+ (value nil))
+ ((or (not (equal (caar hierarchy) :measure))
+ (and (consp (cadar hierarchy))
+ (or (atom (cadr hlevel0))
+ (< (cadadr hlevel0) (cadadr (car hierarchy))))))
+ (chk-measure-hlevel<-all hlevel0 (cdr hierarchy) ctx state))
+ (t
+ (er soft ctx
+ "Each :MEASURE level of a CCG-HIERARCHY should use strictly more ~
+ powerful proof techniques than all those that come before it. ~
+ However, the ~x0 level is subsumed by the earlier level, ~x1."
+ (car hierarchy)
+ hlevel0))))
+
+(defun chk-hlevel<-all (hlevel0 hierarchy ctx state)
+
+; insures that none of the CCG levels of the hierarchy are subsumed by
+; hlevel0.
+
+ (cond ((endp hierarchy)
+ (value nil))
+ ((or (equal (caar hierarchy) :MEASURE)
+ (hlevel< hlevel0 (car hierarchy)))
+ (chk-hlevel<-all hlevel0 (cdr hierarchy) ctx state))
+ (t
+ (er soft ctx
+ "Each level of a CCG-HIERARCHY should be strictly more powerful ~
+ than all the previous levels. That is, it should always be ~
+ possible to refine the CCG or CCMF information at each step in ~
+ the hierarchy. However, the ~x0 level is subsumed by the ~
+ earlier level, ~x1."
+ (car hierarchy)
+ hlevel0))))
+
+(defun chk-hierarchy-strictly-increasing (hierarchy ctx state)
+
+; ensures that no level of hierarchy is subsumed by a later level.
+
+ (if (endp hierarchy)
+ (value nil)
+ (er-progn
+ (cond ((equal (caar hierarchy) :MEASURE)
+ (chk-measure-hlevel<-all (car hierarchy) (cdr hierarchy)
+ ctx state))
+ (t
+ (chk-hlevel<-all (car hierarchy) (cdr hierarchy)
+ ctx state)))
+ (chk-hierarchy-strictly-increasing (cdr hierarchy) ctx state))))
+
+(defun chk-ccg-hierarchy (hierarchy ctx state)
+
+; checks a proposed CCG hierarchy.
+
+ (cond ((and (symbolp hierarchy)
+ (member-eq hierarchy '(:CCG-ONLY
+ :CCG-ONLY-CPN
+ :HYBRID
+ :HYBRID-CPN)))
+ (value nil))
+ ((and (consp hierarchy)
+ (true-listp hierarchy))
+ (er-progn
+ (chk-ccg-hierarchy1 hierarchy t ctx state)
+ (chk-hierarchy-strictly-increasing hierarchy ctx state)))
+ (t
+ (er soft ctx
+ "A CCG-HIERARCHY must be :CCG-ONLY, :CCG-ONLY-CPN, :HYBRID, ~
+ :HYBRID-CPN, or a non-empty true-list. ~x0 does not have ~
+ this form."
+ hierarchy))))
+
+(defmacro set-ccg-hierarchy (v)
+ ":Doc-Section CCG
+
+ Set the default hierarchy of techniques for CCG-based termination
+ analysis. ~/
+ ~bv[]
+ (set-ccg-hierarchy ((:built-in-clauses :equal t)
+ (:measure (:induction-depth 1))
+ ((:induction-depth 0) :EQUAL t)
+ ((:induction-depth 1) :EQUAL t)
+ ((:induction-depth 1) :ALL t)
+ ((:induction-depth 1) :SOME t)
+ ((:induction-depth 1) :NONE t)
+ ((:induction-depth 1) :EQUAL nil)
+ ((:induction-depth 1) :ALL nil)
+ ((:induction-depth 1) :SOME nil)
+ ((:induction-depth 1) :NONE nil)))
+ :set-ccg-hierarchy ((:built-in-clauses :equal t)
+ ((:induction-depth 0) :EQUAL t)
+ ((:induction-depth 1) :EQUAL t)
+ ((:induction-depth 1) :ALL t)
+ ((:induction-depth 1) :SOME t)
+ ((:induction-depth 1) :NONE t))~/
+
+ General Form:
+ (set-ccg-hierarchy v)
+ ~ev[]
+ where ~c[v] is ~c[:CCG-ONLY], ~c[:CCG-ONLY-CPN], ~c[:HYBRID],
+ ~c[:HYBRID-CPN], or a non-empty list of hierarchy levels, which either
+ have the form ~c[(pt ccm-cs cpn)] or the form ~c[(:measure pt)], where
+ ~c[pt] is either ~c[:built-in-clauses] or ~c[(:induction-depth n)] for
+ some natural number ~c[n], ~c[ccm-cs] is one of ~c[:EQUAL], ~c[:ALL],
+ ~c[:SOME], or ~c[:NONE], and ~c[cpn] is ~c[t] or ~c[nil].
+
+ Each level of the hierarchy describes techniques used to prove
+ termination. Termination proofs performed after admitting this event will
+ use the specified techniques in the order in which they are listed.
+
+ Basically, the CCG analysis as described and illustrated at a high level
+ in the documentation for ~il[CCG] can potentially be very expensive. In
+ order to make the analysis as efficient as possible, we use less expensive
+ (and less powerful) techniques first, and resort to more powerful and
+ expensive techniques only when these fail.
+
+ There are three ways of varying the CCG analysis, which are represented by
+ each of the three elements in a hierarchy level (levels of the form
+ ~c[(:measure pt)] will be explained later).
+
+ ~c[Pt] tells the CCG analysis how to limit proof attempts. The idea behind
+ this is that ACL2 is designed to prove statements that the user thinks are
+ true. It therefore does everything it can to prove the conjecture. As ACL2
+ useres already know, this can lead to very long, or even non-terminating
+ proof attempts. The CCG analysis, on the other hand, sends multiple
+ queries to the theorem prover that may or may not be true, in order to
+ improve the accuracy of the analysis. It is therefore necessary to reign
+ in ACL2's proof attempts to keep them from taking too long. Of course, the
+ trade-off is that, the more we limit ACL2's prover, the less powerful it
+ becomes.
+
+ ~c[Pt] can be ~c[:built-in-clauses], which tells ACL2 to use only
+ ~il[built-in-clauses] analysis. This is a very fast, and surprisingly
+ powerful proof technique. For example, the definition of Ackermann's
+ function given in the documentation for ~il[CCG] is solved using only this
+ proof technique.
+
+ ~c[Pt] can also be of the form ~c[(:induction-depth n)], where ~c[n] is a
+ natural number. This uses the full theorem prover, but limits it in two
+ ways. First, it stops proof attempts if ACL2 has been working on a subgoal
+ with no case splitting or induction for 20 steps (that is, at a goal of
+ the form 1.5'20'). It also limits the ~em[induction depth], which
+ describes how many times we allow induction goals to lead to further
+ induction goals. For example, ~c[(:induction-depth 0)] allows no
+ induction, while ~c[(:induction-depth 1)] allows goals of the form ~c[*1]
+ or ~c[*2], but stops if it creates a goal such as ~c[*1.1] or ~c[*2.1].
+
+ ~c[Ccm-cs] limits which CCMs are compared using the theorem
+ prover. Consider again the ~c[ack] example in the documentation for
+ ~il[CCG]. All we needed was to compare the value of ~c[(acl2-count x)]
+ before and after the recursive call and the value of ~c[(acl2-count y)]
+ before and after the recursive call. We would learn nothing, and waste
+ time with the theorem prover if we compared ~c[(acl2-count x)] to
+ ~c[(acl2-count y)]. However, other times, it is important to compare CCMs
+ with each other, for example, when arguments are permuted, or we are
+ dealing with a mutual recursion.
+
+ ~c[Ccm-cs] can be one of ~c[:EQUAL], ~c[:ALL], ~c[:SOME], or
+ ~c[:NONE]. These limit which CCMs we compare based on the variables they
+ mention. Let ~c[c] be a recursive call in the body of function ~c[f] that
+ calls function ~c[g]. Let ~c[m1] be a CCM for ~c[f] and ~c[m2] be a CCM
+ for ~c[g]. Let ~c[v1] be the formals mentioned in ~c[m1] and ~c[v2] be the
+ formals mentioned in ~c[m2'] where ~c[m2'] is derived from ~c[m2] by
+ substituting the formals of ~c[g] with the actuals of ~c[c]. For example,
+ consider following function:
+ ~bv[]
+ (defun f (x)
+ (if (endp x)
+ 0
+ (1+ (f (cdr x)))))
+ ~ev[]
+ Now consider the case where ~c[m1] and ~c[m2] are both the measure
+ ~c[(acl2-count x)]. Then if we look at the recursive call ~c[(f (cdr x))]
+ in the body of ~c[f], then ~c[m2'] is the result of replacing ~c[x] with
+ ~c[(cdr x)] in ~c[m2], i.e., ~c[(acl2-count (cdr x))].
+
+ If ~c[ccm-cs] is ~c[:EQUAL] we will compare ~c[m1] to
+ ~c[m2] if ~c[v1] and ~c[v2] are equal. If ~c[value] is ~c[:ALL] we will
+ compare ~c[m1] to ~c[m2'] if ~c[v2] is a subset of ~c[v1]. If ~c[value] is
+ ~c[:SOME] we will compare ~c[m1] to ~c[m2'] if ~c[v1] and ~c[v2]
+ intersect. If ~c[value] is ~c[:NONE] we will compare ~c[m1] to ~c[m2] no
+ matter what.
+
+ There is one caveat to what was just said: if ~c[m1] and ~c[m2] are
+ syntactically equal, then regardless of the value of ~c[ccm-cs] we will
+ construct a CCMF that will indicate that ~c[(o>= m1 m2)].
+
+
+ ~c[Cpn] tells us how much ruler information we will use to compare CCMs.
+ Unlike ACL2's measure-based termination analysis, CCG has the ability to
+ use the rulers from both the current recursive call the next recursive
+ call when constructing the CCMFs. That is, instead of asking ``What
+ happens when I make recursive call A?'', we can ask, ``What happens when
+ execution moves from recursive call A to recursive call B?''. Using this
+ information potentially strengthens the termination analysis. For a brief
+ example, consider the following code:
+ ~bv[]
+ (defun half (x)
+ (if (zp x)
+ 0
+ (1+ (half (- x 2)))))
+ ~ev[]
+
+ Clearly this is terminating. If we choose a measure of ~c[(nfix x)] we
+ know that if ~c[x] is a positive integer, ~c[(nfix (- x 2))] is less than
+ ~c[(nfix x)]. But consider the measure ~c[(acl2-count x)]. The strange
+ thing here is that if ~c[x] is 1, then ~c[(acl2-count (- x 2))] is
+ ~c[(acl2-count -1)], which is 1, i.e. the ~c[acl2-count] of ~c[x]. So, the
+ fact that we know that ~c[x] is a positive integer is not enough to show
+ that this measure decreases. But notice that if ~c[x] is 1, we will recur
+ just one more time. So, if we consider what happens when we move from the
+ recursive call back to itself. In this case we know
+ ~c[(and (not (zp x)) (not (zp (- x 2))))].
+ Under these conditions, it is trivial for ACL2 to prove that
+ ~c[(acl2-count (- x 2))] is always less than ~c[(acl2-count x)].
+
+ However, this can make the CCG analysis much more expensive, since
+ information about how values change from step to step are done on a
+ per-edge, rather than a per-node basis in the CCG (where the nodes are the
+ recursive calls and the edges indicate that execution can move from one
+ call to another in one step). Thus, calculating CCMFs (how values change
+ across recursive calls) on a per-edge basis rather than a per-node basis
+ can require n^2 instead of n prover queries.
+
+ If ~c[cpn] is ~c[t], we will use only the ruler of the current recursive
+ call to compute our CCMFs. If it is ~c[nil], we will use the much more
+ expensive technique of using the rulers of the current and next call.
+
+ Levels of the hierarchy of the form ~c[(:measure pt)] specify that the CCG
+ analysis is to be set aside for a step, and the traditional measure-based
+ termination proof is to be attempted. Here, ~c[pt] has the same meaning as
+ it does in a CCG hierarchy level. That is, it limits the measure proof in
+ order to avoid prohibitively long termination analyses.
+
+ The user may specify their own hierarchy in the form given above. The main
+ restriction is that no level may be subsumed by an earlier level. That is,
+ it should be the case at each level of the hierarchy, that it is possible
+ to discover new information about the CCG that could help lead to a
+ termination proof.
+
+ In addition to constructing his or her own CCG hierarchy, the user may use
+ several preset hierarchies:
+
+ ~bv[]
+ :CCG-ONLY
+ ((:built-in-clauses :equal t)
+ ((:induction-depth 0) :EQUAL t)
+ ((:induction-depth 1) :EQUAL t)
+ ((:induction-depth 1) :ALL t)
+ ((:induction-depth 1) :SOME t)
+ ((:induction-depth 1) :NONE t)
+ ((:induction-depth 1) :EQUAL nil)
+ ((:induction-depth 1) :ALL nil)
+ ((:induction-depth 1) :SOME nil)
+ ((:induction-depth 1) :NONE nil))
+
+ :CCG-ONLY-CPN
+ ((:built-in-clauses :equal t)
+ ((:induction-depth 0) :EQUAL t)
+ ((:induction-depth 1) :EQUAL t)
+ ((:induction-depth 1) :ALL t)
+ ((:induction-depth 1) :SOME t)
+ ((:induction-depth 1) :NONE t))
+
+ :HYBRID
+ ((:built-in-clauses :equal t)
+ (:measure (:induction-depth 1))
+ ((:induction-depth 0) :EQUAL t)
+ ((:induction-depth 1) :EQUAL t)
+ ((:induction-depth 1) :ALL t)
+ ((:induction-depth 1) :SOME t)
+ ((:induction-depth 1) :NONE t)
+ ((:induction-depth 1) :EQUAL nil)
+ ((:induction-depth 1) :ALL nil)
+ ((:induction-depth 1) :SOME nil)
+ ((:induction-depth 1) :NONE nil))
+
+ :HYBRID-CPN
+ ((:built-in-clauses :equal t)
+ (:measure (:induction-depth 1))
+ ((:induction-depth 0) :EQUAL t)
+ ((:induction-depth 1) :EQUAL t)
+ ((:induction-depth 1) :ALL t)
+ ((:induction-depth 1) :SOME t)
+ ((:induction-depth 1) :NONE t))
+ ~ev[]
+
+ The default hierarchy for CCG termination analysis is :CCG-ONLY.~/"
+
+ `(er-progn
+ (chk-ccg-hierarchy ',v "SET-CCG-HIERARCHY" state)
+ (with-output :off summary
+ (progn (table acl2-defaults-table ':ccg-hierarchy ',(fix-ccg-hierarchy v))
+ (table acl2-defaults-table ':ccg-hierarchy)))))
+
+;; adds :ccg-time-limit to the acl2-global-table.
+
+(add-acl2-defaults-table-key :ccg-time-limit
+ (or (null val)
+ (and (rationalp val)
+ (< 0 val))))
+
+(logic)
+(set-state-ok nil)
+
+(defdoc set-ccg-time-limit
+ ":Doc-Section CCG
+
+ Set a global time limit for CCG-based termination proofs.~/
+ ~bv[]
+ Examples:
+ (set-ccg-time-limit 120) ; limits termination proofs to 120 seconds.
+ (set-ccg-time-limit 53/2) ; limits termination proofs to 53/2 seconds.
+ (set-ccg-time-limit nil) ; removes any time limit for termination proofs.
+ ~ev[]
+
+ Introduced by the CCG analysis book, this macro sets a global time limit for
+ the completion of the CCG analysis. The time limit is given as a rational
+ number, signifying the number of seconds to which the CCG analysis should be
+ limited, or nil, signifying that there should be no such time limit. If CCG
+ has not completed its attempt to prove termination in the number of seconds
+ specified, it will immediately throw an error and the definition attempt will
+ fail. Note: This is an event! It does not print the usual event summary but
+ nevertheless changes the ACL2 logical ~il[world] and is so recorded.~/
+
+ ~bv[] General Form:
+ (set-ccg-time-limit tl)
+ ~ev[]
+ where ~c[tl] is a positive rational number or nil. The default is nil. If the
+ time limit is nil, the CCG analysis will work as long as it needs to in order
+ to complete the analysis. If the ~c[tl] is a positive rational number,
+ all CCG analyses will be limited to ~c[tl] seconds.
+
+ To see what the current time limit is, see
+ ~ilc[get-ccg-time-limit].~/")
+
+(defun get-ccg-time-limit (wrld)
+ ":Doc-Section CCG
+
+ Returns the current default ccg-time-limit setting.~/
+
+ ~bv[]
+ Examples:
+ (get-ccg-time-limit (w state))
+ ~ev[]
+
+ This will return the time-limit as specified by the current world. ~/
+
+ ~bv[]
+ General Form:
+ (get-time-limit wrld)
+ ~ev[]
+
+ where ~c[wrld] is a ~il[world]. For information on the settings and
+ their meaning, ~pl[set-termination-method].~/"
+
+ (declare (xargs :guard (and (plist-worldp wrld)
+ (alistp (table-alist 'acl2-defaults-table wrld)))))
+ (let ((entry (assoc :ccg-time-limit (table-alist 'acl2-defaults-table wrld))))
+ (or (and entry (cdr entry)) nil)))
+
+(verify-guards get-ccg-time-limit)
+
+(defmacro set-ccg-print-proofs (v)
+ ":Doc-Section CCG
+
+ controls whether proof attempts are printed during CCG analysis~/
+
+ ~bv[]
+ Examples:
+ (set-ccg-print-proofs t)
+ (set-ccg-print-proofs nil)
+ :set-ccg-print-proofs t~/
+
+ General Form:
+ (set-ccg-print-proofs v)
+ ~ev[]
+ If ~c[v] is ~c[nil], no proof attempts will be printed during CCG
+ analysis. This is the default. If ~c[v] is anything but ~c[nil], proofs will
+ be displayed. Fair warning: there is potentially a large amount of prover
+ output that might be displayed. It is probably better to use
+ ~l[set-ccg-inhibit-output-lst] to un-inhibit ~c['query] output to figure out
+ what lemmas might be needed to get a given query to go through."
+
+ `(assign ccg-print-proofs ,v))
+
+(defmacro get-ccg-print-proofs ()
+ ":Doc-Section CCG
+
+ returns the setting that controls whether proof attempts are printed during
+ CCG analysis~/
+
+ ~bv[]
+ Examples:
+ (get-ccg-print-proofs)
+ :get-ccg-print-proofs
+ ~ev[]~/
+
+ See ~l[set-ccg-print-proofs] for details."
+ '(and (f-boundp-global 'ccg-print-proofs state)
+ (f-get-global 'ccg-print-proofs state)))
+
+;; The following code is used to implement a parallel to io? as defined in
+;; basis.lisp. Make sure this all stays in sync with the parallel definitions
+;; in that file. To find out more, see the "Essay on Inhibited Output and the
+;; Illusion of Windows" in the comments of basis.lisp.
+
+;; *ccg-window-descriptions* parallels *window-descriptions* as defined in
+;; basis.lisp. See the comments there for details.
+
+(defconst *ccg-window-descriptions*
+; str clr top pop
+ '((query "4" nil nil nil)
+ (basics "4" nil nil nil)
+ (performance "4" nil nil nil)
+ (build/refine "4" nil nil nil)
+ (size-change "4" nil nil nil)
+ (counter-example "4" nil nil nil)))
+
+;; The following mirrors *valid-output-names* as defined in axioms.lisp. This
+;; is the list of valid io "kinds" that can be inhibited.
+
+(defconst *ccg-valid-output-names*
+ '(query basics performance build/refine size-change counter-example))
+
+(defmacro set-ccg-inhibit-output-lst (lst)
+ ":Doc-Section CCG
+
+ control output during CCG termination analysis~/
+ ~bv[]
+ Examples:
+ (set-ccg-inhibit-output-lst '(query))
+ (set-ccg-inhibit-output-lst '(build/refine size-change))
+ (set-ccg-inhibit-output-lst *ccg-valid-output-names*) ; inhibit all ccg output
+ :set-ccg-inhibit-output-lst (build/refine size-change)~/
+
+ General Form:
+ (set-ccg-inhibit-output-lst lst)
+ ~ev[]
+ where ~c[lst] is a form (which may mention ~ilc[state]) that evaluates
+ to a list of names, each of which is the name of one of the
+ following ``kinds'' of output produced by the CCG termination analysis.
+ ~bv[]
+ query prints the goal, restrictions, and results of each prover
+ query (for a discussion on displaying actual proofs,
+ see ~c[set-ccg-display-proofs](yet to be documented).
+ basics the basic CCG output, enough to follow along, but concise
+ enough to keep from drowning in output
+ performance performance information for the size change analysis
+ build/refine the details of CCG construction and refinement
+ size-change the details of size change analysis
+ counter-example prints out a counter-example that can be useful for
+ debugging failed termination proof attempts.
+ ~ev[]
+ It is possible to inhibit each kind of output by putting the corresponding
+ name into ~c[lst]. For example, if ~c['query] is included in (the value of)
+ ~c[lst], then no information about individual queries is printed during CCG
+ analysis.
+
+ The default setting is ~c['(query performance build/refine size-change)].
+ That is, by default only the basic CCG information and counter-example (in
+ the case of a failed proof attempt) are printed. This should hopefully be
+ adequate for most users."
+
+ `(let ((lst ,lst))
+ (cond ((not (true-listp lst))
+ (er soft 'set-ccg-inhibit-output-lst
+ "The argument to set-ccg-inhibit-output-lst must evaluate to a ~
+ true-listp, unlike ~x0."
+ lst))
+ ((not (subsetp-eq lst *ccg-valid-output-names*))
+ (er soft 'set-ccg-inhibit-output-lst
+ "The argument to set-ccg-inhibit-output-lst must evalutate to a ~
+ subset of the list ~X01, but ~x2 contains ~&3."
+ *ccg-valid-output-names*
+ nil
+ ',lst
+ (set-difference-eq lst *ccg-valid-output-names*)))
+ (t (pprogn
+ (f-put-global 'ccg-inhibit-output-lst lst state)
+ (value lst))))))
+
+(defmacro get-ccg-inhibit-output-lst ()
+ ":Doc-Section CCG
+
+ returns the list of ``kinds'' of output that will be inhibited during CCG
+ analysis~/
+
+
+ ~bv[]
+ Examples:
+ (get-ccg-inhibit-output-lst)
+ :get-ccg-inhibit-output-lst
+ ~bv[]~/
+
+ See ~l[set-ccg-inhibit-output-lst]."
+ '(if (f-boundp-global 'ccg-inhibit-output-lst state)
+ (f-get-global 'ccg-inhibit-output-lst state)
+ '(query performance build/refine size-change)))
+
+(program)
+(set-state-ok t)
+
+(defmacro ccg-io? (token commentp shape vars body
+ &key
+ (clear 'nil clear-argp)
+ (cursor-at-top 'nil cursor-at-top-argp)
+ (pop-up 'nil pop-up-argp)
+ (default-bindings 'nil)
+ (chk-translatable 't))
+
+; NOTE: Keep this in sync with io? as defined in basis.lisp. This definition is
+; almost identical to that one, except we use *ccg-window-descriptions* and
+; *ccg-valid-output-names* instead of *window-descriptions* and
+; *valid-output-names*, and we store our inhibited-lst in the global table
+; under the symbol 'ccg-inhibit-output-lst instead of 'inhibit-output-lst. The
+; remaining comments in this definition are from the original io? definition:
+
+; Typical use (io? error nil (mv col state) (x y) (fmt ...)), meaning execute
+; the fmt statement unless 'error is on 'inhibit-output-lst. The mv expression
+; is the shape of the output produced by the fmt expression, and the list (x y)
+; for vars indicates the variables other than state that occur free in that
+; expression. See the comment above, and see the Essay on Saved-output for a
+; comment that gives a convenient macro for obtaining the free variables other
+; than state that occur free in body.
+
+; Default-bindings is a list of doublets (symbol value). It is used in order
+; to supply a non-nil return value for other than state when io is suppressed.
+; For example, fmt returns col and state, as suggested by the third (shape)
+; argument below. Without the :default-bindings, this form would evaluate to
+; (mv nil state) if event IO is inhibited. But there are fixnum declarations
+; that require the first return value of fmt to be an integer, and we can
+; specify the result in the inhibited case to be (mv 0 state) with the
+; following :default-bindings:
+
+; (io? event nil (mv col state) nil (fmt ...) :default-bindings ((col 0)))
+
+; The values in :default-bindings are evaluated, so it would be equivalent to
+; replace 0 with (- 4 4), for example.
+
+ (declare (xargs :guard (and (symbolp token)
+ (symbol-listp vars)
+ (no-duplicatesp vars)
+ (not (member-eq 'state vars))
+ (assoc-eq token *ccg-window-descriptions*))))
+ (let* ((associated-window (assoc-eq token *ccg-window-descriptions*))
+ (expansion
+ `(let* ((io?-output-inhibitedp
+ (member-eq ',token
+ (get-ccg-inhibit-output-lst)))
+ (io?-alist
+ (and (not io?-output-inhibitedp)
+ (list
+ (cons #\w ,(cadr associated-window))
+ (cons #\c ,(if clear-argp
+ clear
+ (caddr associated-window)))
+ (cons #\t ,(if cursor-at-top-argp
+ cursor-at-top
+ (cadddr associated-window)))
+ (cons #\p ,(if pop-up-argp
+ pop-up
+ (car (cddddr associated-window))))
+
+; Peter Dillinger requested the following binding, so that he could specify a
+; window prelude string that distinguishes between, for example, "prove",
+; "event", and "summary" output, which with the default string would all just
+; show up as window 4.
+
+ (cons #\k ,(symbol-name token))))))
+ (pprogn
+ (if (or io?-output-inhibitedp
+ (null (f-get-global 'window-interfacep state)))
+ state
+ (mv-let (io?-col state)
+ (fmt1! (f-get-global 'window-interface-prelude state)
+ io?-alist 0 *standard-co* state nil)
+ (declare (ignore io?-col))
+ state))
+ ,(let ((body
+ `(check-vars-not-free
+ (io?-output-inhibitedp io?-alist)
+ (check-exact-free-vars io? (state ,@vars) ,body)))
+ (nil-output (if (eq shape 'state)
+ 'state
+ (cons 'mv (io?-nil-output (cdr shape)
+ default-bindings))))
+ (postlude
+ `(mv-let
+ (io?-col state)
+ (if (or io?-output-inhibitedp
+ (null (f-get-global 'window-interfacep state)))
+ (mv 0 state)
+ (fmt1! (f-get-global 'window-interface-postlude state)
+ io?-alist 0 *standard-co* state nil))
+ (declare (ignore io?-col))
+ (check-vars-not-free
+ (io?-output-inhibitedp io?-alist io?-col)
+ ,shape))))
+ (let ((body (if commentp
+ `(let ,(io?-wormhole-bindings 0 vars)
+ ,body)
+ body)))
+ (cond
+ ((eq shape 'state)
+ `(pprogn
+ (if io?-output-inhibitedp state ,body)
+ ,postlude))
+ (t `(mv-let ,(cdr shape)
+ (if io?-output-inhibitedp
+ ,nil-output
+ ,body)
+ ,postlude)))))))))
+ (cond
+ (commentp
+ (let ((form
+ (cond
+ ((eq shape 'state)
+ `(pprogn ,expansion (value :q)))
+ (t
+ `(mv-let ,(cdr shape)
+ ,expansion
+ (declare
+ (ignore ,@(remove1-eq 'state (cdr shape))))
+ (value :q))))))
+ `(prog2$
+ ,(if chk-translatable
+ `(chk-translatable ,body ,shape)
+ nil)
+ (wormhole 'comment-window-io
+ '(lambda (whs)
+ (set-wormhole-entry-code whs :ENTER))
+ (list ,@vars)
+ ',form
+ :ld-error-action :return!
+ :ld-verbose nil
+ :ld-pre-eval-print nil
+ :ld-prompt nil))))
+ (t `(pprogn
+ (cond ((saved-output-token-p ',token state)
+ (push-io-record nil ; io-marker
+ (list 'let
+ (list ,@(formal-bindings vars))
+ ',expansion)
+ state))
+ (t state))
+ ,expansion)))))
+
+
+; END public configuration interface
+
+; BEGIN mostly raw definitions for the CCG analysis
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; STRUCT DEFINITIONS ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defstruct-raw funct
+
+ ;; The funct defstruct represents the relevant information about the function
+ ;; definitions provided by the user.
+ ;;
+ ;; * fn: the function name
+
+ (fn nil :type symbol)
+
+ ;; * formals: the formals of the function
+
+ (formals nil :type list)
+
+ ;; * ccms: the ccms associated with the function. This will be a vector of
+ ;; terms, whose value will always be natural numbers.
+
+ (ccms nil :type sequence))
+
+(defstruct-raw context
+
+;; The context defstruct is used to represent a calling context. The
+;; individual fields are as follows:
+;;
+;; * ruler: the ruler of the context.
+
+ (ruler nil)
+
+;; * call: the actual recursive call of the context.
+
+ (call nil)
+
+;; * parent-funct: the funct representing the function containing the context.
+
+ (parent-funct (make-funct) :type funct)
+
+;; * call-funct: the funct representing the function called by the call of the
+;; context.
+
+ (call-funct (make-funct) :type funct)
+
+;; * num: a unique ID number assigned to each context. Also indicates
+;; its index in the context-array.
+
+ num)
+
+;; The following macros make it easy to get and set the fields of the functs of
+;; a given context.
+
+(defmacro-raw context-fn (c)
+ `(funct-fn (context-parent-funct ,c)))
+
+(defmacro-raw context-formals (c)
+ `(funct-formals (context-parent-funct ,c)))
+
+(defmacro-raw context-callfn (c)
+ `(funct-fn (context-call-funct ,c)))
+
+(defmacro-raw context-callformals (c)
+ `(funct-formals (context-call-funct ,c)))
+
+(defmacro-raw context-ccms (c)
+ `(funct-ccms (context-parent-funct ,c)))
+
+(defstruct-raw ccmf-node
+
+ ;; The ccmf-node struct represents nodes in the graph representation
+ ;; of a CCMF (see the comments for the struct ccmf). It contains two
+ ;; lists of edges: >-edges is a list of the indices of the CCMs that
+ ;; are always < the current one, and likewise >=-edges is a list of
+ ;; the indeces of the CCMs that are always <= the current one.
+
+ (>-edges nil :type list)
+ (>=-edges nil :type list))
+
+(defstruct-raw ccmf
+
+ ;; The ccmf struct represents CCMFs as a graph with edges labeled by
+ ;; > or >=. The fields are as follows:
+ ;;
+ ;; * firstsite: the index of the "tail" context of the CCMF.
+
+ (firstsite 0 :type fixnum)
+
+ ;; * lastsite: the index of the "head" context of the CCMF.
+
+ (lastsite 0 :type fixnum)
+
+ ;; * fc-num: the original index of the "tail" context. This is needed
+ ;; because CCGs get separated into SCCs, so the index of the head
+ ;; and tail contexts in the current SCC (firstsite and lastsite)
+ ;; and the context in the original context array may be
+ ;; different. Also, this item is actually a list of indices because
+ ;; of the possibility of context merging. The list keeps track of
+ ;; the original indices of all the contexts that were merged to
+ ;; make the current head or tail context. Currently, absorption and
+ ;; merging are not used, so we tend to just refer to the first item
+ ;; in the list.
+
+ (fc-num (list 0) :type (cons fixnum list))
+
+ ;; * lc-num: the original index of the "head" context (see note for
+ ;; fc-num).
+
+ (lc-num (list 0) :type (cons fixnum list))
+
+ ;; * graph: the graph representing the CCMF. This is an array of
+ ;; ccmf-nodes.
+
+ (graph nil :type (array ccmf-node))
+
+ ;; * in-sizes: the number of CCMFs for the "tail" context.
+
+ (in-sizes 0 :type fixnum)
+
+ ;; * out-sizes: the number of CCMFs for the "head" context.
+
+ (out-sizes 0 :type fixnum)
+
+ ;; * steps: the number of steps in the CCG represented by the
+ ;; CCMF. This is used in the sct algorithm.
+
+ (steps 1 :type fixnum))
+
+
+(defstruct-raw accg-edge
+ ;; The accg-edge struct represents edges in the annotated CCG (ACCG).
+
+ ;; * tail: the index of the tail ACCG node of the edge.
+
+ (tail -1 :type fixnum)
+
+ ;; * head: the index of the head ACCG node of the edge.
+
+ (head -1 :type fixnum)
+
+ ;; * ccmf: the CCMF associated with the edge in the ACCG.
+
+ (ccmf nil :type (or null ccmf)))
+
+
+(defstruct-raw accg-node
+;; The accg-node struct represents nodes in the ACCG. An ACCG is an
+;; array of these.
+
+ ;; * context: the context associated with the node.
+
+ (context (make-context) :type context)
+
+ ;; * fwd-edges: edges for which the current node is the tail.
+
+ (fwd-edges nil :type list)
+
+ ;; * bwd-edges: edges for which the current node is the head.
+
+ (bwd-edges nil :type list)
+
+ ;; * num: the index of the node in the array of nodes of the ACCG.
+
+ (num 0 :type fixnum))
+
+
+;; The following macros are self-explanitory. They allow us to refer
+;; to fields of a substruct of a given struct as if it were a field in
+;; the struct.
+
+(defmacro-raw accg-node-ruler (accg)
+ `(context-ruler (accg-node-context ,accg)))
+
+(defmacro-raw accg-node-call (accg)
+ `(context-call (accg-node-context ,accg)))
+
+(defmacro-raw accg-node-parent-funct (accg)
+ `(context-parent-funct (accg-node-context ,accg)))
+
+(defmacro-raw accg-node-call-funct (accg)
+ `(context-call-funct (accg-node-context ,accg)))
+
+(defmacro-raw accg-node-fn (accg)
+ `(context-fn (accg-node-context ,accg)))
+
+(defmacro-raw accg-node-formals (accg)
+ `(context-formals (accg-node-context ,accg)))
+
+(defmacro-raw accg-node-callformals (accg)
+ `(context-callformals (accg-node-context ,accg)))
+
+(defmacro-raw accg-node-callfn (accg)
+ `(context-callfn (accg-node-context ,accg)))
+
+(defmacro-raw accg-node-context-num (accg)
+ `(context-num (accg-node-context ,accg)))
+
+(defmacro-raw accg-node-ccms (accg)
+ `(context-ccms (accg-node-context ,accg)))
+
+;;; The following two structs are used to represent an SRG. See the
+;;; paper on the polynomial approximation of SCT (a.k.a. SCP) for a
+;;; full explanation. Briefly: an SRG has CCMs for nodes and edges
+;;; labeled with > or >= between them as the corresponding CCMF
+;;; dictates. In other words, the graph connects all the CCMF graphs
+;;; into one graph.
+
+(defstruct-raw srg-edge
+ ;; The srg-edge represents an edge in an SRG.
+
+ ;; * tail: the tail CCM of the edge.
+
+ (tail 0 :type fixnum)
+
+ ;; * head: the head CCM of the edge.
+
+ (head 0 :type fixnum)
+
+ ;; * ccmf: the CCMF from which this edge was derived.
+
+ (ccmf (make-ccmf) :type ccmf)
+
+;; * label: generally > or >=, indicating the label of the CCMF edge
+;; from which this edge is derived.
+
+ (label 'none :type symbol))
+
+(defstruct-raw srg-node
+ ;; The srg-node struct represents a node of the SRG
+
+ ;; * node: the index of the ACCG node associated with this SRG node.
+
+ (node 0 :type fixnum)
+
+ ;; * ccm: the index of the CCM in the array of CCMs assigned to the
+ ;; corresponding ACCG node.
+
+ (ccm 0 :type fixnum)
+
+ ;; * fwd-edges: the list of srg-edges of which this srg-node is the
+ ;; tail.
+
+ (fwd-edges nil :type list)
+
+ ;; * bwd-edges: the list of srg-edges of which this srg-node is the
+ ;; head.
+
+ (bwd-edges nil :type list))
+
+;;; the memoization struct contains the information that we use for
+;;; memoization. The fields are as follows:
+;;;
+;;; * proved: the list of proved conjectures.
+;;; * unproved0: the list of conjectures that we could not prove with 0 inductions.
+;;; * unproved1: the list of conjectures that we could not prove with 1 induction.
+
+(defstruct-raw memoization
+ (proved nil :type list)
+ (unproved (make-array 0 :initial-element nil :element-type 'list)
+ :type (vector list)))
+
+(defun-raw create-memoization (max-ind)
+ (make-memoization :unproved (make-array (1+ max-ind)
+ :initial-element nil
+ :element-type 'list)))
+
+;;; ccg-simplify-hyps-no-split takes a list of expressions, hyps,
+;;; representing a conjunction of predicates and quickly simplifies
+;;; them in such a way that does not cause a case split. It returns
+;;; the list of simplified expressions.
+(defun-raw ccg-simplify-hyps-no-split (hyps ctx ens wrld state)
+ (declare (ignore ctx))
+ (mv-let (nhyps ttree)
+ (normalize-lst hyps t nil ens wrld nil)
+ (er-progn
+ (accumulate-ttree-and-step-limit-into-state ttree :skip state)
+ (value (flatten-ands-in-lit-lst nhyps)))))
+
+(defrec query-spec-var
+ ((wrld . ens)
+ (ctx . otf-flg)
+ (stop-time . mem))
+ t)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; Printing Functions ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun-raw print-funct-ccms (functs wrld state)
+ (if (endp functs)
+ state
+ (pprogn
+ (fms "The CCM~#1~[~/s~] for ~x0 ~#1~[is~/are~] ~&1.~|"
+ `((#\0 . ,(funct-fn (car functs)))
+ (#\1 . ,(untranslate-lst
+ (mapcar #'de-propagate
+ (coerce (funct-ccms (car functs))
+ 'list))
+ nil
+ wrld)))
+ *standard-co*
+ state
+ nil)
+ (print-funct-ccms (cdr functs) wrld state))))
+
+;; The following definitions culminate in print-counter-example.
+
+(defun-raw prettify-ccms (ccm-array vars vals wrld)
+ (let ((fn (if vars
+ #'(lambda (x)
+ (untranslate (subcor-var vars vals
+ (de-propagate x))
+ nil wrld))
+ #'(lambda (x)
+ (untranslate (de-propagate x)
+ nil wrld)))))
+ (map 'vector fn ccm-array)))
+
+(defmacro-raw ce-defun-fn (defun)
+ `(cadr ,defun))
+
+(defmacro-raw ce-defun-formals (defun)
+ `(caddr ,defun))
+
+(defmacro-raw ce-defun-body (defun)
+ `(cadddr ,defun))
+
+(defmacro-raw ce-defun-test (defun)
+ `(let ((body (ce-defun-body ,defun)))
+ (if (eq (fn-symb body) 'if)
+ (cadr body)
+ T)))
+
+(defmacro-raw ce-defun-call (defun)
+ `(let ((body (ce-defun-body ,defun)))
+ (if (eq (fn-symb body) 'if)
+ (caddr body)
+ body)))
+
+(defun-raw ccmf-graph-no-edges? (ccmf-graph)
+ (loop for node across ccmf-graph
+ when (or (consp (ccmf-node->-edges node))
+ (consp (ccmf-node->=-edges node)))
+ return nil
+ finally (return t)))
+
+(defun-raw ccmf-graph-term (i graph ccms0 ccms1 acc)
+ (if (< i 0)
+ (cond ((endp acc) acc)
+ ((endp (cdr acc)) (car acc))
+ (t (cons 'and acc)))
+ (let* ((node (aref graph i))
+ (>=-edges (ccmf-node->=-edges node))
+ (>-edges (ccmf-node->-edges node))
+ (ccm (de-propagate (aref ccms0 i))))
+ (ccmf-graph-term (1- i)
+ graph
+ ccms0
+ ccms1
+ (append (mapcar #'(lambda (x)
+ `(> ,ccm
+ ,(de-propagate
+ (aref ccms1 x))))
+ >-edges)
+ (mapcar #'(lambda (x)
+ `(>= ,ccm
+ ,(de-propagate
+ (aref ccms1 x))))
+ >=-edges)
+ acc)))))
+
+(defun-raw print-ccmfs1 (defuns defun0 defun1 ccmfs flst funct0 col wrld state)
+ (if (endp defuns)
+ state
+ (let* ((graph (ccmf-graph (car ccmfs)))
+ (ne? (ccmf-graph-no-edges? graph))
+ (f0 (car defuns))
+ (f1 (if (consp (cdr defuns))
+ (cadr defuns)
+ defun0))
+ (f2 (cond ((endp (cdr defuns))
+ defun1)
+ ((endp (cddr defuns))
+ defun0)
+ (t (caddr defuns))))
+ (fn0 (ce-defun-fn f0))
+ (fn1 (ce-defun-fn f1))
+ (fn2 (ce-defun-fn f2))
+ (formals (ce-defun-formals f1))
+ (actuals (fargs (ce-defun-call f0)))
+ (ccms0 (prettify-ccms (funct-ccms (car flst)) nil nil wrld))
+ (ccms0-lst (coerce ccms0 'list))
+ (ccms1 (prettify-ccms (funct-ccms (if (endp (cdr flst))
+ funct0
+ (cadr flst)))
+ formals actuals wrld))
+ (ccms1-lst (coerce ccms1 'list)))
+ (pprogn
+ (fms "When execution moves from the recursive call in ~x0 of ~x1 to ~
+ ~#2~[itself~/the recursive call in ~x1 of ~x3~], we need to know ~
+ how the measures of ~x0 compare with the result of substituting ~
+ the formals of ~x1 with the actuals of the call to ~x1 in the ~
+ measures of ~x1. The measure~#4~[~/s~] for ~x0 ~
+ ~#4~[is~/are~]:~|~%~*6~%The result~#5~[~/s~] of applying the ~
+ substitution to the measures of ~x1 ~#5~[is~/are~]:~|~%~*7~%We ~
+ know ~#8~[nothing about how the values of these CCMs ~
+ relate.~/the following about these CCMs:~%~%~Y9A~]~|~%If you can ~
+ show that any of the terms in the first list is always either ~
+ strictly greater than, or greater than or equal to some term in ~
+ the second list, this could be helpful for proving termination.~|"
+ (list (cons #\0 fn0)
+ (cons #\1 fn1)
+ (cons #\2 (if (eq fn0 fn1) 0 1))
+ (cons #\3 fn2)
+ (cons #\4 ccms0-lst)
+ (cons #\5 ccms1-lst)
+ (cons #\6 `("" "~x*.~|" "~x*~|" "~x*~|"
+ ,ccms0-lst))
+ (cons #\7 `("" "~x*.~|" "~x*~|" "~x*~|"
+ ,ccms1-lst))
+ (cons #\8 (if ne? 0 1))
+ (cons #\9 (ccmf-graph-term
+ (1- (array-dimension graph 0))
+ graph
+ ccms0
+ ccms1
+ nil))
+ (cons #\A (term-evisc-tuple nil state)))
+ *standard-co* state nil)
+ (print-ccmfs1 (cdr defuns)
+ defun0
+ defun1
+ (cdr ccmfs)
+ (cdr flst)
+ funct0
+ col wrld state)))))
+
+(defun-raw print-ccmfs (defuns ccmfs flst col wrld state)
+ (if (endp defuns)
+ state
+ (print-ccmfs1 defuns
+ (car defuns)
+ (if (endp (cdr defuns))
+ (car defuns)
+ (cadr defuns))
+ ccmfs
+ flst
+ (car flst)
+ col
+ wrld
+ state)))
+
+(defun-raw print-ccms (defuns functs col wrld state)
+ ;; (format t "defuns: ~A functs: ~A col: ~A state: ~A~%" defuns functs col state)
+ (if (endp defuns)
+ (mv-let (col state)
+ (fmt1 "~|" nil col *standard-co* state nil)
+ (declare (ignore col))
+ state)
+ (mv-let
+ (col state)
+ (fmt1 "The CCM~#1~[~/s~] for ~x0 ~#1~[is~/are~] ~&1. "
+ (list (cons #\0 (cadar defuns))
+ (cons #\1 (untranslate-lst
+ (mapcar #'de-propagate
+ (coerce (funct-ccms (car functs))
+ 'list))
+ nil
+ wrld)))
+ col
+ *standard-co*
+ state nil)
+ (print-ccms (cdr defuns) (cdr functs) col wrld state))))
+
+(defun-raw produce-counter-example1 (ccmfs context-array alist wrld)
+ (if (endp ccmfs)
+ (mv nil nil nil)
+ (let* ((context (aref context-array (car (ccmf-fc-num (car ccmfs)))))
+ (funct (context-parent-funct context))
+ (fn (funct-fn funct)))
+
+ (mv-let
+ (name i)
+ (ccg-counter-example-fn-name fn (assoc-eq-value fn 0 alist) wrld)
+ (mv-let
+ (contexts functs names)
+ (produce-counter-example1 (cdr ccmfs) context-array
+ (assoc-set-eq fn (1+ i) alist) wrld)
+ (mv (cons context contexts)
+ (cons funct functs)
+ (cons name names)))))))
+
+(defun-raw produce-counter-example2 (contexts names name0 ctx ens wrld state)
+ (if (endp contexts)
+ (value nil)
+ (let* ((context (car contexts))
+ (funct (context-parent-funct context))
+ (call (cons (if (endp (cdr names))
+ name0
+ (cadr names))
+ (fargs (context-call context)))))
+ (er-let*
+ ((ruler (state-global-let*
+ ((inhibit-output-lst
+ ;; no output here.
+ *valid-output-names*))
+ ;; remove any redundant or subsumed hyps.
+ (simp-hyps0 (context-ruler context)
+ ctx ens wrld state nil t nil :term-order)))
+ (body (value (if (endp ruler)
+ call
+ `(if ,(if (endp (cdr ruler))
+ (car ruler)
+ `(and ,@ruler))
+ ,call
+ (list ,@(funct-formals funct))))))
+ (rst (produce-counter-example2 (cdr contexts)
+ (cdr names)
+ name0
+ ctx ens wrld state)))
+ (value (cons `(defun ,(car names) ,(funct-formals funct) ,body)
+ rst))))))
+
+(defun-raw accg-find-ccmf (accg i j)
+ (loop for edge in (accg-node-fwd-edges (aref accg i))
+ when (= j (accg-edge-head edge))
+ return (accg-edge-ccmf edge)))
+
+(defun-raw produce-counter-example (path accg context-array ctx ens wrld state)
+ (let* ((ccmfs (loop for p on path
+ when (and (consp p) (consp (cdr p)))
+ collect (accg-find-ccmf accg (car p) (cadr p)))))
+ (pprogn
+ (fms "Producing counter-example, including simplifying rulers in order to ~
+ maximize the reabability of the counter-example."
+ nil
+ *standard-co*
+ state nil)
+ (mv-let
+ (contexts functs names)
+ (produce-counter-example1 ccmfs context-array nil wrld)
+ (er-let* ((defuns (produce-counter-example2 contexts names (car names)
+ ctx ens wrld state)))
+ (value (list* ccmfs functs defuns)))))))
+
+(defun-raw print-counter-example (accg ce contexts ctx ens wrld state)
+ (er-let*
+ ((triple (produce-counter-example (cdr ce)
+ accg
+ contexts
+ ctx ens wrld state))
+ (ccmfs (value (car triple)))
+ (functs (value (cadr triple)))
+ (defuns (value (cddr triple))))
+ (pprogn
+ (fms "The following function definitions correspond to an actual loop in ~
+ your function definitions for which the CCG analysis was unable to ~
+ prove termination in all cases: ~%~%~Y01~%"
+ (list (cons #\0 (untranslate (if (endp (cdr defuns))
+ (car defuns)
+ (cons 'mutual-recursion defuns))
+ nil wrld))
+ (cons #\1 (term-evisc-tuple nil state)))
+ *standard-co*
+ state nil)
+ ;; (print-ccms defuns functs 0 wrld state)
+ (print-ccmfs defuns ccmfs functs 0 wrld state)
+ (let* ((loop-graph (car ce))
+ (ne? (ccmf-graph-no-edges? loop-graph))
+ (ccms (funct-ccms (car functs))))
+ (fms "As it stands, we do not have enough information to show that this ~
+ loop terminates. ~#0~[When we put it all together, we find that ~
+ when we loop from ~x1 to itself, we know ~#2~[nothing about how ~
+ the values of the CCMs change. ~/the following about how values ~
+ change from one iteration to the loop to the next (measures are ~
+ presented without substitution):~%~%~Y34~]~/~]~|~%Note that under ~
+ this abstraction, the loop is idempotent (i.e. going through the ~
+ loop again will result in the same information about ~
+ non-increasing and decreasing values as we have just stated), and ~
+ that there is no CCM that decreases to itself across the loop. ~
+ There are therefore three possibilities: ~|~%(1) We did not guess ~
+ the CCMs needed for proving termination. If this is the case, you ~
+ could provide them for us using a :CONSIDER-CCMS or ~
+ :CONSIDER-ONLY-CCMS hint (see :DOC CCG-XARGS). If you are truly ~
+ desperate, you can resort to proving termination using ACL2's ~
+ measure-based termination method (do this globally by using ~
+ SET-TERMINATION-METHOD or just once by using the ~
+ :TERMINATION-METHOD xarg; see :DOC CCG-XARGS).~|~%(2) We guessed ~
+ the proper CCMs, but were unable to prove some necessary ~
+ theorem(s) about how these values change from step to step in the ~
+ loop. In this case, we suggest that you look at the ~
+ counter-example we generated and use it to determine what ~
+ additional lemmas are needed for CCG analysis to successfully ~
+ prove termination.~|~%(3) The loop really is non-terminating for ~
+ some inputs. In this case, you should alter the definition of the ~
+ function so that it will terminate on all inputs.~%~%"
+ (list (cons #\0 (if (consp (cdr defuns)) 0 1))
+ (cons #\1 (cadar defuns))
+ (cons #\2 (if ne? 0 1))
+ (cons #\3 (untranslate
+ (ccmf-graph-term
+ (1- (array-dimension loop-graph 0))
+ loop-graph
+ ccms
+ ccms
+ nil)
+ nil
+ wrld))
+ (cons #\4 (term-evisc-tuple nil state)))
+ *standard-co*
+ state nil)))))
+
+(defun-raw print-ccmf-changes (col changes state)
+ (if (endp changes)
+ state
+ (let ((change (car changes)))
+ (mv-let
+ (col state)
+ (fmt1 "When execution moves ~@0, the following ~
+ always holds:~|~%~x1.~|~%"
+ `((#\0 . ,(if (consp (car change))
+ `("from context ~x0 to context ~x1"
+ (#\0 . ,(caar change))
+ (#\1 . ,(cdar change)))
+ `("across context ~x0"
+ (#\0 . ,(car change)))))
+ (#\1 . ,(cdr change)))
+ col
+ *standard-co*
+ state
+ nil)
+ (print-ccmf-changes col (cdr changes) state)))))
+
+(defun-raw p< (p1 p2)
+ (or (< (car p1) (car p2))
+ (and (= (car p1) (car p2))
+ (< (cdr p1) (cdr p2)))))
+
+(defun-raw construct-accg-changes-printout (changes)
+ (if (endp changes)
+ nil
+ (cons `("the edge from context ~x0 to context ~x1"
+ (#\0 . ,(caar changes))
+ (#\1 . ,(cdar changes)))
+ (construct-accg-changes-printout (cdr changes)))))
+
+(defun-raw print-accg-changes (changes state)
+ (if (endp changes)
+ (fms "~|" nil *standard-co* state nil)
+ (pprogn
+ (fms "~x0 -> ~x1"
+ `((#\0 . ,(caar changes))
+ (#\1 . ,(cdar changes)))
+ *standard-co*
+ state
+ nil)
+ (print-accg-changes (cdr changes) state))))
+
+(defun-raw print-changes (col changes state)
+ (if (and (endp (car changes))
+ (endp (cdr changes)))
+ (mv-let
+ (col state)
+ (fmt1 "We discovered nothing new about the CCG.~|"
+ nil
+ col
+ *standard-co*
+ state
+ nil)
+ (declare (ignore col))
+ state)
+ (mv-let
+ (col state)
+ (fmt1 "We discovered the following about the CCG.~|~%"
+ nil
+ col
+ *standard-co*
+ state
+ nil)
+ (mv-let
+ (col state)
+ (if (endp (car changes))
+ (mv col state)
+ (mv-let
+ (col state)
+ (fmt1 "We can safely omit the following edges from the CCG:~|"
+ nil
+ col
+ *standard-co*
+ state
+ nil)
+ (declare (ignore col))
+ (mv 0 (print-accg-changes (car changes) state))))
+ (print-ccmf-changes col
+ (sort (copy-list (cdr changes))
+ (if (consp (caadr changes))
+ #'p<
+ #'<)
+ :key #'car)
+ state)))))
+
+
+(defun-raw print-context-array1 (i names context-array state)
+ (if (>= i (array-dimension context-array 0))
+ state
+ (pprogn
+ (let ((context (aref context-array i)))
+ (fms "CALLING CONTEXT ~x0~#1~[~/ in the body of ~x2~]:~|rulers: ~
+ ~x3~|call: ~x4~|"
+ `((#\0 . ,i)
+ (#\1 . ,names)
+ (#\2 . ,(context-fn context))
+ (#\3 . ,(context-ruler context))
+ (#\4 . ,(context-call context)))
+ *standard-co*
+ state
+ nil))
+ (print-context-array1 (1+ i) names context-array state))))
+
+(defun-raw print-context-array (names context-array state)
+ (pprogn
+ (fms "The calling contexts for ~#0~[this definition~/these definitions~] ~
+ are:~|"
+ `((#\0 . ,names))
+ *standard-co*
+ state
+ nil)
+ (print-context-array1 0 names context-array state)))
+
+(defun-raw print-accg-edges3 (edges accg state)
+ (if (endp edges)
+ state
+ (pprogn
+ (let ((pair (accg-edge-context-pair (car edges) accg)))
+ (fms "~x0 -> ~x1"
+ `((#\0 . ,(car pair))
+ (#\1 . ,(cdr pair)))
+ *standard-co*
+ state
+ nil))
+ (print-accg-edges3 (cdr edges) accg state))))
+
+(defun-raw print-accg-edges2 (i n accg state)
+ (if (>= i n)
+ state
+ (pprogn
+ (print-accg-edges3 (accg-node-fwd-edges (aref accg i)) accg state)
+ (print-accg-edges2 (1+ i) n accg state))))
+
+(defun-raw print-accg-edges1 (accgs state)
+ (if (endp accgs)
+ (fms "~|" nil *standard-co* state nil)
+ (pprogn
+ (print-accg-edges2 0
+ (array-dimension (car accgs) 0)
+ (car accgs)
+ state)
+ (print-accg-edges1 (cdr accgs) state))))
+
+(defun-raw print-accg-edges (col accgs state)
+ (if (endp accgs)
+ state
+ (mv-let
+ (col state)
+ (fmt1 "The Calling Context Graph has the following edges:~|"
+ nil col *standard-co* state nil)
+ (declare (ignore col))
+ (print-accg-edges1 accgs state))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; the following code is for building a CCG
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; limit-induction-hint-fn limits the amount of time spent on a proof
+;;; attempt by limiting the amount of induction and subgoals that may
+;;; be considered before the prover gives up. This is done with
+;;; computed hintus.
+(defun limit-induction-hint-fn (i)
+ ;; this computed hint has two pieces. the first limits induction,
+ ;; the second limits subgoals in order to avoid infinite loops.
+ `(or (and (length-exceedsp (car id) ,i) ;;if we are i inductions deep
+ (endp (cdadr id)) ;;and we are not in a subgoal of an induction
+ (eq (cddr id) 0) ;;and we haven't done anything with the current subgoal yet,
+ '(:computed-hint-replacement t :do-not-induct :otf-flg-override));; do not induct any further.
+ (and (> (cddr id) 20) ;; if we have been working on the same subgoal for 20 steps with no induction or case splitting,
+ '(:computed-hint-replacement t
+ :do-not '(eliminate-destructors
+ eliminate-irrelevance
+ generalize fertilize) ;; turn off all proof methods
+ ;; Pete: put a quote in front of (eliminate ...) above since that generated an error
+ :in-theory (theory 'minimal-theory))))) ;; and use minimal theory
+
+(defun translated-limit-induction-hint (i)
+ `((eval-and-translate-hint-expression
+ "CCG Query" nil
+ (cons
+ 'nil
+ (cons
+ ((lambda
+ (i id)
+ (if
+ (if
+ (length-exceedsp (car id) i)
+ (if
+ (endp (cdr (car (cdr id))))
+ (if (eq (cdr (cdr id)) '0)
+ '(:computed-hint-replacement t
+ :do-not-induct :otf-flg-override)
+ 'nil)
+ 'nil)
+ 'nil)
+ (if
+ (length-exceedsp (car id) i)
+ (if
+ (endp (cdr (car (cdr id))))
+ (if (eq (cdr (cdr id)) '0)
+ '(:computed-hint-replacement t
+ :do-not-induct :otf-flg-override)
+ 'nil)
+ 'nil)
+ 'nil)
+ (if (< '20 (cdr (cdr id)))
+ '(:computed-hint-replacement
+ t
+ :do-not '(eliminate-destructors eliminate-irrelevance
+ generalize fertilize)
+ :in-theory (theory 'minimal-theory))
+ 'nil)))
+ ',i
+ id)
+ (cons state 'nil))))))
+
+;;;ccg-simplify-contexts;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun-raw ccg-negate (exp)
+ ;; returns expression corresponding to the negation of expression exp.
+ (if (and (consp exp)
+ (eq (first exp) 'not))
+ (second exp)
+ `(not ,exp)))
+
+(defun-raw ccg-addlist (lst)
+ ;; creates a macro-expanded expression corresponding to the sum of a
+ ;; list of expressions.
+ (cond ((endp lst) 0)
+ ((endp (cdr lst)) (car lst))
+ (t `(binary-+ ,(car lst) ,(ccg-addlist (cdr lst))))))
+
+
+(defun-raw ccg-count-contexts (tms)
+ ;; given a list of lists of items, returns the total number of items.
+ (let ((i 0))
+ (dolist (tm tms i)
+ (setf i (+ i (len tm))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; helper functions ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; The following code implements memoization. Currently this works as
+;;; follows. At the beginning of termination analysis, we create a
+;;; memoization struct with the default values for each list. At each
+;;; prover query that is not built-in-clauses only, we check the prove
+;;; list to see if any previously proved query subsumes our current
+;;; goal. If so, we know our goal is true. Otherwise, we check our
+;;; current goal against those previously unproven using 1 induction
+;;; and, if our current restrictions indicate that we should only use
+;;; 0 inductions, those previously unproven using 0 inductions. Here
+;;; we check for equality (modulo alpha renaming) rather than
+;;; subsumption, due to the fact that ACL2 is not a decision
+;;; procedure, but relies on heuristics to guide proofs. Hence, ACL2
+;;; might fail to prove a given theorem but succeed in proving a more
+;;; general version. Therefore, unless we find the same query (modulo
+;;; alpha renaming) in our unproved lists, we try the proof anyway.
+;;;
+;;; When a ACL2 is done with a query, we add it to proved, unproved0,
+;;; or unproved1 depending on whether the proof attempt was successful
+;;; (and if it was not successful, how many inductions were tried).
+;;;
+;;; Possible improvements:
+;;;
+;;; * instead of proving queries on the fly, perhaps we could collect
+;;; all the queries and sort them from most to least general. That
+;;; way, if we prove a query, we get for free all the queries that
+;;; it generalizes.
+;;;
+;;; * can we do some preprocessing on the queries before we compare
+;;; them for subsumption? The current subsumption checks are simple
+;;; syntactic comparisons.
+;;;
+;;; * we can use random testing to discover queries that are provably
+;;; false. We can then have another list, false-queries that we can
+;;; check against. When doing so, we can safely check subsumption
+;;; rather than equality, making it much more powerful than the
+;;; current unproved checks.
+
+(defun-raw subsumed-by-proved-clause (cl proved)
+ (and (consp proved)
+ (or (eq t (subsumes *init-subsumes-count* (car proved) cl nil))
+ (subsumed-by-proved-clause cl (cdr proved)))))
+
+(defun-raw eliminate-subsumed-tail (cl cl-set acc)
+ (if (endp cl-set)
+ acc
+ (eliminate-subsumed-tail cl (cdr cl-set)
+ (if (subsumes *init-subsumes-count*
+ cl (car cl-set) nil)
+ acc
+ (cons (car cl-set) acc)))))
+
+(defun-raw add-proved-clause (cl proved)
+ (cons cl (eliminate-subsumed-tail cl proved nil)))
+
+(defun-raw equals-unproved-clause1 (cl unproved)
+ ;; note, it is logically sufficient to check that cl subsumes some
+ ;; unproved clause to say that if the unproved clause is unproveable
+ ;; in the current theory, that cl will also be unproveable. However,
+ ;; we are talking about clauses that ACL2 was unable to prove under
+ ;; a set of restrictions. Given ACL2's heuristics and proving
+ ;; algorithm, it is possible that adding hypotheses might lead ACL2
+ ;; astray. Therefore, we want to attempt the proof unless we were
+ ;; unsuccessful proving the exact same query.
+ (and (consp unproved)
+ (or (let ((cl-unproved (car unproved)))
+ (and (eq t (subsumes *init-subsumes-count* cl cl-unproved nil))
+ (eq t (subsumes *init-subsumes-count* cl-unproved cl nil))))
+ (equals-unproved-clause1 cl (cdr unproved)))))
+
+(defun-raw equals-unproved-clause (cl unproved i)
+ ;; checks if we already failed to prove cl using an induction depth of i or
+ ;; higher.
+ (and (< i (array-dimension unproved 0))
+ (or (equals-unproved-clause1 cl (aref unproved i))
+ (equals-unproved-clause cl unproved (1+ i)))))
+
+;;; time-limit check
+(defmacro-raw time-er (ctx)
+ `(er soft ,ctx "CCG analysis has exceeded the specified time ~
+ limit. If you did not expect a time-limit, check the global ~
+ time-limit setting (see :DOC set-ccg-time-limit and the ~
+ discussion of the :time-limit flag in :DOC CCG) to find out ~
+ more. At this point you have several options:~|~% ~
+ * Set the :don't-guess-ccms flag to t. Sometimes CCG analysis ~
+ guesses too many CCMs which leads to excessive prover ~
+ queries. This will eliminate *all* CCMs other than the ~
+ acl2-count of each formal.~|~%~
+ * Do you see a variable that you don't think is relevant to the ~
+ termination proof? In that case, us the :ignore-formals flag ~
+ to tell the CCG analysis to throw out CCMs that contain that ~
+ formal. This may also cut down on CCMs and therefore prover ~
+ queries.~|~%~
+ * Finally, if you are willing to wait some more, you ~
+ could try increasing the time limit, or eliminating it by ~
+ setting it to nil."))
+
+
+(defun-raw time-left (stop-time ctx state)
+ (let ((now (get-internal-run-time)))
+ (if (< now stop-time)
+ (value (/ (- stop-time now)
+ (coerce internal-time-units-per-second 'float)))
+ (time-er ctx))))
+
+(defun-raw time-check (stop-time ctx state)
+ (if (and (posp stop-time)
+ (<= stop-time (get-internal-run-time)))
+ (time-er ctx)
+ (value nil)))
+
+(defmacro-raw maybe-prover-before-stop-time (stop-time ctx state body)
+ `(let ((stop-time ,stop-time))
+ (if (null stop-time)
+ ,body
+ (er-let* ((time-limit (time-left stop-time ,ctx ,state)))
+ (with-prover-time-limit time-limit
+ ,body)))))
+
+(defun prove-no-er (term pspv hints ens wrld ctx state)
+ ;; calls prover, catching any error that occurred. Returns the error
+ ;; triple whose value is the cons of the negation of the error value
+ ;; returned by prove (i.e. whether prove successfully proved the
+ ;; query or not) and either nil (if unsuccessful) or the resulting
+ ;; ttree (if successful).
+ (mv-let (er ttree state)
+ (prove term pspv hints ens wrld ctx state)
+ (if er
+ (value (cons nil nil))
+ (value (cons t ttree)))))
+
+;; query is the work-horse of our algorithm. It calls the prover
+;; with the appropriate restrictions to ensure that it does not
+;; attempt to prove termination forever. This function returns an
+;; error triple whose value is the ttree generated by the proof. If
+;; the proof fails, the triple indicates an error.
+
+(defun-raw query (hyps concl pt qspv state)
+ (let* ((stop-time (access query-spec-var qspv :stop-time))
+ (mem (access query-spec-var qspv :mem))
+ (otf-flg (access query-spec-var qspv :otf-flg))
+ (ens (access query-spec-var qspv :ens))
+ (ctx (access query-spec-var qspv :ctx))
+ (wrld (access query-spec-var qspv :wrld))
+ (clause (add-literal concl (dumb-negate-lit-lst hyps) t))
+ (bic-onlyp (equal pt :built-in-clauses))
+ (ind-limit (if bic-onlyp -1 (cadr pt)))
+ (displayed-goal (prettyify-clause-set (list clause)
+ (let*-abstractionp state)
+ wrld)))
+ (pprogn (ccg-io? query nil state
+ (bic-onlyp ind-limit clause wrld)
+ (fms "We now make the following query, using ~
+ proof-technique ~x0 (see :DOC ~
+ CCG-hierarchy)~#1~[~/ and with the otf-flg set to ~
+ ~x2~]:~|~%GOAL~%~Y34."
+ `((#\0 . ,pt)
+ (#\1 . ,(if bic-onlyp 0 1))
+ (#\2 . ,otf-flg)
+ (#\3 . ,displayed-goal)
+ (#\4 . ,(term-evisc-tuple nil state)))
+ (proofs-co state)
+ state
+ nil))
+ (er-let*
+ ((pair
+ (cond (bic-onlyp
+ ;; if the proof-technique tells us to only use built-in-clauses, we call built-in-clause-p
+ (mv-let (built-in-clausep ttree)
+ (built-in-clausep 'query clause ens (match-free-override wrld) wrld state)
+ (value (if built-in-clausep
+ (cons t ttree)
+ (cons nil nil)))))
+ ;; have we already proved a more general query?
+ ((subsumed-by-proved-clause clause (memoization-proved mem))
+ (pprogn
+ (ccg-io? query nil state
+ ()
+ (fms "But we see that this query is already ~
+ subsumed by another query that was ~
+ previously proven.~%~%"
+ nil
+ (proofs-co state)
+ state
+ nil))
+ (value (cons t nil))))
+ ;; have we already failed to prove this query using the same proof techniques?
+ ((equals-unproved-clause clause
+ (memoization-unproved mem)
+ ind-limit)
+ (pprogn
+ (ccg-io? query nil state
+ ()
+ (fms "But we see that we already tried and ~
+ failed to prove an equivalent query ~
+ using the same restrictions on the ~
+ theorem prover.~%~%"
+ nil
+ (proofs-co state)
+ state
+ nil))
+ (value (cons nil nil))))
+ (t
+ ;; otherwise, we we need to call prove.
+ (er-let*
+ ((pair
+ (let ((hints (translated-limit-induction-hint ind-limit)))
+ (maybe-prover-before-stop-time
+ stop-time ctx state
+ (prove-no-er (termify-clause-set (list clause))
+ (make-pspv ens wrld
+ :displayed-goal displayed-goal
+ :otf-flg otf-flg)
+ hints ens wrld ctx state)))))
+ (progn
+ ;; update the memoization
+ (if (car pair)
+ (setf (memoization-proved mem)
+ (add-proved-clause clause
+ (memoization-proved mem)))
+ (setf (aref (memoization-unproved mem)
+ ind-limit)
+ (cons clause
+ (aref (memoization-unproved mem)
+ ind-limit))))
+ (value pair)))))))
+ (pprogn
+ (ccg-io? query nil state
+ ()
+ (fms "ACL2 has ~#0~[SUCCEEDED in proving this ~
+ query~/FAILED to prove this query~].~|"
+ (list (cons #\0 (if (car pair) 0 1)))
+ (proofs-co state)
+ state
+ nil))
+ (er-progn
+ (time-check stop-time ctx state)
+ (if (car pair)
+ (accumulate-ttree-and-step-limit-into-state
+ (cdr pair)
+ :skip;(initial-step-limit wrld state)
+ state)
+ (pprogn
+ (erase-gag-state state)
+ (value nil)))
+ (value (car pair))))))))
+
+;; the following two functions, ccg-generic-dfs-visit and
+;; ccg-generic-dfs perform a depth-first search of a "generic"
+;; directed graph. That is, a graph that is represented as an array of
+;; nodes with some way to get a list of adjacent nodes
+;; (node-fwd-edges) and some way, given an edge to get the index of
+;; the node that it points to (edge-head). The algorithm itself is
+;; taken directly out of the CLRS algorithms book.
+
+(defun-raw ccg-generic-dfs-visit (u graph f color time node-fwd-edges edge-head)
+ (setf (aref color u) 'grey)
+ (dolist (vn (funcall node-fwd-edges (aref graph u)))
+ (let ((v (funcall edge-head vn)))
+ (when (eq (aref color v) 'white)
+ (setf time (ccg-generic-dfs-visit v graph f color time node-fwd-edges edge-head)))))
+ (setf (aref color u) 'black)
+ (setf (aref f time) u)
+ (incf time))
+
+(defun-raw ccg-generic-dfs (graph node-fwd-edges edge-head)
+ ;; this is the main generic DFS function. See the comment before the
+ ;; previous function for a description of the arguments. This
+ ;; function returns an array of indices indicating the order that
+ ;; the nodes of the graph were visited. That is, the ith element of
+ ;; the return value is the index of the ith node visited.
+ (let* ((size (array-total-size graph))
+ (f (make-array size :element-type 'fixnum))
+ (time 0)
+ (color (make-array size
+ :element-type '(member white grey black)
+ :initial-element 'white)))
+ (dotimes (i size f)
+ (when (eq (aref color i) 'white)
+ (setf time (ccg-generic-dfs-visit i graph f color time node-fwd-edges edge-head))))))
+
+;;; The next two functions, like the previous two, operate on a
+;;; "generic" graph that is represented as an array of
+;;; nodes. Together, they implement an SCC analysis. The algorithm
+;;; used here is straight from the CLRS algorithm book.
+
+(defun-raw ccg-generic-scc-aux (u graph scc scc-array scc-num color node-bwd-edges edge-tail)
+ ;; this is the helper function for ccg-generic-scc. u is the index
+ ;; of the current node. graph is the array of nodes in the
+ ;; graph. scc is the list of nodes in the scc that we are building.
+ (let ((scc scc))
+ (setf (aref color u) 'grey)
+ (dolist (vn (funcall node-bwd-edges (aref graph u)))
+ (let ((v (funcall edge-tail vn)))
+ (when (eq (aref color v) 'white)
+ (setf scc
+ (ccg-generic-scc-aux v graph scc scc-array scc-num color
+ node-bwd-edges edge-tail)))))
+ (setf (aref color u) 'black)
+ (setf (aref scc-array u) scc-num)
+ (cons u scc)))
+
+(defun-raw ccg-generic-scc (graph node-fwd-edges node-bwd-edges edge-tail edge-head)
+ ;; this is the main scc algorithm. graph is the array of nodes
+ ;; representing the graph to be analyzed. node-fwd-edges is a
+ ;; function that takes a node from the graph and returns the list of
+ ;; the edges for which the given node is the tail. node-bwd-edges
+ ;; takes a node from the graph and returns the list of edges for
+ ;; which the given node is the head. edge-tail takes an edge and
+ ;; returns the index in graph that corresponds to the tail of the
+ ;; edge. edge-head takes an edge nad returns the index in graph that
+ ;; corresponds to the head of the edge. the function returns a list
+ ;; of lists of the nodes such that each list lists all the nodes in
+ ;; one scc, as well as an array indicating which scc each node
+ ;; belongs to.
+ (let ((scc-num -1))
+ (loop
+ with f = (ccg-generic-dfs graph node-fwd-edges edge-head)
+ with size = (array-dimension graph 0)
+ with color = (make-array size
+ :element-type '(member black grey white)
+ :initial-element 'white)
+ with scc-array = (make-array size
+ :element-type 'fixnum
+ :initial-element 0)
+ for i from (1- size) downto 0
+ for u = (aref f i)
+ when (eq (aref color u) 'white)
+ collect (ccg-generic-scc-aux u graph nil scc-array (incf scc-num) color
+ node-bwd-edges edge-tail)
+ into sccs
+ finally (return (values sccs scc-array)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; building an accg ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun-raw accg-can-omit-edge? (node1 node2 hlevel qspv state)
+ ;; given two ACCG nodes, node1 and node2, such that the function called by
+ ;; the call of node1 is equal to the fn of node2, as well as a
+ ;; ccg-restrict struct, and proof-related stuff (ens, wrld, ctx,
+ ;; state), this function attempts to prove that it is impossible to
+ ;; end up at node2 directly after visiting node1. We do this by
+ ;; attempting to prove that the ruler of node1 implies the negation of
+ ;; the ruler of node2 after the formals of the fn of node2 have been
+ ;; replaced by the actuals of the call of node1. if this can be
+ ;; proven, we return nil, otherwise, we return t.
+ (if (hlevel-ccmfs-per-nodep hlevel)
+ (value nil)
+ (query (append (accg-node-ruler node1)
+ (subcor-var-lst (accg-node-formals node2)
+ (fargs (accg-node-call node1))
+ (accg-node-ruler node2)))
+ nil
+ (hlevel-proof-technique hlevel) qspv state)))
+
+(defun-raw accg-fill-in-edges (accg name-node-alist)
+ (loop for i from 0 below (array-dimension accg 0)
+ for node1 = (aref accg i)
+ for successors = (cdr (assoc (accg-node-callfn node1)
+ name-node-alist))
+ do (setf (accg-node-fwd-edges node1)
+ (loop for node2 in successors
+ for j = (accg-node-num node2)
+ for edge = (make-accg-edge :tail i :head j)
+ do (setf (accg-node-bwd-edges node2)
+ (cons edge (accg-node-bwd-edges node2)))
+ collect edge))))
+
+(defun-raw context-to-accg-node-lst (contexts total)
+ (if (endp contexts)
+ (mv nil total)
+ (mv-let
+ (nodes ntotal)
+ (context-to-accg-node-lst (cdr contexts) total)
+ (let ((node (make-accg-node :context (car contexts))))
+ (mv (cons node nodes) (cons node ntotal))))))
+
+(defun-raw ccg-build-accg0 (names contexts)
+ (if (endp names)
+ (mv nil nil)
+ (let ((name (car names))
+ (context-list (car contexts)))
+ (mv-let
+ (alist total)
+ (ccg-build-accg0 (cdr names) (cdr contexts))
+ (mv-let
+ (nodes ntotal)
+ (context-to-accg-node-lst context-list total)
+ (mv (acons name nodes alist)
+ ntotal))))))
+
+(defun-raw ccg-build-accg (names contexts)
+ ;; given the names of the functions being analyzed, the contexts
+ ;; organized as a list of lists of contexts such that the ith list
+ ;; in contexts corresponds to the list of contexts in the ith
+ ;; function in names, the ccg-restrict struct restrict, and the
+ ;; other proof-related stuff, we build an ACCG.
+ (mv-let
+ (name-node-alist accg-node-lst)
+ (ccg-build-accg0 names contexts)
+ (let ((accg (coerce accg-node-lst 'vector)))
+ (progn
+ (loop for i from 0 below (array-dimension accg 0)
+ do (setf (accg-node-num (aref accg i)) i))
+ (accg-fill-in-edges accg name-node-alist)
+ accg))))
+
+(defun-raw simplify-contexts1 (context-lst ens wrld ctx state)
+ (if (endp context-lst)
+ state
+ (mv-let
+ (erp value state)
+ (ccg-simplify-hyps-no-split (context-ruler (car context-lst))
+ ctx ens wrld state)
+ (progn
+ (unless erp (setf (context-ruler (car context-lst)) value))
+ (simplify-contexts1 (cdr context-lst) ens wrld ctx state)))))
+
+(defun-raw simplify-contexts (contexts ens wrld ctx state)
+ (if (endp contexts)
+ state
+ (pprogn
+ (simplify-contexts1 (car contexts) ens wrld ctx state)
+ (simplify-contexts (cdr contexts) ens wrld ctx state))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; annotating accgs (ccmfs) ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; choosing ccms (see CAV paper) ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun de-propagate (term)
+ (if (eq (fn-symb term) 'ccg-propagate)
+ (fargn term 2)
+ term))
+
+(defun-raw ccg-formal-sizes (formals)
+ ;; given a list of formals, this function returns a list of
+ ;; expressions to calculate the acl2-count of each formal.
+ (loop for x in formals
+ collect `(acl2-count ,x)))
+
+(defun-raw ccg-add-zp-ccm (r formals ccms)
+ ;; if an expression, r -- which will generally correspond to one of
+ ;; the expressions in a ruler -- is (not (zp e)) for some expression
+ ;; e that is not in the list of formals, then we add e to our list
+ ;; of ccms.
+ (cond ((atom r) ccms)
+ ((and (eq (ffn-symb r) 'not)
+ (consp (fargn r 1))
+ (eq (ffn-symb (fargn r 1)) 'zp)
+ ;; NOTE: We could remove th
+ (not (member-eq (fargn (fargn r 1) 1) formals)))
+ (cons (fargn (fargn r 1) 1) ccms))
+ (t ccms)))
+
+
+(defun-raw ccg-add-<-ccm (r formals ccms)
+ ;; if an expression, r -- which will generally correspond to one of
+ ;; the expressions in a ruler -- is one of the following forms, we
+ ;; add the corresponding expression to the ccms:
+ ;;
+ ;; * (< 0 e2) --> (acl2-count e2)
+ ;; * (< e1 e2) --> (acl2-count (- e2 e1))
+ ;; * (not (< e1 0)) --> (1+ (acl2-count e1))
+ ;; * (not (< e1 e2)) --> (1+ (acl2-count (- e1 e2)))
+ (declare (ignore formals))
+ (cond ((atom r) ccms)
+ ((or (eq (car r) '<)
+ (and (eq (car r) 'not)
+ (consp (second r))
+ (eq (car (second r)) '<)))
+ (let* ((r0 (if (eq (car r) '<) r (second r)))
+ (p (term-order (second r0) (third r0)))
+ (arg1 (if p (second r0) (third r0)))
+ (arg2 (if p (third r0) (second r0))))
+ (cond ((and (quotep arg1) (quotep arg2))
+ ccms)
+ ((not (or (quotep arg1) (quotep arg2)))
+ (cons `(acl2-count (binary-+ '1
+ (binary-+ ,arg2
+ (unary-- ,arg1))))
+ ccms))
+ ((and (quotep arg1) (acl2-numberp (unquote arg1)))
+ (if (and (or (eql (unquote arg1) 0)
+ (eql (unquote arg1) 1))
+ (variablep arg2))
+ ccms
+ (cons `(acl2-count (binary-+ (quote ,(- 1 (unquote arg1))) ,arg2))
+ ccms)))
+ ((and (quotep arg2) (acl2-numberp (unquote arg2)))
+ (if (and (or (eql (unquote arg2) 0)
+ (eql (unquote arg2) 1))
+ (variablep arg1))
+ ccms
+ (cons `(acl2-count (binary-+ (quote ,(- 1 (unquote arg2))) ,arg1))
+ ccms)))
+ (t
+ ccms))))
+ (t ccms)))
+
+(defun-raw ccg-add-dec-ccm (arg ccms)
+ ;; a rule for adding a ccm that is not very helpful in general, but
+ ;; illustrates how it might be useful, in the future, to allow users
+ ;; to define their own rules for adding ccms. given an expression
+ ;; that should correspond to an argument of the call of a context,
+ ;; adds arg to the list of ccms if it is of the form (dec e).
+ (if (and (consp arg)
+ (eq (car arg) 'dec))
+ (cons arg ccms)
+ ccms))
+
+(defun-raw accg-guess-ccms-for-node (node)
+ ;; given a node, guesses ccms beyond the basic acl2-count of the
+ ;; formals.
+ (let ((ccms nil)
+ (rulers (accg-node-ruler node))
+ (formals (accg-node-formals node)))
+ (dolist (r rulers ccms)
+ (setf ccms (ccg-add-<-ccm r formals ccms))
+ (setf ccms (ccg-add-zp-ccm r formals ccms)))
+;; (dolist (a (fargs (accg-node-call node)) ccms)
+;; (setf ccms (ccg-add-dec-ccm a ccms)))
+ ))
+
+(defun-raw ccg-remove-duplicate-ccms-in-functs (functs)
+ ;; a function for removing any duplicate ccms in an array of lists of ccms.
+ (dolist (funct functs functs)
+ (setf (funct-ccms funct)
+ (remove-duplicates (funct-ccms funct)
+ :test #'equal
+ :key #'de-propagate))))
+
+(defun-raw ccg-remove-duplicate-ccms (ccms)
+ ;; a function for removing any duplicate ccms in an array of lists of ccms.
+ (let ((n (array-dimension ccms 0)))
+ (dotimes (i n ccms)
+ (setf (aref ccms i) (remove-duplicates (aref ccms i)
+ :test #'equal
+ :key #'de-propagate)))))
+
+;; when we guess ccms beyond the basic acl2-count of the formals of a
+;; function, we need to propagate the ccms throughout the accg. for
+;; example, suppose we have two functions, f and g, such that f
+;; contains the call (g x y) when (not (zp (- y x))) and g always
+;; calls (f (1+ x) y). then f will get assigned the ccm (- y x), but g
+;; will only have (acl2-count x) and (acl2-count y). in this
+;; situation, there will be no way to tell that (- y x) decreases each
+;; time through the loop. we need some sort of "place-holder" to keep
+;; track of the value of (- y x) when we are in the function g. the
+;; next few functions do this by walking backwards through the graph,
+;; visiting each node just once, and adding the ccm resulting in
+;; substituting actuals for formals in the non-trivial ccms from the
+;; next node. in our example, g would get the ccm (- y (1+ x)).
+
+
+
+(defun-raw accg-propagate-ccm (ccm accg n consider-onlyp)
+ ;; propagates a single ccm through the accg. here ccm is the ccm
+ ;; expression, accg is the accg, n is the index of the node to which
+ ;; the ccm is assigned, and consider-onlyp is an array of booleans
+ ;; that tells us whether the user supplied the ccms using a
+ ;; :CONSIDER-ONLY-CCMS hint or not for each node. this is done in a
+ ;; breadth-first order to ensure the shortest propagation paths and
+ ;; therefore simpler ccms in general.
+ (let* ((size (array-dimension accg 0))
+ ;; queued tells us if node i has been added to the queue for
+ ;; each 0 <= i < size.
+ (queued (make-array size :element-type 'boolean :initial-element nil))
+ ;; successor tells us the index of the successor of node i
+ ;; from which we propagate the ccm.
+ (successor (make-array size :element-type 'integer :initial-element 0))
+ ;; ccms is an array assigning each node index, i, to the ccm
+ ;; for that node.
+ (ccms (make-array size :initial-element nil))
+ ;; queue is the queue into which we put the indices of the
+ ;; nodes we are to visit in the order in which we are to
+ ;; visit them. the initial element is -1 so we know when we
+ ;; reach the end of the queue.
+ (queue (make-array size :element-type 'integer :initial-element -1))
+ (c (accg-node-context-num (aref accg n)))
+ ;; i is the index of the queue where the next enqueue
+ ;; operation should put the next node index.
+ (i 0)
+ ;; queue-preds is a small function that puts all the unqueued
+ ;; predecessors of node m into the queue.
+ (queue-preds (lambda (m)
+ (loop for edge in (accg-node-bwd-edges (aref accg m))
+ for pred = (accg-edge-tail edge)
+ unless (or (aref queued pred)
+ (aref consider-onlyp pred))
+ do (setf (aref queued pred) t)
+ and do (setf (aref queue (incf i)) pred)
+ and do (setf (aref successor pred) m)))))
+ (let ((node (aref accg n)))
+ (setf (accg-node-ccms node)
+ (cons ccm (accg-node-ccms node)))
+ (setf (aref ccms n) ccm))
+ (setf (aref queued n) t)
+ (funcall queue-preds n)
+ (loop for j from 1 below size
+ for k = (aref queue j)
+ when (= k -1) ;; if we get a -1, we have reached the end of the queue.
+ return nil
+ do (let* ((succ (aref successor k))
+ (node (aref accg k))
+ ;; we substitute actuals for formals in the ccm of the
+ ;; successor to get the new ccm.
+ (nccm (subcor-var (accg-node-callformals node)
+ (fargs (accg-node-call node))
+ (aref ccms succ))))
+ (setf (aref ccms k) nccm))
+ do (funcall queue-preds k))
+ (loop for j from 1 below size
+ for k = (aref queue j)
+ when (= k -1)
+ return nil
+ do (let ((node (aref accg k)))
+ (setf (accg-node-ccms node)
+ (cons `(ccg-propagate ,c ,(aref ccms k))
+ (accg-node-ccms node)))))))
+
+(defun-raw accg-propagate-ccms (ccms accg consider-onlyp)
+ ;; (print ccms) accg-propagate-ccms propagates all the ccms in ccms
+ ;; throughout the accg. here, ccms is an array of lists of ccms
+ ;; corresponding to the ccms assigned to each node in the
+ ;; accg. consider-onlyp is an array of booleans telling us whether
+ ;; or not the user supplied the ccms using a :CONSIDER-ONLY-CCMS
+ ;; xarg for each node. we return nccms which holds the new list of
+ ;; ccms for each node.
+ (loop with size = (array-dimension ccms 0)
+ for i from 0 below size
+ do (loop for ccm in (aref ccms i)
+ do (accg-propagate-ccm ccm accg i consider-onlyp))))
+
+(defun-raw accg-partition-ccms-by-function (ccms nodes)
+ ;; in order to compute ccmfs by node instead of by edge, ccms need
+ ;; to be assigned by function, not by accg node. this function takes
+ ;; the ccms assigned to the nodes of a accg and unions all the ccms
+ ;; of the contexts of each function. the result is an alist that
+ ;; maps function names to the ccms for that function.
+ (loop for i from 0 below (array-dimension ccms 0)
+ for funct = (accg-node-parent-funct (aref nodes i))
+ do (setf (funct-ccms funct)
+ (append (aref ccms i) (funct-ccms funct)))))
+
+(defun-raw accg-guess-ccms (accg functs ccm-hints-alist)
+ ;; accg-guess-ccms puts all the ccm-guessing together. it takes an
+ ;; accg and an alist mapping function names to ccms that is
+ ;; presumably provided by the user. the ccms are computed and then
+ ;; the accg is annotated by setting the accg-node-ccms field of each
+ ;; node in the accg to the appropriate list of ccms.
+ (let* ((size (array-dimension accg 0))
+ (ccms (make-array size :element-type 'list :initial-element nil))
+ (consider-onlyp (make-array size :element-type 'boolean :initial-element nil)))
+ ;; first we fill in the correct values for consider-onlyp for each
+ ;; node depending on whether the user provided ccms using
+ ;; :CONSIDER-ONLY-CCMs for the function containing the node. at
+ ;; the same time, we set the ccms for any node for which the user
+ ;; did supply ccms.
+ (loop for i from 0 below size
+ for entry = (assoc (accg-node-fn (aref accg i))
+ ccm-hints-alist)
+ do (setf (aref consider-onlyp i) (cadr entry))
+ unless (eq (cddr entry) *0*) ;; no value supplied is represented as *0*.
+ do (setf (aref ccms i) (cddr entry)))
+ ;; guess the non-trivial ccms for each node.
+ (loop for i from 0 below size
+ for node = (aref accg i)
+ unless (or (aref consider-onlyp i)
+ ;; don't guess ccms for dead-ends.
+ (endp (accg-node-fwd-edges (aref accg i))))
+ do (setf (aref ccms i)
+ (append (accg-guess-ccms-for-node node)
+ (aref ccms i))))
+ ;; next, we propagate the ccms and then partition them by
+ ;; function. finally, we set the ccm list of each node to be the
+ ;; non-trivial ccms for the function plus the acl2-count of each
+ ;; formal of the parent function and the sum of all the formal
+ ;; acl2-counts (if there is more than one formal).
+ (accg-propagate-ccms
+ (ccg-remove-duplicate-ccms ccms)
+ accg
+ consider-onlyp)
+ (ccg-remove-duplicate-ccms-in-functs functs)
+ (loop for funct in functs
+ for fn-sccms in ccm-hints-alist
+ for fsizes = (ccg-formal-sizes (funct-formals funct))
+;;; I've commented out the next line to avoid a compiler warning.
+; for ccms = (funct-ccms funct)
+ unless (cadr fn-sccms)
+ do (setf (funct-ccms funct)
+ (append fsizes
+ (if (length-exceedsp fsizes 1)
+ (cons (ccg-addlist fsizes)
+ (funct-ccms funct))
+ (funct-ccms funct))))
+ finally (ccg-remove-duplicate-ccms-in-functs functs))
+ ;; finally, we coerce the ccms for each function from lists into vectors
+ (loop for funct in functs
+ do (setf (funct-ccms funct)
+ (coerce (funct-ccms funct) 'vector)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; accg annotation (ccmfs) ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun-raw ccmf->-value? (ruler e1 e2 pt qspv state)
+ ;; returns true if we can prove that, under the ruler conditions, e2
+ ;; will always be o< e1.
+ (query ruler `(o< ,(de-propagate e2) ,(de-propagate e1))
+ pt qspv state))
+
+(defun-raw ccmf->=-value? (ruler e1 e2 pt qspv state)
+ ;; returns true if we can prove that, under the ruler conditions, e1
+ ;; will never be o< e2.
+ (query ruler `(not (o< ,(de-propagate e1) ,(de-propagate e2)))
+ pt qspv state))
+
+(defun-raw ccmf-skip-edge (f1 n1 c1 e1 f2 n2 e2 hlevel)
+ ;; returns whether, based on the restrictions indicated by the
+ ;; ccg-restrict struct, restrict, we should skip creating a ccmf
+ ;; edge for the ccms e1 and e2. this is mostly based on the
+ ;; ccg-restrict-measure-vars field.
+
+
+ ;; (format t "ccmf-skip-edge: ~A ~A~%~%" e1 e2)
+ (or (null hlevel)
+ (eq (fn-symb e1) 'ccg-propagated)
+ (and (eq (fn-symb e2) 'ccg-propagated)
+ (not (equal (fargn e2 1) c1)))
+ ;; NOTE: we used to think that built-in-clauses are so fast, we don't
+ ;; need to skip any. However, we came across some very expensive analyses
+ ;; (see one-way-unify1 in the foundations book in the paco directory of
+ ;; the regression suite).
+ (and ;;(not (ccg-restrict-bic-onlyp restrict))
+ (let ((v1 (all-vars e1)) ;; v1 is all the variables in e1
+ (v2 (all-vars e2))) ;; v2 is all the variables in e2
+ (and (not (and (eq f1 f2)
+ (= n1 n2)))
+ (case (hlevel-ccm-comparison-scheme hlevel)
+ ;; (:across
+ ;; (not (and (subsetp v1 v2)
+ ;; (subsetp v2 v1))))
+ ;; ;; if :equal, we skip if the variable sets are not equal.
+ (:equal
+ (not (and (subsetp v1 v2)
+ (subsetp v2 v1))))
+ ;; if :all, we skip if v1 is not a proper subset of v2.
+ (:all
+ (or (subsetp v2 v1)
+ (not (subsetp v1 v2))))
+ ;; if :some, we skip if v1 a subset of v2 or v1 and v2 do
+ ;; not intersect.
+ (:some
+ (or (subsetp v1 v2)
+ (not (intersectp-eq v1 v2))))
+ ;; if :none, we skip if v1 and v2 intersect.
+ (:none
+ (intersectp-eq v1 v2))))))))
+
+(defun-raw accg-copy-ccmf-graph (graph &key (size nil))
+ ;; creates a copy of a ccmf graph
+ (let* ((n (array-dimension graph 0))
+ (ngraph (make-array (if size (max n size) n)
+ :element-type 'ccmf-node
+ :initial-element (make-ccmf-node))))
+ (loop for i from 0 below n
+ for node = (aref graph i)
+ do (setf (aref ngraph i)
+ (make-ccmf-node :>-edges (copy-list (ccmf-node->-edges node))
+ :>=-edges (copy-list (ccmf-node->=-edges node)))))
+ ngraph))
+
+(defun-raw accg-add-ccmfs (accg)
+ (loop for node1 across accg
+ for in-sizes = (array-dimension (accg-node-ccms node1) 0)
+ do (loop for edge in (accg-node-fwd-edges node1)
+ for head = (accg-edge-head edge)
+ for node2 = (aref accg head)
+ for graph = (make-array in-sizes)
+ do (loop for i from 0 below in-sizes
+ do (setf (aref graph i)
+ (make-ccmf-node)))
+ do (setf (accg-edge-ccmf edge)
+ (make-ccmf :firstsite (accg-edge-tail edge)
+ :lastsite head
+ :fc-num (accg-node-context-num node1)
+ :lc-num (accg-node-context-num node2)
+ :in-sizes in-sizes
+ :out-sizes (array-dimension (accg-node-ccms
+ node2)
+ 0)
+ :graph graph)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;
+;;; accg sccs ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun-raw accg-scc (graph)
+ (ccg-generic-scc graph
+ #'accg-node-fwd-edges #'accg-node-bwd-edges
+ #'accg-edge-tail #'accg-edge-head))
+
+(defun-raw accg-edge-context-pair (edge accg)
+ (cons (car
+ (accg-node-context-num
+ (aref accg
+ (accg-edge-tail
+ edge))))
+ (car
+ (accg-node-context-num
+ (aref accg
+ (accg-edge-head
+ edge))))))
+
+(defun-raw accg-delete-non-scc-edges1 (edges accg scc scc-array)
+ (if (endp edges)
+ (mv nil nil)
+ (mv-let
+ (changes nedges)
+ (accg-delete-non-scc-edges1 (cdr edges) accg scc scc-array)
+ (if (= scc (aref scc-array (accg-edge-head (car edges))))
+ (mv changes (cons (car edges) nedges))
+ (mv (cons (accg-edge-context-pair (car edges) accg)
+ changes)
+ nedges)))))
+
+(defun-raw accg-delete-non-scc-edges (accg scc-array)
+ (loop with changes = nil
+ for i from 0 below (array-dimension accg 0)
+ for nodei = (aref accg i)
+ for scci = (aref scc-array i)
+ do (mv-let
+ (nchanges nedges)
+ (accg-delete-non-scc-edges1 (accg-node-fwd-edges nodei) accg scci scc-array)
+ (progn
+ (setf (accg-node-fwd-edges nodei) nedges)
+ (setf changes (append nchanges changes))))
+ do (setf (accg-node-bwd-edges nodei)
+ (delete-if-not #'(lambda (x)
+ (= scci
+ (aref scc-array
+ (accg-edge-tail x))))
+ (accg-node-bwd-edges nodei)))
+ finally (return changes)))
+
+(defun-raw accg-separate-sccs0 (accg sccs scc-array &key (ccmfp nil))
+ (if (endp (cdr sccs))
+ (mv nil (list accg))
+ (let* ((m (array-dimension accg 0)) ;; the number of nodes in the current accg
+ (n (len sccs)) ;; the number of sccs
+ (count (make-array n ;; an array keeping track of the size of each scc.
+ :element-type 'fixnum
+ :initial-element 0))
+ (mapping (make-array m ;; a mapping from the old index of each node to its new index.
+ :element-type 'fixnum
+ :initial-element 0))
+ (changes nil))
+ ;; next, we calculate the values of count and the mapping.
+ (loop for i from 0 below m
+ for j = (aref scc-array i)
+ do (setf (aref mapping i) (aref count j))
+ do (incf (aref count j)))
+ ;; naccgs is an array of the new accgs.
+ (let ((naccgs (make-array n)))
+ ;; we set each accg in naccg to be an array of nodes.
+ (loop for i from 0 below n
+ do (setf (aref naccgs i)
+ (make-array (aref count i))))
+ ;; we now populate naccgs with nodes, setting the
+ ;; accg-node-num and resetting the accg-node-bwd-edges
+ (loop for i from 0 below m
+ for sccn = (aref scc-array i)
+ for noden = (aref mapping i)
+ for node = (aref accg i)
+ do (setf (aref (aref naccgs sccn) noden)
+ node)
+ do (setf (accg-node-num node) noden)
+ do (setf (accg-node-bwd-edges node) nil))
+ ;; now we fix the edges
+ (loop for i from 0 below n
+ for naccg = (aref naccgs i)
+ do (loop for j from 0 below (aref count i)
+ for node = (aref naccg j)
+ ;; we recalculate the accg-node-fwd-edges of node as follows
+ do (setf (accg-node-fwd-edges node)
+ (loop for e in (accg-node-fwd-edges node)
+ for head = (accg-edge-head e)
+ for nhead = (aref mapping head)
+ for ccmf = (accg-edge-ccmf e)
+ ;; if the edge traverses two
+ ;; edges in the same scc,
+ if (= (aref scc-array head) i)
+ ;; set the head and tail of the edge
+ do (setf (accg-edge-head e) nhead)
+ and do (setf (accg-edge-tail e) j)
+ ;; add the edge to the
+ ;; appropriate bwd-edges list
+ and do (let ((hnode (aref naccg nhead)))
+ (setf (accg-node-bwd-edges hnode)
+ (cons e
+ (accg-node-bwd-edges hnode))))
+ ;; collect e into our new list of fwd-edges
+ and collect e
+ ;; when we need to worry about
+ ;; ccmfs, fix this edge's
+ ;; ccmf.
+ and when ccmfp
+ do (setf (ccmf-firstsite ccmf) j)
+ and do (setf (ccmf-lastsite ccmf)
+ nhead)
+ else do (setf changes
+ (cons
+ (accg-edge-context-pair e accg)
+ changes))))))
+ ;; finally, we collect all the non-trivial sccs into a list and return it.
+ (mv changes
+ (loop for i from 0 below n
+ for naccg = (aref naccgs i)
+ unless (and (= (aref count i) 1)
+ (not (accg-node-fwd-edges (aref naccg 0))))
+ collect naccg))))))
+
+(defun-raw accg-separate-sccs (accg &key (ccmfp nil))
+ ;; separates an accg into its sccs. ccmfp indicates whether or not
+ ;; the accg has already been annotated with ccmfs. this function is
+ ;; destructive.
+
+ ;; we start by doing the scc analysis:
+ (multiple-value-bind
+ (sccs scc-array)
+ (accg-scc accg)
+ (accg-separate-sccs0 accg sccs scc-array :ccmfp ccmfp)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; putting it all together ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun-raw build-and-annotate-accgs (names functs contexts ccm-hints-alist)
+ ;; build-and-annotate-accgs does exactly what it says. names is the
+ ;; names of the functions, contexts is a list of lists of contexts
+ ;; such that the ith list in contexts is the list of contexts in the
+ ;; ith function in names. restrict is the current ccg-restrict
+ ;; struct, and ccms-alist is the alist mapping function names to the
+ ;; ccms provided for the user for that function.
+ (let ((accg (ccg-build-accg names contexts)))
+ (multiple-value-bind
+ (sccs scc-array)
+ (accg-scc accg)
+ (progn
+ (accg-delete-non-scc-edges accg scc-array)
+ (accg-guess-ccms accg functs ccm-hints-alist)
+ (accg-add-ccmfs accg)
+ (mv-let
+ (changes0 naccgs)
+ (accg-separate-sccs0 accg sccs scc-array :ccmfp t)
+ (declare (ignore changes0))
+ naccgs)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; refining accgs ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(defun-raw weaker-proof-techniquesp (h1 h2)
+ ;; given two levels in the hierarchy, this function tells us whether the
+ ;; proof-techniques of the first are weaker than the proof-techniques of the
+ ;; second, i.e. that it might be possible to prove something using the proof
+ ;; techniques of h2 that would not be proven using the techniques in h1.
+
+
+ (or ;; h1 is nil in our first round of refinement, when their is no
+ ;; previous level to the hierarchy
+ (null h1)
+ (not (null h2)) ;; this should never happen
+ (let ((pt1 (car h1))
+ (pt2 (car h2)))
+ ;; the proof techniques of h1 are weaker if it limited to built-in-clauses
+ ;; while h2 is not:
+ (if (equal pt1 :built-in-clauses)
+ (not (equal pt2 :built-in-clauses))
+ ;; the proof techniques of h1 are weaker if it is of the form
+ ;; (:induction-depth n1), h2 is of the form (:induction-depth n2) and
+ ;; (< n1 n2).
+ (and (consp pt2)
+ (< (cadr pt1)
+ (cadr pt2)))))))
+
+(defun-raw accg-ccmf-adj-matrix (ccmf)
+ ;; given a ccmf, this function builds an adjacency matrix where
+ ;; element i,j is >, >=, or nil if there is a >-edge, >=-edge, or no
+ ;; edge from ccm i of the first context to ccm j of the second index
+ ;; in the ccmf, respectively.
+ (loop with n1 = (ccmf-in-sizes ccmf)
+ with n2 = (ccmf-out-sizes ccmf)
+ with graph = (ccmf-graph ccmf)
+ with matrix = (make-array `(,n1 ,n2)
+ :initial-element nil
+ :element-type '(member nil '>= '>))
+ for i from 0 below n1
+ for node = (aref graph i)
+ do (loop for j in (ccmf-node->-edges node)
+ do (setf (aref matrix i j) '>))
+ do (loop for j in (ccmf-node->=-edges node)
+ do (setf (aref matrix i j) '>=))
+ finally (return matrix)))
+
+;; currently destructive
+
+(defun-raw accg-refine-ccmf2 (i j matrix node e1 hyps f1 c1 f2 ccms2 cformals args redop
+ changes old-hlevel hlevel qspv state)
+ (let ((wrld (access query-spec-var qspv :wrld)))
+ (if (< j 0)
+ (value changes)
+ (let* ((o2 (aref ccms2 j))
+ (e2 (subcor-var cformals args o2))
+ (u1 (untranslate e1 nil wrld))
+ (u2 (untranslate o2 nil wrld))
+ (skipp (or (ccmf-skip-edge f1 i c1 e1 f2 j e2 hlevel)
+ (not (or redop ;; if circumstances tell us to redo the > proof,
+ (ccmf-skip-edge f1 i c1 e1 f2 j e2 old-hlevel)))))
+ (label (aref matrix i j))
+ (pt (hlevel-proof-technique hlevel)))
+ (er-let*
+ ((nlabel
+ (cond (skipp (value label))
+ ((eq label '>) (value '>))
+ ((equal (de-propagate e1) (de-propagate e2)) (value '>=))
+ (t
+ (er-let*
+ ((result
+ (pprogn
+ (increment-timer 'other-time state)
+ (ccg-io? build/refine nil state
+ (u1 u2)
+ (fms "We attempt to prove that, under the given ~
+ conditions, it is the case that the ~
+ context measure ~x0 is always greater than ~
+ ~x1.~|"
+ `((#\0 . ,u1)
+ (#\1 . ,u2))
+ *standard-co*
+ state
+ nil))
+ (increment-timer 'print-time state)
+ (ccmf->-value? hyps e1 e2 pt qspv state))))
+ (cond (result (value '>))
+ ((eq label '>=) (value '>=))
+ (t
+ (er-let*
+ ((result
+ (pprogn
+ (increment-timer 'other-time state)
+ (ccg-io? build/refine nil state
+ (u1 u2)
+ (fms "Since the previous query failed, ~
+ we attempt to prove that, under ~
+ the given conditions, it is the ~
+ case that the context measure ~x0 ~
+ is never less than ~x1.~|"
+ `((#\0 . ,u1)
+ (#\1 . ,u2))
+ *standard-co*
+ state
+ nil))
+ (increment-timer 'print-time state)
+ (ccmf->=-value? hyps e1 e2 pt qspv state))))
+ (value (if result '>= nil))))))))))
+ (progn
+ ;;(format t "~&e1: ~A e2: ~A label: ~A~%" e1 e2 nlabel)
+ (case nlabel
+ (> (setf (ccmf-node->-edges node)
+ (cons j (ccmf-node->-edges node))))
+ (>= (setf (ccmf-node->=-edges node)
+ (cons j (ccmf-node->=-edges node)))))
+ (accg-refine-ccmf2 i (1- j) matrix node e1
+ hyps f1 c1 f2 ccms2 cformals args redop
+ (if (eq nlabel label)
+ changes
+ (cons `(,nlabel ,u1 ,u2) changes))
+ old-hlevel hlevel qspv state)))))))
+
+(defun-raw accg-refine-ccmf1 (i matrix ccmf
+ hyps f1 ccms1 c1 f2 ccms2 cformals args redop
+ changes old-hlevel hlevel
+ qspv state)
+ ;; this function destructively refines a ccmf. note that its
+ ;; signature looks just like that of accg-construct-ccmf-graph,
+ ;; except we have the added arguments redop and old-hlevel, which
+ ;; help us to know when we need to redo proofs we have already done.
+
+ (if (< i 0)
+ (value (cond ((endp changes) changes)
+ ((endp (cdr changes)) (car changes))
+ (t (cons 'and changes))))
+ (er-let*
+ ((changes0 (accg-refine-ccmf2 i (1- (ccmf-out-sizes ccmf)) matrix (aref (ccmf-graph ccmf) i)
+ (aref ccms1 i) hyps f1 c1 f2 ccms2 cformals args redop
+ changes old-hlevel hlevel qspv state)))
+ (accg-refine-ccmf1 (1- i) matrix ccmf
+ hyps f1 ccms1 c1 f2 ccms2 cformals args redop
+ changes0 old-hlevel hlevel qspv state))))
+
+(defun-raw accg-refine-ccmf (ccmf hyps f1 ccms1 c1 f2 ccms2 cformals args redop
+ old-hlevel hlevel qspv state)
+ (let ((matrix (accg-ccmf-adj-matrix ccmf)))
+ (loop for node across (ccmf-graph ccmf)
+ do (setf (ccmf-node->-edges node) nil)
+ do (setf (ccmf-node->=-edges node) nil))
+ (accg-refine-ccmf1 (1- (ccmf-in-sizes ccmf)) matrix
+ ccmf hyps f1 ccms1 c1 f2 ccms2 cformals args redop
+ nil old-hlevel hlevel qspv state)))
+
+(defun-raw accg-node-refine-ccmfs-per-edge
+ (edges node1 accg ccms1 c1 ruler1 cformals args
+ stronger-proofsp changes old-hlevel hlevel
+ qspv state)
+ (if (endp edges)
+ (value changes)
+ (let* ((edge (car edges))
+ (node2 (aref accg (accg-edge-head edge)))
+ (ccms2 (accg-node-ccms node2))
+ (ruler2 (subcor-var-lst cformals args (accg-node-ruler node2)))
+ (wrld (access query-spec-var qspv :wrld)))
+ (pprogn
+ (increment-timer 'other-time state)
+ (ccg-io? build/refine nil state
+ (node1 ruler1 wrld node2)
+ (fms "We use theorem prover queries to discen how the context ~
+ measures change when execution moves from call ~x0 in ~
+ function ~x1 under the ruler ~x2 to call ~x3 in ~
+ function ~x4 under the ruler ~x5.~|"
+ `((#\0 . ,(accg-node-call node1))
+ (#\1 . ,(accg-node-fn node1))
+ (#\2 . ,(untranslate-lst ruler1 nil wrld))
+ (#\3 . ,(accg-node-call node2))
+ (#\4 . ,(accg-node-fn node2))
+ (#\5 . ,(untranslate-lst (accg-node-ruler node2) nil wrld)))
+ *standard-co*
+ state
+ nil))
+ (increment-timer 'print-time state)
+ (er-let*
+ ((nchanges (accg-refine-ccmf (accg-edge-ccmf edge)
+ (append ruler1 ruler2)
+ (accg-node-fn node1)
+ ccms1
+ c1
+ (accg-node-fn node2)
+ ccms2
+ cformals args
+ stronger-proofsp
+ old-hlevel hlevel
+ qspv state)))
+ (accg-node-refine-ccmfs-per-edge
+ (cdr edges) node1 accg ccms1 c1 ruler1
+ cformals args
+ stronger-proofsp
+ (if (null nchanges)
+ changes
+ (acons (cons (car (accg-node-context-num node1))
+ (car (accg-node-context-num node2)))
+ nchanges
+ changes))
+ old-hlevel hlevel
+ qspv state))))))
+
+(defun-raw accg-refine-ccmfs1 (i accg stronger-proofsp changes
+ old-hlevel hlevel qspv state)
+ ;; refines all the ccmfs in an accg.
+ (if (< i 0)
+ (value changes)
+ (let* ((node1 (aref accg i))
+ (ccms1 (accg-node-ccms node1))
+ (c1 (accg-node-context-num node1))
+ (ruler1 (accg-node-ruler node1))
+ (cformals (accg-node-callformals node1))
+ (args (fargs (accg-node-call node1)))
+ (wrld (access query-spec-var qspv :wrld)))
+ (er-let*
+ ((changes0
+ (if (hlevel-ccmfs-per-nodep hlevel)
+ ;; if we are creating/refining ccmfs on a per-node basis
+ ;; (rather than per-edge), we refine one ccmf for the node and
+ ;; propagate its graph to the ccmf of every edge.
+ (pprogn
+ (ccg-io? build/refine nil state
+ (c1 ruler1 wrld)
+ (fms "We use theorem prover queries to discern how our ~
+ context mesaures change when execution moves ~
+ across call ~x0 in function ~x1 under the ruler ~
+ ~x2.~|"
+ `((#\0 . ,(accg-node-call node1))
+ (#\1 . ,(accg-node-fn node1))
+ (#\2 . ,(untranslate-lst ruler1 nil wrld)))
+ *standard-co*
+ state
+ nil))
+ (er-let*
+ ((edge1 (value (car (accg-node-fwd-edges node1))))
+ (node2 (value (aref accg (accg-edge-head edge1))))
+ (ccmf (value (accg-edge-ccmf (car (accg-node-fwd-edges node1)))))
+ (nchanges (accg-refine-ccmf ccmf
+ ruler1
+ (accg-node-fn node1)
+ ccms1
+ c1
+ (accg-node-fn node2)
+ (accg-node-ccms node2)
+ cformals args
+ stronger-proofsp
+ old-hlevel hlevel
+ qspv state))
+ (ngraph (value (ccmf-graph ccmf))))
+ (loop for edge in (cdr (accg-node-fwd-edges node1))
+ for occmf = (accg-edge-ccmf edge)
+ do (setf (ccmf-graph occmf)
+ (accg-copy-ccmf-graph ngraph))
+ finally (return (value (if (null nchanges)
+ changes
+ (acons (car (accg-node-context-num
+ node1))
+ nchanges
+ changes)))))))
+ ;; if we are creating/refining ccmfs on a per-edge basis, we
+ ;; refine the ccmf of each edge seperately.
+ (accg-node-refine-ccmfs-per-edge (accg-node-fwd-edges node1)
+ node1 accg ccms1 c1 ruler1 cformals args
+ stronger-proofsp changes old-hlevel hlevel
+ qspv state))))
+ (accg-refine-ccmfs1 (1- i) accg stronger-proofsp changes0 old-hlevel hlevel
+ qspv state)))))
+
+(defun-raw accg-refine-ccmfs (accg stronger-proofsp old-hlevel hlevel
+ qspv state)
+ (accg-refine-ccmfs1 (1- (array-dimension accg 0)) accg stronger-proofsp nil
+ old-hlevel hlevel
+ qspv state))
+
+(defun-raw accg-refine-ccmfs-lst1 (accgs caccgs uaccgs changes stronger-proofsp
+ old-hlevel hlevel qspv state)
+ (if (endp accgs)
+ (value (list* changes caccgs uaccgs))
+ (er-let*
+ ((accg (value (car accgs)))
+ (nchanges (accg-refine-ccmfs accg stronger-proofsp old-hlevel hlevel
+ qspv state)))
+ (accg-refine-ccmfs-lst1 (cdr accgs)
+ (if (consp nchanges)
+ (cons accg caccgs)
+ caccgs)
+ (if (consp nchanges)
+ uaccgs
+ (cons accg uaccgs))
+ (append nchanges changes)
+ stronger-proofsp
+ old-hlevel hlevel
+ qspv state))))
+
+(defun-raw accg-refine-ccmfs-lst (accgs stronger-proofsp old-hlevel hlevel
+ qspv state)
+ ;; refines the ccmfs of a list of accgs.
+ ;;
+ ;;
+ ;;
+ ;; OUTPUT: an error triple whose value is (list* d c u) where d ... c is the
+ ;; list of accgs that were changed during refinement, and u is the list of
+ ;; accgs that were unchanged during refinement.
+
+ (accg-refine-ccmfs-lst1 accgs nil nil nil stronger-proofsp old-hlevel hlevel
+ qspv state))
+
+(defun-raw prune-accg-node (node1 edges accg changes hlevel qspv state)
+ (if (endp edges)
+ (value changes)
+ (let* ((edge (car edges))
+ (node2 (aref accg (accg-edge-head edge))))
+ (er-let*
+ ((result
+ (pprogn
+ (increment-timer 'other-time state)
+ (ccg-io? build/refine nil state
+ (node1 node2)
+ (fms "We attempt to prove that it is not possible for ~
+ execution to move from context ~x0 to context ~x1.~|"
+ `((#\0 . ,(car (accg-node-context-num node1)))
+ (#\1 . ,(car (accg-node-context-num node2))))
+ *standard-co*
+ state
+ nil))
+ (increment-timer 'print-time state)
+ (accg-can-omit-edge? node1 node2 hlevel qspv state))))
+ (progn
+ (unless result
+ (setf (accg-node-fwd-edges node1)
+ (cons edge (accg-node-fwd-edges node1)))
+ (setf (accg-node-bwd-edges node2)
+ (cons edge (accg-node-bwd-edges node2))))
+ (prune-accg-node node1 (cdr edges) accg
+ (if result
+ (acons (car (accg-node-context-num node1))
+ (car (accg-node-context-num node2))
+ changes)
+ changes)
+ hlevel qspv state))))))
+
+(defun-raw prune-accg1 (i accg changes hlevel qspv state)
+ (if (< i 0)
+ (value changes)
+ (let* ((node (aref accg i))
+ (edges (accg-node-fwd-edges node)))
+ (setf (accg-node-fwd-edges node) nil)
+ (er-let* ((nchanges (prune-accg-node node edges accg changes
+ hlevel qspv state)))
+ (prune-accg1 (1- i) accg nchanges hlevel qspv state)))))
+
+(defun-raw prune-accg (accg hlevel qspv state)
+ ;; reset all the bwd-edges
+ (loop for node across accg
+ do (setf (accg-node-bwd-edges node) nil))
+ (pprogn
+ (ccg-io? build/refine nil state
+ ()
+ (fms "We attempt to prune the CCG by using theorem prover queries ~
+ to determine if the rulers of adjacent calling contexts are ~
+ incompatible.~|"
+ nil
+ *standard-co*
+ state
+ nil))
+ ;; prune!
+ (prune-accg1 (1- (array-dimension accg 0)) accg nil hlevel qspv state)))
+
+(defun-raw accg-refine-accg (accg stronger-proofsp old-hlevel hlevel
+ qspv state)
+ ;; this function refines an accg based on whether we have stronger
+ ;; proof techniques available (stronger-proofsp), or some other
+ ;; weaker set of restrictions (comparing restrict to
+ ;; old-restrict). The result is a list of new accgs that have been
+ ;; separated into sccs.
+ (er-let*
+ ((accg-changes0
+ (if (and stronger-proofsp
+ (not (hlevel-ccmfs-per-nodep hlevel)))
+ ;; if we are using stronger proof techniques
+ ;; and we are not doing ccmfs on a per-node
+ ;; basis (in which case we avoid pruning to
+ ;; allow for simpler justifications in the end)
+ (prune-accg accg hlevel qspv state)
+ (value nil))))
+ (if (consp accg-changes0)
+ (mv-let
+ (accg-changes1 naccgs)
+ (accg-separate-sccs accg :ccmfp t)
+ (er-let*
+ ((triple (accg-refine-ccmfs-lst naccgs stronger-proofsp
+ old-hlevel hlevel
+ qspv state)))
+ (value (cons (cons (append accg-changes0 accg-changes1)
+ (car triple))
+ naccgs))))
+ (er-let*
+ ((changes0 (accg-refine-ccmfs accg stronger-proofsp
+ old-hlevel hlevel
+ qspv state)))
+ (value (cons (cons nil changes0) (list accg)))))))
+
+(defun-raw accg-refine-accgs1 (accgs ces changes caccgs uaccgs uces
+ stronger-proofsp old-hlevel new-hlevel
+ qspv state)
+ (if (endp accgs)
+ (value (list* changes caccgs uaccgs uces))
+ (er-let*
+ ((pair (accg-refine-accg (car accgs) stronger-proofsp
+ old-hlevel new-hlevel qspv state)))
+ (if (or (consp (caar pair)) (consp (cdar pair)))
+ (accg-refine-accgs1 (cdr accgs)
+ (cdr ces)
+ (cons (append (caar pair) (car changes))
+ (append (cdar pair) (cdr changes)))
+ (append (cdr pair) caccgs)
+ uaccgs
+ uces
+ stronger-proofsp old-hlevel new-hlevel
+ qspv state)
+ (accg-refine-accgs1 (cdr accgs)
+ (cdr ces)
+ changes
+ caccgs
+ ;; if there are no changes, (cdr pair) is a
+ ;; singleton list.
+ (append (cdr pair) uaccgs)
+ (cons (car ces) uces)
+ stronger-proofsp old-hlevel new-hlevel
+ qspv state)))))
+
+(defun-raw accg-refine-accgs (accgs ces old-hlevel new-hlevel qspv state)
+ ;; refines a list of accgs by calling accg-refine-accg repeatedly. Returns an
+ ;; error triple whose value is (cons c u) where c is a list of the accgs that were
+ ;; changed by refinement, and u is a list of the accgs that were not changed
+ ;; by refinement.
+ (pprogn
+ (ccg-io? basics nil state
+ (new-hlevel accgs)
+ (fms "We now move to the ~x0 level of the hierarchy ~
+ (see :DOC CCG-hierarchy) in order to refine the remaining ~
+ SCC~#1~[~/s~] of our anotated CCG.~|"
+ `((#\0 . ,new-hlevel)
+ (#\1 . ,accgs))
+ *standard-co*
+ state
+ nil))
+ (er-let*
+ ((tuple (accg-refine-accgs1 accgs ces nil nil nil nil
+ (weaker-proof-techniquesp old-hlevel
+ new-hlevel)
+ old-hlevel new-hlevel
+ qspv state))
+ (changes (value (car tuple)))
+ (caccgs (value (cadr tuple)))
+ (uaccgs (value (caddr tuple)))
+ (uces (value (cdddr tuple))))
+ (pprogn
+ (ccg-io? basics nil state
+ (changes state)
+ (mv-let
+ (col state)
+ (fmt "We have completed CCG refinement. "
+ nil
+ *standard-co*
+ state
+ nil)
+ (print-changes col changes state)))
+ (value (list* caccgs uaccgs uces))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; the following code is used to clean up CCGs (see the SCP
+;;; paper). the code culminates in the cln function.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun-raw srg-scc (graph)
+ ;; srg-scc is the instantiation of ccg-generic-scc for srgs.
+ (ccg-generic-scc graph
+ #'srg-node-fwd-edges #'srg-node-bwd-edges
+ #'srg-edge-tail #'srg-edge-head))
+
+
+(defun-raw srg-scc-has->-edgep (scc scc-array srg)
+ ;; srg-scc-has->-edgep tells us whether an scc of an srg contains an
+ ;; edge labeled with a >. here scc is a list of indices of nodes in
+ ;; the same scc, and scc-array maps srg indices to a unique scc
+ ;; identifier (as in the second value returned by srg-scc).
+ (let ((scc-num (aref scc-array (car scc))))
+ (dolist (p scc nil)
+ (let ((x (aref srg p)))
+ (when (dolist (e (srg-node-fwd-edges x) nil)
+ (when (and (eq (srg-edge-label e) '>)
+ (= scc-num (aref scc-array
+ (srg-edge-head e))))
+ (return t)))
+ (return t))))))
+
+(defun-raw ccmf-remove-ccms (ccmf first-del-array last-del-array)
+ ;; virtually and destructively removes ccms from a ccmf by removing
+ ;; all edges involving those ccms. This is sufficient for our
+ ;; purposes and easier than rebuilding the ccmf without the
+ ;; ccms. here, ccmf is a ccmf struct, first-del-array and
+ ;; last-del-array are arrays of booleans for which a value of t in
+ ;; slot i indicates that the ith ccm should be removed from the ith
+ ;; source or sink ccm, respectively. returns the ccmf or nil if all
+ ;; the edges have been removed from the ccmf, in which case,
+ ;; termination cannot be proven.
+ (loop with graph = (ccmf-graph ccmf)
+ for i from 0 below (ccmf-in-sizes ccmf) ;; we loop through the graph array.
+ for node = (aref graph i)
+ for f = (lambda (x) (aref last-del-array x))
+ if (aref first-del-array i) ;; if we are supposed to delete this source node,
+ do (setf (aref graph i) (make-ccmf-node)) ;; we set the node to a blank node
+ else ;; otherwise, we remove all the > and >= edges that lead
+ ;; to a deleted sink node:
+ do (setf (aref graph i)
+ (make-ccmf-node :>-edges (delete-if f (ccmf-node->-edges node))
+ :>=-edges (delete-if f (ccmf-node->=-edges node))))))
+
+(defun-raw ccmf-remove-ccms-list (ccmfs deletep-array)
+ ;; given a list of ccmfs and an array of arrays of booleans
+ ;; indicating which ccms to delete for each context, calls
+ ;; ccmf-remove-ccms on each ccmf in ccmfs with the appropriate
+ ;; deletion arrays. this function is destructively updates each
+ ;; ccmf.
+ (dolist (ccmf ccmfs nil)
+ (ccmf-remove-ccms ccmf
+ (aref deletep-array
+ (ccmf-firstsite ccmf))
+ (aref deletep-array
+ (ccmf-lastsite ccmf)))))
+
+(defun-raw srg-restrict (srg ccms)
+ ;; restricts the given srg to only the ccms indexed by the natural
+ ;; numbers in the list ccms. this function is *not* destructive.
+ (let* ((n (length ccms))
+ (rsrg (make-array n)) ;; the restricted srg.
+ (a (make-array (array-dimension srg 0) ;; maps the srg nodes
+ :element-type 'fixnum ;; to their new index
+ :initial-element -1))) ;; if they are in rsrg.
+ ;; create a new node for each slot in rsrg with the node and ccm
+ ;; of the appropriate node in the original srg. we also update the
+ ;; map as we go mapping old node indices to new ones.
+ (loop
+ for p in ccms
+ for i from 0
+ for node = (aref srg p)
+ do (setf (aref a p) i)
+ do (setf (aref rsrg i)
+ (make-srg-node :node (srg-node-node node)
+ :ccm (srg-node-ccm node))))
+ (loop
+ for p in ccms
+ for i from 0
+ for node = (aref srg p)
+ for nnode = (aref rsrg i)
+ do (loop for e in (srg-node-fwd-edges node)
+ unless (= (aref a (srg-edge-head e)) -1)
+ do (let* ((head (aref a (srg-edge-head e)))
+ (hnode (aref rsrg head))
+ (ne (make-srg-edge :head head
+ :tail i
+ :ccmf (srg-edge-ccmf e)
+ :label (srg-edge-label e))))
+ (setf (srg-node-fwd-edges nnode)
+ (cons ne (srg-node-fwd-edges nnode)))
+ (setf (srg-node-bwd-edges hnode)
+ (cons ne (srg-node-bwd-edges hnode))))))
+ rsrg))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; the following code implements the SCP analysis.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun-raw srg-scc-for-node-aux (srg nn visited node-fwd-edges edge-head)
+ ;; this is the helper function for srg-scc-for-node
+ (setf (aref visited nn) t)
+ (loop for edge in (funcall node-fwd-edges (aref srg nn))
+ for head = (funcall edge-head edge)
+ unless (aref visited head)
+ do (srg-scc-for-node-aux srg head visited node-fwd-edges edge-head)))
+
+(defun-raw srg-scc-for-node (srg nn)
+ ;; given an srg and the index of a node in that srg (nn), returns an
+ ;; array of booleans of the same size as srg which indicates for
+ ;; each i whether the node of the srg at index i is in the same srg
+ ;; as the node at index nn. it does so by traversing the srg from
+ ;; node nn forwards and backwards and taking the intersection of the
+ ;; nodes reached.
+ (let* ((n (array-dimension srg 0))
+ (in-scc-array (make-array n :element-type '(member t nil :ignore) :initial-element nil)))
+ (let* ((n (array-dimension in-scc-array 0)))
+ ;; traverse the graph forwards, using in-scc-array to keep track
+ ;; of the visited nodes.
+ (srg-scc-for-node-aux srg nn in-scc-array #'srg-node-fwd-edges #'srg-edge-head)
+ ;; for our backwards traversal, we only want to visit nodes that
+ ;; we already visited on our forward traversal. therefore, we
+ ;; set the index of visited nodes to nil and the index of
+ ;; unvisited nodes to the non-nil value :ignore.
+ (loop for i from 0 below n
+ if (aref in-scc-array i)
+ do (setf (aref in-scc-array i) nil)
+ else
+ do (setf (aref in-scc-array i) :ignore))
+ ;; now traverse the graph backwards.
+ (srg-scc-for-node-aux srg nn in-scc-array #'srg-node-bwd-edges #'srg-edge-tail)
+ ;; finally, reset any :ignore indices to nil, since they are not in the scc.
+ (loop for i from 0 below n
+ when (eq (aref in-scc-array i) :ignore)
+ do (setf (aref in-scc-array i) nil))
+ in-scc-array)))
+
+(defun-raw srg-add-scc-for-node (srg nn in-scc-array)
+ ;; takes the per-index disjunction of the boolean array in-scc-array
+ ;; and the result of calling srg-scc-for-node on srg and nn. In
+ ;; other words, given an array indicating which nodes are in a
+ ;; collection of sccs, this function adds the scc containing node nn
+ ;; to the array.
+ (if (aref in-scc-array nn)
+ in-scc-array
+ (let ((new-in-scc-array (srg-scc-for-node srg nn)))
+ (loop for i from 0 below (length in-scc-array)
+ when (and (not (aref in-scc-array i))
+ (aref new-in-scc-array i))
+ do (setf (aref in-scc-array i) t))
+ in-scc-array)))
+
+(defun-raw mtp (srg ccmfs num-contexts fwd-edges bwd-edges edge-head edge-tail)
+ ;; generic function for finding a maximal thread presever (mtp) as
+ ;; described in the scp paper. However, our algorithm is slightly
+ ;; different than that described in the scp paper. this is because
+ ;; we have a ccmf for every edge rather than every node. because of
+ ;; this, we cannot keep one count value for each ccm in the srg,
+ ;; since the are potentially multiple edges from the context
+ ;; containing the ccm, and if the ccm is not non-increasing or
+ ;; decreasing along any one of those edges, it is not part of the
+ ;; mtp. therefore, for each ccm, we maintain several counts, one for
+ ;; each outgoing edge.
+
+ ;; the srg is an srg, the ccmfs is a list of ccmfs that should be
+ ;; the ccmfs of the srg. num-contexts is the number of contexts
+ ;; represented by the srg. fwd-edges, bwd-edges, edge-head, and
+ ;; edge-tail are functions that tell us how to get around the
+ ;; graph. these are here to allow us to quickly find mtps in a graph
+ ;; and its inverse.
+ (let* ((n (array-dimension srg 0))
+ ;; we make the count array a matrix. for each ccm, we
+ ;; maintain num-context counts. unless the accg is not
+ ;; complete, some of these counts will always be 0. however,
+ ;; this slight inefficiency in space allows us to maintain
+ ;; simpler and more efficient code.
+ (count (make-array `(,n ,num-contexts)
+ :element-type 'fixnum :initial-element 0))
+ ;; the accg matrix is an adjacency matrix representation of
+ ;; the accg implied by the ccmfs.
+ (accg-matrix (make-array `(,num-contexts ,num-contexts)
+ :element-type 'boolean
+ :initial-element nil))
+ ;; marked keeps track of which ccms are marked as not being
+ ;; part of the mtp.
+ (marked (make-array n :element-type 'boolean :initial-element nil))
+ ;; the worklist keeps track of the ccms to visit.
+ (worklist nil))
+ ;; first, we construct the accg-matrix
+ (dolist (ccmf ccmfs)
+ (setf (aref accg-matrix (ccmf-firstsite ccmf) (ccmf-lastsite ccmf)) t))
+ ;; next, we initiate the counts.
+ (dotimes (i n)
+ (let ((node (aref srg i)))
+ ;; for each edge from node i, we increment the counter
+ ;; corresponding to the index of the context for which the
+ ;; head of e is a ccm:
+ (dolist (e (funcall fwd-edges node))
+ (incf (aref count i (srg-node-node (aref srg (funcall edge-head e))))))
+ ;; for every successor of the context of node that has count 0
+ ;; gets added to the worklist and is marked.
+ (dotimes (j num-contexts)
+ (when (and (aref accg-matrix (srg-node-node node) j)
+ (= (aref count i j) 0))
+ (setf worklist (cons i worklist))
+ (setf (aref marked i) t)))))
+ ;; finally, we enter the meat of the algorithm, working through the worklist.
+ (loop while (consp worklist)
+ for cw = (car worklist)
+ for j = (srg-node-node (aref srg cw))
+ do (setf worklist (cdr worklist))
+ ;; every node in the worklist is out of the mtp, so we
+ ;; decrement the appropriate count of all its
+ ;; predecessors. any of them whose count reaches 0 gets
+ ;; added to the worklist and is marked.
+ do (dolist (e (funcall bwd-edges (aref srg cw)))
+ (let ((i (funcall edge-tail e)))
+ (unless (aref marked i)
+ (decf (aref count i j))
+ (when (= (aref count i j) 0)
+ (setf (aref marked i) t)
+ (setf worklist (cons i worklist))))))
+ ;; finally, we return all the unmarked ccms.
+ finally (return (loop for i from 0 below n
+ unless (aref marked i) collect i)))))
+
+(defun-raw mtp-fwd (srg ccmfs num-contexts)
+ ;; instantiation of mtp for analysis of the original srg/accg
+ (mtp srg ccmfs num-contexts
+ #'srg-node-fwd-edges #'srg-node-bwd-edges
+ #'srg-edge-head #'srg-edge-tail))
+
+
+(defun-raw mtp-bwd (srg ccmfs num-contexts)
+ ;; instantiation of mtp for analysis of the transposition of the
+ ;; srg/accg
+ (mtp srg ccmfs num-contexts
+ #'srg-node-bwd-edges #'srg-node-fwd-edges
+ #'srg-edge-tail #'srg-edge-head))
+
+
+(defun-raw fan-free (srg edge-list other-node num-contexts)
+ ;; generic function for determining if there is no fanning in the
+ ;; srg. edge-list is a function for retrieving the list of
+ ;; incoming/outgoing edges of a node. other-node tells us how to get
+ ;; the other node adjacent to an edge. num-contexts is the number of
+ ;; contexts that the srg represents. in our context fanning is when
+ ;; a ccm has multiple incoming/outgoing edges from ccms of the same
+ ;; context.
+ (loop
+ with n = (array-dimension srg 0)
+ ;; seen is an array keeping track of which contexts we have seen ccms from.
+ with seen = (make-array num-contexts :element-type 'boolean :initial-element nil)
+ for i from 0 below n
+ ;; loop through the edges of srg ccm i, keeping track of the
+ ;; contexts to which the adjacent ccms belong. if we see a context
+ ;; twice, we have fanning and return nil.
+ unless (loop for e in (funcall edge-list (aref srg i))
+ for j = (funcall other-node e)
+ for context = (srg-node-node (aref srg j))
+ if (aref seen context) return nil
+ else do (setf (aref seen context) t)
+ finally (return t))
+ return nil
+ ;; reset the seen array. this is cheaper than creating a new array
+ ;; for each iteration of the outer loop.
+ do (loop for i from 0 below num-contexts
+ do (setf (aref seen i) nil))
+ finally (return t)))
+
+(defun-raw fan-in-free (srg num-contexts)
+ ;; instantiation of fan-free to check for fan-in
+ (fan-free srg #'srg-node-bwd-edges #'srg-edge-tail num-contexts))
+
+
+(defun-raw fan-out-free (srg num-contexts)
+ ;; instantiation of fan-free to check for fan-out
+ (fan-free srg #'srg-node-fwd-edges #'srg-edge-head num-contexts))
+
+(defun-raw mtp-to-anchor (srg ahash)
+ ;; given an srg that has been restricted to some mtp and a set of
+ ;; ccmfs represented by a hash table, we add to ahash the anchor
+ ;; implied by srg. that is, we add all ccmfs containing a > edge in
+ ;; the restricted srg.
+ (loop for i from 0 below (array-dimension srg 0)
+ do (loop for e in (srg-node-fwd-edges (aref srg i))
+ when (and (eq (srg-edge-label e) '>)
+ (not (gethash (srg-edge-ccmf e) ahash)))
+ do (setf (gethash (srg-edge-ccmf e) ahash) t))
+ finally (return ahash)))
+
+(defun-raw simple-anchors (srg ahash ccmfs num-contexts)
+ ;; simple anchors, also called type 1 anchors in other papers by the
+ ;; scp authors, are anchors based on mtps.
+ (let ((srgp (srg-restrict srg (mtp-fwd srg ccmfs num-contexts))))
+ (if (fan-in-free srgp num-contexts)
+ (mtp-to-anchor srgp ahash)
+ (let ((srgq (srg-restrict srg (mtp-bwd srg ccmfs num-contexts))))
+ (if (fan-out-free srgq num-contexts)
+ (mtp-to-anchor srgq ahash)
+ nil)))))
+
+(defun-raw srg-restrict-edges (srg pred)
+ ;; this function non-destructively constructs a new srg that is
+ ;; identical to srg except it excludes edges that fail the
+ ;; predicate, pred.
+ (loop
+ with n = (array-dimension srg 0)
+ with rsrg = (make-array n)
+ for i from 0 below n
+ for node = (aref srg i)
+ do (setf (aref rsrg i)
+ (make-srg-node :node (srg-node-node node)
+ :ccm (srg-node-ccm node)
+ :fwd-edges (remove-if-not pred (srg-node-fwd-edges node))
+ :bwd-edges (remove-if-not pred (srg-node-bwd-edges node))))
+ finally (return rsrg)))
+
+(defun-raw ndg (srg)
+ ;; constructs the no-descent graph, a subgraph of the srg consisting
+ ;; of only nonstrict edges.
+ (srg-restrict-edges srg (lambda (e) (eq (srg-edge-label e) '>=))))
+
+
+(defun-raw srg-interior (srg)
+ ;; constructs the interior of an srg, that is, the subgraph of the
+ ;; srg consisting of the edges of the srg that are interior to an
+ ;; scc of the srg.
+ (multiple-value-bind
+ (scc scc-array)
+ (srg-scc srg)
+ (declare (ignore scc))
+ (srg-restrict-edges srg
+ (lambda (e)
+ (eq (aref scc-array (srg-edge-tail e))
+ (aref scc-array (srg-edge-head e)))))))
+
+
+(defun-raw srg-to-matrix (srg)
+ ;; straight-forward function for making an adjacency matrix of srg.
+ (loop with n = (array-dimension srg 0)
+ with matrix = (make-array (list n n)
+ :element-type 'boolean
+ :initial-element nil)
+ for i from 0 below n
+ do (loop for e in (srg-node-fwd-edges (aref srg i))
+ do (setf (aref matrix i (srg-edge-head e)) t))
+ finally (return matrix)))
+
+;; (let* ((n (array-dimension srg 0))
+;; (matrix (make-array (list n n) :element-type 'boolean :initial-element nil)))
+;; (dotimes (i n matrix)
+;; (dolist (e (srg-node-fwd-edges (aref srg i)))
+;; (setf (aref matrix i (srg-edge-head e)) t)))))
+
+
+(defun-raw ccmf-to-ccmfdown-in-srg (srg ccmf ndgi-matrix)
+ ;; by ccmfdown, here, we mean the original ccmf minus any arcs
+ ;; belonging to the interior of ndg of srg. for ccmf, G, this is
+ ;; represented in the scp paper as G with a small down arrow to its
+ ;; right. hence the name. we return a copy of the srg restricted to
+ ;; not include edges in ccmfdown.
+ (srg-restrict-edges srg
+ (lambda (e)
+ (not (and (eq (srg-node-node (aref srg (srg-edge-tail e)))
+ (ccmf-firstsite ccmf))
+ (eq (srg-node-node (aref srg (srg-edge-head e)))
+ (ccmf-lastsite ccmf))
+ (aref ndgi-matrix (srg-edge-tail e) (srg-edge-head e)))))))
+
+(defun-raw anchor-find (srg ccmfs num-contexts)
+ ;; the anchor finding algorithm, as given in the scp paper.
+ (let ((ahash (make-hash-table :rehash-size 2 :rehash-threshold (float 3/4))))
+ (multiple-value-bind
+ (sccs scc-array)
+ (srg-scc srg)
+ (declare (ignore scc-array))
+ ;; for every scc of the srg, look for simple anchors.
+ (dolist (scc sccs)
+ (simple-anchors (srg-restrict srg scc) ahash ccmfs num-contexts))
+ ;; convert the set of anchors to a list.
+ (let ((anchors (loop for k being the hash-keys of ahash using (hash-value v)
+ when v collect k)))
+ ;;(format t "simple anchors: ~A~%" anchors)
+ ;; if we have found anchors, return them.
+ (if anchors
+ anchors
+ ;; otherwise, we attempt to find "type 2" anchors, as they
+ ;; are called in the scp paper.
+ (loop with ndgi-matrix = (srg-to-matrix (srg-interior (ndg srg)))
+ for ccmf in ccmfs
+ for h = (ccmf-to-ccmfdown-in-srg srg ccmf ndgi-matrix)
+ when (or (mtp-fwd h ccmfs num-contexts)
+ (mtp-bwd h ccmfs num-contexts))
+ return (list ccmf)))))))
+
+(defun-raw copy-a-ccmf (ccmf)
+ (make-ccmf :firstsite (ccmf-firstsite ccmf)
+ :lastsite (ccmf-lastsite ccmf)
+ :fc-num (ccmf-fc-num ccmf)
+ :lc-num (ccmf-lc-num ccmf)
+ :graph (accg-copy-ccmf-graph (ccmf-graph ccmf))
+ :in-sizes (ccmf-in-sizes ccmf)
+ :out-sizes (ccmf-out-sizes ccmf)
+ :steps (ccmf-steps ccmf)))
+
+(defun-raw copy-ccmfs (ccmfs)
+ ;; just like it says, this function copies a list of ccmfs.
+ (loop for ccmf in ccmfs
+ collect (copy-a-ccmf ccmf)))
+
+(defun-raw copy-accg (accg)
+ (let* ((n (array-dimension accg 0))
+ (naccg (make-array n)))
+ (loop for i from 0 below n
+ for node = (aref accg i)
+ do (setf (aref naccg i)
+ (make-accg-node :context (accg-node-context node)
+ :num i)))
+ (loop
+ for node across accg
+ for nnode across naccg
+ do (setf (accg-node-fwd-edges nnode)
+ (loop
+ for edge in (accg-node-fwd-edges node)
+ for head = (accg-edge-head edge)
+ for hnode = (aref naccg head)
+ for nedge = (make-accg-edge
+ :tail (accg-edge-tail edge)
+ :head head
+ :ccmf (copy-a-ccmf (accg-edge-ccmf edge)))
+ do (setf (accg-node-bwd-edges hnode)
+ (cons nedge (accg-node-bwd-edges hnode)))
+ collect nedge)))
+ naccg))
+
+(defun-raw accg-ccmfs (accg)
+ ;; returns all the ccmfs used to annotate accg
+ (loop for node across accg
+ append (mapcar #'accg-edge-ccmf
+ (accg-node-fwd-edges node))))
+;; (let ((ccmfs nil))
+;; (dotimes (i (array-dimension accg 0) ccmfs)
+;; (dolist (e (accg-node-fwd-edges (aref accg i)))
+;; (setf ccmfs (cons (accg-edge-ccmf e) ccmfs))))))
+
+(defun-raw accg-contexts (accg)
+ ;; returns the contexts of the accg.
+ (map 'vector (lambda (x) (accg-node-context x)) accg))
+
+(defun-raw accg-srg-add-edge (tailnode headnode tailnum headnum ccmf label)
+ ;; adds an adge to the tailnode and headnode of an srg.
+ (let ((edge (make-srg-edge :tail tailnum
+ :head headnum
+ :ccmf ccmf
+ :label label)))
+ (setf (srg-node-fwd-edges tailnode)
+ (cons edge (srg-node-fwd-edges tailnode)))
+ (setf (srg-node-bwd-edges headnode)
+ (cons edge (srg-node-bwd-edges headnode)))
+ nil))
+
+(defun-raw accg-remove-edges-corresponding-to-ccmfs (accg ccmfs)
+ ;; destructively removes edges corresponding to the list of ccmfs from the
+ ;; accg. The ccmfs must be pointer-equal (eq) to the ones you want removed
+ ;; from the accg.
+
+ ;; first, we set the firstsite field of the ccmfs we want to remove
+ ;; to -1.
+ (loop for ccmf in ccmfs do (setf (ccmf-firstsite ccmf) -1))
+ ;; next, we loop through all the accg-nodes, deleting any
+ ;; incoming/outgoing edges whose firstsite is -1.
+ (loop with pred = (lambda (edge)
+ (= (ccmf-firstsite (accg-edge-ccmf edge)) -1))
+ for node across accg
+ do (setf (accg-node-fwd-edges node)
+ (delete-if pred (accg-node-fwd-edges node)))
+ do (setf (accg-node-bwd-edges node)
+ (delete-if pred (accg-node-bwd-edges node))))
+ accg)
+
+(defun-raw accg-construct-srg (accg)
+ ;; constructs an srg from a accg. to do this, we "flatten" out the
+ ;; ccms of each accg-node, laying all the ccms from all the
+ ;; accg-nodes next to each other and creating an srg-node for each
+ ;; ccm.
+ (let* ((n (array-dimension accg 0))
+ ;; we need an offset array to tell us what index in the srg
+ ;; corresponds to the first ccm in each accg-node.
+ (node-offset (make-array n
+ :element-type 'fixnum
+ :initial-element 0))
+ (c 0))
+ ;; compute the offsets:
+ (dotimes (i n)
+ (setf (aref node-offset i) c)
+ (incf c (array-dimension (accg-node-ccms (aref accg i)) 0)))
+ ;; at this point c = the number of nodes in the srg.
+ (let ((srg (make-array c
+ :element-type 'srg-node
+ :initial-element (make-srg-node))))
+ ;; make all the new nodes.
+ (loop for i from 1 below c
+ do (setf (aref srg i) (make-srg-node)))
+ ;; now we add all the edges.
+ (loop ;; we loop through the accg
+ for i from 0 below n
+ do (loop ;; we loop through the fwd-ccmfs of node i
+ for edge in (accg-node-fwd-edges (aref accg i))
+ for ccmf = (accg-edge-ccmf edge)
+ for offset1 = (aref node-offset i)
+ for offset2 = (aref node-offset (accg-edge-head edge))
+ for cg = (ccmf-graph ccmf)
+ do (loop ;; we loop through the ccmf.
+ for j from 0 below (array-dimension cg 0)
+ for a from offset1
+ for nodea = (aref srg a)
+ do (setf (srg-node-node nodea) i)
+ do (setf (srg-node-ccm nodea) j)
+ do (loop ;; we loop through the >-edges and add them to the srg.
+ for x in (ccmf-node->-edges (aref cg j))
+ for b = (+ offset2 x)
+ do (accg-srg-add-edge nodea (aref srg b) a b ccmf '>))
+ do (loop ;; we loop through the >=-edges and add them to the srg.
+ for x in (ccmf-node->=-edges (aref cg j))
+ for b = (+ offset2 x)
+ do (accg-srg-add-edge nodea (aref srg b) a b ccmf '>=))))
+ finally (return srg)))))
+
+(defun-raw cln-accg (accg)
+ ;; this function cleans a accg by removing any ccmf edge that is
+ ;; not internal to an scc in the corresponding srg that contains a >
+ ;; edge.
+ (let* ((srg (accg-construct-srg accg)) ;; the srg for the accg.
+ (n (array-dimension accg 0))
+ (deletep-array (make-array n))) ;; tells us which ccms to delete.
+ ;; initiate the deletep-array
+ (dotimes (i n)
+ (setf (aref deletep-array i)
+ (make-array (array-dimension
+ (accg-node-ccms (aref accg i))
+ 0)
+ :element-type 'boolean
+ :initial-element nil)))
+ ;; analyze the sccs of the srg.
+ (multiple-value-bind
+ (sccs scc-array)
+ (srg-scc srg)
+ ;; for each scc, add the nodes of the scc to the deletep array
+ ;; unless it contains a > edge.
+ (loop for scc in sccs
+ unless (srg-scc-has->-edgep scc scc-array srg)
+ do (loop for v in scc
+ for node = (aref srg v)
+ for context = (srg-node-node node)
+ for ccm = (srg-node-ccm node)
+ do (setf (aref (aref deletep-array context) ccm) t))))
+ ;; destructively remove the unwanted ccms.
+ (progn
+ (ccmf-remove-ccms-list (accg-ccmfs accg)
+ deletep-array)
+ accg)))
+
+(defun-raw scp (accg)
+ ;; the main scp algorithm. it takes an accg and recursively removes
+ ;; anchors and analyzes the sccs of the remainder of the graph until
+ ;; either there is no graph left, or we can't find any more
+ ;; anchors. see the scp paper.
+ (when accg
+ (let* ((n (array-dimension accg 0))
+ (anchors (anchor-find (accg-construct-srg accg)
+ (accg-ccmfs accg)
+ n)))
+ (when anchors
+ (mv-let
+ (changes sccs)
+ (accg-separate-sccs
+ (accg-remove-edges-corresponding-to-ccmfs accg anchors))
+ (declare (ignore changes))
+ (loop for scc in sccs
+ unless (scp (cln-accg scc))
+ return nil
+ finally (return t)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; the following code implements the SCT analysis
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defstruct-raw scg-path
+ ;; the first num in the path
+ (start 0 :type fixnum)
+ ;; the second num in the path
+ (end 0 :type fixnum)
+ ;; the total length of the path
+ (length 0 :type fixnum)
+ ;; the interior of the path (everything except the start and end). We
+ ;; represent this as a tree so that we don't have to append every time we
+ ;; compose SCGs. We do this in such a way that a depth-first car-to-cdr
+ ;; seorch of the tree returns the path.
+ (interior nil :type (or null fixnum cons)))
+
+(defun-raw new-scg-path (start end)
+ (make-scg-path :start start
+ :end end
+ :length 2
+ :interior nil))
+
+(defun-raw compose-scg-paths (p1 p2)
+ (make-scg-path :start (scg-path-start p1)
+ :end (scg-path-end p2)
+ :length (1- (+ (scg-path-length p1)
+ (scg-path-length p2)))
+ :interior (let ((x (if (null (scg-path-interior p2))
+ (scg-path-start p2)
+ (cons (scg-path-start p2)
+ (scg-path-interior p2)))))
+ (if (null (scg-path-interior p1))
+ x
+ (cons (scg-path-interior p1) x)))))
+
+(defun-raw flatten-scg-interior (interior acc)
+ (cond ((null interior)
+ acc)
+ ((atom interior)
+ (cons interior acc))
+ (t
+ (flatten-scg-interior (car interior)
+ (flatten-scg-interior (cdr interior)
+ acc)))))
+
+(defun-raw flatten-scg-path (path)
+ (cons (scg-path-start path)
+ (flatten-scg-interior (scg-path-interior path)
+ (list (scg-path-end path)))))
+
+
+;; for the purposes of this algorithm, we only need to know the starts and ends
+;; of paths. We only need the interior to construct the paths later. Therefore,
+;; we define functions for equality and ordering paths accordingly.
+(defun-raw scg-path-equal (p1 p2)
+ (and (= (scg-path-start p1)
+ (scg-path-start p2))
+ (= (scg-path-end p1)
+ (scg-path-end p2))))
+
+(defun-raw path< (p1 p2)
+ (or (< (scg-path-start p1)
+ (scg-path-start p2))
+ (and (= (scg-path-start p1)
+ (scg-path-start p2))
+ (< (scg-path-end p1)
+ (scg-path-end p2)))))
+
+
+;; since we keep the interior of a path aronud for constructing
+;; counter-examples, we want to keep around the shortest path. Therefore, when
+;; given two paths with identical start and end points, we pick the one with
+;; the shortest path.
+(defun-raw shortest-scg-path (p1 p2)
+ (if (<= (scg-path-length p1)
+ (scg-path-length p2))
+ p1
+ p2))
+
+(defstruct-raw scg
+ (paths nil :type list)
+ (newest-paths nil :type list)
+ (new-newest-paths nil :type list)
+ (num 0 :type fixnum)
+ (graph nil))
+
+(defun-raw sorted-set-union1 (lst1 lst2 key1 key2 predicate combine key test)
+ ;; lst1 and lst2 should be sorted, non-empty lists.
+ ;; key1 should be equal to (funcall key (car lst1))
+ ;; key2 should be equal to (funcall key (car lst2))
+ ;; key should be a unary function that returns an equal-able value.
+ (cond ((funcall test key1 key2)
+ (cons (car lst1)
+ (sorted-set-union (cdr lst1) (cdr lst2)
+ predicate
+ :key key
+ :combine combine
+ :test test)))
+ ((funcall predicate key1 key2)
+ (cons (car lst1)
+ (if (endp (cdr lst1))
+ lst2
+ (sorted-set-union1 (cdr lst1) lst2
+ (funcall key (cadr lst1))
+ key2
+ predicate
+ combine
+ key
+ test))))
+ (t
+ (cons (car lst2)
+ (if (endp (cdr lst2))
+ lst1
+ (sorted-set-union1 lst1 (cdr lst2)
+ key1
+ (funcall key (cadr lst2))
+ predicate
+ combine
+ key
+ test))))))
+
+(defun-raw sorted-set-union (lst1 lst2 predicate
+ &key (key #'identity)
+ (combine #'(lambda (x y)
+ (declare (ignore y))
+ x))
+ (test #'equal))
+ (cond ((endp lst1) lst2)
+ ((endp lst2) lst1)
+ (t
+ (sorted-set-union1 lst1 lst2
+ (funcall key (car lst1))
+ (funcall key (car lst2))
+ predicate
+ combine
+ key
+ test))))
+
+(defun-raw sorted-set-difference1 (lst1 lst2 key1 key2 predicate key test)
+ ;; lst1 and lst2 should be sorted, non-empty lists.
+ ;; key1 should be equal to (funcall key (car lst1))
+ ;; key2 should be equal to (funcall key (car lst2))
+ ;; key should be a unary function that returns an equal-able value.
+ (cond ((funcall test key1 key2)
+ (sorted-set-difference (cdr lst1) (cdr lst2)
+ predicate
+ :key key
+ :test test))
+ ((funcall predicate key1 key2)
+ (cons (car lst1)
+ (if (endp (cdr lst1))
+ nil
+ (sorted-set-difference1 (cdr lst1) lst2
+ (funcall key (cadr lst1))
+ key2
+ predicate
+ key
+ test))))
+ (t
+ (if (endp (cdr lst2))
+ lst1
+ (sorted-set-difference1 lst1 (cdr lst2)
+ key1
+ (funcall key (cadr lst2))
+ predicate
+ key
+ test)))))
+
+(defun-raw sorted-set-difference (lst1 lst2 predicate
+ &key (key #'identity)
+ (test #'equal))
+ (cond ((endp lst1) nil)
+ ((endp lst2) lst1)
+ (t
+ (sorted-set-difference1 lst1 lst2
+ (funcall key (car lst1))
+ (funcall key (car lst2))
+ predicate
+ key
+ test))))
+
+(defun-raw sorted-union/difference1 (lst1 lst2 key1 key2 predicate combine key test)
+ ;; lst1 and lst2 should be sorted, non-empty lists.
+ ;; key1 should be equal to (funcall key (car lst1))
+ ;; key2 should be equal to (funcall key (car lst2))
+ ;; key should be a unary function that returns an equal-able value.
+ (cond ((funcall test key1 key2)
+ (mv-let (union difference)
+ (sorted-union/difference (cdr lst1) (cdr lst2)
+ predicate
+ :combine combine
+ :key key
+ :test test)
+ (mv (cons (funcall combine (car lst1) (car lst2))
+ union)
+ difference)))
+ ((funcall predicate key1 key2)
+ (mv-let (union difference)
+ (if (endp (cdr lst1))
+ (mv lst2 nil)
+ (sorted-union/difference1 (cdr lst1) lst2
+ (funcall key (cadr lst1))
+ key2
+ predicate
+ combine
+ key
+ test))
+ (mv (cons (car lst1) union)
+ (cons (car lst1) difference))))
+ (t
+ (mv-let (union difference)
+ (if (endp (cdr lst2))
+ (mv lst1 lst1)
+ (sorted-union/difference1 lst1 (cdr lst2)
+ key1
+ (funcall key (cadr lst2))
+ predicate
+ combine
+ key
+ test))
+ (mv (cons (car lst2) union)
+ difference)))))
+
+(defun-raw sorted-union/difference (lst1 lst2 predicate
+ &key (key #'identity)
+ (combine #'(lambda (x y)
+ (declare (ignore y))
+ x))
+ (test #'equal))
+ (cond ((endp lst1) (mv lst2 nil))
+ ((endp lst2) (mv lst1 lst1))
+ (t
+ (sorted-union/difference1 lst1 lst2
+ (funcall key (car lst1))
+ (funcall key (car lst2))
+ predicate
+ combine
+ key
+ test))))
+
+(defun-raw sorted-adjoin (element set predicate
+ &key (key #'identity)
+ (combine #'(lambda (x y)
+ (declare (ignore y))
+ x))
+ (test #'equal))
+ (sorted-set-union (list element) set predicate
+ :key key :combine combine :test test))
+
+(defun-raw sorted-remove-duplicates1 (lst carkey key combine test)
+ (if (endp (cdr lst))
+ lst
+ (let ((cadrkey (funcall key (cadr lst))))
+ (if (funcall test carkey cadrkey)
+ (let ((comb (funcall combine (car lst) (cadr lst))))
+ (sorted-remove-duplicates1 (cons comb (cddr lst))
+ (funcall key comb)
+ key
+ combine
+ test))
+ (cons (car lst)
+ (sorted-remove-duplicates1 (cdr lst)
+ cadrkey
+ key
+ combine
+ test))))))
+
+(defun-raw sorted-remove-duplicates (lst &key (key #'identity)
+ (combine #'(lambda (x y)
+ (declare (ignore y))
+ x))
+ (test #'equal))
+ (cond ((endp lst) nil)
+ ((endp (cdr lst)) lst)
+ (t
+ (sorted-remove-duplicates1 lst
+ (funcall key (car lst))
+ key
+ combine
+ test))))
+
+
+(defun-raw list-to-sorted-set (lst predicate
+ &key (key #'identity)
+ (combine #'(lambda (x y)
+ (declare (ignore y))
+ x))
+ (test #'equal))
+ ;; WARNING: THIS FUNCTION IS DESTRUCTIVE TO LST.
+ (sorted-remove-duplicates (sort lst predicate :key key)
+ :key key
+ :combine combine
+ :test test))
+
+(defun-raw scg-graph-key (graph)
+ #-gcl
+ graph
+ #+gcl
+ (loop for node across graph
+ for >-edges = (ccmf-node->-edges node)
+ for >=-edges = (ccmf-node->=-edges node)
+ collect (cons (length >-edges) (length >=-edges)) into lens
+ collect (cons >-edges >=-edges) into lst
+ finally (list* (array-dimension graph 0) lens lst)))
+
+(defun-raw update-scg-paths (graph paths i graph-hash)
+ ;; graph is a ccmf-graph
+ ;; paths is a sorted set of paths to be added for graph
+ ;; i is our scg counter, used for giving each scg a unique numerical id.
+ ;; graph-hash is an equalp hash-table (an equal hash-table in GCL)
+ ;;
+ ;; OUTPUT: 4 values:
+ ;; 1. the new value of i.
+ ;; 2. whether this is the first update to the new-newest-paths of the scg.
+ ;; 3. the new paths added.
+ ;; 4. the scg that was updated.
+ ;; (format t "~&Calling: ~A~%" `(update-scg-paths ,graph ,paths ,i ,graph-hash))
+ (let* ((key (scg-graph-key graph))
+ (scg (gethash key graph-hash)))
+ (if scg
+ (let* ((new-newest-paths (scg-new-newest-paths scg))
+ (npaths (sorted-set-difference
+ (sorted-set-difference paths
+ (scg-paths scg)
+ #'path<
+ :test #'scg-path-equal)
+ (scg-newest-paths scg)
+ #'path<
+ :test #'scg-path-equal)))
+ (mv-let (union difference)
+ (sorted-union/difference npaths new-newest-paths #'path<
+ :test #'scg-path-equal
+ :combine #'shortest-scg-path)
+ (progn
+ (setf (scg-new-newest-paths scg) union)
+ (mv i (endp new-newest-paths) difference scg))))
+ (let ((nscg (make-scg :graph graph
+ :num i
+ :new-newest-paths paths)))
+ (setf (gethash key graph-hash) nscg)
+ ;; (format t "Returning: ~A~%"
+ ;; `(update-scg-paths ,(1+ i)
+ ;; t
+ ;; ,paths
+ ;; ,nscg))
+ (mv (1+ i) t paths nscg)))))
+
+(defun-raw age-scgs (lst)
+ ;; lst is a list of scgs
+ ;;
+ ;; SIDE-EFFECT: the scgs are "aged", i.e. their newest-paths are unioned with
+ ;; their paths, the new-newest-paths are moved to the newest-paths, and their
+ ;; new-newest-paths slot is set to nil.
+ ;;
+ ;; OUTPUT: lst
+ (loop for scg in lst
+ do (setf (scg-paths scg)
+ (sorted-set-union (scg-paths scg)
+ (scg-newest-paths scg)
+ #'path<
+ :combine #'shortest-scg-path
+ :test #'scg-path-equal))
+ do (setf (scg-newest-paths scg)
+ (scg-new-newest-paths scg))
+ do (setf (scg-new-newest-paths scg)
+ nil)
+ finally (return lst)))
+
+(defun-raw ccmfs-to-scgs1 (ccmfs graph-hash i acc)
+ (if (endp ccmfs)
+ (mv i (sort acc #'< :key #'scg-num))
+ (let ((ccmf (car ccmfs)))
+ (mv-let (ni new? diff scg)
+ (update-scg-paths (ccmf-graph ccmf)
+ (list (new-scg-path (ccmf-firstsite ccmf)
+ (ccmf-lastsite ccmf)))
+ i
+ graph-hash)
+ (ccmfs-to-scgs1 (cdr ccmfs) graph-hash ni
+ (if (and new? (consp diff))
+ (cons scg acc)
+ acc))))))
+
+(defun-raw ccmfs-to-scgs (ccmfs graph-hash)
+ (ccmfs-to-scgs1 ccmfs graph-hash 0 nil))
+
+(defun-raw compose-scg-graphs (g h)
+ (loop with n = (array-dimension g 0)
+ with gh = (make-array (array-dimension g 0)
+ :element-type 'ccmf-node
+ :initial-element (make-ccmf-node))
+ for i below n
+ for nodei = (aref g i)
+ for >-edges = nil
+ for >=-edges = nil
+ do (loop for j in (ccmf-node->-edges nodei)
+ for nodej = (aref h j)
+ do (loop for k in (ccmf-node->-edges nodej)
+ do (setf >-edges (cons k >-edges)))
+ do (loop for k in (ccmf-node->=-edges nodej)
+ do (setf >-edges (cons k >-edges))))
+ do (loop for j in (ccmf-node->=-edges nodei)
+ for nodej = (aref h j)
+ do (loop for k in (ccmf-node->-edges nodej)
+ do (setf >-edges (cons k >-edges)))
+ do (loop for k in (ccmf-node->=-edges nodej)
+ do (setf >=-edges (cons k >=-edges))))
+ do (let* ((sorted->-edges (list-to-sorted-set >-edges #'<)))
+ (setf (aref gh i)
+ (make-ccmf-node
+ :>-edges sorted->-edges
+ :>=-edges (sorted-set-difference
+ (list-to-sorted-set >=-edges #'<)
+ sorted->-edges
+ #'<))))
+ finally (return gh)))
+
+(defun-raw compose-scg-path-lsts1 (gpath hpaths acc)
+ (if (or (endp hpaths)
+ (not (= (scg-path-start (car hpaths))
+ (scg-path-end gpath))))
+ acc
+ (compose-scg-path-lsts1 gpath (cdr hpaths)
+ (cons (compose-scg-paths gpath (car hpaths))
+ acc))))
+
+(defun-raw compose-scg-path-lsts (gpaths hpaths acc)
+ ;; gpaths should be a list of paths sorted in increasing order by their cdrs.
+ ;; hpaths should be a list of paths sorted in increasing order by their cars.
+ ;; acc is the accumulator
+ ;; returns a sorted-set of paths (sorted by path<).
+ (cond ((or (endp gpaths) (endp hpaths))
+ (list-to-sorted-set acc #'path<
+ :test #'scg-path-equal
+ :combine #'shortest-scg-path))
+ ((< (scg-path-end (car gpaths))
+ (scg-path-start (car hpaths)))
+ (compose-scg-path-lsts (cdr gpaths) hpaths acc))
+ ((> (scg-path-end (car gpaths))
+ (scg-path-start (car hpaths)))
+ (compose-scg-path-lsts gpaths (cdr hpaths) acc))
+ (t
+ (compose-scg-path-lsts (cdr gpaths)
+ hpaths
+ (compose-scg-path-lsts1 (car gpaths)
+ hpaths
+ acc)))))
+
+(defun-raw scg-counter-example? (scg diff)
+ (and ;;there is a new self loop:
+ (loop for path in diff
+ when (= (scg-path-start path)
+ (scg-path-end path))
+ return t
+ finally (return nil))
+ ;;there is no old self loop (in which case, we have already checked it out).
+ (loop for path in (append (scg-paths scg)
+ (scg-newest-paths scg)
+ (sorted-set-difference (scg-new-newest-paths scg)
+ diff
+ #'path<
+ :test #'scg-path-equal))
+ when (= (scg-path-start path)
+ (scg-path-end path))
+ return nil
+ finally (return t))
+ ;; there is no >-edge from a CCM to itself:
+ (loop with graph = (scg-graph scg)
+ for i from 0 below (array-dimension graph 0)
+ when (member i (ccmf-node->-edges (aref graph i)))
+ return nil
+ finally (return t))
+ ;; the graph is idempotent
+ (let ((graph (scg-graph scg)))
+ (equalp (compose-scg-graphs graph graph)
+ graph))))
+
+(defun-raw shortest-self-loop (paths path)
+ (cond ((endp paths) path)
+ ((= (scg-path-start (car paths))
+ (scg-path-end (car paths)))
+ (shortest-self-loop (cdr paths)
+ (if (or (null path)
+ (< (scg-path-length (car paths))
+ (scg-path-length path)))
+ (car paths)
+ path)))
+ (t
+ (shortest-self-loop (cdr paths) path))))
+
+(defun-raw compose-scgs (g h i graph-hash)
+ (let ((ghgraph (compose-scg-graphs (scg-graph g) (scg-graph h)))
+ (ghpaths (compose-scg-path-lsts (sort (copy-list (scg-newest-paths g))
+ #'< :key #'scg-path-end)
+ (scg-newest-paths h)
+ nil)))
+ (mv-let (ni new? diff gh)
+ (update-scg-paths ghgraph ghpaths i graph-hash)
+ (if (scg-counter-example? gh diff)
+ (mv t ni (cons (scg-graph gh)
+ (flatten-scg-path (shortest-self-loop diff nil))))
+ (mv nil ni (if (and new? (consp diff)) gh nil))))))
+
+(defun-raw scg-predecessors (scg)
+ (sorted-remove-duplicates (mapcar #'scg-path-start (scg-newest-paths scg))))
+
+(defun-raw scg-successors (scg)
+ (list-to-sorted-set (mapcar #'scg-path-end (scg-newest-paths scg))
+ #'<))
+
+(defun-raw organize-scgs-by-preds1 (scgs array)
+ (if (endp scgs)
+ nil
+ (let ((scg (car scgs)))
+ ;; to maintain the sortedness of the slots in the array, we loop through
+ ;; and build our lists on the way back.
+ (organize-scgs-by-preds1 (cdr scgs) array)
+ (loop for i in (scg-predecessors scg)
+ do (setf (aref array i)
+ (cons scg (aref array i)))))))
+
+(defun-raw organize-scgs-by-preds (scgs numsites)
+ (let ((array (make-array numsites :initial-element nil :element-type 'list)))
+ (organize-scgs-by-preds1 scgs array)
+ array))
+
+(defun-raw union-scgs (scg-array indices)
+ (loop for i in indices
+ append (aref scg-array i) into union
+ finally (return (list-to-sorted-set union #'< :key #'scg-num))))
+
+(defun-raw copy-scgs (scgs)
+ (loop for scg in scgs
+ collect (make-scg :graph (scg-graph scg)
+ :num (scg-num scg)
+ :paths (scg-paths scg)
+ :newest-paths (scg-newest-paths scg)
+ :new-newest-paths (scg-new-newest-paths scg))))
+
+(defun print-sct-loop-report (iteration comps state)
+ (ccg-io? performance nil state
+ (iteration comps)
+ (fms "Iteration: ~x0 Compositions: ~x1."
+ (list (cons #\0 iteration)
+ (cons #\1 comps))
+ *standard-co*
+ state
+ nil)))
+
+(defun-raw print-sct-total-report (success? comps graph-hash start-time state)
+ (mv-let
+ (col state)
+ (ccg-io? size-change nil (mv col state)
+ (success?)
+ (fmt "~%SCT has found ~#0~[no~/a~] counter-example to ~
+ termination. "
+ (list (cons #\0 (if success? 0 1)))
+ *standard-co*
+ state
+ nil)
+ :default-bindings ((col 0)))
+ (mv-let
+ (col state)
+ (ccg-io? performance nil (mv col state)
+ (comps graph-hash start-time internal-time-units-per-second)
+ (fmt1 "In the process, ~x0 total ~#1~[compositions ~
+ were~/composition was~] performed and ~x2 unique ~
+ ~#3~[graphs were~/graph was~] created. Total time taken ~
+ was ~x4 seconds.~|"
+ (list (cons #\0 comps)
+ (cons #\1 (if (= comps 1) 1 0))
+ (cons #\2 (hash-table-count graph-hash))
+ (cons #\3 (if (= (hash-table-count graph-hash) 1)
+ 1 0))
+ (cons #\4 (/ (- (get-internal-run-time) start-time)
+ ;;internal-time-units-per-second
+ (coerce internal-time-units-per-second 'float))))
+ col
+ *standard-co*
+ state
+ nil)
+ :default-bindings ((col 0)))
+ (mv-let
+ (col state)
+ (ccg-io? size-change nil (mv col state)
+ ()
+ (fmt1 "~|" nil col *standard-co* state nil))
+ (declare (ignore col))
+ state))))
+
+(defun-raw sct (ccmfs numsites state)
+ ;; ccmfs: a list of CCMFs to be analyzed
+ ;; numsites: the number of contexts over which the CCMFs range.
+ ;; state: the state
+ ;;
+ ;; OUTPUT: an error triple whose value is a counter-example of the form (cons
+ ;; g p) where g is a ccmf-graph and p is the shortest self-looping path
+ ;; associated with g.
+
+ ;; the basic algorithm for sct is fairly simple:
+ ;; * let S be the set of SCGs
+ ;; * repeat the following
+ ;; * if there is a maximal ccmf without a > edge from some ccm to
+ ;; itself, return the counter-example associated with that ccmf.
+ ;; * let S' be S unioned with the result of composing every pair
+ ;; in SxS such that the lastsite of s is the firstsite of s'.
+ ;; * if S' = S, return nil
+ ;; * set S <- S'
+ ;;
+ ;; however, this is inefficient, due to duplicate SCGs and the associativity
+ ;; of composition. Therefore, we do the following.
+
+ (let ((graph-hash (make-hash-table :test #-gcl 'equalp #+gcl 'equal))
+ (start-time (get-internal-run-time)))
+ ;; first, we create the scgs, putting them in the graph-hash
+ (mv-let
+ (i newest)
+ (ccmfs-to-scgs ccmfs graph-hash)
+ (progn
+ ;;(format t "~&i: ~A~%newest: ~A~%" i newest)
+ ;; we check if any of the new scgs are counter-examples to termination.
+ (loop
+ for scg in newest
+ for nnp = (scg-new-newest-paths scg)
+ when (scg-counter-example? scg nnp)
+ do (return-from sct (value (cons (scg-graph scg)
+ (flatten-scg-path
+ (shortest-self-loop nnp nil))))))
+ ;; we age the scgs.
+ (age-scgs newest)
+ ;; the main loop:
+ (loop
+ with total-comps = 0
+ with generators = (organize-scgs-by-preds (copy-scgs newest) numsites)
+ until (endp newest)
+ for iteration from 0
+ for new-newest = nil
+ for comps = 0
+ ;;do (print iteration)
+ ;; for every scg, g, to be processed
+ do (loop
+ for g in newest
+ ;; all the ends of the pathst associated with g:
+ for gsucc = (scg-successors g)
+ do (loop
+ ;; for each generator that starts at a context where g ends,
+ for h in (union-scgs generators gsucc)
+ ;; compose them together, checking for counter-examples along
+ ;; the way
+ do (mv-let (counter-example? ni gh)
+ (compose-scgs g h i graph-hash)
+ (progn
+ (incf comps)
+ (incf total-comps)
+ (setf i ni)
+ ;; if we've found it, print out the report and
+ ;; return the counter-example.
+ (cond (counter-example?
+ (pprogn
+ (increment-timer 'other-time state)
+ (print-sct-loop-report iteration comps
+ state)
+ (print-sct-total-report nil
+ total-comps
+ graph-hash
+ start-time
+ state)
+ (increment-timer 'print-time state)
+ (return-from sct (value gh))))
+ ;; otherwise, if gh is new and different, we
+ ;; add it to our new-newest set.
+ (gh
+ (setf new-newest
+ (cons gh new-newest))))))))
+ ;; we age all of our SCGs.
+ do (age-scgs (list-to-sorted-set (append newest
+ (copy-list new-newest))
+ #'< :key #'scg-num))
+ ;; new-newest is the new newest (hence the name).
+ do (setf newest new-newest)
+ ;; print the loop report.
+ do (pprogn
+ (increment-timer 'other-time state)
+ (print-sct-loop-report iteration comps state)
+ (increment-timer 'print-time state))
+ ;; if we never find a counter-example, print out the report and return
+ ;; nil.
+ finally (pprogn
+ (increment-timer 'other-time state)
+ (print-sct-total-report t total-comps graph-hash start-time state)
+ (increment-timer 'print-time state)
+ (return (value nil))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; the rest of the code connects our termination analysis with ACL2's ;;;
+;;; function admission process. ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun-raw find-funct (fn functs)
+ (cond ((endp functs)
+ (make-funct :fn fn))
+ ((eq fn (funct-fn (car functs)))
+ (car functs))
+ (t
+ (find-funct fn (cdr functs)))))
+
+(defun-raw t-machine-to-contexts (t-machine parent-funct functs)
+ (if (endp t-machine)
+ nil
+ (let* ((tac (car t-machine))
+ (call (access tests-and-call tac :call)))
+ (cons (make-context :ruler (access tests-and-call tac :tests)
+ :call call
+ :parent-funct parent-funct
+ :call-funct (find-funct (ffn-symb call) functs))
+ (t-machine-to-contexts (cdr t-machine) parent-funct functs)))))
+
+(defun-raw t-machines-to-contexts1 (t-machines functs all-functs)
+ (if (endp t-machines)
+ nil
+ (cons (t-machine-to-contexts (car t-machines)
+ (car functs)
+ all-functs)
+ (t-machines-to-contexts1 (cdr t-machines)
+ (cdr functs)
+ all-functs))))
+
+(defun-raw t-machines-to-contexts (t-machines functs)
+ (t-machines-to-contexts1 t-machines functs functs))
+
+(defun-raw make-funct-structs (names arglists)
+ (if (endp names)
+ nil
+ (cons (make-funct :fn (car names)
+ :formals (car arglists))
+ (make-funct-structs (cdr names) (cdr arglists)))))
+
+(defun ccg-measures-declared (measures)
+ ;;; tells us whether the user declared any measures
+ (and (consp measures)
+ (or (not (equal (car measures) *0*))
+ (ccg-measures-declared (cdr measures)))))
+
+(defun-raw context-array (contexts)
+ ;; turns a list of lists of contexts into an array and fixes the
+ ;; context-num field of each context to be its index in the array.
+ (let ((carray (coerce (loop for cs in contexts
+ append cs)
+ 'vector)))
+ (loop for i from 0 below (length carray)
+ do (setf (context-num (aref carray i))
+ (list i)))
+ carray))
+
+(defun-raw accg-scp-list (lst proved unproved)
+ ;; given a list of accgs, lst, performs scp on a cleaned version of the accg,
+ ;; putting the cleaned accg into proved if scp determines the accg is
+ ;; terminating or the original accg into unproved if it is not proven
+ ;; terminating.
+ (if (endp lst)
+ (mv proved unproved)
+ (let* ((accg (cln-accg (copy-accg (car lst)))))
+ (cond ((scp (copy-accg accg))
+ (accg-scp-list (cdr lst)
+ (cons accg proved)
+ unproved))
+ (t
+ (accg-scp-list (cdr lst) proved (cons (car lst) unproved)))))))
+
+(defun-raw accg-sct-list1 (lst i n proved unproved ces state)
+ ;; given a list of accgs, lst, performs sct on a cleaned version of each
+ ;; accg, putting the cleaned into proved if sct determines the accg is
+ ;; terminating or the original accg into unproved if it is not proven
+ ;; terminating.
+ (if (endp lst)
+ (pprogn
+ (let ((plen (len proved)))
+ (ccg-io? basics nil state
+ (plen unproved)
+ (fms "Size-change analysis has proven ~x0 out of ~x1 SCCs of ~
+ the CCG terminating.~|"
+ `((#\0 . ,plen)
+ (#\1 . ,(+ plen (len unproved))))
+ *standard-co*
+ state
+ nil)))
+ (value (list* proved unproved ces)))
+ (pprogn
+ (increment-timer 'other-time state)
+ (ccg-io? size-change nil state
+ ()
+ (fms "We now begin size change analysis on the ~n0 SCC out of ~
+ ~n1."
+ (list (cons #\0 `(,i))
+ (cons #\1 n))
+ *standard-co*
+ state
+ nil))
+ (increment-timer 'print-time state)
+ (let* ((accg (cln-accg (copy-accg (car lst)))))
+ (if (null accg)
+ ;; this should no longer happen because cln-accg no
+ ;; longer returns nil if there are empty ccmfs.
+ (pprogn
+ (increment-timer 'other-time state)
+ (ccg-io? size-change nil state
+ ()
+ (fms "A trivial analysis has revealed that this SCC is ~
+ potentially non-terminating. We will set it aside ~
+ for further refinement.~|"
+ nil *standard-co* state nil))
+ (increment-timer 'print-time state)
+ (accg-sct-list1 (cdr lst) (1+ i) n proved (cons (car lst) unproved)
+ (cons nil ces) state))
+ (er-let*
+ ((ce (sct (accg-ccmfs accg) (array-dimension accg 0) state)))
+ (if (null ce)
+ (pprogn
+ (increment-timer 'other-time state)
+ (ccg-io? size-change nil state
+ ()
+ (fms "We have shown this SCC to be terminating, so we ~
+ do not need to refine it any further.~|"
+ nil *standard-co* state nil))
+ (increment-timer 'print-time state)
+ (accg-sct-list1 (cdr lst)
+ (1+ i)
+ n
+ (cons accg proved)
+ unproved
+ ces
+ state))
+ (pprogn
+ (increment-timer 'other-time state)
+ (ccg-io? size-change nil state
+ ()
+ (fms "This SCC is potentially non-terminating. We will ~
+ set it aside for further refinement.~|"
+ nil *standard-co* state nil))
+ (increment-timer 'print-time state)
+ (accg-sct-list1 (cdr lst)
+ (1+ i)
+ n
+ proved
+ (cons (car lst) unproved)
+ (cons ce ces)
+ state)))))))))
+
+(defun-raw accg-sct-list (lst proved unproved ces state)
+ (accg-sct-list1 lst 1 (len lst) proved unproved ces state))
+
+(defun ccg-counter-example-fn-name1 (char-lst pkg i wrld)
+ (declare (xargs :guard (and (standard-char-listp char-lst)
+ (stringp pkg)
+ (natp i)
+ (plist-worldp wrld))))
+ (let ((name (intern$ (coerce (append char-lst
+ `(#\_)
+ (explode-nonnegative-integer i 10 nil))
+ 'string)
+ pkg)))
+ (cond ((new-namep name wrld) (mv name i))
+ (t (ccg-counter-example-fn-name1 char-lst pkg (1+ i) wrld)))))
+
+(defun ccg-counter-example-fn-name (root i wrld)
+ (declare (xargs :guard (and (symbolp root)
+ (plist-worldp wrld)
+ (natp i))))
+ (ccg-counter-example-fn-name1 (coerce (symbol-name root) 'list)
+ (symbol-package-name root)
+ i
+ wrld))
+
+(defun assoc-set-eq (key value alist)
+ (declare (xargs :guard (and (symbolp key)
+ (alistp alist))))
+ (cond ((endp alist)
+ (acons key value alist))
+ ((eq key (caar alist))
+ (acons key value (cdr alist)))
+ (t
+ (assoc-set-eq key value (cdr alist)))))
+
+(defun assoc-eq-value (key default alist)
+ (declare (xargs :guard (and (symbolp key)
+ (alistp alist))))
+ (let ((pair (assoc-eq key alist)))
+ (if (consp pair)
+ (cdr pair)
+ default)))
+
+(defun-raw aref-lst (array lst)
+ (mapcar #'(lambda (x) (aref array x)) lst))
+
+(defun-raw alist-add-eq (alist key val)
+ ;; given an alist whose values are lists, returns the alist
+ ;; resulting from adding val to the list that is the value
+ ;; corresponding to the key key.
+ (cond ((endp alist)
+ (acons key (list val) nil))
+ ((eq (caar alist) key)
+ (acons key (cons val (cdar alist)) (cdr alist)))
+ (t
+ (cons (car alist) (alist-add-eq (cdr alist) key val)))))
+
+(defun-raw order-names-arglists (names arglists rv-alist)
+ ;; when determining the minimal set of formals necessary to prove
+ ;; termination, we do a simple search of all the subsets of
+ ;; variables. to speed this up, we create a list indicating the
+ ;; order that we add the variables. this list is ordered by number
+ ;; of formals first, formal order second, and by function last. so,
+ ;; if we have function f with formals (x y) and function g with
+ ;; formals (a b), then the order would be ((f x) (g a) (f y) (g
+ ;; b)). So, the sets we would try, in the order we try them, are as
+ ;; follows:
+ ;;
+ ;; 1. {(f x)}
+ ;; 2. {(g a)}
+ ;; 3. {(f y)}
+ ;; 4. {(g b)}
+ ;; 5. {(f x) (g a)}
+ ;; 6. {(f x) (f y)}
+ ;; 7. {(f x) (g b)}
+ ;; 8. {(g a) (f y)}
+ ;; 9. {(g a) (g b)}
+ ;; 10. {(f y) (g b)}
+ ;; 11. {(f x) (g a) (f y)}
+ ;; 12. {(f x) (g a) (g b)}
+ ;; 13. {(f x) (f y) (g b)}
+ ;; 14. {(g a) (f y) (g b)}
+ ;; 15. {(f x) (g a) (f y) (g b)}
+ ;;
+ ;; the idea is that most functions require only a small subset of
+ ;; the actuals to prove termination.
+
+ (let* ((na-arrays (coerce (mapcar (lambda (x y) (coerce (cons x y) 'vector))
+ names arglists)
+ 'vector))
+ (maxsize (loop for v across na-arrays maximize (array-dimension v 0))))
+ (loop for i from 1 below maxsize
+ append (loop for array across na-arrays
+ when (and (< i (array-dimension array 0))
+ (not (member-eq (aref array i)
+ (cdr (assoc (aref array 0) rv-alist)))))
+ collect (cons (aref array 0)
+ (aref array i))))))
+
+(defmacro-raw ccmf-tail-fn (ccmf contexts)
+ `(context-fn (aref ,contexts
+ (car (ccmf-fc-num ,ccmf)))))
+
+(defmacro-raw ccmf-head-fn (ccmf contexts)
+ `(context-fn (aref ,contexts
+ (car (ccmf-lc-num ,ccmf)))))
+
+(defun-raw restrict-ccmf (ccmf ccmr1 ccmr2)
+ ;; the dual to ccmf-remove-ccms, in that it only retains the ccms
+ ;; indicated by ccmr1 and ccmr2, but is not destructive.
+ (let* ((graph (ccmf-graph ccmf))
+ (n (array-dimension graph 0))
+ (ngraph (make-array n
+ :element-type 'ccmf-node
+ :initial-element (make-ccmf-node)))
+ (nccmf (make-ccmf :firstsite (ccmf-firstsite ccmf)
+ :lastsite (ccmf-lastsite ccmf)
+ :fc-num (ccmf-fc-num ccmf)
+ :lc-num (ccmf-lc-num ccmf)
+ :in-sizes (ccmf-in-sizes ccmf)
+ :out-sizes (ccmf-out-sizes ccmf)
+ :graph ngraph))
+ (f (lambda (x) (aref ccmr2 x))))
+ (loop for i from 0 below n
+ for node = (aref graph i)
+ if (aref ccmr1 i)
+ do (setf (aref ngraph i)
+ (make-ccmf-node
+ :>-edges (remove-if-not f (ccmf-node->-edges node))
+ :>=-edges (remove-if-not f (ccmf-node->=-edges node))))
+ else
+ do (setf (aref ngraph i) (make-ccmf-node)))
+ (loop for node across ngraph
+ when (or (consp (ccmf-node->-edges node))
+ (consp (ccmf-node->=-edges node)))
+ return nccmf
+ finally (return nil))))
+
+(defun-raw can-solve-restricted-accgs? (accgs ccmrs scp? state)
+ ;; this is the workhorse of our controller-alist search. given ccm
+ ;; restrictions (see create-ccm-restrictions), ccmrs, and a flag to
+ ;; indicate whether the original accg was solved using scp or sct,
+ ;; we restrict the accg and attempt to reprove termination.
+ (loop for accg in accgs
+ for n = (array-dimension accg 0)
+ for naccg = (make-array n)
+ ;; first, initiate the naccg nodes
+ do (loop for i from 0 below n
+ for node = (aref accg i)
+ do (setf (aref naccg i)
+ (make-accg-node
+ :context (accg-node-context node)
+ :num i)))
+ ;; next, set the ccmfs for those nodes to be the restricted
+ ;; version of the ccmfs of the original accg node.
+ do (loop
+ for i from 0 below n
+ for node = (aref accg i)
+ for nnode1 = (aref naccg i)
+ for ccmr1 = (aref ccmrs (car (accg-node-context-num node)))
+ do (loop
+ for edge in (accg-node-fwd-edges node)
+ for ccmf = (accg-edge-ccmf edge)
+ for ccmr2 = (aref ccmrs (accg-edge-head edge))
+ for nnode2 = (aref naccg (accg-edge-head edge))
+ for nccmf = (restrict-ccmf ccmf ccmr1 ccmr2)
+ if nccmf
+ do (let ((nedge (make-accg-edge :head (accg-edge-head edge)
+ :tail (accg-edge-tail edge)
+ :ccmf nccmf)))
+ (setf (accg-node-fwd-edges nnode1)
+ (cons nedge (accg-node-fwd-edges nnode1)))
+ (setf (accg-node-bwd-edges nnode2)
+ (cons nedge (accg-node-bwd-edges nnode2))))
+ else do (return-from can-solve-restricted-accgs? (value nil))))
+ ;; finally, run scp or sct as indicated. if we fail, then we
+ ;; immediately return nil.
+ do (if scp?
+ (unless (scp (cln-accg naccg)) (return (value nil)))
+ (er-let*
+ ((caccg (value (cln-accg naccg)))
+ (ce (if (null caccg)
+ (value t)
+ (sct (accg-ccmfs caccg) n state))))
+ (unless (null ce) (return (value nil)))))
+ finally (return (value t))))
+
+(defun-raw create-ccm-restrictions (contexts av-alist)
+ ;; creates "ccm restrictions", which is an array of boolean arrays
+ ;; such that element i j is t iff we want to keep ccm j from context
+ ;; i. which ccms to keep is determined by av-alist, which tells us
+ ;; which variables from each function we are using for the current
+ ;; restriction.
+ (loop with n = (array-dimension contexts 0)
+ with ccmrs = (make-array n)
+ for i from 0 below n
+ for context = (aref contexts i)
+ for ccms = (context-ccms context)
+ ;; vars are the variables we are allowed to use for this context.
+ for vars = (cdr (assoc (context-fn context) av-alist))
+ for m = (array-dimension ccms 0)
+ for ccmri = (make-array m
+ :element-type 'boolean
+ :initial-element nil)
+ do (setf (aref ccmrs i) ccmri)
+ do (loop for j from 0 below m
+ do (setf (aref ccmri j)
+ (subsetp (all-vars (aref ccms j))
+ vars)))
+ finally (return ccmrs)))
+
+(defun-raw ruler-vars (names contexts)
+ ;; returns an alist mapping fucntion names to the variables used in
+ ;; the rulers of the contexts of that function.
+ (loop with rv-alist = (pairlis$ names nil)
+ for context across contexts
+ for fn = (context-fn context)
+ for vars = (all-vars1-lst (context-ruler context) nil)
+ for pair = (assoc fn rv-alist)
+ do (setf (cdr pair) (union-eq vars (cdr pair)))
+ finally (return rv-alist)))
+
+(defun-raw cgma-aux (nalist proved-scp proved-sct contexts av-alist i state)
+ ;; helper function for ccg-generate-measure-alist. nalist is the
+ ;; list of function-formal pairs as generated by
+ ;; order-names-arglists. proved-scp is a list of accgs proved
+ ;; terminating by the scp algorithm, and proved-sct is a list of
+ ;; accgs proved terminating by the sct algorithm. contexts is the
+ ;; array of contexts. av-alist is an alist mapping each function
+ ;; name to the formals that we want enabled, and i is the number of
+ ;; formals we want to enable. returns the first av-alist
+ ;; for which we can prove termination, or nil if we cannot
+ ;; prove termination.
+ (cond ((zp i) ;; if we don't want to add any more variables, try to
+ ;; prove termination of the restricted accgs.
+ (let ((ccmrs (create-ccm-restrictions contexts av-alist)))
+ (er-let*
+ ((p1 (can-solve-restricted-accgs? proved-scp ccmrs t state))
+ (p2 (if p1
+ (can-solve-restricted-accgs? proved-sct ccmrs nil state)
+ (value nil))))
+ (if p2
+ (value av-alist)
+ (value nil)))))
+ ((endp nalist) ;; if we reach the end of the list before i
+ ;; reaches 0, just return nil.
+ (value nil))
+ (t ;; otherwise, we proceed in two different ways:
+ (er-let*
+ ;; first, we enable the first formal in nalist and
+ ;; proceed to enable i-1 of the rest of the formals.
+ ((nav-alist (cgma-aux (cdr nalist) proved-scp proved-sct contexts
+ (alist-add-eq av-alist
+ (caar nalist)
+ (cdar nalist))
+ (1- i)
+ state)))
+ ;; if we were successful, report our success.
+ (if nav-alist
+ (value nav-alist)
+ ;; otherwise, try leaving the current variable out
+ ;; and enable i of the remaining variables.
+ (cgma-aux (cdr nalist) proved-scp proved-sct
+ contexts av-alist i state))))))
+
+(defun-raw ccg-generate-measure-alist1 (i nalist proved-scp proved-sct
+ contexts rv-alist state)
+ (er-let* ((av-alist (cgma-aux nalist proved-scp proved-sct
+ contexts rv-alist i state)))
+ (if av-alist
+ (value (mapcar (lambda (x) (cons (car x) (cons :? (cdr x))))
+ av-alist))
+ (ccg-generate-measure-alist1 (1+ i) nalist
+ proved-scp proved-sct
+ contexts rv-alist state))))
+
+(defun-raw ccg-generate-measure-alist (proved-scp proved-sct names arglists
+ contexts cpn state)
+ ;; generates a measure-alist designed to minimize the resulting
+ ;; controller-alist. we return the restricted set of the ccms
+ ;; necessary for proving termination with :CCG consed onto the
+ ;; front. the result is a "pseudo-measure" from which ACL2 can
+ ;; compute a safe controller alist. proved-scp and proved-sct are
+ ;; the accgs proved terminating using the scp or sct algorithm,
+ ;; respectively. names is the list of names of the functions, and
+ ;; arglists is the list of the arglists for each function. contexts
+ ;; is the array of contexts. cpn tells us whether or not we proved
+ ;; termination constructing contexts by node rather than by
+ ;; edge. This is important because, in order to construct a sound
+ ;; controller-alist we need to include all the variables in the
+ ;; context rulers if we could not prove termination using per-node
+ ;; contexts.
+
+ ;; first, we construct an alist of the initially enabled formals
+ ;; based on cpn, and use it to make an ordered list of name-formal
+ ;; pairs.
+
+ (let* ((rv-alist (if cpn (pairlis$ names nil) (ruler-vars names contexts)))
+ (nalist (order-names-arglists names arglists rv-alist)))
+ (ccg-generate-measure-alist1 0 nalist proved-scp proved-sct
+ contexts rv-alist state)))
+
+
+;;;;; ALL TERMINATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun-raw name-var-pairs1 (name arglist rst)
+ ;; name: the name of a function
+ ;; arglist: the arglist of the function whose name is name
+ ;; rst: the list to which to append the result
+ ;;
+ ;; OUTPUT: ((name . x) | x in arglist) appended to rst.
+
+ (if (endp arglist)
+ rst
+ (acons name (car arglist)
+ (name-var-pairs1 name (cdr arglist) rst))))
+
+(defun-raw name-var-pairs (functs rv-alist)
+ ;; functs: a list of structs of type funct.
+ ;; rv-alist: an alist mapping the names of the functions in functs
+ ;; to subsets of their formals. The idea is that these are
+ ;; restricted variables. That is, in the measured-subset analysis,
+ ;; all subsets must be supersets of the variables specified in
+ ;; rv-alist.
+ ;;
+ ;; OUTPUT: two lists of the form ((fn . x) ...) where fn is the name
+ ;; of a function in funct and x is a formal of that function. The
+ ;; first list is of these pairs that we may consider removing from
+ ;; the measured subset, and the second is a list of these pairs that
+ ;; we may *not* consider removing from the measured subset (as
+ ;; specified by rv-alist).
+ (if (endp functs)
+ (mv nil nil)
+ (mv-let
+ (free fixed)
+ (name-var-pairs (cdr functs) rv-alist)
+ (let* ((funct (car functs))
+ (fn (funct-fn funct))
+ (rv (cdr (assoc fn rv-alist))))
+ (mv (name-var-pairs1 fn
+ (set-difference-eq (funct-formals funct) rv)
+ free)
+ (name-var-pairs1 fn rv fixed))))))
+
+(defun-raw get-ccm-vars1 (i ccms ccm-vars)
+ ;; i: integer such that 0 <= i < |ccms|.
+ ;; ccms: an array of calling context measures.
+ ;; ccm-vars: accumulator array such that ccm-vars[j] contains a list
+ ;; of all the variables in the expression ccms[j].
+ ;;
+ ;; OUTPUT: completed ccm-vars.
+ (cond ((< i 0)
+ ccm-vars)
+ (t
+ (setf (aref ccm-vars i)
+ (all-vars (aref ccms i)))
+ (get-ccm-vars1 (1- i) ccms ccm-vars))))
+
+(defun-raw get-ccm-vars (ccms)
+ ;; ccms: an array of ccms.
+ ;;
+ ;; OUTPUT: an array, ccm-vars, such that ccm-vars[i] contains the
+ ;; list of variables in expression ccms[i] for all 0 <= i < |ccms|
+ (let ((len (array-dimension ccms 0)))
+ (get-ccm-vars1 (1- len) ccms (make-array len
+ :element-type 'list
+ :initial-element nil))))
+
+(defun-raw fn-ccm-vars-alist (functs)
+ (if (endp functs)
+ nil
+ (let ((funct (car functs)))
+ (acons (funct-fn funct) (get-ccm-vars (funct-ccms funct))
+ (fn-ccm-vars-alist (cdr functs))))))
+
+(defun-raw gather-relevant-ccms1 (i var ccm-vars indices)
+ ;; i: an integer such that 0 <= i < |ccm-vars|. Should initially be |ccm-vars|-1.
+ ;; ccm-vars: an array of lists of integers.
+ ;; var: a variable
+ ;; indices: the accumulator; it is { k | i < k < |ccm-vars|
+ ;; s.t. ccm-vars[k] contains var }. Should initially be nil.
+ ;;
+ ;; OUTPUT: { k | 0 <= k < |ccm-vars| s.t. ccm-vars[k] contains var }
+ (if (< i 0)
+ indices
+ (gather-relevant-ccms1 (1- i) var ccm-vars
+ (if (member-eq var (aref ccm-vars i))
+ (cons i indices)
+ indices))))
+
+(defun-raw gather-relevant-ccms (var ccm-vars)
+ ;; ccm-vars: an array of lists of variables
+ ;; var: a variable
+ ;;
+ ;; OUTPUT: the list of the indices of the slots of ccm-vars that
+ ;; contain var.
+ (gather-relevant-ccms1 (1- (array-dimension ccm-vars 0)) var ccm-vars nil))
+
+(defun-raw gather-all-relevant-ccms1 (avars alist)
+ ;; functs: a list of structures of type funct
+ ;;
+ ;; OUTPUT: a mapping of sorts from formals to the ccms containing
+ ;; those formals. See the note on the output of
+ ;; gather-all-relevant-ccms-for-funct.
+ (if (endp avars)
+ nil
+ (let* ((avar (car avars))
+ (fn (car avar))
+ (var (cdr avar)))
+ (cons (gather-relevant-ccms var (cdr (assoc fn alist)))
+ (gather-all-relevant-ccms1 (cdr avars) alist)))))
+
+(defun-raw gather-all-relevant-ccms (avars functs)
+ (gather-all-relevant-ccms1 avars (fn-ccm-vars-alist functs)))
+
+(defun set-difference-and-intersection (set1 set2)
+ (declare (xargs :guard (and (eqlable-listp set1)
+ (eqlable-listp set2))))
+ ;; set1: an eqlable-listp.
+ ;; set2: an eqlable-listp
+ ;;
+ ;; OUTPUT: two lists. The first is the difference of set1 and set2,
+ ;; and the second is the intersection of set1 and set2.
+ (if (endp set1)
+ (mv nil nil)
+ (mv-let (difference intersection)
+ (set-difference-and-intersection (cdr set1) set2)
+ (if (member (car set1) set2)
+ (mv difference (cons (car set1) intersection))
+ (mv (cons (car set1) difference) intersection)))))
+
+(defun-raw ccmf-remove-relevant-edges1 (i graph relevant-ccms1 relevant-ccms2
+ edges-alist)
+ ;; i: integer such that 0 <= i < |graph|.
+ ;; graph: a ccmf-graph.
+ ;; relevant-ccms1: an increasing list of integers, j, such that 0 <=
+ ;; j < |graph|. These are the ccms we are to virtually remove from
+ ;; the graph by removing all its outgoing edges.
+ ;; ASSUMPTION: relevant-ccms1 is in increasing order.
+ ;; relevant-ccms2: a list of natural numbers. These are the ccms we
+ ;; are to virtually remove from the target context of the graph by
+ ;; removing all of its incoming edges.
+ ;; edges-alist: the accumulator alist that maps each 0 <= j <
+ ;; |graph| to a cons of the >-edges and >=-edges removed from the
+ ;; graph, so we can put them back later.
+ ;;
+ ;; SIDE EFFECT: all edges to and from relevant ccms in the graph are
+ ;; removed.
+ ;;
+ ;; OUTPUT: the completed edges-alist.
+
+ (cond ((<= (array-dimension graph 0) i)
+ edges-alist)
+ ((and (consp relevant-ccms1)
+ (= i (car relevant-ccms1)))
+ ;; if i is a member of relevant-ccms1, it is the first
+ ;; element because of our assumption that relevant-ccms1 is
+ ;; increasing. In this case we remove all the outgoing edges
+ ;; from graph[i].
+ (let* ((node (aref graph i))
+ (>-edges-i (ccmf-node->-edges node)) ;;get the >-edges
+ (>=-edges-i (ccmf-node->=-edges node))) ;; get the >=-edges
+ (setf (ccmf-node->-edges node) nil) ;; set the >-edges to nil
+ (setf (ccmf-node->=-edges node) nil) ;; set the >=-edges to nil
+ (ccmf-remove-relevant-edges1 (1+ i) graph
+ (cdr relevant-ccms1) relevant-ccms2
+ ;; add the removed edges (if
+ ;; any) to the accumulator:
+ (if (and (endp >-edges-i) (endp >=-edges-i))
+ edges-alist
+ (acons i (cons >-edges-i >=-edges-i)
+ edges-alist)))))
+ ((consp relevant-ccms2)
+ ;; if a non-nil relevant-ccms2 was supplied, we remove all
+ ;; the edges pointing from graph[i] to ccms specified by
+ ;; relevant-ccms2.
+ (let* ((node (aref graph i))
+ (>-edges-i (ccmf-node->-edges node))
+ (>=-edges-i (ccmf-node->=-edges node)))
+ (mv-let (>-diff >-intersect)
+ (set-difference-and-intersection >-edges-i relevant-ccms2)
+ (mv-let (>=-diff >=-intersect)
+ (set-difference-and-intersection >=-edges-i relevant-ccms2)
+ (progn
+ ;; if we removed any edges, set the new
+ ;; edge lists.
+ (when (consp >-intersect)
+ (setf (ccmf-node->-edges node) >-diff))
+ (when (consp >=-intersect)
+ (setf (ccmf-node->=-edges node) >=-diff))
+ (ccmf-remove-relevant-edges1
+ (1+ i) graph
+ relevant-ccms1 relevant-ccms2
+ ;; add the removed edges (if any) to the accumulator.
+ (if (and (endp >-intersect) (endp >=-intersect))
+ edges-alist
+ (acons i (cons >-intersect >=-intersect)
+ edges-alist))))))))
+ (t
+ ;; if the current index is not in relevant-ccms1 and
+ ;; relevant-ccms2 is empty, there is nothing to do, so we
+ ;; move on to the next index.
+ (ccmf-remove-relevant-edges1 (1+ i)
+ graph
+ relevant-ccms1
+ relevant-ccms2
+ edges-alist))))
+
+(defun-raw ccmf-remove-relevant-edges (ccmf relevant-ccms1 relevant-ccms2)
+ ;; ccmf: a struct of type ccmf.
+ ;; relevant-ccms1: an increasing list of integers, j, such that 0 <=
+ ;; j < |graph|. These are the ccms we are to virtually remove from
+ ;; the graph by removing all its outgoing edges.
+ ;; ASSUMPTION: relevant-ccms1 is in increasing order.
+ ;; relevant-ccms2: a list of natural numbers. These are the ccms we
+ ;; are to virtually remove from the target context of the graph by
+ ;; removing all of its incoming edges.
+ ;;
+ ;; SIDE EFFECT: all edges to and from relevant ccms in the ccmf are
+ ;; removed.
+ ;;
+ ;; OUTPUT: the ccmf consed to an alist that maps each 0 <= j <
+ ;; |graph| to a cons of the >-edges and >=-edges removed from the
+ ;; graph, so we can put them back later.
+
+ (let ((graph (ccmf-graph ccmf)))
+ (cons ccmf
+ (ccmf-remove-relevant-edges1 0
+ graph
+ relevant-ccms1 relevant-ccms2
+ nil))))
+
+(defun-raw ccmf-remove-relevant-edges-lst (ccmfs contexts fn relevant-ccms acc)
+ ;; ccmfs: a list of structs of type ccmf which should be the ccmfs for fn.
+ ;; contexts: an array of contexts.
+ ;; fn: a function name
+ ;; relevant-ccms: a list of indices of the ccms of fn. Indicates
+ ;; which ccms to remove.
+ ;; acc: the accumulator. This accumulates the removed edge
+ ;; information so we can restore the ccmfs when we are done.
+ ;;
+ ;; SIDE EFFECT: all edges to and from relevant ccms in the ccmfs of
+ ;; are removed.
+ ;;
+ ;; OUTPUT: the completed accumulator. It is an alist mapping the
+ ;; ccmfs to an alist mapping the indicices of the source ccms of the
+ ;; ccmf to a cons of the >-edges and >=-edges that were removed.
+
+ (if (endp ccmfs)
+ acc
+ (let* ((ccmf (car ccmfs))
+ (tcontext (aref contexts (car (ccmf-fc-num ccmf))))
+ (relevant-ccms1 (if (eq (context-fn tcontext) fn) relevant-ccms nil))
+ (hcontext (aref contexts (car (ccmf-lc-num ccmf))))
+ (relevant-ccms2 (if (eq (context-fn hcontext) fn) relevant-ccms nil)))
+ (ccmf-remove-relevant-edges-lst
+ (cdr ccmfs)
+ contexts
+ fn
+ relevant-ccms
+ (cons (ccmf-remove-relevant-edges ccmf relevant-ccms1 relevant-ccms2)
+ acc)))))
+
+(defun-raw accg-remove-relevant-ccmf-edges1 (i accg contexts fn relevant-ccms acc)
+ ;; i: natural number such that 0 <= i < |accg|.
+ ;; accg: an array of structs of type accg-node.
+ ;; contexts: an array of contexts.
+ ;; fn: a function name.
+ ;; relevant-ccms: the ccms to remove from all ccmfs corresponding to fn.
+ ;; acc: the accumulator.
+ ;;
+ ;; SIDE EFFECT: all edges to and from relevant ccms in the ccmfs of
+ ;; the accg are removed.
+ ;;
+ ;; OUTPUT: an alist mapping the ccmfs to an alist mapping the
+ ;; indicices of the source ccms of the ccmf to a cons of the >-edges
+ ;; and >=-edges that were removed.
+ (if (< i 0)
+ acc
+ (let* ((node (aref accg i)))
+ (accg-remove-relevant-ccmf-edges1
+ (1- i)
+ accg
+ contexts
+ fn
+ relevant-ccms
+ (if (eq (accg-node-fn node) fn)
+ (let ((pred (lambda (edge)
+ (equal (accg-node-fn (aref accg (accg-edge-tail edge)))
+ fn))))
+ (ccmf-remove-relevant-edges-lst
+ (append (mapcar #'accg-edge-ccmf
+ (accg-node-fwd-edges node))
+ ;; remove all edges from contexts of fn to avoid
+ ;; redundant work.
+ (mapcar #'accg-edge-ccmf
+ (remove-if pred
+ (accg-node-bwd-edges node))))
+ contexts
+ fn
+ relevant-ccms
+ acc))
+ acc)))))
+
+(defun-raw accg-remove-relevant-ccmf-edges (accg contexts fn relevant-ccms)
+
+ ;; accg: an array of structs of type accg-node.
+ ;; contexts: an array of contexts.
+ ;; fn: a function name.
+ ;; relevant-ccms: the ccms to remove from all ccmfs corresponding to fn.
+ ;;
+ ;; SIDE EFFECT: all edges to and from relevant ccms in the ccmfs of
+ ;; the accg are removed.
+ ;;
+ ;; OUTPUT: an alist mapping the ccmfs to an alist mapping the
+ ;; indicices of the source ccms of the ccmf to a cons of the >-edges
+ ;; and >=-edges that were removed.
+
+ (accg-remove-relevant-ccmf-edges1 (1- (array-dimension accg 0))
+ accg
+ contexts
+ fn
+ relevant-ccms
+ nil))
+
+(defun-raw accg-remove-relevant-ccmf-edges-lst-tail (accgs contexts fn relevant-ccms acc)
+ ;; tail recursive implementation of accg-remove-relevant-ccmf-edges-lst
+
+ (if (endp accgs)
+ acc
+ (accg-remove-relevant-ccmf-edges-lst-tail
+ (cdr accgs)
+ contexts
+ fn
+ relevant-ccms
+ (accg-remove-relevant-ccmf-edges1
+ (1- (array-dimension (car accgs) 0))
+ (car accgs)
+ contexts
+ fn
+ relevant-ccms
+ acc))))
+
+(defun-raw accg-remove-relevant-ccmf-edges-lst (accgs contexts fn relevant-ccms)
+ ;; accgs: a list of accgs.
+ ;; contexts: an array of contexts
+ ;; fn: function name
+ ;; relevant-ccms: the ccms of fn to "remove" (ccms are kept, but all
+ ;; incoming and outgoing edges are removed).
+ ;;
+ ;; SIDE-EFFECT: all the incoming and outgoing edges of the indicated
+ ;; ccms of fn in the ccmfs of the accgs are removed.
+ ;;
+ ;; OUTPUT: an alist mapping the ccmfs to an alist mapping the
+ ;; indicices of the source ccms of the ccmf to a cons of the >-edges
+ ;; and >=-edges that were removed.
+ (accg-remove-relevant-ccmf-edges-lst-tail accgs contexts fn relevant-ccms nil))
+
+(defun-raw restore-edges1 (ccmf alist)
+ ;; ccmf: a struct of type ccmf.
+ ;; alist: maps indices of the ccmf to the cons of the >-edges and
+ ;; >=-edges that should be added back to the ccmf.
+ ;;
+ ;; SIDE-EFFECT: the edges indicated by the alist are added back to the ccmf.
+ ;;
+ ;; OUTPUT: nil.
+ (if (endp alist)
+ nil
+ (let* ((entry (car alist))
+ (i (car entry))
+ (>-edges (cadr entry))
+ (>=-edges (cddr entry))
+ (node (aref (ccmf-graph ccmf) i)))
+ (setf (ccmf-node->-edges node)
+ (merge 'list
+ >-edges
+ (ccmf-node->-edges node)
+ #'<))
+ (setf (ccmf-node->=-edges node)
+ (merge 'list
+ >=-edges
+ (ccmf-node->=-edges node)
+ #'<))
+ (restore-edges1 ccmf (cdr alist)))))
+
+(defun-raw restore-edges (alist)
+ ;; alist: maps ccmfs to alists mapping indices of the ccmf to the
+ ;; cons of the >-edges and >=-edges that should be added back to the
+ ;; ccmf.
+ ;;
+ ;; SIDE-EFFECT: the edges indicated by the alist are added back to
+ ;; their respective ccmfs.
+ ;;
+ ;; OUTPUT: nil.
+
+ (if (endp alist)
+ nil
+ (progn
+ (restore-edges1 (caar alist) (cdar alist))
+ (restore-edges (cdr alist)))))
+
+(defun-raw can-scp-lstp (accgs)
+ ;; accgs: a list of accgs.
+ ;;
+ ;; OUTPUT: returns non-nil iff scp succeeds for all the accgs.
+ (or (endp accgs)
+ (and (scp (cln-accg (copy-accg (car accgs))))
+ (can-scp-lstp (cdr accgs)))))
+
+(defun-raw can-sct-lstp (accgs state)
+ ;; accgs: a list of accgs
+ ;; state: the state
+ ;;
+ ;; OUTPUT: returns non-nil iff sct succeeds for the ccmfs of all the accgs.
+ (if (endp accgs)
+ (value t)
+ (let ((naccg (cln-accg (copy-accg (car accgs)))))
+ (if (null naccg)
+ (value nil)
+ (er-let*
+ ((ce (sct (accg-ccmfs naccg)
+ (array-dimension naccg 0)
+ state)))
+ (if (null ce)
+ (can-sct-lstp (cdr accgs) state)
+ (value nil)))))))
+
+(defun remove-covered-subsets-tail (avar subsets acc)
+ ;;tail recursive implementation of remove-covered-subsets
+ (cond ((endp subsets) acc)
+ ((equal avar (caar subsets))
+ (remove-covered-subsets-tail avar (cdr subsets) acc))
+ (t
+ (remove-covered-subsets-tail avar
+ (cdr subsets)
+ (cons (car subsets) acc)))))
+
+(defun remove-covered-subsets (avar subsets)
+ ;; avar: an element.
+ ;; subsets: a list of lists.
+ ;;
+ ;; OUTPUT: the subset of subsets which do not have avar as its first element.
+ (remove-covered-subsets-tail avar subsets nil))
+
+(defun remove-avar-from-subsets-tail (avar subsets acc)
+ ;; a tail-recursive implementation of remove-avar-from-subsets.
+ (if (endp subsets)
+ acc
+ (remove-avar-from-subsets-tail avar (cdr subsets)
+ (cons (if (equal avar (caar subsets))
+ (cdar subsets)
+ (car subsets))
+ acc))))
+
+(defun remove-avar-from-subsets (avar subsets)
+ ;; avar: an element
+ ;; subsets: a list of lists
+ ;;
+ ;; OUTPUT: the result of removing avar from all the lists in subsets
+ ;; for which avar is the first element.
+ (remove-avar-from-subsets-tail avar subsets nil))
+
+(defun add-avar-to-subsets-tail (avar subsets acc)
+ ;; a tail-recursive implementation of add-avar-to-subsets.
+ (if (endp subsets)
+ acc
+ (add-avar-to-subsets-tail avar (cdr subsets)
+ (acons avar (car subsets) acc))))
+
+(defun add-avar-to-subsets (avar subsets)
+ ;; avar: an element.
+ ;; subsets: a list of lists.
+ ;;
+ ;; OUTPUT: the result of consing avar to every element of subsets.
+ (add-avar-to-subsets-tail avar subsets nil))
+
+(defun-raw all-termination1 (proved-scp proved-sct contexts avars
+ relevant-edges subsets state)
+ ;; proved-scp: a list of accgs for which scp succeeds.
+ ;; proved-sct: a list of accgs for which sct succeeds.
+ ;; contexts: an array of contexts.
+ ;; avars: a list of pairs of the form (fn. x) where fn is a function
+ ;; name, and x is a formal of that function.
+ ;; relevant-edges: a list of lists of indices such that the ith
+ ;; element of avars appears exactly in the ccms of the corresponding
+ ;; function indicated by the indices of the ith member of relevant-edges.
+
+ ;; subsets: a list of lists of the elements of avars. This helps us
+ ;; avoid finding supersets of already discovered measured-subsets by
+ ;; telling us what subsets to avoid (because they would result in a
+ ;; superset of an already calculated measured-subset).
+ ;;
+ ;; OUTPUT: a list of lists of the elements of avars coresponding to
+ ;; minimal variables needed to still successfully run scp on the
+ ;; elements of proved-scp and run sct on the elements of proved-sct.
+ (cond ((member-equal '() subsets)
+ ;; if '() is in subsets, that means that we have recreated an
+ ;; already calculated measured-subset, so we stop and return
+ (value '()))
+ ((endp avars)
+ ;; since we prune as we go, we know that if we make it to the
+ ;; end of the avars, we have a solution. So, we return the
+ ;; set containing the empty set, which will be populated on
+ ;; our way back up the search tree.
+ (value '(())))
+ (t
+ (let* ((avar (car avars)) ;; take the first avar.
+ (fn (car avar)) ;; the formal name
+
+ ;; we begin by removing all the ccm edges that are
+ ;; relevant to var from all the accgs in both
+ ;; proved-sct and proved scp.
+
+ (re-info (accg-remove-relevant-ccmf-edges-lst-tail
+ proved-sct
+ contexts
+ fn
+ (car relevant-edges)
+ (accg-remove-relevant-ccmf-edges-lst
+ proved-scp
+ contexts
+ fn
+ (car relevant-edges)))))
+
+ ;; if we can still prove termination without var, we
+ ;; continue our search down the subtree in which var
+ ;; is disabled. otherwise, we set nsubsets to be the
+ ;; empty set.
+ (er-let*
+ ((p (can-sct-lstp proved-sct state))
+ (nsubsets (if (and p
+ (can-scp-lstp proved-scp))
+ (all-termination1 proved-scp proved-sct
+ contexts
+ (cdr avars) (cdr relevant-edges)
+ (remove-covered-subsets avar subsets)
+ state)
+ (value '()))))
+ (progn
+ ;; next we restore the edges we removed.
+ (restore-edges re-info)
+ ;; finally, we search the branch of the search tree in
+ ;; which var is enabled.
+ (er-let*
+ ((nnsubsets (all-termination1
+ proved-scp proved-sct
+ contexts
+ (cdr avars) (cdr relevant-edges)
+ (append nsubsets
+ (remove-avar-from-subsets avar subsets))
+ state)))
+ ;; our solution is all the minimal measured subsets we
+ ;; discovered with var disabled along with var added to
+ ;; all the minimal measured subsets we discovered with
+ ;; var enabled.
+ (value (append nsubsets
+ (add-avar-to-subsets avar nnsubsets))))))))))
+
+(defun-raw funct-fns-lst (functs)
+ ;; given a list of functs, returns a corresponding list of all their funct-fns.
+ (if (endp functs)
+ nil
+ (cons (funct-fn (car functs)) (cdr functs))))
+
+(defun append-to-all (list list-of-lists)
+ (if (endp list-of-lists)
+ nil
+ (cons (append list (car list-of-lists))
+ (append-to-all list (cdr list-of-lists)))))
+
+(defun-raw all-termination (proved-scp proved-sct contexts functs cpn state)
+ ;; proved-scp: a list of accgs for which scp succeeds.
+ ;; proved-sct: a list of accgs for which sct succeeds.
+ ;; contexts: an array of contexts.
+ ;; functs: a list of structures of type funct.
+ ;; cpn: a boolean telling us if we proved termination using ccmfs
+ ;; per node (as opposed to per edge).
+ ;;
+ ;; OUTPUT: the minimal measured subsets of functs using the accgs
+ ;; that were used to prove termination.
+
+ ;; we need this strange case in the beginning.
+ (if (and (endp proved-scp)
+ (endp proved-sct))
+ (value '(()))
+
+ (let ((names (funct-fns-lst functs)))
+ (mv-let
+ (free fixed)
+ ;; if we proved termination with ccmfs per node, then by
+ ;; Vroon's dissertation, there is a measure involving only
+ ;; those variables that are needed to show termination in
+ ;; proved-scp and proved-sct. That is, all variables are
+ ;; candidates for removal from the measured-subset. If we
+ ;; used ccmfs per edge, then the dissertation tells us
+ ;; that we need to keep all variables that appear in the
+ ;; ruler. So these are off-limits for removal from the
+ ;; measured subset.
+ (name-var-pairs functs
+ (if cpn
+ (pairlis$ names nil)
+ (ruler-vars names contexts)))
+ ;; we append all the required variables to the calculated
+ ;; measured subset.
+ (let ((relevant-ccms (gather-all-relevant-ccms free functs)))
+ (er-let* ((at1 (all-termination1 proved-scp proved-sct
+ contexts free relevant-ccms nil state)))
+ (value (append-to-all fixed at1))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; ACL2 integration ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun get-ccms1 (m edcls key ctx state)
+
+ ;; this function is based on get-measures1 in the ACL2 sources.
+
+ ;; A typical edcls is given above, in the comment for get-guards. Note
+ ;; that the :CCMs entry is found in an XARGS declaration. By the check
+ ;; in chk-dcl-lst we know there is at most one :CCMs entry in each XARGS
+ ;; declaration. But there may be more than one declaration. If more than
+ ;; one measure is specified by this edcls, we'll cause an error. Otherwise,
+ ;; we return the measure or the term *0*, which is taken as a signal that
+ ;; no measure was specified.
+
+ ;; Our first argument, m, is the list of ccms term found so far, or
+ ;; *0* if none has been found. We map down edcls and ensure that
+ ;; each XARGS either says nothing about :CCMs or specifies m.
+
+ (cond ((null edcls) (value m))
+ ((eq (caar edcls) 'xargs)
+ (let ((temp (assoc-keyword key (cdar edcls))))
+ (cond ((null temp)
+ (get-ccms1 m (cdr edcls) key ctx state))
+ ((equal m *0*)
+ (get-ccms1 (cadr temp) (cdr edcls) key ctx state))
+ ((and (subsetp-equal m (cadr temp))
+ (subsetp-equal (cadr temp) m))
+ (get-ccms1 m (cdr edcls) key ctx state))
+ (t (er soft ctx
+ "It is illegal to declare two different ~
+ sets values for the key ~x0 for the admission ~
+ of a single function. But you have specified ~
+ ~x0 ~x1 and ~x1 ~x2."
+ key m (cadr temp))))))
+ (t (get-ccms1 m (cdr edcls) key ctx state))))
+
+(defun get-ccms2 (lst key ctx state)
+ ;; this function is based on get-measures2 in the acl2-sources
+ (cond ((null lst) (value nil))
+ (t (er-let* ((m (get-ccms1 *0* (fourth (car lst)) key ctx state))
+ (rst (get-ccms2 (cdr lst) key ctx state)))
+ (value (cons m rst))))))
+
+(defun get-ccms (symbol-class lst key ctx state)
+
+ ;; based on get-measures in the ACL2 sources
+
+ ;; This function returns a list in 1:1 correspondence with lst containing
+ ;; the user's specified :CCMs (or *0* if no measure is specified). We
+ ;; cause an error if more than one :CCMs is specified within the edcls of
+ ;; a given element of lst.
+
+ ;; If symbol-class is program, we ignore the contents of lst and simply return
+ ;; all *no-measure*s. See the comment in chk-acceptable-defuns where get-ccms is
+ ;; called.
+
+ (cond
+ ((eq symbol-class :program)
+ (value (make-list (length lst) :initial-element *0*)))
+ (t (get-ccms2 lst key ctx state))))
+
+(defun translate-ccms-list (ccms-list ctx wrld state)
+ ;; translates a list of ccm lists using translate measures.
+ (cond ((endp ccms-list) (value nil))
+ (t (er-let* ((tccms (if (eq (car ccms-list) *0*)
+ (value *0*)
+ (translate-measures (car ccms-list)
+ ctx wrld state)))
+ (rst (translate-ccms-list (cdr ccms-list)
+ ctx wrld state)))
+ (value (cons tccms rst))))))
+
+(defun chk-no-overlap (consider consider-only)
+ ;; makes sure that, for each function, there is not both a consider
+ ;; and consider-only hint.
+ (cond ((endp consider)
+ nil)
+ ((not (or (eq (car consider) *0*)
+ (eq (car consider-only) *0*)))
+ (cons consider consider-only))
+ (t
+ (chk-no-overlap (cdr consider) (cdr consider-only)))))
+
+(defun combine-ccm-hints (consider consider-only uc uco ctx state)
+
+ ;; combines the :CONSIDER-CCMS and :CONSIDER-ONLY-CCMS hints into one list of
+ ;; CCMs. We do not allow both of these to be specified for the same function,
+ ;; so we check that one or the other is *0*. The value returned is a list of
+ ;; pairs. The car of each pair is nil iff the given CCM is from a
+ ;; :CONSIDER-CCMS hint and non-nil if it is from a :CONSIDER-ONLY-CCMS
+ ;; hint. The cdr of each pair is the hint itself. If neither xarg is given
+ ;; (i.e. if they are both *0*) for a given function, the car of the pair is
+ ;; nil, and the cdr is *0*.
+
+ (cond ((endp consider)
+ (value nil))
+ ((eq (car consider-only) *0*)
+ (er-let* ((rst (combine-ccm-hints (cdr consider) (cdr consider-only)
+ (cdr uc) (cdr uco)
+ ctx state)))
+ (value (acons nil (car consider) rst))))
+ ((eq (car consider) *0*)
+ (er-let* ((rst (combine-ccm-hints (cdr consider) (cdr consider-only)
+ (cdr uc) (cdr uco)
+ ctx state)))
+ (value (acons t (car consider-only) rst))))
+ (t
+ (er soft ctx
+ "It is illegal to provide both a :CONSIDER and ~
+ a :CONSIDER-ONLY hint for the same function. But ~
+ you have specified :CONSIDER ~x0 and :CONSIDER-ONLY ~x1."
+ (car uc) (car uco)))))
+
+(defconst *ccg-xargs-keywords*
+ '(:CONSIDER-CCMS :CONSIDER-ONLY-CCMS :TERMINATION-METHOD
+ :CCG-PRINT-PROOFS :TIME-LIMIT
+ :CCG-HIERARCHY))
+
+(defun get-unambiguous-xargs-val1/edcls (key v edcls ctx state)
+
+; V is the value specified so far for key in the XARSGs of this or previous
+; edcls, or else the consp '(unspecified) if no value has been specified yet.
+; We cause an error if a value different from that specified so far is
+; specified. We return either the consp '(unspecified) or the uniformly agreed
+; upon value.
+
+ (cond
+ ((null edcls) (value v))
+ ((eq (caar edcls) 'xargs)
+ (let ((temp (assoc-keyword key (cdar edcls))))
+ (cond ((null temp)
+ (get-unambiguous-xargs-val1/edcls key v (cdr edcls) ctx state))
+ ((or (consp v)
+ (equal v (cadr temp)))
+ (get-unambiguous-xargs-val1/edcls key (cadr temp) (cdr edcls)
+ ctx state))
+ (t
+ (er soft ctx
+ "It is illegal to specify ~x0 ~x1 in one place and ~
+ ~x2 in another within the same definition. The ~
+ functionality controlled by that flag operates on ~
+ the entire event or not at all."
+ key v (cadr temp))))))
+ (t (get-unambiguous-xargs-val1/edcls key v (cdr edcls) ctx state))))
+
+(defun get-unambiguous-xargs-val1 (key lst ctx state)
+
+; We scan the edcls of lst and either extract a single uniformly agreed
+; upon value for key among the XARGS and return that value, or else no
+; value is specified and we return the consp '(unspecified) or else two or
+; more values are specified and we cause an error. We also cause an error
+; if any edcls specifies a non-symbol for the value of key. Thus, if we
+; return a symbol it is the uniformly agreed upon value and if we return
+; a consp there was no value specified.
+
+ (cond ((null lst) (value '(unspecified)))
+ (t (er-let*
+ ((v (get-unambiguous-xargs-val1 key (cdr lst) ctx state))
+ (ans (get-unambiguous-xargs-val1/edcls key v (fourth (car lst))
+ ctx state)))
+ (value ans)))))
+
+(defun get-unambiguous-xargs-val (key lst default ctx state)
+
+; Lst is a list of mutually recursive defun tuples of the form (name args doc
+; edcls body). We scan the edcls for the settings of the XARGS keyword key.
+; If at least one entry specifies a setting, x, and all entries that specify a
+; setting specify x, we return x. If no entry specifies a setting, we return
+; default. If two or more entries specify different settings, we cause an
+; error.
+
+; We assume every legal value of key is a symbol. If you supply a consp
+; default and the default is returned, then no value was specified for key.
+
+; Just to be concrete, suppose key is :mode and default is :logic. The
+; user has the opportunity to specify :mode in each element of lst, i.e., he
+; may say to make the first fn :logic and the second fn :program. But
+; that is nonsense. We have to process the whole clique or none at all.
+; Therefore, we have to meld all of his various :mode specs together to come
+; up with a setting for the DEFUNS event. This function explores lst and
+; either comes up with an unambiguous :mode or else causes an error.
+
+ (er-let* ((x (get-unambiguous-xargs-val1 key lst ctx state)))
+ (cond ((equal x '(unspecified)) (value default))
+ (t (value x)))))
+
+(defdoc CCG-XARGS
+ ":Doc-Section CCG
+
+ giving hints to CCG analysis via ~l[xargs]~/
+
+ In addition to the ~ilc[xargs] provided by ACL2 for passing ~il[hints] to
+ function definitions, the CCG analysis enables several others for guiding the
+ CCG termination analysis for a given function definition. The following
+ example is nonsensical but illustrates all of these xargs:
+ ~bv[]
+ (declare (xargs :termination-method :ccg
+ :consider-ccms ((foo x) (bar y z))
+ :consider-only-ccms ((foo x) (bar y z))
+ :ccg-print-proofs nil
+ :time-limit 120
+ :ccg-hierarchy *ccg-hierarchy-hybrid*))~/
+
+ General Form:
+ (xargs :key1 val1 ... :keyn valn)
+ ~ev[]
+
+ Where the keywords and their respective values are as shown below.
+
+ Note that the :TERMINATION-METHOD ~c[xarg] is always valid, but the other
+ ~c[xargs] listed above are only valid if the termination method being used
+ for the given function is :CCG.
+
+ ~c[:TERMINATION-METHOD value]~nl[]
+ ~c[Value] here is either ~c[:CCG] or ~c[:MEASURE]. For details on the meaning
+ of these settings, see the documentation for ~ilc[set-termination-method]. If
+ this ~c[xarg] is given, it overrides the global setting for the current
+ definition. If the current definition is part of a ~ilc[mutual-recursion],
+ and a ~c[:termination-method] is provided, it must match that provided by all
+ other functions in the ~c[mutual-recursion].
+
+ ~c[:CONSIDER-CCMS value] or ~c[:CONSIDER-ONLY-CCMS value]~nl[]
+ ~c[Value] is a list of terms involving only the formals of the function being
+ defined. Both suggest measures for the current function to the CCG
+ analysis. ACL2 must be able to prove that each of these terms always evaluate
+ to an ordinal ~pl[ordinals]. ACL2 will attempt to prove this before beginning
+ the CCG analysis. The difference between ~c[:consider-ccms] and
+ ~c[:consider-only-ccms] is that if ~c[:consider-ccms] is used, the CCG
+ analysis will attempt to guess additional measures that it thinks might be
+ useful for proving termination, whereas if ~c[:consider-only-ccms] is used,
+ only the measures given will be used for the given function in the CCG
+ analysis. These two ~c[xargs] may not be used together, and attempting to do
+ so will result in an error.
+
+ ~c[:CCG-PRINT-PROOFS value]~nl[]
+ ~c[Value] is either ~c[t] or ~c[nil]. This is a local override of the
+ ~ilc[set-ccg-print-proofs] setting. See this documentation topic for details.
+
+ ~c[:TIME-LIMIT value]~nl[]
+ ~c[Value] is either a positive rational number or nil. This is a local
+ override of the ~ilc[set-ccg-time-limit] setting. See this documentation
+ topic for details.
+
+ ~c[:CCG-HIERARCHY value]~nl[]
+ ~c[Value] is a CCG hierarchy. This is a local override of the
+ ~ilc[set-ccg-hierarchy] setting. See this documentation topic for details.~/")
+
+(defun chk-acceptable-ccg-xargs (fives symbol-class ctx wrld state)
+ (er-let* ((untranslated-consider (get-ccms symbol-class
+ fives
+ :CONSIDER-CCMs
+ ctx state))
+ (consider (translate-ccms-list untranslated-consider ctx wrld state))
+ (untranslated-consider-only (get-ccms symbol-class
+ fives
+ :CONSIDER-ONLY-CCMs
+ ctx state))
+ (consider-only (translate-ccms-list untranslated-consider-only
+ ctx wrld state))
+ (ccms (combine-ccm-hints consider consider-only
+ untranslated-consider
+ untranslated-consider-only
+ ctx state))
+ (verbose (get-unambiguous-xargs-flg
+ :CCG-PRINT-PROOFS
+ fives
+ (get-ccg-print-proofs) ;; default is global setting
+ ctx state))
+ (time-limit (get-unambiguous-xargs-val
+ :TIME-LIMIT
+ fives
+ ;; the default time-limit is that specified in the
+ ;; world
+ (get-ccg-time-limit wrld)
+ ctx state)))
+ (cond ((not (booleanp verbose))
+ (er soft ctx
+ "The :CCG-PRINT-PROOFS specified by XARGS must either ~
+ be NIL or T. ~x0 is neither."
+ verbose))
+ ((not (or (null time-limit)
+ (rationalp time-limit)))
+ (er soft ctx
+ "The :TIME-LIMIT specified by XARGS must either be NIL ~
+ or a rational number. ~x0 is neither."
+ time-limit))
+ (t
+ (value (list ccms
+ verbose
+ time-limit))))))
+
+(defun ?-ccm-lstp (lst)
+ (or (endp lst)
+ (let ((ccm (car lst)))
+ (and (true-listp ccm)
+ (eq (car ccm) :?)
+ (arglistp (cdr ccm))
+ (?-ccm-lstp (cdr lst))))))
+
+(defun ccg-redundant-measure-for-defunp (def justification wrld)
+ (let ((name (car def))
+ (measure0 (if justification
+ (access justification
+ justification
+ :measure)
+ nil))
+ (measures (fetch-dcl-field :measure
+ (butlast (cddr def)
+ 1))))
+ (cond ((and (consp measure0)
+ (eq (car measure0) :?))
+ (if (and (consp measures)
+ (null (cdr measures))
+ (eq (caar measures) :?)
+ (set-equalp-eq (cdar measures)
+ (cdr measure0)))
+ 'redundant
+ (msg "the existing measure for ~x0 is ~x1, possibly indicating ~
+ it was previously proven terminating using the CCG ~
+ analysis. The new measure must therefore be explicitly ~
+ declared to be a call of :? on the measured subset; for ~
+ example, ~x1 will serve as the new :measure."
+ name
+ measure0)))
+ (t
+ (let* ((wrld1 (decode-logical-name name wrld))
+ (val (scan-to-cltl-command (cdr wrld1)))
+ (old-def (assoc-eq name (cdddr val))))
+ (or (non-identical-defp-chk-measures
+ name
+ measures
+ (fetch-dcl-field :measure
+ (butlast (cddr old-def)
+ 1))
+ justification)
+ 'redundant))))))
+
+(defun ccg-redundant-subset-for-defunp (chk-measurep chk-ccmsp def wrld)
+ (let* ((name (car def))
+ (justification (getprop name
+ 'justification
+ 'nil
+ 'current-acl2-world
+ wrld))
+ (mok (if chk-measurep
+ (ccg-redundant-measure-for-defunp def justification wrld)
+ 'redundant)))
+ (cond ((consp mok) ; a message
+ mok)
+ ((and chk-ccmsp justification)
+ (let ((subset (access justification justification :subset))
+ (ccms-lst (fetch-dcl-field :consider-only-ccms
+ (butlast (cddr def) 1))))
+ (if (and (consp ccms-lst)
+ (null (cdr ccms-lst))
+ (?-ccm-lstp (car ccms-lst))
+ (set-equalp-eq (all-vars1-lst (car ccms-lst) nil)
+ subset))
+ 'redundant
+ (msg "A redundant definition using CCG termination must use ~
+ the xarg :consider-only-ccms to declare a list of CCMs ~
+ of the form (:? ...) whose arguments are equal to the ~
+ measured subset of the previous definition. The ~
+ definition of ~x0 does not do this. The previously ~
+ defined version of this function has measured subset ~
+ ~x1. Thus, an appropriate list of CCMs to declare would ~
+ be ~x2."
+ name
+ subset
+ `((:? ,@subset))))))
+ (t
+ 'redundant))))
+
+(defun ccg-redundant-subset-for-defunsp1 (chk-measurep chk-ccmsp def-lst wrld ans)
+ (if (endp def-lst)
+ ans
+ (let ((ans0 (ccg-redundant-subset-for-defunp chk-measurep
+ chk-ccmsp
+ (car def-lst)
+ wrld)))
+ (cond ((consp ans0) ans0) ; a message
+ ((eq ans ans0)
+ (ccg-redundant-subset-for-defunsp1 chk-measurep
+ chk-ccmsp
+ (cdr def-lst)
+ wrld
+ ans))
+ (t nil)))))
+
+(defun ccg-redundant-subset-for-defunsp (chk-measurep chk-ccmsp def-lst wrld)
+ (if (null def-lst)
+ 'redundant
+ (let ((ans (ccg-redundant-subset-for-defunp chk-measurep
+ chk-ccmsp
+ (car def-lst)
+ wrld)))
+ (if (consp ans)
+ ans ;; a message
+ (ccg-redundant-subset-for-defunsp1 chk-measurep
+ chk-ccmsp
+ (cdr def-lst)
+ wrld
+ ans)))))
+
+; Should this be in sync with redundant-or-reclassifying-defunsp ? --harshrc
+(defun ccg-redundant-or-reclassifying-defunsp (chk-measurep
+ chk-ccmsp
+ defun-mode
+ symbol-class
+ ld-skip-proofsp
+ def-lst
+ wrld)
+ (let ((ans (redundant-or-reclassifying-defunsp0 defun-mode
+ symbol-class
+ ld-skip-proofsp
+ nil
+ def-lst
+ wrld)))
+ (cond ((or (consp ans) ;; a message
+ (not (eq ans 'redundant))
+
+; the following 2 are a negation of the conditions for checking measures in
+; redundant-or-reclassifying-defunsp. We skip the check that each old
+; definition also has defun-mode of :logic, because if
+; redundant-or-reclassifying-defunsp0 returns 'redundant, and defun-mode is
+; :logic, we know that the old definitions must also all be logic (otherwise
+; there would have been an error or the new definitions would be
+; reclassifications). Keep this in sync with the conditions for checking
+; measures in redundant-or-reclassifying-defunsp.
+
+ (not (eq defun-mode :logic))
+ ld-skip-proofsp)
+ ans)
+ (t
+ (ccg-redundant-subset-for-defunsp chk-measurep
+ chk-ccmsp
+ def-lst
+ wrld)))))
+
+(defun get-and-chk-ccg-hierarchy (fives ctx wrld state)
+ (er-let*
+ ((hierarchy (get-unambiguous-xargs-val
+ :CCG-HIERARCHY
+ fives
+ *0*
+ ctx state)))
+ (if (equal hierarchy *0*)
+ (value (get-ccg-hierarchy wrld))
+ (er-progn
+ (chk-ccg-hierarchy hierarchy ctx state)
+ (value (fix-ccg-hierarchy hierarchy))))))
+
+(defun ccg-hierarchy-kinds-of-levels (hierarchy has-ccgp has-measurep)
+ (declare (xargs :guard (and (hlevel-listp hierarchy)
+ (booleanp has-ccgp)
+ (booleanp has-measurep))))
+ (cond ((and has-ccgp has-measurep)
+ (mv t t))
+ ((endp hierarchy)
+ (mv has-ccgp has-measurep))
+ (t
+ (let ((is-measurep (equal (caar hierarchy) :measure)))
+ (ccg-hierarchy-kinds-of-levels (cdr hierarchy)
+ (or has-ccgp (not is-measurep))
+ (or has-measurep is-measurep))))))
+
+
+; ccg version of chk-acceptable-defuns (see defuns.lisp). Should be synced? --harshrc
+; annotated portions which differ by "ccg rewrite" comment --harshrc
+(defun ccg-chk-acceptable-defuns (lst ctx wrld state #+:non-standard-analysis std-p)
+
+; WARNING: This function installs a world, hence should only be called when
+; protected by a revert-world-on-error.
+
+; Rockwell Addition: We now also return the non-executable flag.
+
+; This function does all of the syntactic checking associated with defuns. It
+; causes an error if it doesn't like what it sees. It returns the traditional
+; 3 values of an error-producing, output-producing function. However, the
+; "real" value of the function is a list of items extracted from lst during the
+; checking. These items are:
+
+; names - the names of the fns in the clique
+; arglists - their formals
+; docs - their documentation strings
+; pairs - the (section-symbol . citations) pairs parsed from docs
+; guards - their translated guards
+; measures - their translated measure terms
+; ruler-extenders-lst
+; - their ruler-extenders
+; mp - the domain predicate (e.g., o-p) for well-foundedness
+; rel - the well-founded relation (e.g., o<)
+; hints - their translated hints, to be used during the proofs of
+; the measure conjectures, all flattened into a single list
+; of hints of the form ((cl-id . settings) ...).
+; guard-hints
+; - like hints but to be used for the guard conjectures and
+; untranslated
+; std-hints (always returned, but only of interest when
+; #+:non-standard-analysis)
+; - like hints but to be used for the std-p conjectures
+; otf-flg - t or nil, used as "Onward Thru the Fog" arg for prove
+; bodies - their translated bodies
+; symbol-class
+; - :program, :ideal, or :common-lisp-compliant
+; normalizeps
+; - list of Booleans, used to determine for each fn in the clique
+; whether its body is to be normalized
+; reclassifyingp
+; - t or nil, t if this is a reclassifying from :program
+; with identical defs.
+; wrld - a modified wrld in which the following properties
+; may have been stored for each fn in names:
+; 'formals, 'stobjs-in and 'stobjs-out
+; non-executablep - t or nil according to whether these defuns are to
+; non-executable. Non-executable defuns may violate the
+; translate conventions on stobjs.
+; guard-debug
+; - t or nil, used to add calls of EXTRA-INFO to guard conjectures
+; split-types-terms
+; - list of translated terms, each corresponding to type
+; declarations made for a definition with XARGS keyword
+; :SPLIT-TYPES T
+
+ (er-let*
+ ((fives (chk-defuns-tuples lst nil ctx wrld state))
+
+; Fives is a list in 1:1 correspondence with lst. Each element of
+; fives is a 5-tuple of the form (name args doc edcls body). Consider the
+; element of fives that corresponds to
+
+; (name args (DECLARE ...) "Doc" (DECLARE ...) body)
+
+; in lst. Then that element of fives is (name args "Doc" (...) body),
+; where the ... is the cdrs of the DECLARE forms appended together.
+; No translation has yet been applied to them. The newness of name
+; has not been checked yet either, though we know it is all but new,
+; i.e., is a symbol in the right package. We do know that the args
+; are all legal.
+
+ (tm (get-unambiguous-xargs-flg :TERMINATION-METHOD
+ fives
+ (get-termination-method wrld)
+ ctx state)) ;ccg rewrite
+ (term-method (if (or (eq tm :ccg)
+ (eq tm :measure))
+ (value tm)
+ (er soft ctx
+ "The :TERMINATION-METHOD flag must be :CCG or ~
+ :MEASURE, but ~x0 is none of these."
+ tm))) ;ccg rewrite
+
+ (names (value (strip-cars fives))))
+ (er-progn
+ (chk-no-duplicate-defuns names ctx state)
+ (chk-xargs-keywords fives ;ccg rewrite
+ (if (eq term-method :ccg)
+ (append *ccg-xargs-keywords*
+ *xargs-keywords*)
+ (cons :termination-method
+ *xargs-keywords*))
+ ctx state)
+ (er-let*
+ ((tuple (chk-acceptable-defuns0 fives ctx wrld state))
+ (hierarchy (if (eq term-method :ccg)
+ (get-and-chk-ccg-hierarchy fives ctx wrld state)
+ (value nil)))) ;ccg rewrite
+ (let* ((stobjs-in-lst (car tuple))
+ (defun-mode (cadr tuple))
+ (non-executablep (caddr tuple))
+ (symbol-class (cdddr tuple)))
+ (mv-let ;ccg rewrite
+ (has-ccgp has-measurep)
+ (if (eq term-method :measure)
+ (mv nil t)
+ (ccg-hierarchy-kinds-of-levels hierarchy nil nil))
+ (let ((rc (ccg-redundant-or-reclassifying-defunsp
+ has-measurep has-ccgp
+ defun-mode symbol-class
+ (ld-skip-proofsp state) lst wrld))) ;ccg rewrite - CHECK - harshrc
+ (cond
+ ((eq rc 'redundant)
+ (chk-acceptable-defuns-redundancy names ctx wrld state))
+ ((eq rc 'verify-guards)
+
+; We avoid needless complication by simply causing a polite error in this
+; case. If that proves to be too inconvenient for users, we could look into
+; arranging for a call of verify-guards here.
+
+ (chk-acceptable-defuns-verify-guards-er names ctx wrld state))
+
+; Synced with latest version of chk-acceptable-defuns svn version 1020
+; Added below cond clause for hons.
+; june 16 2013 - harshrc
+ #+hons
+ ((and (eq rc 'reclassifying)
+ (conditionally-memoized-fns names
+ (table-alist 'memoize-table wrld)))
+
+; We no longer recall exactly why we have this restriction. However, after
+; discussing this with Sol Swords we think it's because we tolerate all sorts
+; of guard violations when dealing with :program mode functions, but we expect
+; guards to be handled properly with :logic mode functions, including the
+; condition function. If we verify termination and guards for the memoized
+; function but not the condition, that could present a problem. Quite possibly
+; we can relax this check somewhat after thinking things through -- e.g., if
+; the condition function is a guard-verified :logic mode function -- if there
+; is demand for such an enhancement.
+
+ (er soft ctx
+ "It is illegal to verify termination (i.e., convert from ~
+ :program to :logic mode) for function~#0~[~/s~] ~&0, because ~
+ ~#0~[it is~/they are~] currently memoized with conditions; you ~
+ need to unmemoize ~#0~[it~/them~] first. See :DOC memoize."
+ (conditionally-memoized-fns names
+ (table-alist 'memoize-table wrld))))
+ (t
+ (er-let*
+ ((tuple1 (chk-acceptable-defuns1 names fives
+ stobjs-in-lst defun-mode symbol-class rc
+ non-executablep ctx wrld state
+ #+:non-standard-analysis std-p))
+ (tuplec (if (eq term-method :measure)
+ (value (list nil nil nil)) ;ccg rewrite
+ (chk-acceptable-ccg-xargs fives symbol-class
+ ctx wrld state))))
+ (value (append (list 'chk-acceptable-defuns term-method)
+ (cdr tuple1)
+ tuplec
+ `(,hierarchy))))))))))))) ;ccg rewrite
+
+;; (defun ccg-chk-acceptable-defuns (fives lst ctx wrld state #+:non-standard-analysis std-p)
+
+;; ; Rockwell Addition: We now also return the non-executable flag.
+
+;; ; This function does all of the syntactic checking associated with defuns. It
+;; ; causes an error if it doesn't like what it sees. It returns the traditional
+;; ; 3 values of an error-producing, output-producing function. However, the
+;; ; "real" value of the function is a list of items extracted from lst during the
+;; ; checking. These items are:
+
+;; ; names - the names of the fns in the clique
+;; ; arglists - their formals
+;; ; docs - their documentation strings
+;; ; pairs - the (section-symbol . citations) pairs parsed from docs
+;; ; guards - their translated guards
+;; ; measures - their translated measure terms
+;; ; ruler-extenders-lst
+;; ; - their ruler-extenders
+;; ; mp - the domain predicate (e.g., o-p) for well-foundedness
+;; ; rel - the well-founded relation (e.g., o<)
+;; ; hints - their translated hints, to be used during the proofs of
+;; ; the measure conjectures, all flattened into a single list
+;; ; of hints of the form ((cl-id . settings) ...).
+;; ; guard-hints
+;; ; - like hints but to be used for the guard conjectures and
+;; ; untranslated
+;; ; std-hints (always returned, but only of interest when
+;; ; #+:non-standard-analysis)
+;; ; - like hints but to be used for the std-p conjectures
+;; ; otf-flg - t or nil, used as "Onward Thru the Fog" arg for prove
+;; ; bodies - their translated bodies
+;; ; symbol-class
+;; ; - :program, :ideal, or :common-lisp-compliant
+;; ; normalizeps
+;; ; - list of Booleans, used to determine for each fn in the clique
+;; ; whether its body is to be normalized
+;; ; reclassifyingp
+;; ; - t or nil, t if this is a reclassifying from :program
+;; ; with identical defs.
+;; ; wrld - a modified wrld in which the following properties
+;; ; may have been stored for each fn in names:
+;; ; 'formals, 'stobjs-in and 'stobjs-out
+;; ; non-executablep - t or nil according to whether these defuns are to
+;; ; non-executable. Non-executable defuns may violate the
+;; ; translate conventions on stobjs.
+;; ; guard-debug
+;; ; - t or nil, used to add calls of EXTRA-INFO to guard conjectures
+
+;; (er-let*
+;; ((tm (get-unambiguous-xargs-flg :TERMINATION-METHOD
+;; fives
+;; (get-termination-method wrld)
+;; ctx state))
+;; (term-method (if (or (eq tm :ccg)
+;; (eq tm :measure))
+;; (value tm)
+;; (er soft ctx
+;; "The :TERMINATION-METHOD flag must be :CCG or ~
+;; :MEASURE, but ~x0 is none of these."
+;; tm)))
+;; (names (value (strip-cars fives))))
+;; (er-progn
+;; (chk-no-duplicate-defuns names ctx state)
+;; (chk-xargs-keywords fives
+;; (if (eq term-method :ccg)
+;; (append *ccg-xargs-keywords*
+;; *xargs-keywords*)
+;; (cons :termination-method
+;; *xargs-keywords*))
+;; ctx state)
+;; (er-let*
+;; ((tuple0 (chk-acceptable-defuns0 fives ctx wrld state))
+;; (stobjs-in-lst (value (car tuple0)))
+;; (defun-mode (value (cadr tuple0)))
+;; (verify-guards (value (caddr tuple0)))
+;; (symbol-class (value (cdddr tuple0)))
+;; (hierarchy (if (eq term-method :ccg)
+;; (get-and-chk-ccg-hierarchy fives ctx wrld state)
+;; (value nil))))
+;; (mv-let
+;; (has-ccgp has-measurep)
+;; (if (eq term-method :measure)
+;; (mv nil t)
+;; (ccg-hierarchy-kinds-of-levels hierarchy nil nil))
+;; (er-let*
+;; ((rc (value (ccg-redundant-or-reclassifying-defunsp
+;; has-measurep has-ccgp
+;; defun-mode symbol-class
+;; (ld-skip-proofsp state) lst wrld))))
+;; (cond
+;; ((eq rc 'redundant)
+;; (chk-acceptable-defuns-redundancy names ctx wrld state))
+;; ((eq rc 'verify-guards)
+;; (chk-acceptable-defuns-verify-guards names ctx wrld state))
+;; (t
+;; (er-let*
+;; ((tuple1 (chk-acceptable-defuns1 names fives stobjs-in-lst
+;; defun-mode symbol-class rc ctx
+;; wrld state
+;; #+:non-standard-analysis
+;; std-p))
+;; (tuplec (if (eq term-method :measure)
+;; (value (list nil nil nil))
+;; (chk-acceptable-ccg-xargs fives symbol-class
+;; ctx wrld state))))
+;; (value (append (list 'chk-acceptable-defuns term-method)
+;; (cdr tuple1)
+;; tuplec
+;; `(,hierarchy))))))))))))
+
+(defun find-?-ccm1 (ccm-list)
+ (and (consp ccm-list)
+ (let ((ccm (car ccm-list)))
+ (or (and (consp ccm)
+ (eq (car ccm) :?)
+ ccm)
+ (find-?-ccm1 (cdr ccm-list))))))
+
+(defun find-?-ccm (names ccms)
+ ;; looks for CCMS with :? as the function.
+ (if (endp ccms)
+ nil
+ (let ((bad-ccm (find-?-ccm1 (car ccms))))
+ (if bad-ccm
+ (cons (car names) bad-ccm)
+ (find-?-ccm (cdr names) (cdr ccms))))))
+
+(defun fns-without-consider-only-ccms-hints (names ccms)
+ ;; checks if all the CCMs have been declared using :CONSIDER-ONLY-CCMS. Any
+ ;; functions for which this is not the case are collected into a list.
+ ;; Ccms should of the form returned by combine-ccm-hints.
+ (if (endp ccms)
+ nil
+ (let ((rst (fns-without-consider-only-ccms-hints (cdr names)
+ (cdr ccms))))
+ (if (and (consp (car ccms))
+ (caar ccms))
+ rst
+ (cons (car names)
+ rst)))))
+
+(defun-raw ccm-o-p-clauses2 (contexts term clauses)
+ (if (endp contexts)
+ clauses
+ (ccm-o-p-clauses2
+ (cdr contexts)
+ term
+ (conjoin-clause-to-clause-set
+ (add-literal term
+ (dumb-negate-lit-lst (context-ruler (car contexts)))
+ t)
+ clauses))))
+
+(defun-raw ccm-o-p-clauses1 (contexts ccm-list clauses)
+ (if (endp ccm-list)
+ clauses
+ (ccm-o-p-clauses1 contexts (cdr ccm-list)
+ (ccm-o-p-clauses2 contexts
+ (mcons-term* 'o-p (car ccm-list))
+ clauses))))
+
+(defun-raw ccm-o-p-clauses0 (contexts ccm-list clauses)
+ (cond ((endp contexts)
+ clauses)
+ ((eq (car ccm-list) *0*)
+ (ccm-o-p-clauses0 (cdr contexts)
+ (cdr ccm-list)
+ clauses))
+ (t
+ (ccm-o-p-clauses0 (cdr contexts)
+ (cdr ccm-list)
+ (ccm-o-p-clauses1 (car contexts)
+ (car ccm-list)
+ clauses)))))
+
+(defun-raw ccm-o-p-clauses (contexts ccm-list)
+ ;; builds the clauses to prove that the CCMs in ccm-list all
+ ;; evaluate to natural numbers.
+ (ccm-o-p-clauses0 contexts ccm-list nil))
+
+(defun-raw ccg-intermediate-step (accgs ces new-hlevel old-hlevel proved qspv state)
+ (er-let*
+ ((triple (accg-refine-accgs accgs ces old-hlevel new-hlevel qspv state))
+ (caccgs (value (car triple)))
+ (uaccgs (value (cadr triple)))
+ (uces (value (cddr triple))))
+ (cond ((endp caccgs)
+ (pprogn
+ ;;(progn (print uaccgs) state)
+ (ccg-io? basics nil state
+ ()
+ (fms "Since we have no new information, we skip size ~
+ change analysis and attempt to further refine the ~
+ SCCs.~|"
+ nil
+ *standard-co*
+ state
+ nil))
+ (value (list* proved uaccgs uces))))
+ (t
+ (pprogn
+ (let ((clen (len caccgs)))
+ (ccg-io? basics nil state
+ (uaccgs clen caccgs)
+ (fms "~@0 of the CCG ~#\3~[was~/were~] altered. We ~
+ analyze ~#\3~[it~/each of these~] with the size ~
+ change termination analysis.~@4~|"
+ `((#\0 . ,(if (consp uaccgs)
+ "~N1 of the ~n2 SCCs"
+ "~#\3~[The sole SCC~/All the SCCs~]"))
+ (#\1 . ,clen)
+ (#\2 . ,(+ clen (len uaccgs)))
+ (#\3 . ,caccgs)
+ (#\4 . ,(if (endp uaccgs)
+ ""
+ " The others will be set aside ~
+ for further refinement.")))
+ *standard-co*
+ state
+ nil)))
+ (accg-sct-list caccgs proved uaccgs uces state))))))
+
+(defun-raw ccg-measure-step (hlevel names t-machines measure-alist mp rel
+ bodies verbose qspv state)
+ (if (consp measure-alist)
+ (let ((ctx (access query-spec-var qspv :ctx))
+ (wrld (access query-spec-var qspv :wrld))
+ (ens (access query-spec-var qspv :ens))
+ (stop-time (access query-spec-var qspv :stop-time))
+ (otf-flg (access query-spec-var qspv :otf-flg))
+ (pt (cadr hlevel)))
+ (pprogn
+ (ccg-io? basics nil state
+ (hlevel)
+ (fms "The current level of the CCG hierarchy is ~x0. We ~
+ therefore attempt a measure proof.~|"
+ `((#\0 . hlevel))
+ *standard-co*
+ state
+ nil))
+ (mv-let
+ (erp pair state)
+ (er-let*
+ ((hints (if (equal pt :built-in-clauses)
+ (translate-hints
+ "Measure Built-in-clauses Hint"
+ '(("goal"
+ :do-not '(eliminate-destructors
+ eliminate-irrelevance
+ generalize
+ fertilize)
+ :in-theory (theory 'minimal-theory)
+ :do-not-induct :otf-flg-override))
+ ctx wrld state)
+ (value (translated-limit-induction-hint (cadr pt))))))
+ (state-global-let*
+ ((inhibit-output-lst (if verbose
+ (@ inhibit-output-lst)
+ (list* 'event 'error (@ inhibit-output-lst)))))
+ (maybe-prover-before-stop-time
+ stop-time ctx state
+ (prove-termination names t-machines measure-alist mp rel
+ hints otf-flg bodies
+ ctx ens wrld state
+ (f-get-global
+ 'accumulated-ttree
+ state)))))
+ (if erp
+ (er-progn
+ (time-check stop-time ctx state)
+ (pprogn
+ (ccg-io? basics nil state
+ ()
+ (fms "Since ACL2 has failed to prove the measure ~
+ conjecture, we continue with the hierarchical ~
+ analysis.~|"
+ nil
+ *standard-co*
+ state
+ nil))
+ (value nil)))
+ (pprogn
+ (ccg-io? basics nil state
+ ()
+ (fms "ACL2 has succeeded in proving the measure ~
+ conjecture, thereby proving termination."
+ nil
+ *standard-co*
+ state
+ nil))
+ (value (list* :measure
+ (car pair)
+ measure-alist
+ (cdr pair))))))))
+ (pprogn
+ (ccg-io? basics nil state
+ (hlevel)
+ (fms "Skipping level ~x0 of the hierarchy due to previously ~
+ mentioned error when guessing measures."
+ `((#\0 . hlevel))
+ *standard-co*
+ state
+ nil))
+ (value nil))))
+
+(defun-raw ccg (accgs ces last-ccg-hlevel hierarchy proved context-array
+ names arglists t-machines measure-alist mp rel bodies
+ verbose qspv state)
+ (cond ((endp accgs)
+ (pprogn
+ (increment-timer 'other-time state)
+ (ccg-io? basics nil state
+ ()
+ (fms "We have successfully proven termination! We now weed ~
+ out irrelevant CCMs so that we can minimize the ~
+ measured-subset. This may require running the size ~
+ change analysis several more times.~|"
+ nil
+ *standard-co*
+ state
+ nil))
+ (increment-timer 'print-time state)
+ (er-let*
+ ((ms (ccg-generate-measure-alist
+ nil proved
+ names arglists
+ context-array
+ ;; the following is overly-cautious. It could be the case that
+ ;; some SCCs were proven terminating with ccmfs-per-node
+ ;; and others with ccmfs-per-edge, in which case we would
+ ;; be assuming here that we proved all of the SCCs terminating
+ ;; with ccmfs-per-edge.
+ (hlevel-ccmfs-per-nodep last-ccg-hlevel)
+ state)))
+ (pprogn
+ (mv-let
+ (col state)
+ (io? event nil (mv col state)
+ (names ms)
+ (fmt "CCG analysis has succeeded in proving termination of ~
+ ~&0 using CCMs over the following variables~#0~[~/, ~
+ respectively~]: ~&1. Thus, we admit ~#0~[this ~
+ function~/these ~ functions~] under the principle of ~
+ definition."
+ (list (cons #\0 names)
+ (cons #\1 (strip-cddrs ms)))
+ *standard-co*
+ state
+ nil)
+ :default-bindings ((col 0)))
+ (value (list* :ccg
+ col
+ ms
+ (f-get-global
+ 'accumulated-ttree
+ state))))))))
+ ((endp hierarchy)
+ (pprogn
+ (ccg-io? basics nil state
+ ()
+ (fms "We have completed all levels of the hierarchy, but ~
+ have failed to prove termination."
+ ()
+ *standard-co*
+ state
+ nil))
+ (if (null (car ces))
+ state
+ (ccg-io? counter-example nil state
+ ()
+ (print-counter-example
+ (car accgs) (car ces)
+ context-array
+ (access query-spec-var qspv :ctx)
+ (access query-spec-var qspv :ens)
+ (access query-spec-var qspv :wrld)
+ state)))
+ (mv t nil state)))
+ ((eq (caar hierarchy) :MEASURE)
+ (er-let*
+ ((tuple (ccg-measure-step (car hierarchy)
+ names
+ t-machines
+ measure-alist
+ mp
+ rel
+ bodies
+ verbose
+ qspv
+ state)))
+ (if tuple
+ (value tuple)
+ (ccg accgs ces last-ccg-hlevel (cdr hierarchy) proved context-array
+ names arglists t-machines measure-alist mp rel bodies
+ verbose qspv state))))
+ (t
+ (er-let*
+ ((tuple
+ (state-global-let*
+ ((inhibit-output-lst
+ (if verbose
+ (@ inhibit-output-lst)
+ (list* 'prove 'proof-tree (@ inhibit-output-lst)))))
+ (ccg-intermediate-step accgs
+ ces
+ (car hierarchy)
+ last-ccg-hlevel
+ proved
+ qspv
+ state)))
+ (nproved (value (car tuple)))
+ (naccgs (value (cadr tuple)))
+ (nces (value (cddr tuple))))
+ (ccg naccgs nces (car hierarchy) (cdr hierarchy) nproved
+ context-array
+ names arglists t-machines measure-alist mp rel bodies
+ verbose qspv state)))))
+
+(defun-raw build-accgs (names contexts functs ccm-hints wrld state)
+ (let* ((context-array (context-array contexts))
+ ;; (num-contexts (array-dimension context-array 0))
+ (accgs (build-and-annotate-accgs names
+ functs
+ contexts
+ (pairlis$ names ccm-hints))))
+ ;; first we build the accgs using the first restriction
+ (pprogn
+ (increment-timer 'other-time state)
+ (ccg-io? basics nil state
+ (names context-array accgs)
+ (pprogn
+ (fms "We begin with the Calling Context Graph (CCG), ~
+ containing the following contexts (if the output doesn't ~
+ make sense, see :DOC CCG and also the paper referenced ~
+ above):~|"
+ nil
+ *standard-co*
+ state
+ nil)
+ (print-context-array1 0 names context-array state)
+ (fms "and the following edges:~|"
+ nil *standard-co* state nil)
+ (print-accg-edges1 accgs state)
+ (fms "We have annotated the CCG with the following calling ~
+ context measures (CCMs):~|"
+ nil *standard-co* state nil)
+ (print-funct-ccms functs wrld state)))
+ (increment-timer 'print-time state)
+ (pprogn
+ (ccg-io? basics nil state
+ ()
+ (fms "Before we begin the hierarchical analysis, we run our ~
+ size-change analysis so we have a baseline for refinement."
+ nil
+ *standard-co*
+ state
+ nil))
+ (er-let*
+ ((tuple (accg-sct-list accgs nil nil nil state)))
+ (value (cons context-array tuple)))))))
+
+(defun max-induction-depth1 (hierarchy max)
+ (declare (xargs :guard (and (hlevel-listp hierarchy)
+ (integerp max)
+ (<= -1 max))))
+ (if (endp hierarchy)
+ max
+ (max-induction-depth1
+ (cdr hierarchy)
+ (cond ((or (equal (caar hierarchy) :measure)
+ (equal (hlevel-proof-technique (car hierarchy))
+ :built-in-clauses))
+ max)
+ (t
+ (max max (cadr (hlevel-proof-technique (car hierarchy)))))))))
+
+(defun max-induction-depth (hierarchy)
+ (max-induction-depth1 hierarchy -1))
+
+(defun ruler-extender-printout1 (names ruler-extenders-lst)
+ (if (endp names)
+ nil
+ (cons `("function ~x0 has ruler extenders ~x1"
+ (#\0 . ,(car names))
+ (#\1 . ,(car ruler-extenders-lst)))
+ (ruler-extender-printout1 (cdr names)
+ (cdr ruler-extenders-lst)))))
+
+(defun ruler-extender-printout (names ruler-extenders-lst)
+ `("" "~@*." "~@*, and " "~@*, "
+ ,(ruler-extender-printout1 names ruler-extenders-lst)))
+
+(defun-raw prove-termination-with-ccg (names functs contexts
+ ruler-extenders-lst ccm-hints
+ hierarchy verbose time-limit
+ arglists measures t-machines mp
+ rel otf-flg bodies
+ ctx ens wrld state ttree)
+
+ ;; based on prove-termination in the ACL2 sources, this function
+ ;; attempts to prove the termination of the given functions. names
+ ;; is the list of names of the the functions, term-method is the
+ ;; termination method to be used (:hybrid or :ccg), contexts are the
+ ;; contexts for the functions, ccm-hints is a list of pairs as defined by
+ ;; combine-ccm-hints, cpn, verbose, time-limit, and ccm-comparison-scheme are the
+ ;; user-specified CCG options, arglists is the list of lists of
+ ;; formals for the functions, measures are the user-specified
+ ;; measures, t-machines are the termination machines of the
+ ;; functions, mp and rel are the domain and relation for proving
+ ;; termination with a measure and otf-flg is the on-through-the-fog
+ ;; flag.
+
+ ;; If we succeed, we return 4 values, consed together as "the" value
+ ;; in this error/value/state producing function. The first value is
+ ;; the proof method that ultimately proved termination (:ccg or
+ ;; :measure). The second value is the "justification" alist. For a
+ ;; measure-based proof, this is the measure-alist, and for a
+ ;; CCG-based proof, this is the result of
+ ;; ccg-generate-measure-alist. The last two values are the column
+ ;; and ttree. Currently, we simply return 0 for the column and nil
+ ;; for the ttree. I believe the column value is correct, but the
+ ;; ttree should eventually be the accumulation of all the ttrees
+ ;; associated with all the proofs done in the termination analysis.
+
+
+ ;; This function is specially coded so that if contexts is nil then
+ ;; it is a signal that there is only one element of names and it is
+ ;; a non-recursive function. In that case, we short-circuit all of
+ ;; the proof machinery and simply do the associated output. We
+ ;; coded it this way to preserve the invariant that
+ ;; prove-termination is THE place the defun output is initiated.
+
+ ;; This function increments timers. Upon entry, any accumulated time
+ ;; is charged to 'other-time. The printing done herein is charged
+ ;; to 'print-time and the proving is charged to 'prove-time.
+
+ (let* ((ccms (mapcar #'cdr ccm-hints))
+ (entry (find-?-ccm names ccms))
+ ;;(time-limit (get-ccg-time-limit wrld))
+ (stop-time (if time-limit (+ (get-internal-run-time)
+ (* internal-time-units-per-second
+ time-limit))
+ nil))
+ (qspv (make query-spec-var
+ :stop-time stop-time
+ :mem (create-memoization
+ (max-induction-depth hierarchy))
+ :otf-flg otf-flg
+ :ens ens
+ :ctx ctx
+ :wrld wrld)))
+ (cond
+ ((and entry
+ (not (ld-skip-proofsp state)))
+ (let ((fn (car entry))
+ (ccm (cdr entry)))
+ (er soft ctx
+ "A CCM of the form (:? v1 ... vk) is only legal when the defun is ~
+ redundant (see :DOC redundant-events) or when skipping proofs ~
+ (see :DOC ld-skip-proofsp). The CCM ~x0 supplied for function ~
+ symbol ~x1 is thus illegal."
+ ccm fn)))
+ ((null contexts)
+ (mv-let (col state)
+ (io? event nil (mv col state)
+ (names)
+ (fmt "Since ~&0 is non-recursive, its admission is trivial. "
+ (list (cons #\0 names))
+ (proofs-co state)
+ state
+ nil)
+ :default-bindings ((col 0)))
+ (value (list* :ccg (or col 0) nil nil))))
+ ((ld-skip-proofsp state)
+ (let ((fns (fns-without-consider-only-ccms-hints names ccms)))
+ (if (consp fns)
+ (er soft ctx
+ "Proofs cannot be skipped on a CCG termination proof unless ~
+ CCMs are defined for every function. You did not supply CCMs ~
+ for function~#0~[~/s~] ~&0. Therefore, proofs cannot be skipped."
+ fns)
+ (value (list* :ccg
+ 0
+ (pairlis$ names
+ (mapcar (lambda (x)
+ `(:? ,@(all-vars1-lst (cdr x) nil)))
+ ccms))
+ nil
+ nil)))))
+ (t
+ (pprogn
+ (ccg-io?
+ basics nil state
+ (names ruler-extenders-lst)
+ (fms "Attempting to prove termination using Calling Context Graph ~
+ (CCG) analysis. There are various ways in which users can ~
+ control CCG analysis. See the :DOC CCG for details. This ~
+ analysis is described in a 2006 CAV paper by Manolios and ~
+ Vroon.~|~%The ruler-extenders for each function are as follows: ~
+ ~*0~|"
+ `((#\0 .
+ ,(ruler-extender-printout names
+ ruler-extenders-lst)))
+ *standard-co*
+ state
+ nil))
+ (simplify-contexts contexts ens wrld ctx state)
+ (mv-let
+ (o-p-clauses ttree)
+ (clean-up-clause-set (ccm-o-p-clauses contexts ccms)
+ ens wrld ttree state)
+ (er-let*
+ ((ttree (accumulate-ttree-and-step-limit-into-state
+ ttree :skip state)))
+ (pprogn
+ (increment-timer 'other-time state)
+ (er-let*
+ ((displayed-goal (value
+ (prettyify-clause-set o-p-clauses
+ (let*-abstractionp state)
+ wrld)))
+ (simp-phrase (value (tilde-*-simp-phrase ttree)))
+ (ttree1
+ (if o-p-clauses
+ (pprogn
+ (io? event nil state
+ (ttree displayed-goal simp-phrase)
+ (fms "You have told us to consider CCMs that are not ~
+ trivially proved to be ordinals. ~
+ Therefore, the conjecture that we must prove ~
+ before we can continue with the CCG ~
+ analysis~#0~[~/, given ~*1,~] is ~
+ ~@2~%~%Goal~%~Q34."
+ `((#\0 . ,(if (nth 4 simp-phrase) 1 0))
+ (#\1 . ,simp-phrase)
+ (#\2 . ,(if (tagged-objectsp 'sr-limit ttree)
+ " as follows (where the ~
+ subsumption/replacement limit ~
+ affected this analysis; see :DOC ~
+ case-split-limitations)."
+ ""))
+ (#\3 . ,displayed-goal)
+ (#\4 . ,(term-evisc-tuple nil state)))
+ (proofs-co state)
+ state
+ nil))
+ (increment-timer 'print-time state)
+ (prove (termify-clause-set o-p-clauses)
+ (make-pspv
+ ens wrld
+ :displayed-goal displayed-goal
+ :otf-flg otf-flg)
+ nil ens wrld ctx state))
+ (value ttree))))
+ (mv-let
+ (has-ccgp has-measurep)
+ (ccg-hierarchy-kinds-of-levels hierarchy nil nil)
+ (er-let*
+ ((ba-tuple
+ (if has-ccgp
+ (build-accgs names contexts functs ccm-hints wrld state)
+ (list* (make-array 0
+ :initial-element (make-context)
+ :element-type 'context)
+ `(,(make-array 0
+ :initial-element (make-accg-node)
+ :element-type 'accg-node))
+ `(,(make-array 0
+ :initial-element (make-accg-node)
+ :element-type 'accg-node))
+ `(nil))))
+ (context-array (value (car ba-tuple)))
+ (proved-accgs (value (cadr ba-tuple)))
+ (accgs (value (caddr ba-tuple)))
+ (ces (value (cdddr ba-tuple)))
+ (measure-alist
+ (if (not has-measurep)
+ (value nil)
+ (mv-let
+ (erp ma state)
+ (guess-measure-alist names arglists
+ measures
+ t-machines
+ ctx wrld state)
+ (if (not erp)
+ (value ma)
+ (pprogn
+ (ccg-io? basics nil state
+ (names)
+ (fms "Since there was an error guessing the ~
+ measure~#0~[~/s~], we will skip all levels ~
+ of the hierarchy of the form (:MEASURE ~
+ PT).~|"
+ `((#\0 . ,names))
+ *standard-co*
+ state
+ nil))
+ (value nil)))))))
+ (er-let* ((quadruple
+ (ccg accgs ces nil hierarchy proved-accgs context-array
+ names arglists t-machines measure-alist mp rel bodies
+ verbose qspv state)))
+ (let* ((term-method (car quadruple))
+ (col (cadr quadruple))
+ (measure-alist (caddr quadruple))
+ (ttree-new (cdddr quadruple)))
+ (prog2$
+ nil;dummy --harshrc
+ ;(cw "~|**DEBUG**:: old ttree=~x0 ~ new ttree is ~x1 ~ and ttree1 is ~x2~|" ttree ttree-new ttree1)
+ (value (list* term-method
+ col
+ measure-alist
+ (cons-tag-trees ttree-new ttree1))))))
+
+ )))))))))))
+
+(defun-raw ccg-prove-termination-recursive
+ (names arglists measures ccm-hints
+ ruler-extenders-lst t-machines mp rel
+ verbose time-limit hierarchy
+ otf-flg bodies ctx ens wrld state)
+
+; Next we get the measures for each function. That may cause an error
+; if we couldn't guess one for some function.
+
+ (let ((functs (make-funct-structs names arglists)))
+ (prove-termination-with-ccg
+ names functs (t-machines-to-contexts t-machines functs)
+ ruler-extenders-lst
+ ccm-hints hierarchy verbose time-limit arglists measures t-machines
+ mp rel otf-flg bodies ctx ens wrld state nil)))
+
+(defun-raw ccg-put-induction-info
+ (names arglists term-method measures ccms ruler-extenders-lst bodies
+ mp rel verbose time-limit hierarchy
+ hints otf-flg big-mutrec ctx ens wrld state)
+
+; WARNING: This function installs a world. That is safe at the time of this
+; writing because this function is only called by defuns-fn0, which is only
+; called by defuns-fn, where that call is protected by a revert-world-on-error.
+
+; We are processing a clique of mutually recursive functions with the names,
+; arglists, measures, ruler-extenders-lst, and bodies given. All of the above
+; lists are in 1:1 correspondence. The hints is the result of appending
+; together all of the hints provided. Mp and rel are the domain predicate and
+; well-founded relation to be used. We attempt to prove the admissibility of
+; the recursions. We cause an error if any proof fails. We put a lot of
+; properties under the function symbols, namely:
+
+; recursivep all fns in names
+; justification all recursive fns in names
+; induction-machine the singly recursive fn in name*
+; quick-block-info the singly recursive fn in name*
+; symbol-class :ideal all fns in names
+
+; *If names consists of exactly one recursive fn, we store its
+; induction-machine and its quick-block-info, otherwise we do not.
+
+; If no error occurs, we return a triple consisting of the column the printer
+; is in, the final value of wrld and a tag tree documenting the proofs we did.
+
+; Note: The function could be declared to return 5 values, but we would rather
+; use the standard state and error primitives and so it returns 3 and lists
+; together the three "real" answers.
+
+ (let ((wrld1 (putprop-recursivep-lst names bodies wrld)))
+
+; The put above stores a note on each function symbol as to whether it is
+; recursive or not. An important question arises: have we inadventently
+; assumed something axiomatically about inadmissible functions? We say no.
+; None of the functions in question have bodies yet, so the simplifier doesn't
+; care about properties such as 'recursivep. However, we make use of this
+; property below to decide if we need to prove termination.
+
+ (cond ((and (null (cdr names))
+ (null (getprop (car names) 'recursivep nil
+ 'current-acl2-world wrld1)))
+
+; If only one function is being defined and it is non-recursive, we can quit.
+; But we have to store the symbol-class and we have to print out the admission
+; message with prove-termination so the rest of our processing is uniform.
+
+ (er-let*
+ ((tuple (prove-termination-non-recursive names bodies mp rel hints otf-flg big-mutrec
+ ctx ens wrld1 state)))
+ (value (cons nil tuple))))
+ (t
+ (let ((t-machines (termination-machines names bodies ruler-extenders-lst)))
+ (er-let*
+ ((wrld1 (update-w
+
+; Sol Swords sent an example in which a clause-processor failed during a
+; termination proof. That problem goes away if we install the world, which we
+; do by making the following binding.
+
+ t ; formerly big-mutrec
+ wrld1))
+ (quadruple
+ (if (eq term-method :measure)
+ (er-let* ((triple (prove-termination-recursive
+ names arglists
+ measures
+ t-machines
+ mp rel hints otf-flg bodies
+ ctx ens wrld1 state)))
+ (value (cons :measure triple)))
+ (ccg-prove-termination-recursive names arglists
+ measures
+ ccms
+ ruler-extenders-lst
+ t-machines
+ mp rel
+ verbose
+ time-limit
+ hierarchy
+ otf-flg bodies
+ ctx ens wrld1 state))))
+ ;;(progn
+ ;;(print quadruple)
+ (let* ((term-method (car quadruple))
+ (col (cadr quadruple))
+ (measure-alist (caddr quadruple))
+ (ttree (cdddr quadruple)))
+ (er-let*
+ ((tuple (put-induction-info-recursive names arglists
+ col ttree
+ measure-alist t-machines
+ ruler-extenders-lst
+ bodies mp rel wrld1
+ state)))
+ (value (cons term-method tuple))))))))))
+
+(defun defun-redundant-get-ccms (fives wrld)
+ ;; gets the CCMs installed into the world for a given set of function definitions.
+ (if (endp fives)
+ nil
+ (let ((subset (access justification
+ (getprop (first (car fives))
+ 'justification
+ (make justification :subset '())
+ 'current-acl2-world
+ wrld)
+ :subset)))
+ (cons `((:? ,@subset))
+ (defun-redundant-get-ccms (cdr fives) wrld)))))
+
+
+(defun defun-redundant-get-measures (fives wrld)
+ ;; gets the CCMs installed into the world for a given set of function definitions.
+ (if (endp fives)
+ nil
+ (let ((subset (access justification
+ (getprop (first (car fives))
+ 'justification
+ (make justification :subset '())
+ 'current-acl2-world
+ wrld)
+ :subset)))
+ (cons `(:? ,@subset)
+ (defun-redundant-get-measures (cdr fives) wrld)))))
+
+(defun remove-keywords (keys lst)
+ (cond ((endp lst)
+ nil)
+ ((member-eq (car lst) keys)
+ (remove-keywords keys (cddr lst)))
+ (t
+ (list* (car lst) (cadr lst) (remove-keywords keys (cddr lst))))))
+
+(defun remove-dcls0 (edcls keys)
+ (cond ((endp edcls) nil) ;; if we don't have any xargs, we don't need to do anything.
+ ((eq (caar edcls) 'xargs)
+ (let ((newlst (remove-keywords keys (cdar edcls))))
+ (if (endp newlst)
+ (remove-dcls0 (cdr edcls) keys)
+ (acons 'xargs
+ newlst
+ (remove-dcls0 (cdr edcls) keys)))))
+ (t (cons (car edcls)
+ (remove-dcls0 (cdr edcls) keys)))))
+
+(defun remove-dcls (fives keys)
+ ;; we alter the definitions given in fives to remove xarg
+ ;; declarations corresponding to the given keys
+ (cond ((endp fives)
+ nil)
+ ((endp (nth 3 (car fives))) ;; if there are no declarations, there is nothing to do.
+ (cons (car fives)
+ (remove-dcls (cdr fives) keys)))
+ (t
+ (cons (update-nth 3 (remove-dcls0 (nth 3 (car fives)) keys) (car fives))
+ (remove-dcls (cdr fives) keys)))))
+
+(defun update-keyword (key val lst)
+ (cond ((endp lst)
+ (list key val))
+ ((eq (car lst) key)
+ (cons key (cons val (remove-keywords `(,key) (cddr lst)))))
+ (t
+ (cons (car lst)
+ (cons (cadr lst)
+ (update-keyword key val (cddr lst)))))))
+
+(defun unambiguously-fix-dcls0 (edcls key val)
+ (cond ((endp edcls)
+ (list (cons 'xargs (list key val))))
+ ((eq (caar edcls) 'xargs)
+ (acons 'xargs (update-keyword key val (cdar edcls))
+ (remove-dcls0 (cdr edcls) `(,key))))
+ (t
+ (cons (car edcls)
+ (unambiguously-fix-dcls0 (cdr edcls) key val)))))
+
+(defun unambiguously-fix-dcls (fives key vals)
+ ;; we alter the definitions given in fives to declare key to be of
+ ;; vals, such that the ith definition in fives has key set to the
+ ;; ith value of vals.
+ (cond ((endp fives)
+ nil)
+ (t
+ (cons (update-nth 3 (unambiguously-fix-dcls0 (nth 3 (car fives)) key (car vals))
+ (car fives))
+ (unambiguously-fix-dcls (cdr fives) key (cdr vals))))))
+
+(defun app-lst (lst)
+ ;; appends all the elements of lst together.
+ (if (endp lst)
+ nil
+ (append (car lst) (app-lst (cdr lst)))))
+
+(defun fives-to-defuns0 (fives)
+ (if (endp fives)
+ nil
+ (let* ((five (car fives))
+ (name (first five))
+ (args (second five))
+ (doc (third five))
+ (dcls (fourth five))
+ (body (fifth five))
+ (d1 (list body))
+ (d2 (if doc (cons doc d1) d1))
+ (d3 (if dcls (acons 'declare dcls d2) d2)))
+ (cons `(defun ,name ,args ,@d3)
+ (fives-to-defuns0 (cdr fives))))))
+
+(defun fives-to-defuns (fives)
+ ;; turns a list of "fives" into defuns from which such "fives" would
+ ;; be derived.
+ `(with-output
+ :off (summary event)
+ ,(if (endp (cdr fives))
+ (car (fives-to-defuns0 fives))
+ (cons 'mutual-recursion
+ (fives-to-defuns0 fives)))))
+
+
+;; END raw definitions for CCG analysis
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; These support optional make-event expansion by events other than make-event.
+; -Peter Dillinger
+
+(defun dynamic-make-event-fn (body event-form state)
+;; (declare (xargs :mode :program))
+ (make-event-fn `',body
+ nil
+ nil
+ nil
+ event-form
+ state))
+
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun defun-make-event (names fives symbol-class term-method wrld event-form state)
+ (if (or (eq symbol-class :program)
+ (and (null (cdr names))
+ (null (getprop (car names) 'recursivep nil
+ 'current-acl2-world wrld))))
+ (value (cond ((null (cdr names)) (car names))
+ (t names)))
+ (let* ((fives0 (remove-dcls fives
+ (if (eq term-method :measure)
+ *ccg-xargs-keywords*
+ (list* :HINTS
+ :MEASURE
+ :WELL-FOUNDED-RELATION
+ *ccg-xargs-keywords*))))
+ (fives1 (unambiguously-fix-dcls fives0 :termination-method
+ (make-list (length fives)
+ :initial-element :measure)))
+ (fives2 (if (eq term-method :measure)
+ fives1
+ (unambiguously-fix-dcls
+ fives1
+ :MEASURE
+ (defun-redundant-get-measures fives wrld)))))
+ (er-progn
+ (state-global-let* ((accumulated-ttree nil)
+ (inhibit-output-lst (cons 'summary (@ inhibit-output-lst))))
+ (dynamic-make-event-fn (fives-to-defuns fives2)
+ event-form
+ state))
+ (value (cond ((null (cdr names)) (car names))
+ (t names)))))))
+
+; defines a function to bridge ACL2 and raw lisp. if you ask ACL2 what its
+; definition is, it will say "(value nil)," but if you run it, you get the
+; behavior of the raw body. there are no soundness issues with that because
+; the function is flagged as permanently :program-mode only.
+;
+; defun-bridge is provided by my hacker stuff. -Peter
+
+; June 16 2013 - ccg.lisp certification breaks with ACL2 6.2
+; Keep this function and defuns-fn1 call in sync in ACL2 sources - harshrc
+
+(defun-raw ccg-defuns-fn0
+
+; WARNING: This function installs a world. That is safe at the time of this
+; writing because this function is only called by defuns-fn, where that call is
+; protected by a revert-world-on-error.
+
+ (names arglists docs pairs guards term-method measures
+ ccms ;ccg
+ ruler-extenders-lst mp rel
+ verbose time-limit hierarchy ;ccg
+ hints guard-hints std-hints
+ otf-flg guard-debug bodies symbol-class normalizeps
+ split-types-terms non-executablep
+ #+:non-standard-analysis std-p
+ ctx wrld state)
+ (cond
+ ((eq symbol-class :program)
+ (defuns-fn-short-cut names docs pairs guards split-types-terms bodies
+ non-executablep ; not sure about this, but seems plausible
+ wrld state))
+ (t
+ (let ((ens (ens state))
+ (big-mutrec (big-mutrec names)))
+ (er-let*
+ ((tuple (ccg-put-induction-info names arglists
+ term-method ;ccg specific
+ measures
+ ccms ;ccg
+ ruler-extenders-lst
+ bodies
+ mp rel
+ verbose ;ccg
+ time-limit ;ccg
+ hierarchy ;ccg
+ hints
+ otf-flg
+ big-mutrec
+ ctx ens wrld state)))
+ (defuns-fn1
+ (cdr tuple) ;(car tuple) is term-method
+ ens
+ big-mutrec
+ names
+ arglists
+ docs
+ pairs
+ guards
+ guard-hints
+ std-hints
+ otf-flg
+ guard-debug
+ bodies
+ symbol-class
+ normalizeps
+ split-types-terms
+ non-executablep
+ #+:non-standard-analysis std-p
+ ctx
+ state))))))
+
+(defun-bridge ccg-defuns-fn (def-lst state event-form #+:non-standard-analysis std-p)
+
+; Important Note: Don't change the formals of this function without
+; reading the *initial-event-defmacros* discussion in axioms.lisp.
+
+; On Guards
+
+; When a function symbol fn is defund the user supplies a guard, g, and a
+; body b. Logically speaking, the axiom introduced for fn is
+
+; (fn x1...xn) = b.
+
+; After admitting fn, the guard-related properties are set as follows:
+
+; prop after defun
+
+; body b*
+; guard g
+; unnormalized-body b
+; type-prescription computed from b
+; symbol-class :ideal
+
+; * We actually normalize the above. During normalization we may expand some
+; boot-strap non-rec fns.
+
+; In addition, we magically set the symbol-function of fn
+
+; symbol-function b
+
+; and the symbol-function of *1*fn as a program which computes the logical
+; value of (fn x). However, *1*fn is quite fancy because it uses the raw body
+; in the symbol-function of fn if fn is :common-lisp-compliant, and may signal
+; a guard error if 'guard-checking-on is set to other than nil or :none. See
+; oneify-cltl-code for the details.
+
+; Observe that the symbol-function after defun may be a form that
+; violates the guards on primitives. Until the guards in fn are
+; checked, we cannot let raw Common Lisp evaluate fn.
+
+; Intuitively, we think of the Common Lisp programmer intending to defun (fn
+; x1...xn) to be b, and is declaring that the raw fn can be called only on
+; arguments satisfying g. The need for guards stems from the fact that there
+; are many Common Lisp primitives, such as car and cdr and + and *, whose
+; behavior outside of their guarded domains is unspecified. To use these
+; functions in the body of fn one must "guard" fn so that it is never called in
+; a way that would lead to the violation of the primitive guards. Thus, we
+; make a formal precondition on the use of the Common Lisp program fn that the
+; guard g, along with the tests along the various paths through body b, imply
+; each of the guards for every subroutine in b. We also require that each of
+; the guards in g be satisfied. This is what we mean when we say fn is
+; :common-lisp-compliant.
+
+; It is, however, often impossible to check the guards at defun time. For
+; example, if fn calls itself recursively and then gives the result to +, we
+; would have to prove that the guard on + is satisfied by fn's recursive
+; result, before we admit fn. In general, induction may be necessary to
+; establish that the recursive calls satisfy the guards of their masters;
+; hence, it is probably also necessary for the user to formulate general lemmas
+; about fn to establish those conditions. Furthermore, guard checking is no
+; longer logically necessary and hence automatically doing it at defun time may
+; be a waste of time.
+
+ :program (value nil)
+ :raw
+ (with-ctx-summarized
+ (defun-ctx def-lst state event-form #+:non-standard-analysis std-p)
+ (let ((wrld (w state))
+ (def-lst0
+ #+:non-standard-analysis
+ (if std-p
+ (non-std-def-lst def-lst)
+ def-lst)
+ #-:non-standard-analysis
+ def-lst)
+ (event-form (or event-form (list 'defuns def-lst))))
+ (revert-world-on-error
+ (er-let*
+ ((tuple (ccg-chk-acceptable-defuns def-lst ctx wrld state
+ #+:non-standard-analysis std-p)))
+
+; Chk-acceptable-defuns puts the 'formals, 'stobjs-in and 'stobjs-out
+; properties (which are necessary for the translation of the bodies).
+; All other properties are put by the defuns-fn0 call below.
+
+ (cond
+ ((eq tuple 'redundant)
+ (stop-redundant-event ctx state))
+ (t
+ (enforce-redundancy
+ event-form ctx wrld
+ (let ((term-method (nth 1 tuple))
+ (names (nth 2 tuple))
+ (arglists (nth 3 tuple))
+ (docs (nth 4 tuple))
+ (pairs (nth 5 tuple))
+ (guards (nth 6 tuple))
+ (measures (nth 7 tuple))
+ (ruler-extenders-lst (nth 8 tuple))
+ (mp (nth 9 tuple))
+ (rel (nth 10 tuple))
+ (hints (nth 11 tuple))
+ (guard-hints (nth 12 tuple))
+ (std-hints (nth 13 tuple))
+ (otf-flg (nth 14 tuple))
+ (bodies (nth 15 tuple))
+ (symbol-class (nth 16 tuple))
+ (normalizeps (nth 17 tuple))
+ (reclassifyingp (nth 18 tuple))
+ (wrld (nth 19 tuple))
+ (non-executablep (nth 20 tuple))
+ (guard-debug (nth 21 tuple))
+ (split-types-terms (nth 22 tuple))
+ (ccms (nth 23 tuple))
+ (verbose (nth 24 tuple))
+ (time-limit (nth 25 tuple))
+ (hierarchy (nth 26 tuple)))
+ (er-let*
+ ((pair (ccg-defuns-fn0
+ names
+ arglists
+ docs
+ pairs
+ guards
+ term-method
+ measures
+ ccms
+ ruler-extenders-lst
+ mp
+ rel
+ verbose
+ time-limit
+ hierarchy
+ hints
+ guard-hints
+ std-hints
+ otf-flg
+ guard-debug
+ bodies
+ symbol-class
+ normalizeps
+ split-types-terms
+ non-executablep
+ #+:non-standard-analysis std-p
+ ctx
+ wrld
+ state)))
+
+; Triple is of the form (term-method wrld . ttree), where term-method is the
+; actual termination method used to prove termination.
+; Pair is of the form (wrld . ttree).
+
+ ;;--harshrc: As Daron says (where?), I changed code, to force checking a nil ttree
+ ;;but ideally we shud accumulate all successful ttrees.
+
+ (er-progn
+ (chk-assumption-free-ttree nil;(cdr pair)
+ ctx state)
+
+ (install-event-defuns names event-form def-lst0 symbol-class
+ reclassifyingp non-executablep pair ctx wrld
+ state)
+ (if (or (eq symbol-class :program)
+ (ld-skip-proofsp state)
+ (and (null (cdr names))
+ (null (getprop (car names)
+ 'recursivep
+ nil
+ 'current-acl2-world
+ wrld))))
+ (value (cond ((null (cdr names)) (car names))
+ (t names)))
+ (er-let* ((fives (chk-defuns-tuples def-lst nil ctx wrld state)))
+ (defun-make-event
+ names fives symbol-class term-method
+ (car pair) event-form state))))))))))))))
+
+; redefine defuns-fn to "be" (call) ccg-defuns-fn.
+;
+; redefun is provided by my hacker stuff. -Peter
+
+(redefun defuns-fn (def-lst state event-form #+:non-standard-analysis std-p)
+ (ccg-defuns-fn def-lst state event-form #+:non-standard-analysis std-p))
+
+(progn+touchable
+ :all
+ (redefun+rewrite
+ defstobj-fn
+ (:carpat (process-embedded-events %1%
+ %2%
+ %3%
+ %4%
+ %5%
+ (append
+ . %app-cdr%)
+ . %pee-cdr%)
+ :repl (process-embedded-events %1%
+ %2%
+ %3%
+ %4%
+ %5%
+ (append
+ '((set-termination-method :measure))
+ . %app-cdr%)
+ . %pee-cdr%)
+ :vars (%1% %2% %3% %4% %5% %app-cdr% %pee-cdr%)
+ :mult 1)))
+
diff -Nru acl2-6.2/books/centaur/4v-sexpr/4v-logic.lisp acl2-6.3/books/centaur/4v-sexpr/4v-logic.lisp
--- acl2-6.2/books/centaur/4v-sexpr/4v-logic.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/4v-logic.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -142,7 +142,16 @@
:parents (4v)
:short "Primitive operations in our four-valued logic."
- :long " Note that all of these operations are monotonic .
")
@@ -553,6 +562,29 @@
(t
(4vx))))))
+(defsection 4v-zif
+ :parents (4v-operations)
+ :short "Unusual semantics for a multiplexor, used mainly to implement composition
+features in @(see esim) "
+
+ :long "A ZIF module is in some ways similar to a pass-gate based
+multiplexor, but is probably not the sort of thing you would actually want to
+use to model a mux. It is very similar to an @(see 4v-ite*) but does not @(see
+4v-unfloat) its inputs. We include this mainly as a way to implement
+experimental composition features in @(see esim).
"
+
+ (defun 4v-zif (c a b)
+ (declare (xargs :guard t))
+ (mbe :logic
+ (4vcases c
+ (t (4v-fix a))
+ (f (4v-fix b))
+ (& (4vx)))
+ :exec
+ (cond ((eq c (4vt)) (4v-fix a))
+ ((eq c (4vf)) (4v-fix b))
+ (t
+ (4vx))))))
(defsection 4v-tristate
@@ -889,7 +921,7 @@
(def-ruleset 4v-op-defs '(4v-fix 4v-unfloat 4v-not 4v-and 4v-or 4v-xor 4v-iff
- 4v-res 4v-ite 4v-ite* 4v-tristate 4v-pullup
+ 4v-res 4v-ite 4v-ite* 4v-zif 4v-tristate 4v-pullup
4v-wand 4v-wor))
(def-ruleset 4v-op-execs '((4v-fix$inline)
@@ -902,6 +934,7 @@
(4v-res)
(4v-ite)
(4v-ite*)
+ (4v-zif)
(4v-tristate)
(4v-pullup)
(4v-wand)
@@ -1042,6 +1075,7 @@
(prove-4v-monotonic 4v-res (a b))
(prove-4v-monotonic 4v-ite (c a b))
(prove-4v-monotonic 4v-ite* (c a b))
+ (prove-4v-monotonic 4v-zif (c a b))
(prove-4v-monotonic 4v-tristate (c a))
(prove-4v-monotonic 4v-pullup (a))
(prove-4v-monotonic 4v-wand (a b))
@@ -1217,3 +1251,21 @@
(y b)
(k k0)))))))))
+
+
+(defun bool-to-4v (x)
+ (declare (xargs :guard t))
+ (if x *4vt* *4vf*))
+
+(defun 4v-to-nat (a)
+ (declare (xargs :guard t))
+ (if (atom a)
+ 0
+ (let ((rest (4v-to-nat (cdr a))))
+ (if (integerp rest)
+ (case (car a)
+ ((t) (+ 1 (* 2 rest)))
+ ((f) (* 2 rest))
+ (t 'x))
+ rest))))
+
diff -Nru acl2-6.2/books/centaur/4v-sexpr/bitspecs.lisp acl2-6.3/books/centaur/4v-sexpr/bitspecs.lisp
--- acl2-6.2/books/centaur/4v-sexpr/bitspecs.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/bitspecs.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -1132,13 +1132,14 @@
(x x) (y (car spec)) (spec (cdr spec)))))))
-(defthm true-listp-and-subset-and-no-intersect-impl-nil
- (implies (and (true-listp x)
- (subsetp-equal x y)
- (not (intersectp-equal x y)))
- (Equal x nil))
- :hints ((set-reasoning))
- :rule-classes nil)
+(local (defthm true-listp-and-subset-and-no-intersect-impl-nil
+ (implies (and (true-listp x)
+ (subsetp-equal x y)
+ (not (intersectp-equal x y)))
+ (Equal x nil))
+ :hints (("Goal" :in-theory (enable intersectp-equal))
+ (set-reasoning))
+ :rule-classes nil))
(defthm true-listp-4v-bitspec-entry-vars
(implies (4v-bitspec-entryp x)
@@ -1150,9 +1151,10 @@
(iff (intersectp-equal (4v-bitspec-entry-vars x)
(4v-bitspec-vars spec))
(not (equal (4v-bitspec-entry-vars x) nil))))
- :hints (("goal" :use ((:instance true-listp-and-subset-and-no-intersect-impl-nil
- (x (4v-bitspec-entry-vars x))
- (y (4v-bitspec-vars spec))))
+ :hints (("goal"
+ :use ((:instance true-listp-and-subset-and-no-intersect-impl-nil
+ (x (4v-bitspec-entry-vars x))
+ (y (4v-bitspec-vars spec))))
:in-theory (disable 4v-bitspec-entry-vars))))
(defthm param-for-4v-bitspec-entryp-when-no-vars
diff -Nru acl2-6.2/books/centaur/4v-sexpr/compose-sexpr.lisp acl2-6.3/books/centaur/4v-sexpr/compose-sexpr.lisp
--- acl2-6.2/books/centaur/4v-sexpr/compose-sexpr.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/compose-sexpr.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -543,7 +543,6 @@
intersectp-equal-non-cons
4v-sexpr-vars-list
4v-sexpr-restrict-alist
- alist-equiv-append-atom
alist-vals-when-atom
alist-keys-when-atom
4v-alist-to-params-append-when-first-does-not-intersect-vars
diff -Nru acl2-6.2/books/centaur/4v-sexpr/g-sexpr-eval.lisp acl2-6.3/books/centaur/4v-sexpr/g-sexpr-eval.lisp
--- acl2-6.2/books/centaur/4v-sexpr/g-sexpr-eval.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/g-sexpr-eval.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -29,7 +29,7 @@
(local (include-book "centaur/misc/hons-sets" :dir :system))
(local (include-book "centaur/aig/eval-restrict" :dir :system))
(local (include-book "arithmetic/top-with-meta" :dir :system))
-
+(local (in-theory (disable nth-when-zp)))
(defun num-varmap (keys n)
@@ -156,9 +156,15 @@
(implies (acl2-numberp idx)
(good-svarmap (num-varmap keys idx))))
-
(in-theory (disable num-varmap))))
+(defthm good-svarmap-num-varmap
+ ;; [Jared]: Adding this non-locally so that I can use it in simple
+ ;; sexpr->faig conversion.
+ (implies (acl2-numberp idx)
+ (good-svarmap (num-varmap keys idx))))
+
+
(defun 4v-sexpr-eval-by-faig (x al)
(let* ((vars (alist-keys al))
@@ -389,6 +395,18 @@
'(:in-theory (enable 4v-fix))))
:otf-flg t)))
+(defthm 4v-alist-equiv-faig-const-alist->4v-alist-lemma
+ ;; [Jared]: Adding this non-locally so that I can use it in simple
+ ;; sexpr->faig conversion.
+ (4v-env-equiv
+ (FAIG-CONST-ALIST->4V-ALIST
+ (FAIG-EVAL-ALIST
+ (num-varmap (alist-keys al) 0)
+ (SIG-AL-TO-sVAR-AL
+ (4V-ALIST->FAIG-CONST-ALIST AL)
+ (num-varmap (alist-keys al) 0))))
+ al))
+
(defthm 4v-sexpr-eval-by-faig-is-4v-sexpr-eval
(equal (4v-sexpr-eval-by-faig x al)
(4v-sexpr-eval x al))
@@ -523,3 +541,79 @@
alist-keys
good-svarmap
4v-sexpr-to-faig-opt))
+
+
+(include-book "centaur/gl/def-gl-rewrite" :dir :system)
+
+(gl::gl-set-uninterpreted bool-to-4v)
+(gl::gl-set-uninterpreted faig-const->4v)
+(gl::def-gl-rewrite 4v->faig-const-of-bool-to-4v-gl
+ (equal (4v->faig-const (bool-to-4v x))
+ (cons (not (not x)) (not x))))
+(gl::def-gl-rewrite faig-const->4v-equal-x-gl
+ (equal (equal (faig-const->4v a) 'x)
+ (not (or (equal a (faig-t))
+ (equal a (faig-f))
+ (equal a (faig-z))))))
+
+(gl::def-gl-rewrite 4v->faig-const-of-faig-const->4v-gl
+ (equal (4v->faig-const (faig-const->4v x))
+ (if (and (consp x)
+ (booleanp (car x))
+ (booleanp (cdr x)))
+ x
+ '(t . t))))
+
+(gl::def-gl-rewrite 4vp-of-faig-const->4v-rewrite
+ (equal (4vp (faig-const->4v x)) t))
+
+;; the following 4 theorems are not needed in STV proofs but end up being
+;; useful in non-STV ones
+(gl::def-gl-rewrite equal-of-bool-to-4v-1
+ (equal (equal (bool-to-4v x) y)
+ (or (and x (equal y (4vt)))
+ (and (equal x nil) (equal y (4vf))))))
+
+(gl::def-gl-rewrite equal-of-bool-to-4v-2
+ (equal (equal y (bool-to-4v x))
+ (or (and x (equal y (4vt)))
+ (and (equal x nil) (equal y (4vf))))))
+
+(gl::def-gl-rewrite equal-of-faig-const->4v-1
+ (equal (equal (faig-const->4v x) y)
+ (or (and (equal x (faig-t)) (equal y (4vt)))
+ (and (equal x (faig-f)) (equal y (4vf)))
+ (and (equal x (faig-z)) (equal y (4vz)))
+ (and (not (equal x (faig-t)))
+ (not (equal x (faig-f)))
+ (not (equal x (faig-z)))
+ (equal y (4vx))))))
+
+(gl::def-gl-rewrite equal-of-faig-const->4v-2
+ (equal (equal y (faig-const->4v x))
+ (or (and (equal x (faig-t)) (equal y (4vt)))
+ (and (equal x (faig-f)) (equal y (4vf)))
+ (and (equal x (faig-z)) (equal y (4vz)))
+ (and (not (equal x (faig-t)))
+ (not (equal x (faig-f)))
+ (not (equal x (faig-z)))
+ (equal y (4vx))))))
+
+
+;; this is used in STVs
+(defun 4v-to-nat-cons (car rest)
+ (b* (((unless (integerp rest)) rest)
+ (a (4v->faig-const car))
+ ((unless (or (equal a (faig-t))
+ (equal a (faig-f))))
+ 'x))
+ (+ (if (equal a (faig-t)) 1 0) (* 2 rest))))
+
+(defthmd 4v-to-nat-redef
+ (equal (4v-to-nat x)
+ (b* (((when (atom x)) 0)
+ (rest (4v-to-nat (cdr x))))
+ (4v-to-nat-cons (car x) rest)))
+ :rule-classes ((:definition :install-body nil)))
+
+(gl::set-preferred-def 4v-to-nat 4v-to-nat-redef)
diff -Nru acl2-6.2/books/centaur/4v-sexpr/onehot-rewrite.lisp acl2-6.3/books/centaur/4v-sexpr/onehot-rewrite.lisp
--- acl2-6.2/books/centaur/4v-sexpr/onehot-rewrite.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/onehot-rewrite.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -136,7 +136,8 @@
(defthm member-equal-of-list-fix
(equal (member-equal a (list-fix x))
- (list-fix (member-equal a x))))
+ (list-fix (member-equal a x)))
+ :hints(("Goal" :in-theory (enable member-equal))))
(defthm list-fix-under-set-equiv
(set-equiv (list-fix x)
@@ -265,7 +266,8 @@
(local (defthm l0
(implies (and (member-equal a x)
(member-equal k (4v-sexpr-vars a)))
- (member-equal k (4v-sexpr-vars-list x)))))
+ (member-equal k (4v-sexpr-vars-list x)))
+ :hints(("Goal" :in-theory (enable member-equal)))))
(defthm member-of-4v-sexpr-vars-list-when-subsetp
(implies (and (subsetp-equal a b)
@@ -598,7 +600,7 @@
:long "How is this reduction accomplished? Well, in the implementation of
@(see 4v-shannon-expansion), reduced expressions are formed by using @(see
-sexpr-restrict) to assume that the variable being is first true, and then
+4v-sexpr-restrict) to assume that the variable being is first true, and then
false. Our approach is basically similar, and our new sexpr is essentially the
following:
@@ -771,7 +773,8 @@
(implies (and (all-equalp *4vf* (4v-sexpr-eval-list x env))
(member-equal a x))
(equal (4v-sexpr-eval a env)
- *4vf*))))
+ *4vf*))
+ :hints(("Goal" :in-theory (enable member-equal)))))
(local (defthm h3
(implies (and (4v-onehot-list-p (4v-sexpr-eval-list sexprs env))
@@ -1039,8 +1042,8 @@
(false-bindings (hons-acons var (4vs-f) bindings)))
(4vs-ite*-list-dumb (car vars)
- sexprs/bindings
- (4v-onehot-sexpr-list-prime-exec (cdr vars) false-bindings sexprs))))
+ sexprs/bindings
+ (4v-onehot-sexpr-list-prime-exec (cdr vars) false-bindings sexprs))))
(local (in-theory (enable 4v-onehot-sexpr-list-prime-exec)))
@@ -1072,6 +1075,11 @@
(implies (atom sexprs)
(not (4v-onehot-sexpr-list-prime-exec vars false-bindings sexprs)))))
+ (local (defthm l1a
+ (iff (4vs-ite*-list-dumb c as bs)
+ (consp as))
+ :hints(("Goal" :in-theory (enable 4vs-ite*-list-dumb)))))
+
(local (defthm l1
(equal (consp (4v-onehot-sexpr-list-prime-exec vars false-bindings sexprs))
(consp sexprs))))
diff -Nru acl2-6.2/books/centaur/4v-sexpr/portcullis.acl2 acl2-6.3/books/centaur/4v-sexpr/portcullis.acl2
--- acl2-6.2/books/centaur/4v-sexpr/portcullis.acl2 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/portcullis.acl2 2013-09-30 17:53:10.000000000 +0000
@@ -20,7 +20,7 @@
(in-package "ACL2")
(ld "tools/flag-package.lsp" :dir :system)
-(ld "xdoc/package.lsp" :dir :system)
-(ld "centaur/vl/package.lsp" :dir :system)
+(include-book "xdoc/portcullis" :dir :system)
+(include-book "centaur/vl/portcullis" :dir :system)
; cert-flags: ? t :ttags :all
(certify-book "portcullis" ? t :ttags :all)
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/4v-sexpr/sexpr-3v.lisp acl2-6.3/books/centaur/4v-sexpr/sexpr-3v.lisp
--- acl2-6.2/books/centaur/4v-sexpr/sexpr-3v.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/sexpr-3v.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -32,6 +32,7 @@
(not (or (eq fn (4vz))
(eq fn 'id)
(eq fn 'res)
+ (eq fn 'zif)
(eq fn 'tristate))))))
(local (in-theory (enable* 3v-syntax-sexprp
diff -Nru acl2-6.2/books/centaur/4v-sexpr/sexpr-building.lisp acl2-6.3/books/centaur/4v-sexpr/sexpr-building.lisp
--- acl2-6.2/books/centaur/4v-sexpr/sexpr-building.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/sexpr-building.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -24,9 +24,9 @@
(in-package "ACL2")
(include-book "sexpr-eval")
(include-book "sexpr-vars")
-(include-book "sexpr-3v")
(include-book "cutil/defprojection" :dir :system)
(include-book "misc/definline" :dir :system)
+(local (include-book "sexpr-3v"))
;(local (include-book "sexpr-to-faig")) ;; for 3v-opt stuff
(set-inhibit-warnings "theory" "non-rec")
@@ -40,7 +40,7 @@
These functions carry out a few trivial rewrites (constant folding, double
negation elimination). An open question: how much rewriting should they do?
-Right now I don't try to optimize very aggressively, e.g., @(see sexpr-and)
+Right now I don't try to optimize very aggressively, e.g., @(see 4vs-and)
doesn't eat bufs. It's not clear how much of the code from @(see
sexpr-rewrite) should be duplicated here.
")
@@ -469,6 +469,32 @@
+(defsection 4vs-zif-dumb
+ :parents (4vs-constructors)
+ :short "@(call 4vs-zif-dumb) constructs @('(ZIF C A B)'), i.e., the
+s-expression for an pass-gate style multiplexor."
+
+ (definlined 4vs-zif-dumb (c a b)
+ (declare (xargs :guard t))
+ (hons-list 'zif c a b))
+
+ (local (in-theory (enable 4vs-zif-dumb)))
+
+ (defthm 4v-sexpr-eval-of-4vs-zif-dumb
+ (equal (4v-sexpr-eval (4vs-zif-dumb c a b) env)
+ (4v-zif (4v-sexpr-eval c env)
+ (4v-sexpr-eval a env)
+ (4v-sexpr-eval b env)))
+ :hints(("Goal" :in-theory (enable 4vs-zif-dumb))))
+
+ (defthm 4v-sexpr-vars-of-4vs-zif-dumb
+ (equal (4v-sexpr-vars (4vs-zif-dumb c a b))
+ (hons-alphorder-merge (4v-sexpr-vars c)
+ (hons-alphorder-merge (4v-sexpr-vars a)
+ (4v-sexpr-vars b))))
+ :hints(("Goal" :in-theory (enable 4vs-zif-dumb)))))
+
+
(defsection 4vs-or
diff -Nru acl2-6.2/books/centaur/4v-sexpr/sexpr-equivs.lisp acl2-6.3/books/centaur/4v-sexpr/sexpr-equivs.lisp
--- acl2-6.2/books/centaur/4v-sexpr/sexpr-equivs.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/sexpr-equivs.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -32,8 +32,8 @@
(def-universal-equiv 4v-equiv
;; X === Y for in the sense of four-valued objects if they fix to the same
- ;; four-vauled constant. That is, besides *4f*, *4z*, and *4t*, all objects
- ;; are equivalent to *4x* under this relationship.
+ ;; four-vauled constant. That is, besides *4vf*, *4vz*, and *4vt*, all
+ ;; objects are equivalent to *4vx* under this relationship.
:equiv-terms ((equal (4v-fix x))))
(in-theory (enable 4v-equiv))
@@ -59,6 +59,7 @@
(prove-4v-equiv-cong 4v-res (a b))
(prove-4v-equiv-cong 4v-ite (c a b))
(prove-4v-equiv-cong 4v-ite* (c a b))
+(prove-4v-equiv-cong 4v-zif (c a b))
(prove-4v-equiv-cong 4v-tristate (c a))
(prove-4v-equiv-cong 4v-pullup (a))
diff -Nru acl2-6.2/books/centaur/4v-sexpr/sexpr-eval.lisp acl2-6.3/books/centaur/4v-sexpr/sexpr-eval.lisp
--- acl2-6.2/books/centaur/4v-sexpr/sexpr-eval.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/sexpr-eval.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -1,4 +1,4 @@
-; S-Expressions for 4-Valued Logic
+ ; S-Expressions for 4-Valued Logic
; Copyright (C) 2010-2012 Centaur Technology
;
; Contact:
@@ -130,6 +130,7 @@
counterpart.
")
(defun 4v-sexpr-apply (fn args)
+ (declare (xargs :guard (true-listp args)))
(b* (((when (or (eq fn (4vt))
(eq fn (4vf))
(eq fn (4vx))
@@ -145,6 +146,7 @@
(iff (4v-iff arg1 arg2))
(or (4v-or arg1 arg2))
(ite* (4v-ite* arg1 arg2 arg3))
+ (zif (4v-zif arg1 arg2 arg3))
(buf (4v-unfloat arg1))
(res (4v-res arg1 arg2))
(tristate (4v-tristate arg1 arg2))
@@ -154,8 +156,7 @@
;; (wand (4v-wand arg1 arg2))
;; (wor (4v-wor arg1 arg2))
(otherwise (4vx)))))
-
-
+
; [Jared] I was tempted to make a 4v-sexpr-eval1 function in the style of
; 4v-sexpr-eval-alist1, but this seems troublesome because it would mean
@@ -190,6 +191,7 @@
(iff (4v-iff arg1 arg2))
(or (4v-or arg1 arg2))
(ite* (4v-ite* arg1 arg2 arg3))
+ (zif (4v-zif arg1 arg2 arg3))
(buf (4v-unfloat arg1))
(res (4v-res arg1 arg2))
(tristate (4v-tristate arg1 arg2))
@@ -257,7 +259,7 @@
:flag sexpr-list)
:hints (("goal"
:in-theory (disable* (:ruleset 4v-op-defs) 4v-<= 4v-lookup
- default-car default-cdr nth-add1 nth))
+ default-car default-cdr nth-when-zp nth-add1 nth))
(and stable-under-simplificationp
'(:use ((:instance 4v-alist-<=-necc
(k x)
@@ -534,8 +536,8 @@
We construct a new sexpr by copying @('x'), except that we
unconditionally replace every variable in @('x') with its binding in
@('al'), regardless of whether such a binding actually exists. Any unbound
-variables are just replaced by NIL, which in our @(see 4v-sexpr) format always
-evaluates to X.
+variables are just replaced by NIL, which in our semantics always evaluates to
+X.
We @(see memoize) this function, but this only helps when you are composing
with the same alist. We don't use @(':forget t') because you frequently want
@@ -643,7 +645,7 @@
(defsection 4v-sexpr-alist-extract
:parents (4v-sexprs)
- :short "Extract a portion of a @(see 4v-sexpr) alist."
+ :short "Extract a portion of a 4v-sexpr alist."
:long "
@(call 4v-sexpr-alist-extract) is given:
@('keys'), a list of names, and @('al'), a fast alist binding
diff -Nru acl2-6.2/books/centaur/4v-sexpr/sexpr-fixpoint-spec.lisp acl2-6.3/books/centaur/4v-sexpr/sexpr-fixpoint-spec.lisp
--- acl2-6.2/books/centaur/4v-sexpr/sexpr-fixpoint-spec.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/sexpr-fixpoint-spec.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -79,16 +79,13 @@
(set-equiv (remove b a) (remove b c))))
:hints(("Goal" :use ((:instance set-equiv-breakdown-cons)))))
-(defthm remove-remove
- (equal (remove k (remove k x))
- (remove k x))
- :hints (("goal" :induct t)))
(defthm remove-when-not-member
(implies (not (member-equal k x))
(equal (remove k x)
(append x nil)))
- :hints(("Goal" :induct t)))
+ :hints(("Goal" :induct t
+ :in-theory (enable remove))))
@@ -175,7 +172,8 @@
(and (4v-sexpr-<= v (cdr (hons-assoc-equal k al2)))
(4v-sexpr-alist-<= al1 al2))))
:hints (("Goal" :do-not-induct t)
- (witness) (witness)))
+ (witness :ruleset (4v-sexpr-alist-<=-hons-assoc-equal-example
+ 4v-sexpr-alist-<=-witnessing))))
(defthm 4v-sexpr-<=-restrict
(implies (and (4v-sexpr-alist-<= a b)
diff -Nru acl2-6.2/books/centaur/4v-sexpr/sexpr-fixpoint.lisp acl2-6.3/books/centaur/4v-sexpr/sexpr-fixpoint.lisp
--- acl2-6.2/books/centaur/4v-sexpr/sexpr-fixpoint.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/sexpr-fixpoint.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -250,7 +250,8 @@
(local (defthm natp-when-nat-listp-member
(implies (and (member a x)
(nat-listp x))
- (natp a))))
+ (natp a))
+ :hints(("Goal" :in-theory (enable nat-listp)))))
(local (defthm nat-listp-when-subsetp
(implies (and (subsetp-equal x y)
diff -Nru acl2-6.2/books/centaur/4v-sexpr/sexpr-rewrites.lisp acl2-6.3/books/centaur/4v-sexpr/sexpr-rewrites.lisp
--- acl2-6.2/books/centaur/4v-sexpr/sexpr-rewrites.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/sexpr-rewrites.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -19,7 +19,7 @@
; Original author: Sol Swords
(in-package "ACL2")
-(include-book "centaur/aig/base" :dir :system) ;; BOZO for alphorder-sort
+(include-book "centaur/aig/aig-base" :dir :system) ;; BOZO for alphorder-sort
(include-book "sexpr-advanced")
(include-book "centaur/misc/hons-extra" :dir :system)
(include-book "sexpr-vars-1pass")
@@ -884,6 +884,7 @@
((buf (buf a)) . (buf a))
((buf (ite a b c)) . (ite a b c))
((buf (ite* a b c)) . (ite* a b c))
+ ((buf (zif a b c)) . (ite* a b c))
((buf (and a b)) . (and a b))
((buf (or a b)) . (or a b))
((buf (not a)) . (not a))
@@ -991,6 +992,14 @@
((ite* a b (not b)) . (not (xor a b)))
((ite* a (not b) b) . (xor a b))
+ ;; ZIF constant propagation
+ ((zif (t) a b) . a)
+ ((zif (f) a b) . b)
+ ;; ZIF remove NOT on condition
+ ((zif (not c) a b) . (zif c b a))
+ ;; ZIF select is buffered
+ ((zif (buf c) a b) . (zif c a b))
+
;; ??? Normalize IFF to NOT of XOR.
;; If we decide not to do this normalization, maybe move IFF up in the
;; order.
@@ -1921,6 +1930,7 @@
(iff a b)
(or a b)
(ite* a b c)
+ (zif a b c)
(buf a)
(res a a)
(ite a b c)
@@ -2223,6 +2233,12 @@
(equal (4v-sexpr-eval y env)
(4v-sexpr-eval x (4v-sexpr-eval-alist al env))))))
+ (local (in-theory (disable sexpr-booleanp-by-rule
+ sexpr-booleanp-by-rules
+ sexpr-booleanp
+ intersection$-of-cons-left
+ sexpr-booleanp-list)))
+
(defthm-flag-sexpr-booleanp
(defthm 4v-boolp-when-sexpr-booleanp-by-rule
(implies (and (sexpr-booleanp-by-rule rule x all-rules)
@@ -2230,7 +2246,8 @@
(4v-sexpr-boolean-rulesp all-rules)
(4v-alist-boolp (4v-sexpr-vars x) alist))
(4v-boolp (4v-sexpr-eval x alist)))
- :hints ((and stable-under-simplificationp
+ :hints ('(:expand ((sexpr-booleanp-by-rule rule x all-rules)))
+ (and stable-under-simplificationp
'(:use ((:instance sexpr-unify-4v-sexpr-compose
(pat rule) (term x) (alist nil)))
:in-theory (e/d (4v-sexpr-eval-4v-sexpr-compose-strong)
@@ -2242,13 +2259,16 @@
(4v-sexpr-boolean-rulesp all-rules)
(4v-alist-boolp (4v-sexpr-vars x) alist))
(4v-boolp (4v-sexpr-eval x alist)))
+ :hints ('(:expand ((sexpr-booleanp-by-rules rules x all-rules))))
:flag rules)
(defthm 4v-boolp-when-sexpr-booleanp
(implies (and (sexpr-booleanp x all-rules)
(4v-sexpr-boolean-rulesp all-rules)
(4v-alist-boolp (4v-sexpr-vars x) alist))
(4v-boolp (4v-sexpr-eval x alist)))
- :hints ((and stable-under-simplificationp
+ :hints ('(:expand ((sexpr-booleanp x all-rules)
+ (sexpr-booleanp nil all-rules)))
+ (and stable-under-simplificationp
'(:expand ((:free (x) (4v-alist-boolp (list x) alist))))))
:flag sexpr)
(defthm 4v-boolp-when-sexpr-booleanp-list
@@ -2256,6 +2276,7 @@
(4v-sexpr-boolean-rulesp all-rules)
(4v-alist-boolp (4v-sexpr-vars-list x) alist))
(4v-bool-listp (4v-sexpr-eval-list x alist)))
+ :hints ('(:expand ((sexpr-booleanp-list x all-rules))))
:flag list))
@@ -2281,7 +2302,10 @@
;; need not be known Boolean.)
'(((xor a a) . (f))
((xor a (not a)) . (t))
- ((ite* a x x) . (buf x))))
+ ((ite* a x x) . (buf x))
+ ((zif a x x) . x)
+ ((zif x a b) . (ite* x a b))
+ ((buf a) . a)))
(defsection 4v-sexpr-boolean-rewritep
@@ -2389,8 +2413,8 @@
(sexpr-brules->boolp-rules brules)))
(mv nil nil))
(new-x (4v-sexpr-compose-nofal rhs subst)))
- (mv (sexpr-rewrite new-x (sexpr-brules->rewrites brules))
- t)))
+ (mv (sexpr-rewrite new-x (sexpr-brules->rewrites brules))
+ t)))
(local (in-theory (enable sexpr-boolean-rw-apply-rule)))
@@ -2405,7 +2429,7 @@
env))
(4v-sexpr-eval x env)))
:hints (("goal" :use ((:instance sexpr-unify-4v-sexpr-compose
- (term x)))
+ (term x)))
:in-theory (disable sexpr-unify-4v-sexpr-compose))))
(defthm sexpr-booleanp-keys-implies-4v-key-bool-alistp-of-eval
@@ -2425,16 +2449,18 @@
(defthm 4v-sexpr-eval-of-sexpr-boolean-rw-apply-rule
(mv-let (new-x ok)
- (sexpr-boolean-rw-apply-rule x rule brules)
- (implies (and ok
- (4v-sexpr-brules-p brules)
- (4v-sexpr-boolean-rewritep (car rule) (cdr rule))
- (subsetp-equal (4v-sexpr-vars (cdr rule))
- (4v-sexpr-vars (car rule)))
- (4v-alist-boolp (4v-sexpr-vars x) alist))
- (equal (4v-sexpr-eval new-x alist)
- (4v-sexpr-eval x alist))))
- :hints(("Goal" :in-theory (enable 4v-sexpr-brules-p)
+ (sexpr-boolean-rw-apply-rule x rule brules)
+ (implies (and ok
+ (4v-sexpr-brules-p brules)
+ (4v-sexpr-boolean-rewritep (car rule) (cdr rule))
+ (subsetp-equal (4v-sexpr-vars (cdr rule))
+ (4v-sexpr-vars (car rule)))
+ (4v-alist-boolp (4v-sexpr-vars x) alist))
+ (equal (4v-sexpr-eval new-x alist)
+ (4v-sexpr-eval x alist))))
+ :hints(("Goal" :in-theory (e/d (4v-sexpr-brules-p)
+ (intersection$-of-cons-left
+ intersection$-when-atom-left))
:use ((:instance
sexpr-booleanp-keys-implies-4v-key-bool-alistp-of-eval
(keys (sexpr-bool-special-vars))
diff -Nru acl2-6.2/books/centaur/4v-sexpr/sexpr-to-faig.lisp acl2-6.3/books/centaur/4v-sexpr/sexpr-to-faig.lisp
--- acl2-6.2/books/centaur/4v-sexpr/sexpr-to-faig.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/sexpr-to-faig.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -21,7 +21,9 @@
(in-package "ACL2")
(include-book "sexpr-eval")
(include-book "sexpr-3v")
-(include-book "centaur/aig/three-four" :dir :system)
+(include-book "centaur/aig/faig-base" :dir :system)
+(include-book "centaur/aig/faig-constructors" :dir :system)
+(include-book "centaur/aig/faig-equivs" :dir :system)
(include-book "centaur/aig/aig-equivs" :dir :system)
(include-book "centaur/misc/tuplep" :dir :system)
(local (include-book "centaur/aig/eval-restrict" :dir :system))
@@ -94,22 +96,22 @@
(defthm faig-eval-of-constants
;; BOZO find me a home
- (and (equal (faig-eval *4t* env) *4t*)
- (equal (faig-eval *4f* env) *4f*)
- (equal (faig-eval *4z* env) *4z*)
- (equal (faig-eval *4x* env) *4x*)
- (equal (faig-eval nil env) *4x*))
+ (and (equal (faig-eval (faig-t) env) (faig-t))
+ (equal (faig-eval (faig-f) env) (faig-f))
+ (equal (faig-eval (faig-z) env) (faig-z))
+ (equal (faig-eval (faig-x) env) (faig-x))
+ (equal (faig-eval nil env) (faig-x)))
:hints(("Goal" :in-theory (enable faig-eval))))
(local (defthm faig-equiv-nil-x
;; BOZO find me a home?
- (equal (faig-equiv nil *4x*) t)
+ (equal (faig-equiv nil (faig-x)) t)
:hints (("goal" :in-theory (enable faig-equiv)))))
(local (defthm faig-eval-when-atom
(implies (atom x)
(equal (faig-eval x env)
- *4x*))
+ (faig-x)))
:hints(("Goal" :in-theory (enable faig-eval)))))
@@ -141,7 +143,7 @@
(declare (xargs :guard t))
(if (faig-const-p x)
x
- *4x*))
+ (faig-x)))
(defthm faig-const-fix-of-faig-eval
(equal (faig-const-fix (faig-eval x env))
@@ -160,7 +162,7 @@
(let ((x (faig-const-fix x))
(y (faig-const-fix y)))
(or (equal x y)
- (equal x *4x*)))))
+ (equal x (faig-x))))))
@@ -172,9 +174,9 @@
(defun faig-const->4v (x)
(declare (xargs :guard t))
- (cond ((equal x *4t*) (4vt))
- ((equal x *4f*) (4vf))
- ((equal x *4z*) (4vz))
+ (cond ((equal x (faig-t)) (4vt))
+ ((equal x (faig-f)) (4vf))
+ ((equal x (faig-z)) (4vz))
(t (4vx)))))
(defsection faig-const-list->4v-list
@@ -220,10 +222,10 @@
(defun 4v->faig-const (x)
"4V constant --> FAIG constant"
(declare (xargs :guard t))
- (cond ((eq x (4vt)) *4t*)
- ((eq x (4vf)) *4f*)
- ((eq x (4vz)) *4z*)
- (t *4x*)))
+ (cond ((eq x (4vt)) (faig-t))
+ ((eq x (4vf)) (faig-f))
+ ((eq x (4vz)) (faig-z))
+ (t (faig-x))))
(local (in-theory (enable 4v-fix)))
@@ -306,7 +308,7 @@
(,fvfn . ,(apply-to-args '4v->faig-const args)))))
(fv-4v-commute 4v-fix faig-const-fix (a))
- (fv-4v-commute 4v-unfloat t-aig-fix (a))
+ (fv-4v-commute 4v-unfloat f-aig-unfloat (a))
(fv-4v-commute 4v-not f-aig-not (a))
(fv-4v-commute 4v-and f-aig-and (a b))
(fv-4v-commute 4v-or f-aig-or (a b))
@@ -314,7 +316,8 @@
(fv-4v-commute 4v-iff f-aig-iff (a b))
(fv-4v-commute 4v-ite f-aig-ite (a b c))
(fv-4v-commute 4v-ite* f-aig-ite* (a b c))
- (fv-4v-commute 4v-tristate t-aig-buf (c a))
+ (fv-4v-commute 4v-zif f-aig-zif (a b c))
+ (fv-4v-commute 4v-tristate t-aig-tristate (c a))
(fv-4v-commute 4v-pullup f-aig-pullup (a))
(fv-4v-commute 4v-res f-aig-res (a b)))
@@ -337,13 +340,13 @@
(let ((look (hons-get x onoff)))
(if (consp (cdr look))
(cdr look)
- *4x*))
- *4x*))
+ (faig-x)))
+ (faig-x)))
(fn (car x))
- ((when (eq fn (4vt))) *4t*)
- ((when (eq fn (4vf))) *4f*)
- ((when (eq fn (4vz))) *4z*)
- ((when (eq fn (4vx))) *4x*)
+ ((when (eq fn (4vt))) (faig-t))
+ ((when (eq fn (4vf))) (faig-f))
+ ((when (eq fn (4vz))) (faig-z))
+ ((when (eq fn (4vx))) (faig-x))
(args (4v-sexpr-to-faig-plain-list (cdr x) onoff))
(arg1 (4v-first args))
(arg2 (4v-second args))
@@ -355,13 +358,14 @@
(iff (f-aig-iff arg1 arg2))
(or (f-aig-or arg1 arg2))
(ite* (f-aig-ite* arg1 arg2 arg3))
- (buf (t-aig-fix arg1))
+ (zif (f-aig-zif arg1 arg2 arg3))
+ (buf (f-aig-unfloat arg1))
(res (f-aig-res arg1 arg2))
- (tristate (t-aig-buf arg1 arg2))
+ (tristate (t-aig-tristate arg1 arg2))
(ite (f-aig-ite arg1 arg2 arg3))
(pullup (f-aig-pullup arg1))
(id (faig-fix arg1))
- (otherwise *4x*))))
+ (otherwise (faig-x)))))
(defun 4v-sexpr-to-faig-plain-list (x onoff)
(declare (xargs :guard t))
@@ -416,6 +420,7 @@
(e/d* ()
(4v->faig-const
nth
+ nth-when-zp
faig-const-fix
faig-const-alist->4v-alist
faig-const->4v
@@ -432,32 +437,36 @@
(local (in-theory (enable* (:ruleset f-aig-defs)
(:ruleset t-aig-defs))))
- (defthm t-aig-not-of-t-aig-fix
- (equal (t-aig-not (t-aig-fix x))
+ (defthm t-aig-not-of-f-aig-unfloat
+ (equal (t-aig-not (f-aig-unfloat x))
(f-aig-not x)))
- (defthm t-aig-and-t-aig-fix
- (equal (t-aig-and (t-aig-fix x) (t-aig-fix y))
+ (defthm t-aig-and-f-aig-unfloat
+ (equal (t-aig-and (f-aig-unfloat x) (f-aig-unfloat y))
(f-aig-and x y)))
- (defthm t-aig-or-t-aig-fix
- (equal (t-aig-or (t-aig-fix x) (t-aig-fix y))
+ (defthm t-aig-or-f-aig-unfloat
+ (equal (t-aig-or (f-aig-unfloat x) (f-aig-unfloat y))
(f-aig-or x y)))
- (defthm t-aig-xor-t-aig-fix
- (equal (t-aig-xor (t-aig-fix x) (t-aig-fix y))
+ (defthm t-aig-xor-f-aig-unfloat
+ (equal (t-aig-xor (f-aig-unfloat x) (f-aig-unfloat y))
(f-aig-xor x y)))
- (defthm t-aig-iff-t-aig-fix
- (equal (t-aig-iff (t-aig-fix x) (t-aig-fix y))
+ (defthm t-aig-iff-f-aig-unfloat
+ (equal (t-aig-iff (f-aig-unfloat x) (f-aig-unfloat y))
(f-aig-iff x y)))
- (defthm t-aig-ite-t-aig-fix
- (equal (t-aig-ite (t-aig-fix c) (t-aig-fix x) (t-aig-fix y))
+ (defthm t-aig-ite-f-aig-unfloat
+ (equal (t-aig-ite (f-aig-unfloat c) (f-aig-unfloat x) (f-aig-unfloat y))
(f-aig-ite c x y)))
- (defthm t-aig-ite*-t-aig-fix
- (equal (t-aig-ite* (t-aig-fix c) (t-aig-fix x) (t-aig-fix y))
+ (defthm t-aig-ite*-unfloat-is-f-aig-zif-unfloat
+ (equal (t-aig-ite* (f-aig-unfloat c) x y)
+ (f-aig-zif c x y)))
+
+ (defthm t-aig-ite*-f-aig-unfloat
+ (equal (f-aig-zif c (f-aig-unfloat x) (f-aig-unfloat y))
(f-aig-ite* c x y)))))
@@ -469,48 +478,48 @@
-(defsection maybe-t-aig-fix
+(defsection maybe-f-aig-unfloat
- (defund maybe-t-aig-fix (sexpr faig)
+ (defund maybe-f-aig-unfloat (sexpr faig)
(declare (xargs :guard t))
(if (3v-syntax-sexprp sexpr)
faig
- (t-aig-fix faig)))
+ (f-aig-unfloat faig)))
- (local (in-theory (enable maybe-t-aig-fix)))
+ (local (in-theory (enable maybe-f-aig-unfloat)))
- (defthm faig-eval-maybe-t-aig-fix
+ (defthm faig-eval-maybe-f-aig-unfloat
(implies (equal (faig-eval x fenv)
(4v->faig-const (4v-sexpr-eval sexpr senv)))
- (equal (faig-eval (maybe-t-aig-fix sexpr x) fenv)
- (faig-eval (t-aig-fix x) fenv)))))
+ (equal (faig-eval (maybe-f-aig-unfloat sexpr x) fenv)
+ (faig-eval (f-aig-unfloat x) fenv)))))
-(defsection maybe-t-aig-fix-list
+(defsection maybe-f-aig-unfloat-list
- (defun maybe-t-aig-fix-list (sexprs faigs)
+ (defun maybe-f-aig-unfloat-list (sexprs faigs)
(declare (xargs :guard (equal (len sexprs) (len faigs))))
(if (atom sexprs)
nil
- (cons (maybe-t-aig-fix (car sexprs) (car faigs))
- (maybe-t-aig-fix-list (cdr sexprs) (cdr faigs)))))
+ (cons (maybe-f-aig-unfloat (car sexprs) (car faigs))
+ (maybe-f-aig-unfloat-list (cdr sexprs) (cdr faigs)))))
- (defthm nth-maybe-t-aig-fix-list
+ (defthm nth-maybe-f-aig-unfloat-list
(implies (equal (len x) (len sexprs))
- (equal (faig-fix (nth n (maybe-t-aig-fix-list sexprs x)))
- (faig-fix (maybe-t-aig-fix (nth n sexprs) (nth n x)))))
+ (equal (faig-fix (nth n (maybe-f-aig-unfloat-list sexprs x)))
+ (faig-fix (maybe-f-aig-unfloat (nth n sexprs) (nth n x)))))
:hints(("Goal"
:induct (nth-both-ind n sexprs x)
- :expand ((maybe-t-aig-fix-list sexprs x)))))
+ :expand ((maybe-f-aig-unfloat-list sexprs x)))))
- (defthm nth-maybe-t-aig-fix-list-faig-equiv
+ (defthm nth-maybe-f-aig-unfloat-list-faig-equiv
(implies (equal (len x) (len sexprs))
- (faig-equiv (nth n (maybe-t-aig-fix-list sexprs x))
- (maybe-t-aig-fix (nth n sexprs) (nth n x))))
+ (faig-equiv (nth n (maybe-f-aig-unfloat-list sexprs x))
+ (maybe-f-aig-unfloat (nth n sexprs) (nth n x))))
:hints(("Goal"
:induct (nth-both-ind n sexprs x)
- :expand ((maybe-t-aig-fix-list sexprs x))))))
+ :expand ((maybe-f-aig-unfloat-list sexprs x))))))
@@ -528,23 +537,30 @@
(let ((look (hons-get x onoff)))
(if (consp (cdr look))
(cdr look)
- *4x*))
- *4x*))
+ (faig-x)))
+ (faig-x)))
(fn (car x))
- ((when (eq fn (4vt))) *4t*)
- ((when (eq fn (4vf))) *4f*)
- ((when (eq fn (4vz))) *4z*)
- ((when (eq fn (4vx))) *4x*)
+ ((when (eq fn (4vt))) (faig-t))
+ ((when (eq fn (4vf))) (faig-f))
+ ((when (eq fn (4vz))) (faig-z))
+ ((when (eq fn (4vx))) (faig-x))
(sargs (cdr x))
(args (4v-sexpr-to-faig-opt-list sargs onoff))
;; There are a few functions where we don't really get any benefit from
;; knowing the args are three-valued:
((when (eq fn 'id)) (faig-fix (4v-first args))) ;; bozo why??
((when (eq fn 'res)) (f-aig-res (4v-first args) (4v-second args)))
- ((when (eq fn 'tristate)) (t-aig-buf (4v-first args) (4v-second args)))
+ ((when (eq fn 'tristate)) (t-aig-tristate (4v-first args) (4v-second args)))
((when (eq fn 'pullup)) (f-aig-pullup (4v-first args)))
+ ((when (eq fn 'zif))
+ (t-aig-ite* (maybe-f-aig-unfloat
+ (mbe :logic (first sargs)
+ :exec (and (consp sargs) (car sargs)))
+ (4v-first args))
+ (4v-second args)
+ (4v-third args)))
;; Otherwise, fixup only those subexpressions that might produce Zs
- (args (maybe-t-aig-fix-list (cdr x) args))
+ (args (maybe-f-aig-unfloat-list sargs args))
(arg1 (4v-first args))
(arg2 (4v-second args))
(arg3 (4v-third args)))
@@ -557,7 +573,7 @@
(or (t-aig-or arg1 arg2))
(buf (faig-fix arg1))
(ite (t-aig-ite arg1 arg2 arg3))
- (otherwise *4x*))))
+ (otherwise (faig-x)))))
(defun 4v-sexpr-to-faig-opt-list (x onoff)
(declare (xargs :guard t))
(if (atom x)
@@ -605,36 +621,36 @@
- (local (defthm faig-eval-maybe-t-aig-fix-rw
+ (local (defthm faig-eval-maybe-f-aig-unfloat-rw
(let ((4v-env (faig-const-alist->4v-alist (faig-eval-alist al fenv))))
(implies (and (bind-free '((al . al)) (al))
(equal (faig-eval x fenv)
(4v->faig-const (4v-sexpr-eval sexpr 4v-env))))
- (equal (faig-eval (maybe-t-aig-fix sexpr x) fenv)
- (faig-eval (t-aig-fix x) fenv))))
- :hints(("Goal" :in-theory (enable maybe-t-aig-fix)))))
+ (equal (faig-eval (maybe-f-aig-unfloat sexpr x) fenv)
+ (faig-eval (f-aig-unfloat x) fenv))))
+ :hints(("Goal" :in-theory (enable maybe-f-aig-unfloat)))))
- (local (defthm faig-eval-maybe-t-aig-fix-rw1
+ (local (defthm faig-eval-maybe-f-aig-unfloat-rw1
(let ((4v-env (faig-const-alist->4v-alist (faig-eval-alist al fenv))))
(implies
(and (bind-free '((al . al)) (al))
(equal (faig-eval-list x fenv)
(4v-list->faig-const-list (4v-sexpr-eval-list sexprs 4v-env))))
- (equal (faig-eval (maybe-t-aig-fix (nth n sexprs) (nth n x)) fenv)
- (faig-eval (t-aig-fix (nth n x)) fenv))))
+ (equal (faig-eval (maybe-f-aig-unfloat (nth n sexprs) (nth n x)) fenv)
+ (faig-eval (f-aig-unfloat (nth n x)) fenv))))
:hints(("Goal"
- :in-theory (disable* maybe-t-aig-fix)
+ :in-theory (disable* maybe-f-aig-unfloat)
:expand ((faig-eval-list x fenv)
(:free (a) (4v-sexpr-eval-list sexprs a))
(:free (a b) (4v-list->faig-const-list (cons a b))))
:induct (nth-both-ind n sexprs x)))))
- (local (defthm faig-eval-nth-maybe-t-aig-fix-list
+ (local (defthm faig-eval-nth-maybe-f-aig-unfloat-list
(implies (and (equal (faig-eval (nth n x) fenv)
(4v->faig-const (4v-sexpr-eval (nth n sexprs) senv)))
(equal (len x) (len sexprs)))
- (equal (faig-eval (nth n (maybe-t-aig-fix-list sexprs x)) fenv)
- (faig-eval (t-aig-fix (nth n x)) fenv)))
+ (equal (faig-eval (nth n (maybe-f-aig-unfloat-list sexprs x)) fenv)
+ (faig-eval (f-aig-unfloat (nth n x)) fenv)))
:hints(("Goal" :in-theory (disable* 4v->faig-const)))))
(defthm-4v-sexpr-flag
@@ -654,7 +670,7 @@
faig-const-fix
faig-const-alist->4v-alist
faig-const->4v
- maybe-t-aig-fix
+ maybe-f-aig-unfloat
)))
(and stable-under-simplificationp
'(:expand ((4v-sexpr-to-faig-opt-list (cdr x) al)))))))
diff -Nru acl2-6.2/books/centaur/4v-sexpr/sexpr-vars-1pass.lisp acl2-6.3/books/centaur/4v-sexpr/sexpr-vars-1pass.lisp
--- acl2-6.2/books/centaur/4v-sexpr/sexpr-vars-1pass.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/sexpr-vars-1pass.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -25,6 +25,7 @@
(in-package "ACL2")
(include-book "sexpr-vars")
+(local (include-book "std/lists/sets" :dir :system))
(defsection 4v-sexpr-vars-1pass
:parents (4v-sexpr-vars)
@@ -102,33 +103,31 @@
:flag-mapping ((4v-sexpr-vars-1pass-exec . sexpr)
(4v-sexpr-vars-1pass-list-exec . list))))
-(local (defthm hons-assoc-equal-under-iff
- (iff (hons-assoc-equal k al)
- (member k (alist-keys al)))))
-
-(local (in-theory (disable alist-keys-member-hons-assoc-equal)))
-
-(local (defthm member-by-subset
- (and (implies (and (subsetp-equal x y)
- (member-equal a x))
- (member-equal a y))
- (implies (and (member-equal a x)
- (subsetp-equal x y))
- (member-equal a y)))))
-
-(local (defthm subset-transitive
- (and (implies (and (subsetp-equal x y)
- (subsetp-equal y z))
- (subsetp-equal x z))
- (implies (and (subsetp-equal y z)
- (subsetp-equal x y))
- (subsetp-equal x z)))))
+(local (in-theory (e/d (hons-assoc-equal-iff-member-alist-keys)
+ (alist-keys-member-hons-assoc-equal))))
+
+;; (local (defthm member-by-subset
+;; (and (implies (and (subsetp-equal x y)
+;; (member-equal a x))
+;; (member-equal a y))
+;; (implies (and (member-equal a x)
+;; (subsetp-equal x y))
+;; (member-equal a y)))))
+
+;; (local (defthm subset-transitive
+;; (and (implies (and (subsetp-equal x y)
+;; (subsetp-equal y z))
+;; (subsetp-equal x z))
+;; (implies (and (subsetp-equal y z)
+;; (subsetp-equal x y))
+;; (subsetp-equal x z)))))
(local (defthm helper-1
;; this works out because if x is an atom, then its sexpr-vars are just itself
(implies (and (member-equal x (alist-keys seen))
(not (consp x))
- x)
+ x
+ )
(member-equal x (4v-sexpr-vars-list (alist-keys seen))))
:hints(("goal" :induct (len seen)))))
@@ -143,6 +142,12 @@
(4v-sexpr-vars-list (alist-keys seen))))
:hints(("goal" :induct (len seen)))))
+(local (defthm helper-4
+ (implies (member-equal a x)
+ (subsetp-equal (4v-sexpr-vars a)
+ (4v-sexpr-vars-list x)))
+ :hints(("Goal" :in-theory (enable member-equal)))))
+
(local (defthm-flag-4v-sexpr-vars-1pass-exec
(defthm seen-has-correct-vars-sexpr
(b* (((mv new-seen &) (4v-sexpr-vars-1pass-exec x seen vars)))
diff -Nru acl2-6.2/books/centaur/4v-sexpr/svarmap.lisp acl2-6.3/books/centaur/4v-sexpr/svarmap.lisp
--- acl2-6.2/books/centaur/4v-sexpr/svarmap.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/svarmap.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -26,7 +26,8 @@
; [Jared] After consideration, we think this is the right book to use; the FAIG
; monotonicity stuff was just too hard and should eventually be scrapped.
-(include-book "centaur/aig/base" :dir :system)
+(include-book "centaur/aig/aig-base" :dir :system)
+(include-book "centaur/aig/faig-base" :dir :system)
(include-book "centaur/misc/fast-alists" :dir :system)
(include-book "centaur/misc/hons-sets" :dir :system)
(local (include-book "data-structures/no-duplicates" :dir :system))
diff -Nru acl2-6.2/books/centaur/4v-sexpr/top.lisp acl2-6.3/books/centaur/4v-sexpr/top.lisp
--- acl2-6.2/books/centaur/4v-sexpr/top.lisp 2013-06-06 17:11:44.000000000 +0000
+++ acl2-6.3/books/centaur/4v-sexpr/top.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -47,7 +47,9 @@
(defxdoc 4v
- :short "Centaur four-valued logic library."
+ :parents (boolean-reasoning)
+ :short "An @(see hons)-based, s-expression representation of monotonic , four-valued functions."
:long "This library defines the logic of the @(see esim) symbolic
simulator. By \"four-valued\", we mean that each wire can take one of the four
@@ -176,8 +178,8 @@
operations are monotonic ,
monotonicity is an intrinsic property of every sexpr.
-As with our @(see aig) and @(see ubdd) representations, we generally expect
-to create all sexprs with @(see hons), and we often @(see memoize) operations
-that deal with sexprs. We provide some @(see 4vs-constructors) for building
-s-expressions.
")
+As with our @(see aig) and ubdd
+representations, we generally expect to create all sexprs with @(see hons), and
+we often @(see memoize) operations that deal with sexprs. We provide some
+@(see 4vs-constructors) for building s-expressions.
")
diff -Nru acl2-6.2/books/centaur/README.html acl2-6.3/books/centaur/README.html
--- acl2-6.2/books/centaur/README.html 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/README.html 2013-09-30 17:53:15.000000000 +0000
@@ -73,7 +73,7 @@
processors for our parent company, VIA
Technologies . We have used these books to prove correctness properties of
several execution units, and to develop other tools such as an equivalence
-checker, a linter, etc.
+checker, a linter, etc.
Prerequisites
@@ -86,23 +86,26 @@
Recommended Hardware
-You probably want at least a dual-core machine with 8 GB of
-memory.
-
-You might even want more memory than this. Having ample memory is
-especially important when you want to carry out proofs using BDDs. Many of our
-real hardware proofs are made faster (or possible) by having 32 or more GB of
-memory. Even things like our Verilog parser are written in a memory-hungry way
-because that's just the kind of environment we work in.
-
-Having additional cores is very useful for certifying books in parallel.
+You will at least want a fast dual-core machine with 8 GB of
+memory. Having additional cores is very useful for quickly re-certifying books
+in parallel, but careful here: with more cores you'll need even more memory to
+avoid swapping death. A good target might be at least
+4 GB per core .
+
+We used to recommend even more memory than this. Ample memory was
+especially important when we carried out large proofs using BDDs, but these
+days we often use SAT instead, and SAT is far less memory intensive. Even so,
+today many of our real hardware proofs are made faster (or possible) by having
+32 or more GB of memory. Also, many of our tools, e.g., our Verilog parser,
+are written in a memory-hungry way because that's just the kind of environment
+we work in.
Recommended Operating System
-We use 64-bit Linux . It might be possible to use Darwin or BSD or
-other unixes instead, but Linux is the main platform. You will need the
-typical tools like perl, make, etc.
+We use 64-bit Linux . Other unix derivatives like Darwin, FreeBSD,
+etc., might work reasonably well, but Linux is our main platform. Windows
+probably won't work. You will need ordinary tools like perl, make, etc.
Clozure Common Lisp Configuration
@@ -112,9 +115,10 @@
We usually use a fairly recent SVN snapshot.
-We use ccl-config.lsp to do some extra
-configuration that increases the stack sizes and tunes the garbage
-collector for better performance.
+CCL Configuration before building ACL2: We
+use ccl-config.lsp to do some extra configuration
+that increases the stack sizes and tunes the garbage collector for better
+performance.
We configure our PATH so that we can launch CCL by
typing ccl .
@@ -124,26 +128,30 @@
You will need to
build ACL2 with Hons
-enabled. The recommended way to build is with:
+enabled. The recommended way to build is, with:
-make LISP=ccl ACL2_HONS=h ACL2_SIZE=3000000
+
+$ # rebuild ccl using ccl-config.lsp
+$ cd [...]/acl2/
+$ make LISP=ccl ACL2_HONS=h ACL2_SIZE=3000000
+
-Using a large ACL2_SIZE can help avoid performance problems due to
+Using a large ACL2_SIZE can help avoid performance problems due to
filling up the ACL2 package with too many symbols.
-We generally configure our PATH so that we can launch ACL2(h) by
+We configure our PATH so that we can launch ACL2(h) by
typing acl2 .
cert.pl Configuration
-We use cert.pl instead of Makefiles. This script is located in
-the acl2/books directory. We recommend that you configure
+We generally use cert.pl to certify books. This script is located
+in the acl2/books directory. We recommend that you configure
your PATH so you can invoke it by just typing cert.pl .
+ (Optional) GTKWave Configuration
-
-GTKWave Configuration (Optional)
+You can skip this if you aren't doing hardware verification.
We often use GTKWave for
debugging waveforms. Other VCD file viewers may also work.
@@ -151,47 +159,66 @@
We configure our PATH so that we can run GTKWave by
typing gtkwave .
-
+(Optional) Glucose Configuration
-Building the Centaur Books
+We often use the Glucose
+Sat Solver.
-Once you have all the above prerequisites, you will be ready to certify the
-Centaur books. There are two steps:
+We configure out PATH so that we can run Glucose (sometimes called
+glucose.sh ) by typing glucose .
-1. Build the Quicklisp book. This is special because it has to go download
-Quicklisp and run its setup.
-
-cd [...]/acl2/books/centaur/quicklisp
-make
-
+(Optional) Lingeling Configuration
+
+We sometimes use the Lingeling
+Sat Solver.
-2. Build the rest of the books and all available documentation:
+We configure our path so that we can run the Lingeling executable by
+typing lingeling .
+
+
+
+
+Building the Books
+
+Once you have the above prerequisites, you will be ready to certify the ACL2
+books. The preferred command to do this is:
-cd [...]/acl2/books/centaur
-cert.pl doc.lisp -j 4 # -j 4 for a quad-core processor
+$ # get ccl, reconfigure it, build acl2, set up your path as explained above.
+$ cd [...]/acl2/books/
+$ make USE_QUICKLISP=1 -j 4 # -j 4 for a quad-core processor
-Depending on your hardware this may take ten minutes up to hours.
+The USE_QUICKLISP=1 instructs make to download and install
+Quicklisp , which is sort of a Common
+Lisp equivalent to CPAN for Perl, RubyGems for Ruby, etc. This is necessary
+for certain books.
+
+Depending on your hardware this may take ten minutes up to hours. For
+reference, it takes about an hour on an 8-core AMD-FX8350 with 32 GB of memory
+running FreeBSD, using -j 8.
Next Steps
-The cert.pl command above should produce a reference manual
-with documentation for the Centaur books. The manual also has all of the
-regular documentation for ACL2 and also for several other libraries that we
-use, e.g., str, osets, ihs, etc.
+After building the books with the make command above, you should
+obtain an XDOC Manual with documentation for the Centaur books, and also
+has the regular documentation for ACL2 and other Community Books like str,
+osets, ihs, etc.
To view the manual, point your web browser
-at books/centaur/manual/preview.html . (Note:
-this will be a broken link until you generate the manual.) You can also build
-an HTML version of the manual that may render faster, see the documentation for
-XDOC for more information.
-
-There is also a very preliminary tutorial that walks through the
-verification of a trivial ALU module. To get started, see:
+at manual/index.html —this link will be
+broken until you generate the manual. (We also keep
+a public copy of the
+manual on our web site, but we only update it at each ACL2 release, so it's
+generally best to use a local copy that matches your specific version of the
+books.)
+
+If you are specifically interested in hardware verification, there is also a
+preliminary tutorial that walks through the verification of a trivial
+ALU module. To get started, see:
books/centaur/tutorial/intro.lisp
@@ -209,7 +236,7 @@
License Information
-Copyright © 2008-2012 Centaur Technology and others
+
Copyright © 2008-2013 Centaur Technology and others
(see ** )
@@ -236,10 +263,10 @@
under the GPL "2 or later." Most are copyright by Centaur Technology, but some
are copyrights of others, e.g., the books in ubdds/ are copyright by Bob Boyer
and Warren Hunt; see the individual headers on each file for more information.
-Also note that many books here depend on other ACL2 libraries, each of which
-are copyright by their respective owners. To the best of our knowledge, we
-believe all libraries we include are also licensed under the GPL "2 or later"
-or compatible licenses.
+Many of these books also depend on other ACL2 libraries that are copyright by
+their respective owners. To the best of our knowledge, we believe all
+libraries we include are also licensed under the GPL "2 or later" or compatible
+licenses.
diff -Nru acl2-6.2/books/centaur/acl2-customization.lsp acl2-6.3/books/centaur/acl2-customization.lsp
--- acl2-6.2/books/centaur/acl2-customization.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/acl2-customization.lsp 2013-09-30 17:53:15.000000000 +0000
@@ -0,0 +1,29 @@
+; Centaur Books ACL2 Customization File
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+#!ACL2
+(in-package "ACL2")
+
+(assign :suppress-preload-xdoc t)
+(ld "~/acl2-customization.lsp" :ld-missing-input-ok t)
+
+
+
+
diff -Nru acl2-6.2/books/centaur/aig/acl2-customization.lsp acl2-6.3/books/centaur/aig/acl2-customization.lsp
--- acl2-6.2/books/centaur/aig/acl2-customization.lsp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/acl2-customization.lsp 2013-09-30 17:53:11.000000000 +0000
@@ -18,4 +18,5 @@
;
; Original author: Sol Swords
-(set-inhibit-warnings "theory" "disable")
\ No newline at end of file
+(set-inhibit-warnings "theory" "disable")
+(ld "~/acl2-customization.lsp" :ld-missing-input-ok t)
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/aig/aig-base.lisp acl2-6.3/books/centaur/aig/aig-base.lisp
--- acl2-6.2/books/centaur/aig/aig-base.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/aig/aig-base.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,804 @@
+; Centaur AIG Library
+; Copyright (C) 2008-2011 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+;
+; July 2011, Jared added lots of documentation.
+
+(in-package "ACL2")
+(include-book "cutil/define" :dir :system)
+(include-book "../misc/hons-alphorder-merge")
+
+; aig-base.lisp
+; - Semantics of AIGs (aig-eval)
+; - Primitive AIG constructors (aig-not, aig-and, ...)
+; - Substitution operations: aig-restrict, aig-compose, aig-partial-eval
+
+; BOZO consider using defprojection throughout?
+
+(defsection aig-cases
+ :parents (aig-other)
+ :short "Control-flow macro to split into cases on what kind of AIG you have
+encountered."
+ :long "@(def aig-cases)"
+
+ (defmacro aig-cases (x &key true false var inv and)
+ `(let ((aig-cases-var ,x))
+ (cond
+ ((atom aig-cases-var)
+ (cond ((eq aig-cases-var t) ,true)
+ ((eq aig-cases-var nil) ,false)
+ (t ,var)))
+ ((eq (cdr aig-cases-var) nil) ,inv)
+ (t ,and)))))
+
+
+; -----------------------------------------------------------------------------
+;
+; EVALUATING AIGS
+;
+; -----------------------------------------------------------------------------
+
+(defsection aig-env-lookup-missing-output
+ :parents (aig-eval)
+ :short "Stub for warnings about missing variables in AIG evaluation."
+
+ :long "This stub is called when @(see aig-eval) encounters a variable in
+the AIG that has no binding in the environment. It is generally configured
+with @(see aig-env-lookup-missing-action).
"
+
+ (defstub aig-env-lookup-missing-output (name) nil))
+
+
+(defsection aig-env-lookup-missing-action
+ :parents (aig-eval)
+ :short "Configurable warnings about missing variables in AIG evaluation."
+
+ :long "Ordinarily @(see aig-eval) treats any variables that are not bound
+in the environment as having value @('t'). But a missing bindings could be the
+result of a bug in your program, so by default @('aig-eval') is set up to print
+a warning if this happens.
+
+@(call aig-env-lookup-missing-action) allows you to control whether these
+warnings are printed, and also whether @(see break$) should be called. The
+valid @('action')s are:
+
+
+ @('nil'), silently bind the variable to @('t'),
+ @(':warn') (the default), print a warning but do not @('break$'), and
+ @(':break'), to print the warning and then call @('break$').
+ "
+
+ (defconst *aig-env-lookup-warn-missing-binding*
+ ;; Even with the stub and defattach, it is useful to have this "constant"
+ ;; so that, in raw lisp, we can use a let-binding to disable missing output
+ ;; warnings temporarily, e.g., so that if a SAT solver produces an
+ ;; incomplete counterexample, we don't print warnings when we check it.
+ ;; Doing this with defattach directly would be hard/impossible due to
+ ;; attachment being an event.
+ t)
+
+ (defun aig-env-lookup-missing-quiet (name)
+ (declare (xargs :guard t) (ignore name))
+ nil)
+
+ (defun aig-env-lookup-missing-complain (name)
+ (declare (xargs :guard t))
+ (and *aig-env-lookup-warn-missing-binding*
+ (cw "WARNING: Missing variable binding ~x0 in AIG-ENV-LOOKUP; ~
+ assigning T~%"
+ name)))
+
+ (local (in-theory (disable (break$))))
+
+ (defun aig-env-lookup-missing-break (name)
+ (declare (xargs :guard t))
+ (and *aig-env-lookup-warn-missing-binding*
+ (prog2$ (cw "WARNING: Missing variable binding ~x0 in ~x1; assigning ~
+ T. To avoid this break, run ~x2, where action is NIL or ~
+ :WARN.~%"
+ name
+ 'aig-env-lookup
+ '(aig-env-lookup-missing-action action))
+ (break$))))
+
+ (defmacro aig-env-lookup-missing-action (val)
+ (case val
+ ((nil) '(defattach aig-env-lookup-missing-output
+ aig-env-lookup-missing-quiet))
+ (:warn '(defattach aig-env-lookup-missing-output
+ aig-env-lookup-missing-complain))
+ (:break '(defattach aig-env-lookup-missing-output
+ aig-env-lookup-missing-break))
+ (t (er hard 'aig-env-lookup-missing-action
+ "Expected argument NIL, :WARN, or :BREAK.~%"))))
+
+ (aig-env-lookup-missing-action :warn))
+
+
+(define aig-env-lookup
+ :parents (aig-eval)
+ :short "Look up the value of an AIG variable in an environment."
+
+ ((x "Variable to look up.")
+ (env "Fast alist mapping variables to values."))
+
+ :long "Unbound variables are given the default value @('t') instead of
+@('nil') because this makes theorems about @(see faig) evaluation work out more
+nicely (it makes unbound FAIG variables evaluate to @('X')).
+
+Jared was once tempted to change this to produce an always Boolean
+result, since it would seem nicer to do that here than in @(see aig-eval). But
+this function is also used in @(see aig-compose), and it is not valid to
+Boolean-fix it there.
"
+
+ :enabled t
+
+ (let ((look (hons-get x env)))
+ (if look
+ (cdr look)
+ (mbe :logic t
+ :exec
+ (if *aig-env-lookup-warn-missing-binding*
+ (prog2$ (aig-env-lookup-missing-output x)
+ t)
+ t)))))
+
+
+(define aig-eval
+ :parents (aig-semantics)
+ :short "@(call aig-eval) gives the semantics of @(see AIG)s: it gives the
+Boolean value of the AIG @('x') under the environment @('env')."
+
+ ((x "The AIG to evaluate.")
+ (env "A fast alist that binds variables to values. Typically it should bind
+every variable in @('x') to some Boolean value. When this isn't the case,
+variables are assigned the default value @('t'); see @(see aig-env-lookup)."))
+
+ :long "This function is @(see memoize)d. You should typically free its
+memo table after you are done with whatever @('env') you are using, to avoid
+excessive memory usage. (We don't use @(':forget t') because you often want to
+evaluate several related AIGs.)
"
+
+ :enabled t
+
+ (aig-cases x
+ :true t
+ :false nil
+ :var (and (aig-env-lookup x env) t)
+ :inv (not (aig-eval (car x) env))
+ :and (and (aig-eval (car x) env)
+ (aig-eval (cdr x) env)))
+
+ ///
+ (memoize 'aig-eval :condition '(and (consp x) (cdr x))))
+
+(define aig-eval-list
+ :parents (aig-semantics)
+ :short "@(call aig-eval-list) evaluates a list of AIGs."
+ ((x "The AIG list to evaluate.")
+ (env "The environment to use; see @(see aig-eval)."))
+ :returns
+ (vals "A list of Boolean values; the evaluations of each AIG under this
+ environment.")
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (aig-eval (car x) env)
+ (aig-eval-list (cdr x) env))))
+
+(define aig-eval-alist
+ :parents (aig-semantics)
+ :short "@(call aig-eval-alist) evaluates an AIG Alist (an alist binding keys
+to AIGs)."
+ ((x "The AIG alist to evaluate. This does not need to be a fast alist.")
+ (env "The environment to use; see @(see aig-eval)."))
+ :returns
+ (vals-alist "An ordinary (slow) alist that binds the same keys to the values
+ of their associated AIGs.")
+ :enabled t
+ (cond ((atom x)
+ nil)
+ ((atom (car x))
+ ;; Bad-alist convention
+ (aig-eval-alist (cdr x) env))
+ (t
+ (cons (cons (caar x) (aig-eval (cdar x) env))
+ (aig-eval-alist (cdr x) env))))
+ ///
+ (defthm hons-assoc-equal-aig-eval-alist
+ (equal (hons-assoc-equal key (aig-eval-alist x env))
+ (and (hons-assoc-equal key x)
+ (cons key
+ (aig-eval (cdr (hons-assoc-equal key x)) env))))
+ :hints(("Goal" :induct t))))
+
+(define aig-eval-alists
+ :parents (aig-semantics)
+ :short "Evaluate a list of AIG Alists."
+ ((x "List of AIG Alists to evaluate.")
+ (env "The environment to use; see @(see aig-eval)."))
+ :returns
+ (vals-alists "A copy of @('x'), except that each AIG has been replaced with
+ its value.")
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (aig-eval-alist (car x) env)
+ (aig-eval-alists (cdr x) env))))
+
+
+
+
+; -----------------------------------------------------------------------------
+;
+; COLLECTING AIG VARIABLES
+;
+; -----------------------------------------------------------------------------
+
+(define aig-vars (x)
+ :parents (aig)
+ :short "@(call aig-vars) returns the variables of the AIG @('X')."
+ :returns (vars "An ordered set of AIG variables (atoms).")
+
+ :long "Note: variable collection can be surprisingly tricky to do
+efficiently. For a good background discussion that describes various
+approaches to the problem and ways to avoid needing to collect variables, see
+@(see 4v-sexpr-vars).
+
+@('aig-vars') is a slow but simple way to collect the variables that occur
+within an AIG, and we adopt it as our normal form for talking about the
+variables of an AIG. That is, when we introduce other, faster algorithms for
+collecting variables, we always relate them back to @('aig-vars').
+
+The variable collection strategy used by @('aig-vars') is to memoize the
+whole computation; this implicitly records, for every AND node, the exact set
+of variables that are found under that node. We use ordinary @(see osets) as
+our variable set representation so that merging these sets is linear at each
+node. The overall complexity is then @('O(n^2)') in the size of the AIG.
+
+This approach records the full variable information for every AND node
+throughout the AIG. This takes a lot of memory, and often you do not need
+nearly this much information. In practice, functions like @(see
+aig-vars-1pass) are often much more practical.
"
+
+ :verify-guards nil
+ :enabled t
+ (aig-cases x
+ :true nil
+ :false nil
+ :var (mbe :logic (sets::insert x nil)
+ :exec (hons x nil))
+ :inv (aig-vars (car x))
+ :and (mbe :logic (sets::union (aig-vars (car x))
+ (aig-vars (cdr x)))
+ :exec (hons-alphorder-merge (aig-vars (car x))
+ (aig-vars (cdr x)))))
+ ///
+ (defthm atom-listp-aig-vars
+ (atom-listp (aig-vars x)))
+
+ (defthm true-listp-aig-vars
+ (true-listp (aig-vars x))
+ :rule-classes :type-prescription)
+
+ (defthm setp-aig-vars
+ (sets::setp (aig-vars x))
+ :hints(("Goal" :in-theory (enable* (:ruleset sets::primitive-rules)))))
+
+ (verify-guards aig-vars
+ :hints(("Goal" :in-theory (enable* (:ruleset sets::primitive-rules)))))
+
+ (memoize 'aig-vars :condition '(and (consp x) (cdr x))))
+
+
+
+
+; -----------------------------------------------------------------------------
+;
+; AIG CONSTRUCTION
+;
+; -----------------------------------------------------------------------------
+
+(define aig-not (x)
+ :parents (aig-constructors)
+ :short "@(call aig-not) constructs an AIG representing @('(not x)')."
+ :long "This could be implemented as @('(hons x nil)'), but we at least
+take care to fold constants and avoid creating double negatives.
"
+ :returns aig
+ (cond ((eq x nil) t)
+ ((eq x t) nil)
+ ((and (consp x) (eq (cdr x) nil))
+ (car x))
+ (t
+ (hons x nil)))
+ ///
+ (defthm aig-eval-not
+ (equal (aig-eval (aig-not x) env)
+ (not (aig-eval x env)))))
+
+(define aig-and (x y)
+ :parents (aig-constructors)
+ :short "@(call aig-and) constructs an AIG representing @('(and x y)')."
+ :long "This could have been implemented as @('(hons x y)'), but we take
+care to fold constants and reduce @('x & x') and @('x & ~x').
"
+ :returns aig
+ (cond ((or (eq x nil) (eq y nil)) nil)
+ ((eq x t) y)
+ ((eq y t) x)
+ ((hons-equal x y) x)
+ ((and (consp y) (eq (cdr y) nil)
+ (hons-equal (car y) x))
+ nil)
+ ((and (consp x) (eq (cdr x) nil)
+ (hons-equal (car x) y))
+ nil)
+ (t (hons x y)))
+ ///
+ (defthm aig-eval-and
+ (equal (aig-eval (aig-and x y) env)
+ (and (aig-eval x env)
+ (aig-eval y env))))
+ (defthm aig-and-constants
+ (and (equal (aig-and nil x) nil)
+ (equal (aig-and x nil) nil)
+ (equal (aig-and x t) x)
+ (equal (aig-and t x) x))))
+
+(define aig-or (x y)
+ :parents (aig-constructors)
+ :short "@(call aig-or) constructs an AIG representing @('(or x y)')."
+ :returns aig
+ (aig-not (aig-and (aig-not x) (aig-not y)))
+ ///
+ (defthm aig-eval-or
+ (equal (aig-eval (aig-or x y) env)
+ (or (aig-eval x env)
+ (aig-eval y env)))))
+
+(define aig-xor (x y)
+ :parents (aig-constructors)
+ :short "@(call aig-xor) constructs an AIG representing @('(xor x y)')."
+ :returns aig
+ (aig-or (aig-and x (aig-not y))
+ (aig-and (aig-not x) y))
+ ///
+ (defthm aig-eval-xor
+ (equal (aig-eval (aig-xor x y) env)
+ (xor (aig-eval x env)
+ (aig-eval y env)))))
+
+(define aig-iff (x y)
+ :parents (aig-constructors)
+ :short "@(call aig-iff) constructs an AIG representing @('(iff x y)')."
+ :returns aig
+ (aig-or (aig-and x y)
+ (aig-and (aig-not x) (aig-not y)))
+ ///
+ (defthm aig-eval-iff
+ (equal (aig-eval (aig-iff x y) env)
+ (iff (aig-eval x env)
+ (aig-eval y env)))))
+
+(define aig-implies (x y)
+ :parents (aig-constructors)
+ :short "@(call aig-implies) constructs an AIG representing @('(implies x
+ y)')."
+ :returns aig
+ (aig-not (aig-and x (aig-not y)))
+ ///
+ (defthm aig-eval-implies
+ (equal (aig-eval (aig-implies x y) env)
+ (implies (aig-eval x env)
+ (aig-eval y env)))))
+
+(define aig-ite (a b c)
+ :parents (aig-constructors)
+ :short "@(call aig-ite) constructs an AIG representing @('(if a b c)')."
+ :returns aig
+ (cond ((hons-equal b c)
+ b)
+ ((eq b t)
+ (aig-or a c))
+ (t
+ (aig-or (aig-and a b)
+ (aig-and (aig-not a) c))))
+ ///
+ (defthm aig-eval-ite
+ (iff (aig-eval (aig-ite a b c) env)
+ (if (aig-eval a env)
+ (aig-eval b env)
+ (aig-eval c env)))))
+
+(define aig-not-list (x)
+ :parents (aig-constructors)
+ :short "@(call aig-not-list) negates every AIG in the list @('x')."
+ :returns aig-list
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (aig-not (car X))
+ (aig-not-list (cdr x)))))
+
+(define aig-and-list (x)
+ :parents (aig-constructors)
+ :short "@(call aig-and-list) and s together all of the AIGs in the list
+@('x')."
+ :returns aig
+ :enabled t
+ (if (atom x)
+ t
+ (aig-and (car x)
+ (aig-and-list (cdr x)))))
+
+(define aig-or-list (x)
+ :parents (aig-constructors)
+ :short "@(call aig-or-list) or s together all of the AIGs in the list
+@('x')."
+ :returns aig
+ :enabled t
+ (if (atom x)
+ nil
+ (aig-or (car x) (aig-or-list (cdr x)))))
+
+(define aig-and-lists (x y)
+ :parents (aig-constructors)
+ :short "@(call aig-and-lists) pairwise and s together the AIGs from the
+lists @('x') and @('y')."
+ :returns aig-list
+ :enabled t
+ (if (or (atom x) (atom y))
+ nil
+ (cons (aig-and (car x) (car y))
+ (aig-and-lists (cdr x) (cdr y)))))
+
+(define aig-or-lists (x y)
+ :parents (aig-constructors)
+ :short "@(call aig-or-lists) pairwise or s together the AIGs from the
+lists @('x') and @('y')."
+ :returns aig-list
+ :enabled t
+ (if (or (atom x) (atom y))
+ nil
+ (cons (aig-or (car x) (car y))
+ (aig-or-lists (cdr x) (cdr y)))))
+
+(define aig-iff-lists (x y)
+ :parents (aig-constructors)
+ :short "@(call aig-iff-lists) pairwise iff s together the AIGs from the
+lists @('x') and @('y')."
+ :returns aig-list
+ :enabled t
+ (if (or (atom x) (atom y))
+ nil
+ (cons (aig-iff (car x) (car y))
+ (aig-iff-lists (cdr x) (cdr y)))))
+
+(define aig-xor-lists (x y)
+ :parents (aig-constructors)
+ :short "@(call aig-xor-lists) pairwise xor s together the AIGs from the
+lists @('x') and @('y')."
+ :returns aig-list
+ :enabled t
+ (if (or (atom x) (atom y))
+ nil
+ (cons (aig-xor (car x) (car y))
+ (aig-xor-lists (cdr x) (cdr y)))))
+
+(define aig-implies-lists (x y)
+ :parents (aig-constructors)
+ :short "@(call aig-implies-lists) pairwise implies together the AIGs
+from the lists @('x') and @('y')."
+ :returns aig-list
+ :enabled t
+ (if (or (atom x) (atom y))
+ nil
+ (cons (aig-implies (car x) (car y))
+ (aig-implies-lists (cdr x) (cdr y)))))
+
+
+
+; -----------------------------------------------------------------------------
+;
+; SUBSTITUTION INTO AIGS
+;
+; -----------------------------------------------------------------------------
+
+(define aig-restrict
+ :parents (aig-substitution)
+ :short "@(call aig-restrict) performs variable substitution throughout the
+AIG @('x'), replacing any variables bound in @('sigma') with their
+corresponding values."
+ ((x "The AIG to restrict.")
+ (sigma "A fast alist binding variables to replacement AIGs."))
+ :returns
+ (aig "Modified version of @('x') where all variables bound in @('sigma') are
+replaced, and any unmentioned variables are left unchanged .")
+
+ :long "The name @('sigma') is intended to evoke the notion of substitution
+lists in logic. Any variables that are not mentioned in @('sigma') are left
+unchanged. When all of the variables in @('x') are bound in @('sigma'), and
+all of the values are Boolean, this is equivalent to @(see aig-eval).
+
+This function is @(see memoize)d. You should typically free its memo table
+after you are done with whatever @('sigma') you are using, to avoid excessive
+memory usage. (We don't use @(':forget t') because you often want to restrict
+several related AIGs.)
"
+
+ :enabled t
+
+ (aig-cases x
+ :true t
+ :false nil
+ :var (let ((a (hons-get x sigma)))
+ (if a
+ (cdr a)
+ x))
+ :inv (aig-not (aig-restrict (car x) sigma))
+ :and (let ((a (aig-restrict (car x) sigma)))
+ (and a (aig-and a (aig-restrict (cdr x) sigma)))))
+ ///
+ (memoize 'aig-restrict :condition '(and (consp x) (cdr x)))
+
+ (local (defthm hons-assoc-equal-of-append
+ (equal (hons-assoc-equal k (append a b))
+ (or (hons-assoc-equal k a)
+ (hons-assoc-equal k b)))))
+
+ (defthm aig-eval-of-aig-restrict
+ (equal (aig-eval (aig-restrict x al1) al2)
+ (aig-eval x (append (aig-eval-alist al1 al2) al2)))
+ :hints(("Goal"
+ :induct t
+ :in-theory (enable aig-env-lookup)))))
+
+(define aig-restrict-list
+ :parents (aig-substitution)
+ :short "@(call aig-restrict-list) substitutes into a list of AIGs."
+ ((x "List of AIGs.")
+ (sigma "Fast alist binding variables to replacement AIGs, as in @(see
+ aig-restrict)."))
+ :returns aig-list
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (aig-restrict (car x) sigma)
+ (aig-restrict-list (cdr x) sigma))))
+
+(define aig-restrict-alist
+ :parents (aig-substitution)
+ :short "@(call aig-restrict-alist) substitutes into an AIG Alist (an alist
+binding keys to AIGs)."
+ ((x "Alist binding names to AIGs. This doesn't need to be a fast alist.")
+ (sigma "Fast alist binding variables to replacement AIGs, as in @(see
+ aig-restrict)."))
+ :returns
+ (aig-alist "Ordinary (slow) alist with the same keys as @('x'), and values
+ formed by restricting each aig with @(see aig-restrict).")
+ :enabled t
+ (cond ((atom x)
+ nil)
+ ((atom (car x))
+ ;; Bad-alist convention
+ (aig-restrict-alist (cdr x) sigma))
+ (t
+ (cons (cons (caar x)
+ (aig-restrict (cdar x) sigma))
+ (aig-restrict-alist (cdr x) sigma))))
+ ///
+ (defthm alistp-of-aig-restrict-alist
+ (alistp (aig-restrict-alist x sigma))))
+
+(define aig-restrict-alists
+ :parents (aig-substitution)
+ :short "@(call aig-restrict-alists) substitutes into a list of AIG Alists."
+ ((x "List of AIG alists, which need not be fast.")
+ (sigma "Fast alist binding variables to replacement AIGs, as in @(see
+ aig-restrict)."))
+ :returns
+ (aig-alists "List of ordinary (slow) alists, derived from @('x') via
+ @(see aig-restrict-alist).")
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (aig-restrict-alist (car x) sigma)
+ (aig-restrict-alists (cdr x) sigma))))
+
+
+
+; -----------------------------------------------------------------------------
+;
+; AIG COMPOSITION
+;
+; -----------------------------------------------------------------------------
+
+(define aig-compose
+ :parents (aig-substitution)
+ :short "@(call aig-compose) performs variable substitution throughout the AIG
+@('x'), unconditionally replacing every variable in @('x') with its
+binding in @('sigma')."
+ ((x "The AIG to compose into.")
+ (sigma "A fast alist that should bind variables to replacement AIGs."))
+ :returns
+ (aig "Modified version of @('x') where every variable is replaced with its
+ binding in @('sigma') or @('t') if it has no binding.")
+
+ :long "The name @('sigma') is intended to evoke the notion of substitution
+lists in logic. This operation is similar to @(see aig-restrict), except that
+whereas @('aig-restrict') leaves unbound variables alone, @('aig-compose')
+replaces them with @('t'). This has the logically nice property that the
+variables after composition are just the variables in the AIGs of
+@('sigma').
+
+This function is @(see memoize)d. You should typically free its memo table
+after you are done with whatever @('sigma') you are using, to avoid excessive
+memory usage. (We don't use @(':forget t') because you often want to compose
+several related AIGs.)
"
+
+ :enabled t
+
+ (aig-cases x
+ :true t
+ :false nil
+ :var (aig-env-lookup x sigma)
+ :inv (aig-not (aig-compose (car x) sigma))
+ :and (let ((a (aig-compose (car x) sigma)))
+ (and a (aig-and a (aig-compose (cdr x) sigma)))))
+ ///
+ (memoize 'aig-compose :condition '(and (consp x) (cdr x))))
+
+(define aig-compose-list
+ :parents (aig-substitution)
+ :short "@(call aig-compose-list) composes into a list of AIGs."
+ ((x "List of AIGs.")
+ (sigma "Fast alist binding variables to replacement AIGs, as in @(see
+ aig-compose)."))
+ :returns aig-list
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (aig-compose (car x) sigma)
+ (aig-compose-list (cdr x) sigma))))
+
+(define aig-compose-alist
+ :parents (aig-substitution)
+ :short "@(call aig-compose-alist) composes into an AIG Alist (an alist
+binding keys to AIGs)."
+ ((x "Alist binding names to AIGs. This doesn't need to be a fast alist.")
+ (sigma "Fast alist binding variables to replacement AIGs, as in @(see
+ aig-compose)."))
+ :returns
+ (aig-alist "Ordinary (slow) alist with the same keys as @('x'), and values formed
+ by restricting each aig with @(see aig-compose).")
+ :enabled t
+ (cond ((atom x)
+ nil)
+ ((atom (car x))
+ ;; Bad alist convention
+ (aig-compose-alist (cdr x) sigma))
+ (t
+ (cons (cons (caar x)
+ (aig-compose (cdar x) sigma))
+ (aig-compose-alist (cdr x) sigma)))))
+
+(define aig-compose-alists
+ :parents (aig-substitution)
+ :short "@(call aig-compose-alists) composes into a list of AIG Alists."
+ ((x "List of AIG alists, which need not be fast.")
+ (sigma "Fast alist binding variables to replacement AIGs, as in @(see
+ aig-compose)."))
+ :returns
+ (aig-alists "List of ordinary (slow) alists, derived from @('x') via @(see
+ aig-compose-alist).")
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (aig-compose-alist (car x) sigma)
+ (aig-compose-alists (cdr x) sigma))))
+
+
+
+; -----------------------------------------------------------------------------
+;
+; PARTIALLY EVALUATING AIGS
+;
+; -----------------------------------------------------------------------------
+
+(define aig-partial-eval
+ :parents (aig-substitution)
+ :short "@(call aig-partial-eval) evaluates @('x'), an AIG, under the partial
+environment @('env'), producing a new AIG as a result."
+ ((x "The AIG to partially evaluate.")
+ (env "A fast alist that (typically) binds some of the variables in @('x') to
+ Boolean values."))
+ :returns
+ (aig "Modified version of @('x') obtained by replacing bound variables with their
+ values and doing basic constant propagation.")
+
+ :long "In ordinary AIG evaluation with @(see aig-eval), any variables that
+are missing from @('env') are just assumed to have a default value. Because of
+this, every variable can be given a Boolean value and we can evaluate the whole
+AIG to produce a Boolean result.
+
+In partial evaluation, variables that aren't bound in @('env') are left
+alone. Because of this, the result of a partial evaluation is a typically a
+reduced AIG instead of a Boolean.
+
+Another way to do partial evaluations is with @(see aig-restrict). In fact,
+the only difference between @('aig-restrict') and @('aig-partial-eval') is that
+@('aig-partial-eval') Boolean-fixes the values in the alist as it looks them
+up. This has logically nice properties, e.g., since we never replace a
+variable by a subtree, only by a Boolean, we know unconditionally that the
+variables of the resulting AIG are a subset of the variables of the
+original.
+
+This function is @(see memoize)d. You should typically free its memo table
+after you are done with whatever @('env') you are using, to avoid excessive
+memory usage. (We don't use @(':forget t') because you often want to evaluate
+several related AIGs.)
"
+
+ :enabled t
+ (aig-cases x
+ :true t
+ :false nil
+ :var (let ((a (hons-get x env)))
+ (if a (and (cdr a) t) x))
+ :inv (aig-not (aig-partial-eval (car x) env))
+ :and (let ((a (aig-partial-eval (car x) env)))
+ (and a
+ (aig-and a (aig-partial-eval (cdr x) env)))))
+ ///
+ (memoize 'aig-partial-eval :condition '(and (consp x) (cdr x))))
+
+(define aig-partial-eval-list
+ :parents (aig-substitution)
+ :short "@(call aig-partial-eval-list) partially evaluates a list of AIGs."
+ ((x "List of AIGs.")
+ (env "Fast alist binding variables to Booleans, as in @(see
+ aig-partial-eval)."))
+ :returns aig-list
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (aig-partial-eval (car x) env)
+ (aig-partial-eval-list (cdr x) env))))
+
+(define aig-partial-eval-alist
+ :parents (aig-substitution)
+ :short "@(call aig-partial-eval-alist) partially evaluates an AIG Alist (an
+alist binding keys to AIGs)."
+ ((x "Alist binding names to AIGs. This doesn't need to be a fast alist.")
+ (env "Fast alist binding variables to Booleans, as in @(see
+ aig-partial-eval)."))
+ :returns
+ (aig-alist "Ordinary (slow) alist with the same keys as x, and values formed
+ by restricting each aig with @(see aig-partial-eval).")
+ :enabled t
+ (cond ((atom x)
+ nil)
+ ((atom (car x))
+ ;; Bad-alist convention
+ (aig-partial-eval-alist (cdr x) env))
+ (t
+ (cons (cons (caar x)
+ (aig-partial-eval (cdar x) env))
+ (aig-partial-eval-alist (cdr x) env))))
+ ///
+ (defthm alistp-of-aig-partial-eval-alist
+ (alistp (aig-partial-eval-alist x env))))
+
diff -Nru acl2-6.2/books/centaur/aig/aig-equivs.lisp acl2-6.3/books/centaur/aig/aig-equivs.lisp
--- acl2-6.2/books/centaur/aig/aig-equivs.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/aig-equivs.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -19,8 +19,7 @@
; Original author: Sol Swords
(in-package "ACL2")
-
-(include-book "base")
+(include-book "aig-base")
(include-book "centaur/misc/witness-cp" :dir :system)
(include-book "centaur/misc/universal-equiv" :dir :system)
(include-book "centaur/misc/fast-alists" :dir :system)
@@ -28,7 +27,7 @@
(defsection aig-equiv
- :parents (aig)
+ :parents (aig-semantics)
:short "We say the AIGs @('X') and @('Y') are equivalent when they always
evaluate to the same value, per @(see aig-eval)."
:long "@(def aig-equiv)"
@@ -44,7 +43,7 @@
(defsection aig-alist-equiv
- :parents (aig)
+ :parents (aig-semantics)
:short "We say the AIG Alists @('X') and @('Y') are equivalent when they bind
the same keys to equivalent AIGs, in the sense of @(see aig-equiv)."
:long "@(def aig-alist-equiv)"
@@ -65,7 +64,7 @@
(defsection aig-env-equiv
- :parents (aig)
+ :parents (aig-semantics)
:short "We say the environments @('X') and @('Y') are equivalent when they
give equivalent values to variables looked up with @(see aig-env-lookup)."
:long "@(def aig-env-equiv)"
@@ -81,38 +80,3 @@
(defrefinement alist-equiv aig-env-equiv
:hints ((witness))))
-
-
-
-(defsection faig-equiv
- :parents (faig)
- :short "We say the FAIGs @('X') and @('Y') are equivalent when they always
-evaluate to the same value, per @(see faig-eval)."
-
- (def-universal-equiv faig-equiv
- :qvars env
- :equiv-terms ((equal (faig-eval x env)))
- :defquant t
- :witness-dcls ((declare (xargs :guard t))))
-
- (verify-guards faig-equiv))
-
-
-(defsection faig-alist-equiv
- :parents (faig)
- :short "We say the FAIG Alists @('X') and @('Y') are equivalent when they
-bind the same keys to equivalent FAIGs, in the sense of @(see faig-equiv)."
-
- (def-universal-equiv faig-alist-equiv
- :qvars k
- :equiv-terms ((iff (hons-assoc-equal k x))
- (faig-equiv (cdr (hons-assoc-equal k x))))
- :defquant t
- :witness-dcls ((declare (xargs :guard t))))
-
- (verify-guards faig-alist-equiv)
-
- (defrefinement alist-equiv faig-alist-equiv
- :hints ((witness))))
-
-
diff -Nru acl2-6.2/books/centaur/aig/aig-print.lisp acl2-6.3/books/centaur/aig/aig-print.lisp
--- acl2-6.2/books/centaur/aig/aig-print.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/aig/aig-print.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,124 @@
+; Centaur AIG Library
+; Copyright (C) 2008-2011 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "ACL2")
+(include-book "aig-base")
+
+(define aig-print
+ :parents (aig-other)
+ :short "Convert an AIG into an ACL2-like S-expression."
+ ((x "An AIG"))
+ :returns (sexpr "A s-expression with AND and NOT calls.")
+ :long "We generally don't imagine using this for anything other than
+one-off debugging. Note that the S-expressions you generate this way can
+easily be too large to print.
"
+ :verify-guards nil
+ (aig-cases
+ x
+ :true t
+ :false nil
+ :var x
+ :inv `(not ,(aig-print (car x)))
+ :and (let* ((a (aig-print (car x)))
+ (d (aig-print (cdr x))))
+ `(and ,@(if (and (consp a) (eq (car a) 'and))
+ (cdr a)
+ (list a))
+ ,@(if (and (consp d) (eq (car d) 'and))
+ (cdr d)
+ (list d)))))
+ ///
+ (local (defthm lemma
+ (implies (and (consp (aig-print x))
+ (eq (car (aig-print x)) 'and))
+ (true-listp (cdr (aig-print x))))))
+ (verify-guards aig-print)
+ (memoize 'aig-print :condition '(consp x)))
+
+
+
+(defsection expr-to-aig
+ :parents (aig-other)
+ :short "Convert an ACL2-like S-expression into an AIG."
+ :long "@(call expr-to-aig) accepts S-expressions @('expr') such as:
+
+@({
+ a
+ (not a)
+ (and a b c)
+})
+
+It currently accepts S-expressions composed of the following operators, all
+of which are assumed to be Boolean-valued (i.e., there's nothing four-valued
+going on here):
+
+
+ @('not') -- unary
+ @('and'), @('or'), @('nand'), @('nor') -- variable arity
+ @('iff'), @('xor'), @('implies') -- binary
+ @('if') -- ternary
+
+
+It constructs an AIG from the S-expression using the ordinary @(see
+aig-constructors).
+
+This can be useful for one-off debugging. We probably wouldn't recommend
+using it for anything serious, or trying to prove anything about it.
"
+
+ (mutual-recursion
+ (defun expr-to-aig (expr)
+ (declare (Xargs :guard t
+ :measure (+ 1 (* 2 (acl2-count expr)))))
+ (if (atom expr)
+ expr
+ (let ((fn (car expr))
+ (args (cdr expr)))
+ (cond
+ ((and (eq fn 'not) (= (len args) 1))
+ (aig-not (expr-to-aig (car args))))
+ ((eq fn 'and) (expr-to-aig-args 'and t args))
+ ((eq fn 'or) (expr-to-aig-args 'or nil args))
+ ((eq fn 'nand) (aig-not (expr-to-aig-args 'and t args)))
+ ((eq fn 'nor) (aig-not (expr-to-aig-args 'or nil args)))
+ ((and (eq fn 'iff) (= (len args) 2))
+ (aig-iff (expr-to-aig (car args))
+ (expr-to-aig (cadr args))))
+ ((and (eq fn 'xor) (= (len args) 2))
+ (aig-xor (expr-to-aig (car args))
+ (expr-to-aig (cadr args))))
+ ((and (eq fn 'implies) (= (len args) 2))
+ (aig-or (aig-not (expr-to-aig (car args)))
+ (expr-to-aig (cadr args))))
+ ((and (eq fn 'if) (= (len args) 3))
+ (aig-ite (expr-to-aig (car args))
+ (expr-to-aig (cadr args))
+ (expr-to-aig (caddr args))))
+ (t (prog2$ (er hard? 'expr-to-aig "Malformed: ~x0~%" expr)
+ nil))))))
+ (defun expr-to-aig-args (op final exprs)
+ (declare (xargs :guard t
+ :measure (* 2 (acl2-count exprs))))
+ (if (atom exprs)
+ final
+ (let ((first (expr-to-aig (car exprs)))
+ (rest (expr-to-aig-args op final (cdr exprs))))
+ (case op
+ (and (aig-and first rest))
+ (or (aig-or first rest))))))))
diff -Nru acl2-6.2/books/centaur/aig/aig-sat-tests.lisp acl2-6.3/books/centaur/aig/aig-sat-tests.lisp
--- acl2-6.2/books/centaur/aig/aig-sat-tests.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/aig/aig-sat-tests.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,74 @@
+; Centaur AIG Library
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original authors: Jared Davis
+; Sol Swords
+
+; cert_param: (uses-glucose)
+
+(in-package "ACL2")
+
+(local (progn
+
+(include-book "aig-sat")
+
+(defun my-glucose-config ()
+ (declare (xargs :guard t))
+ (satlink::make-config :cmdline "glucose"
+ :verbose t
+ :mintime 1/2
+ :remove-temps t))
+
+(value-triple (tshell-ensure))
+
+; These are some extremely basic tests. The point isn't to thoroughly test the
+; SAT solver. It's just to make sure that everything seems to be basically
+; holding together.
+
+(defun test-aig-sat (input expect)
+ (b* (((mv status ?alist)
+ (aig-sat input :config (my-glucose-config))))
+ (cw "Alist: ~x0" alist)
+ (equal status expect)))
+
+(assert! (test-aig-sat nil :unsat))
+(assert! (test-aig-sat t :sat))
+
+(assert! (test-aig-sat 'x :sat))
+(assert! (test-aig-sat (aig-and 'x 'y) :sat))
+(assert! (test-aig-sat (aig-ite 'x 'y 'z) :sat))
+
+(assert! (test-aig-sat (aig-and
+ (aig-ite 'x 'y 'z)
+ (aig-ite 'x (aig-not 'y) (aig-not 'z)))
+ :unsat))
+
+
+(assert! (test-aig-sat (aig-and-list
+ (list (aig-or 'x 'y)
+ 'a
+ (aig-or (aig-not 'x) 'y)
+ (aig-and 'a 'b)
+ (aig-or 'x (aig-not 'y))
+ 'c
+ (aig-not 'x)
+ (aig-not 'y)))
+ :unsat))
+
+
+))
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/aig/aig-sat.lisp acl2-6.3/books/centaur/aig/aig-sat.lisp
--- acl2-6.2/books/centaur/aig/aig-sat.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/aig/aig-sat.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,101 @@
+; Centaur AIG Library
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original authors: Jared Davis
+; Sol Swords
+
+(in-package "ACL2")
+(include-book "centaur/aignet/aig-cnf" :dir :system)
+(include-book "centaur/satlink/top" :dir :system)
+(local (include-book "centaur/satlink/cnf-basics" :dir :system))
+(local (in-theory (disable nth update-nth aig-eval)))
+
+(define aig-sat
+ :parents (aig)
+ :short "Determine whether an AIG is satisfiable."
+ ((aig "The AIG to inspect.")
+ &key
+ ((config satlink::config-p "How to invoke the SAT solver.")
+ 'satlink::*default-config*))
+ :returns (mv (status "Either :sat, :unsat, or :failed")
+ (env "When :sat, an (ordinary, slow) alist binding the
+ aig vars to t/nil."))
+
+ :long "This is a convenient, high level way to ask a SAT solver whether a
+Hons AIG is satisfiable. When the AIG is satisfiable, you get back a
+satisfying assignment in terms of the Hons AIG's variables.
+
+This function should only fail if there is some problem with the SAT solver,
+e.g., it produces output that @(see satlink) does not understand.
+
+The underlying mechanism takes advantage of @(see aignet) to carry out the
+cnf conversion and @(see satlink) to call
+the SAT solver. As a picture:
+
+@({
+ convert export dimacs
+ AIG -------------> AIGNET -----------------> CNF -------> Solver
+ || || || |
+ || || || | interpret
+ satisfying satisfying satisfying | output
+ alist or <------- array or <----------- assign or <----'
+ 'unsat' convert 'unsat' translate 'unsat'
+})
+
+We simply trust the SAT solver if it says @('unsat'), but the other
+translation and conversion steps are all verified.
"
+
+ (b* (;; Locally create arrays to work with
+ ((local-stobjs satlink::env$ aignet::sat-lits aignet::aignet)
+ (mv status env satlink::env$ aignet::sat-lits aignet::aignet))
+
+ ;; Convert the AIG into a CNF formula, using fancy AIGNET algorithm
+ ((mv cnf ?lit vars aignet::sat-lits aignet::aignet)
+ (aignet::aig->cnf aig aignet::sat-lits aignet::aignet))
+
+ ((mv result satlink::env$)
+ (satlink::sat cnf satlink::env$ :config config))
+
+ ((unless (eq result :sat))
+ (mv result nil satlink::env$ aignet::sat-lits aignet))
+
+ (env (aignet::aig-cnf-vals->env satlink::env$ vars aignet::sat-lits aignet)))
+
+ (mv :sat env satlink::env$ aignet::sat-lits aignet))
+
+ ///
+ (defthm aig-sat-when-sat
+ (b* (((mv status env) (aig-sat aig :config config)))
+ (implies (equal status :sat)
+ (aig-eval aig env))))
+
+ (defthm aig-sat-when-unsat
+ (b* (((mv status &) (aig-sat aig :config config)))
+ (implies (aig-eval aig env)
+ (not (equal status :unsat))))
+ :hints (("goal"
+ :use ((:instance
+ aignet::aig-satisfying-assign-induces-aig->cnf-satisfying-assign
+ (aignet::aig aig)
+ (aignet::env env)
+ (aignet::sat-lits (aignet::create-sat-lits))
+ (aignet::aignet (acl2::create-aignet))))
+ :in-theory (disable
+ aignet::aig-satisfying-assign-induces-aig->cnf-satisfying-assign)))))
+
+
diff -Nru acl2-6.2/books/centaur/aig/aig-vars-ext.lisp acl2-6.3/books/centaur/aig/aig-vars-ext.lisp
--- acl2-6.2/books/centaur/aig/aig-vars-ext.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/aig-vars-ext.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -21,7 +21,7 @@
(in-package "ACL2")
(include-book "defsort/defsort" :dir :system)
-(include-book "centaur/aig/base" :dir :system)
+(include-book "aig-base")
(include-book "tools/bstar" :dir :system)
(include-book "centaur/bitops/sbitsets" :dir :system)
(include-book "centaur/misc/hons-extra" :dir :system)
diff -Nru acl2-6.2/books/centaur/aig/aig-vars.lisp acl2-6.3/books/centaur/aig/aig-vars.lisp
--- acl2-6.2/books/centaur/aig/aig-vars.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/aig-vars.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -19,45 +19,50 @@
; Original author: Sol Swords
(in-package "ACL2")
+(include-book "aig-base")
-(include-book "base")
+;; BOZO should these be local?
(include-book "centaur/misc/equal-sets" :dir :system)
(include-book "centaur/misc/alist-equiv" :dir :system)
(local (in-theory (disable sets::double-containment)))
-(defthm aig-vars-cons
- (equal (aig-vars (cons x y))
- (sets::union (aig-vars x)
- (aig-vars y))))
-
-(defthm member-aig-vars-alist-vals
- (implies (not (sets::in v (aig-vars (alist-vals al))))
- (not (sets::in v (aig-vars (cdr (hons-assoc-equal x al))))))
- :hints(("Goal" :in-theory (enable hons-assoc-equal))))
-
-(defthm member-aig-vars-aig-and
- (implies (and (not (sets::in v (aig-vars x)))
- (not (sets::in v (aig-vars y))))
- (not (sets::in v (aig-vars (aig-and x y)))))
- :hints(("Goal" :in-theory (enable aig-and))))
-
-(defthm aig-vars-aig-not
- (equal (aig-vars (aig-not x))
- (aig-vars x))
- :hints(("Goal" :in-theory (enable aig-not))))
-
-(defthm member-aig-vars-aig-restrict
- (implies (and (not (and (sets::in v (aig-vars x))
- (not (member-equal v (alist-keys al)))))
- (not (sets::in v (aig-vars (alist-vals al)))))
- (not (sets::in v (aig-vars (aig-restrict x al)))))
- :hints(("Goal" :in-theory (enable aig-restrict))))
-
-(defthm member-aig-vars-aig-partial-eval
- (implies (not (and (sets::in v (aig-vars x))
- (not (member-equal v (alist-keys al)))))
- (not (sets::in v (aig-vars (aig-partial-eval x al)))))
- :hints(("Goal" :in-theory (enable aig-partial-eval))))
+(defsection aig-vars-thms
+ :parents (aig-vars)
+ :short "Theorems about @(see aig-vars) from @(see centaur/aig/aig-vars)."
+
+ (defthm aig-vars-cons
+ (equal (aig-vars (cons x y))
+ (sets::union (aig-vars x)
+ (aig-vars y))))
+
+ (defthm member-aig-vars-alist-vals
+ (implies (not (sets::in v (aig-vars (alist-vals al))))
+ (not (sets::in v (aig-vars (cdr (hons-assoc-equal x al))))))
+ :hints(("Goal" :in-theory (enable hons-assoc-equal))))
+
+ (defthm member-aig-vars-aig-and
+ (implies (and (not (sets::in v (aig-vars x)))
+ (not (sets::in v (aig-vars y))))
+ (not (sets::in v (aig-vars (aig-and x y)))))
+ :hints(("Goal" :in-theory (enable aig-and))))
+
+ (defthm aig-vars-aig-not
+ (equal (aig-vars (aig-not x))
+ (aig-vars x))
+ :hints(("Goal" :in-theory (enable aig-not))))
+
+ (defthm member-aig-vars-aig-restrict
+ (implies (and (not (and (sets::in v (aig-vars x))
+ (not (member-equal v (alist-keys al)))))
+ (not (sets::in v (aig-vars (alist-vals al)))))
+ (not (sets::in v (aig-vars (aig-restrict x al)))))
+ :hints(("Goal" :in-theory (enable aig-restrict))))
+
+ (defthm member-aig-vars-aig-partial-eval
+ (implies (not (and (sets::in v (aig-vars x))
+ (not (member-equal v (alist-keys al)))))
+ (not (sets::in v (aig-vars (aig-partial-eval x al)))))
+ :hints(("Goal" :in-theory (enable aig-partial-eval)))))
diff -Nru acl2-6.2/books/centaur/aig/aig2c.lisp acl2-6.3/books/centaur/aig/aig2c.lisp
--- acl2-6.2/books/centaur/aig/aig2c.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/aig/aig2c.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,630 @@
+; Centaur AIG Library
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "ACL2")
+(include-book "cutil/top" :dir :system)
+(include-book "centaur/vl/util/namedb" :dir :system)
+(include-book "aig-base")
+(include-book "aig-vars-ext")
+(local (include-book "std/typed-lists/string-listp" :dir :system))
+
+(local (defthm stringp-of-lookup-when-string-listp-of-alist-vals
+ (implies (string-listp (alist-vals map))
+ (equal (stringp (cdr (hons-assoc-equal key map)))
+ (if (hons-assoc-equal key map)
+ t
+ nil)))
+ :hints(("Goal" :induct (len map)))))
+
+
+(defsection aig2c
+ :parents (aig-other)
+ :short "Naive compiler from Hons AIGs into C/C++ code fragments."
+
+ :long "The idea here is to be able to take an AIG and embed it in a C or
+C++ program. You can tweak various aspects of the code that gets generated,
+but some basic example output is:
+
+@({
+ const uint32_t n_8 = inputs.a; // prologue: initializes temp variables
+ const uint32_t n_2 = inputs.b; // you can control the rhs'es here
+ const uint32_t n_4 = inputs.c;
+
+ const uint32_t n_3 = ~n_4; // main aig contents
+ const uint32_t n_1 = n_2 & n_3; // never try to understand this
+ const uint32_t n_7 = ~n_8;
+ const uint32_t n_6 = n_4 & n_7;
+ const uint32_t n_5 = n_6 & n_1;
+
+ out1 = n_1; // epilogue: extracts aigs to outputs
+ out2 = n_5; // you can control the lhs'es here
+})
+
+We try to make relatively few assumptions about how you might actually use
+this code. Toward that goal, you may configure , e.g., the names and types of the temporary
+variables, and the operators used to carry out each AND and NOT operation.
+
+Some high level notes:
+
+
+
+We basically turn each AIG node into one line of C/C++ code.
+
+We do at least take advantage of shared structure in the AIG, and avoid
+recomputing an AND node just because it has multiple fanouts.
+
+We don't even do basic optimizations like using @('|') or @('^') operators,
+but doing so might be useful.
+
+We do nothing to smartly collapse the AIG into vectors to take advantage
+of, e.g., 32-bit bitwise ANDs, or anything like that.
+
+
+
+The top-level function is @(see aig2c-compile).
")
+
+
+(define aig2c-boolean-sanity-check-p ((type stringp)
+ (op-and stringp)
+ (op-not stringp))
+ :parents (aig2c-config-p)
+ (b* ((tokens (str::strtok type '(#\Space #\Newline #\Tab)))
+ ((unless (or (equal tokens '("bool"))
+ (equal tokens '("const" "bool"))))
+ t)
+ ((unless (and (equal op-and "&&")
+ (equal op-not "!")))
+ (raise "Insane AIG2C configuration. You are trying to make an aig2c ~
+ configuration using bool variables, but with operators other ~
+ than && and !. The bitwise operators won't work here. See ~
+ :xdoc aig2c-config-p for more information.")))
+ t))
+
+(cutil::defaggregate aig2c-config
+ :parents (aig2c)
+ :short "Configuration object that governs how we translate an AIG into C/C++."
+
+ :long "The default configuration generates code for carry out 32-bit wide
+AIG simulations on @('uint32_t')s. Changing to, e.g., 8-bit or 64-bit wide
+simulations is trivial.
+
+But the C++ @('bool') type is special. If you want to use it, you need to
+make sure to use @('&&') and @('!') instead of @('&') and @('~'). Consider for
+instance this C++ program:
+
+@({
+ int main() {
+ bool b = true;
+ cout << \"B is \" << (bool)b << endl; // Prints 'B is 1'
+ b = ~b;
+ cout << \"~B is \" << (bool)b << endl; // Prints '~B is 1' (!!!)
+ return 0;
+ }
+})
+
+We try to at least do a rudimentary check for incorrect uses of @('bool'),
+but it's not any sort of foolproof thing.
"
+
+ :tag :aig2c-config
+
+ ((prefix stringp
+ :rule-classes :type-prescription
+ :default "_temp"
+ "The naming prefix to use for generating temporary variable
+ names. Typically you just want this to be something that won't
+ clash with other names in the rest of your C program. By default
+ we use @('\"_temp\"').")
+
+ (type stringp
+ :rule-classes :type-prescription
+ :default "const uint32_t"
+ "The C/C++ data type to use for each temporary variable. By default
+ we use @('\"const uint32_t\"'), which might be appropriate for
+ 32-bit wide simulations. For single-bit simulations, you could
+ use, e.g., @('\"const bool\"') here, but WARNING if you use
+ @('bool') or @('const bool') you need to also change the operators
+ from @('&') and @('~') to @('&&') and @('!'), respectively. See
+ @(see aig2c) for more information.")
+
+ (op-and stringp
+ :rule-classes :type-prescription
+ :default "&"
+ "The C/C++ operator to use to AND expressions of this @('type').
+ Typically this should be @('&') for integers or @('&&') for
+ booleans.")
+
+ (op-not stringp
+ :rule-classes :type-prescription
+ :default "~"
+ "The C/C++ operator used to NOT expressions of this type. Typically
+ this should be @('~') for integers or @('!') for booleans."))
+
+ :require
+ ((aig2c-config-sanity-constraint
+ (aig2c-boolean-sanity-check-p type op-and op-not)
+ :rule-classes nil)))
+
+(defconst *aig2c-default-config*
+ (make-aig2c-config))
+
+
+(define aig2c-maketemps
+ :parents (aig2c)
+ :short "Create the temporary C code variable names that will be used for each
+each AIG node, for a single AIG."
+
+ ((x "The AIG to process.")
+ (config aig2c-config-p)
+ (tempmap "Answer we are accumulating. Fast alist assigning AIG nodes and
+ variables to fresh, \"temporary\" names."
+ (string-listp (alist-vals tempmap)))
+ (db "Name database to make sure the names we are generating are
+ really unique."
+ vl::vl-namedb-p))
+
+ :returns
+ (mv (new-map "Fast alist mapping AIG nodes to their newly assigned names.")
+ (new-db "Updated name database."
+ vl::vl-namedb-p
+ :hyp (and (force (vl::vl-namedb-p db))
+ (force (aig2c-config-p config)))))
+
+ :verify-guards nil
+ (b* (((when (hons-get x tempmap))
+ ;; Already have a name for this node.
+ (mv tempmap db))
+ ((mv fresh-name db) (vl::vl-namedb-indexed-name
+ (aig2c-config->prefix config)
+ db))
+ (tempmap (hons-acons x fresh-name tempmap))
+ ((when (atom x))
+ (mv tempmap db))
+ ((when (not (cdr x))) ;; NOT node
+ (aig2c-maketemps (car x) config tempmap db))
+ ((mv tempmap db) (aig2c-maketemps (car x) config tempmap db))
+ ((mv tempmap db) (aig2c-maketemps (cdr x) config tempmap db)))
+ (mv tempmap db))
+ ///
+ (defthm string-listp-of-alist-vals-of-aig2c-maketemps
+ (b* (((mv new-map ?new-db)
+ (aig2c-maketemps x config tempmap db)))
+ (implies (and (force (string-listp (alist-vals tempmap)))
+ (force (vl::vl-namedb-p db))
+ (force (aig2c-config-p config)))
+ (string-listp (alist-vals new-map)))))
+
+ (defthm aig2c-maketemps-monotonic
+ (b* (((mv new-map ?new-db)
+ (aig2c-maketemps x config tempmap db)))
+ (implies (subsetp-equal keys (alist-keys tempmap))
+ (subsetp-equal keys (alist-keys new-map)))))
+
+ (verify-guards aig2c-maketemps))
+
+
+(define aig2c-maketemps-list
+ :parents (aig2c)
+ :short "Create the temporary C code variable names for a whole list of AIGs."
+ :long "This just extends @(see aig2c-maketemps) to an AIG list.
"
+
+ ((x "AIG list to process.")
+ (config aig2c-config-p)
+ (tempmap (string-listp (alist-vals tempmap)))
+ (db vl::vl-namedb-p))
+
+ :returns
+ (mv (new-map)
+ (new-db vl::vl-namedb-p :hyp (and (force (vl::vl-namedb-p db))
+ (force (aig2c-config-p config)))))
+
+ (b* (((when (atom x))
+ (mv tempmap db))
+ ((mv tempmap db)
+ (aig2c-maketemps (car x) config tempmap db)))
+ (aig2c-maketemps-list (cdr x) config tempmap db))
+ ///
+ (defthm string-listp-of-alist-vals-of-aig2c-maketemps-list
+ (b* (((mv new-map ?new-db)
+ (aig2c-maketemps-list x config tempmap db)))
+ (implies (and (force (string-listp (alist-vals tempmap)))
+ (force (vl::vl-namedb-p db))
+ (force (aig2c-config-p config)))
+ (string-listp (alist-vals new-map)))))
+
+ (defthm aig2c-maketemps-list-monotonic
+ (b* (((mv new-map ?new-db)
+ (aig2c-maketemps-list x config tempmap db)))
+ (implies (subsetp-equal keys (alist-keys tempmap))
+ (subsetp-equal keys (alist-keys new-map)))))
+
+ (verify-guards aig2c-maketemps-list))
+
+
+(define aig2c-prologue
+ :parents (aig2c)
+ :short "Create the assignments for AIG constant and variable nodes."
+
+ ((input-init "Mapping from every AIG variable to a C code fragment that
+ should be used to initialize it."
+ (string-listp (alist-vals input-init)))
+
+ (tempmap "Fast alist mapping every AIG variable (and other nodes) to
+ the temporary variable name to use."
+ (string-listp (alist-vals tempmap)))
+
+ (config aig2c-config-p)
+
+ (code "The C code fragment we are building, a character list in reverse
+ order (e.g., for use with @(see str::revappend-chars))."
+ character-listp))
+
+ :returns (new-code character-listp
+ :hyp (force (character-listp code)))
+
+ (b* (((when (atom input-init))
+ code)
+ ((when (atom (car input-init)))
+ ;; Bad alist convention
+ (aig2c-prologue (cdr input-init) tempmap config code))
+ (var (caar input-init)) ;; The AIG variable
+ (c-rhs (cdar input-init)) ;; C code fragment to initialize this var
+ (c-lhs (cdr (hons-get var tempmap))) ;; C variable name for this AIG var
+ ((unless c-lhs)
+ (raise "Variable ~x0 not bound in tempmap!")
+ code)
+
+ ;; Now print, e.g., "int temp_123 = init;"
+ (code (str::revappend-chars " " code))
+ (code (str::revappend-chars (aig2c-config->type config) code))
+ (code (str::revappend-chars " " code))
+ (code (str::revappend-chars c-lhs code))
+ (code (str::revappend-chars " = " code))
+ (code (str::revappend-chars c-rhs code))
+ (code (list* #\Newline #\; code)))
+ (aig2c-prologue (cdr input-init) tempmap config code)))
+
+#||
+;; Example:
+(str::rchars-to-string
+ (aig2c-prologue
+ '((nil . "0")
+ (t . "~temp_false")
+ (a . "inputs.a")
+ (b . "inputs.b")
+ (c . "inputs.c"))
+ (make-fast-alist '((nil . "temp_false")
+ (t . "temp_true")
+ (a . "temp_123")
+ (b . "temp_124")
+ (c . "temp_125")))
+ (make-aig2c-config)
+ nil))
+||#
+
+(define aig2c-main
+ :parents (aig2c)
+ :short "Create the assignments for a single AIG."
+
+ ((x "The AIG we are compiling.")
+
+ (seen "Fast alist mapping AIG nodes we've already compiled to T.")
+
+ (tempmap "Fast alist mapping every AIG node to its C variable name."
+ (string-listp (alist-vals tempmap)))
+
+ (config aig2c-config-p)
+
+ (code "The C code fragment we are building, a character list in reverse
+ order (e.g., for use with @(see str::revappend-chars))."
+ character-listp))
+
+ :verify-guards nil
+ :returns (mv (new-code character-listp
+ :hyp (force (character-listp code)))
+ seen)
+
+ (b* ((name (cdr (hons-get x tempmap)))
+
+ ((unless name)
+ ;; We shouldn't hit this if we've constructed the tempmap correctly.
+ (raise "AIG node isn't bound!")
+ (mv code seen))
+
+ ((when (atom x))
+ ;; We don't need to do anything in this case because we've dealt
+ ;; with all the variables and constants in the prologue.
+ (mv code seen))
+
+ ((when (hons-get x seen))
+ ;; We already initialized this variable so we don't need to process it
+ ;; again.
+ (mv code seen))
+
+ (seen (hons-acons x t seen))
+
+ ;; Recursively process fanins
+ ((mv code seen)
+ (aig2c-main (car x) seen tempmap config code))
+
+ ((mv code seen)
+ (if (cdr x)
+ (aig2c-main (cdr x) seen tempmap config code)
+ (mv code seen)))
+
+ (code (list* #\Space #\Space code))
+ (code (str::revappend-chars (aig2c-config->type config) code))
+ (code (cons #\Space code))
+ (code (str::revappend-chars name code))
+ (code (list* #\Space #\= #\Space code))
+
+ (car-name (cdr (hons-get (car x) tempmap)))
+ ((unless car-name)
+ (raise "AIG node for CAR isn't bound!")
+ (mv code seen))
+
+ ((unless (cdr x))
+ (b* ((code (str::revappend-chars (aig2c-config->op-not config) code))
+ (code (str::revappend-chars car-name code))
+ (code (list* #\Newline #\; code)))
+ (mv code seen)))
+
+ ;; Else, an AND node.
+ (cdr-name (cdr (hons-get (cdr x) tempmap)))
+ ((unless cdr-name)
+ (raise "AIG node for CDR isn't bound!")
+ (mv code seen))
+
+ (code (str::revappend-chars car-name code))
+ (code (cons #\Space code))
+ (code (str::revappend-chars (aig2c-config->op-and config) code))
+ (code (cons #\Space code))
+ (code (str::revappend-chars cdr-name code))
+ (code (list* #\Newline #\; code)))
+ (mv code seen))
+
+ ///
+ (verify-guards aig2c-main))
+
+
+#||
+;; Example:
+
+(b* ((x0 'a)
+ (x1 'b)
+ (x2 'c)
+ (x3 (aig-not x1))
+ (x4 (aig-not x2))
+ (x5 (aig-and x1 x4))
+ (x6 (aig-and x0 x3))
+ (x7 (aig-and x5 x6))
+ (x8 (aig-and x7 x4))
+
+ (tempmap `((,x0 . "_var0")
+ (,x1 . "_var1")
+ (,x2 . "_var2")
+ (,x3 . "_foo3")
+ (,x4 . "_foo4")
+ (,x5 . "_foo5")
+ (,x6 . "_foo6")
+ (,x7 . "_foo7")
+ (,x8 . "_foo8")))
+ ((with-fast tempmap))
+ ((mv code seen)
+ (aig2c-main x8 'seen tempmap
+ (make-aig2c-config)
+ nil))
+ ((mv code2 seen2)
+ (aig2c-main x8 'seen2 tempmap
+ (make-aig2c-config :type "const bool"
+ :op-and "&&"
+ :op-not "!")
+ nil)))
+ (fast-alist-free seen)
+ (fast-alist-free seen2)
+ (list :code (str::rchars-to-string code)
+ :code2 (str::rchars-to-string code2)))
+
+||#
+
+(define aig2c-main-list
+ :parents (aig2c)
+ :short "Create the assignments for a list of AIGs."
+ ((x "The AIG list to compile.")
+ (seen)
+ (tempmap (string-listp (alist-vals tempmap)))
+ (config aig2c-config-p)
+ (code character-listp))
+ :returns (mv (new-code character-listp
+ :hyp (force (character-listp code)))
+ seen)
+ (b* (((when (atom x))
+ (mv code seen))
+ ((mv code seen)
+ (aig2c-main (car x) seen tempmap config code)))
+ (aig2c-main-list (cdr x) seen tempmap config code)))
+
+
+
+
+(define aig2c-epilogue
+ :parents (aig2c)
+ :short "Create the assignments from AIG nodes to outputs."
+ ((aig-alist "Alist binding names to AIGs."
+ (string-listp (alist-keys aig-alist)))
+ (tempmap "Binds each AIG to its temporary C variable name."
+ (string-listp (alist-vals tempmap)))
+ (code character-listp))
+ :returns (new-code character-listp
+ :hyp (force (character-listp code)))
+ (b* (((when (atom aig-alist))
+ code)
+ ((when (atom (car aig-alist)))
+ ;; Bad alist convention
+ (aig2c-epilogue (cdr aig-alist) tempmap code))
+ ((cons c-out-name aig1) (car aig-alist))
+ (c-temp-name (cdr (hons-get aig1 tempmap)))
+ ((unless c-temp-name)
+ (raise "AIG not bound in tempmap!")
+ code)
+ (code (list* #\Space #\Space code))
+ (code (str::revappend-chars c-out-name code))
+ (code (list* #\Space #\= #\Space code))
+ (code (str::revappend-chars c-temp-name code))
+ (code (list* #\Newline #\; code)))
+ (aig2c-epilogue (cdr aig-alist) tempmap code)))
+
+
+(define aig2c-compile
+ :parents (aig2c)
+ :short "Compile an alist of AIGs into a C code fragment."
+
+ ((aig-alist "Name → AIG Alist. The names here must be strings and should
+ refer to proper lvalues in your C code, i.e., they might be
+ variables, or fields in a structure that you want to
+ initialize. For the C code to work, these names must be
+ compatible with the datatype you want to use."
+ (string-listp (alist-keys aig-alist)))
+
+ (input-names "AIG Variable → Name Alist. This should bind every AIG
+ variable to a string that will be used as its initial value in
+ the C code. Each name should be a C code fragment that
+ evaluates without side effects."
+ (string-listp (alist-vals input-names)))
+
+ &key
+ ((config "Controls names, types, and operators to use in the C code being
+ generated."
+ aig2c-config-p)
+ '*aig2c-default-config*))
+
+ :returns (mv (err "NIL on success, or an error @(see msg) on failure,
+ suitable for printing with @('~@').")
+
+ (c-code "C code fragment that implements this AIG, on success,
+ or the empty string on failure."
+ stringp :rule-classes :type-prescription))
+
+ (b* ((output-c-names (alist-keys aig-alist))
+ (output-aigs (alist-vals aig-alist))
+
+ (input-vars (alist-keys input-names))
+ (input-c-names (alist-vals input-names))
+
+ (all-aig-vars (aig-vars-1pass output-aigs))
+
+ ((unless (uniquep input-vars))
+ (mv (msg "Error: multiple bindings for input variables ~x0"
+ (duplicated-members input-vars))
+ ""))
+
+ ((unless (sets::subset all-aig-vars (sets::mergesort input-vars)))
+ (mv (msg "Some AIG variables do not have C input names: ~x0"
+ (sets::difference all-aig-vars (sets::mergesort input-vars)))
+ ""))
+
+ ;; I originally thought I might check for unique input-c-names and
+ ;; unique output-c-names. This would be important if we were going to
+ ;; avoid prologue and epilogue parts. But by separating out the
+ ;; prologue and epilogue, there's no danger of overwriting an input
+ ;; before we use it again. And, moreover, it might sometimes be useful
+ ;; to write the same AIG to multiple places, or to read the same
+ ;; location and feed it into several parts of the AIG. So I no longer
+ ;; have these checks.
+
+ (all-c-names (append input-c-names output-c-names))
+ (db (vl::vl-starting-namedb all-c-names))
+ ((mv tempmap db) (aig2c-maketemps-list output-aigs config 'aig2c-tempmap db))
+ (- (vl::vl-free-namedb db))
+
+ ;; Most AIGs, built with things like AIG-AND and AIG-NOT, won't include
+ ;; NIL or T because it can get constant-propagated. But if these do
+ ;; occur, they will show up in the tempmap. We'll hack the
+ ;; input-c-names list to handle these in the prologue.
+ (input-names
+ (if (hons-get nil tempmap)
+ (cons (cons nil "0") input-names)
+ input-names))
+
+ (input-names
+ (if (hons-get t tempmap)
+ (cons (cons t (str::cat (aig2c-config->op-not config)
+ "((" (aig2c-config->type config) ")0)"))
+ input-names)
+ input-names))
+
+ ;; Assign C expressions to each input variable
+ (code nil)
+ (code (aig2c-prologue input-names tempmap config code))
+ ((mv code seen)
+ (aig2c-main-list output-aigs 'aig2c-seen tempmap config code))
+ (- (fast-alist-free seen))
+ (code (aig2c-epilogue aig-alist tempmap code))
+ (- (fast-alist-free tempmap)))
+
+ (mv nil (str::rchars-to-string code))))
+
+
+#||
+
+(defconst *bool-config*
+ (make-aig2c-config :type "bool" :op-and "&&" :op-not "!"))
+
+(aig2c-compile '(("foo" . nil)) nil)
+(aig2c-compile '(("foo" . t)) nil)
+
+(aig2c-compile '(("foo" . nil)) nil :config *bool-config*)
+(aig2c-compile '(("foo" . t)) nil :config *bool-config*)
+
+(aig2c-compile '(("foo" . (t . nil))) nil)
+(aig2c-compile '(("foo" . (nil . nil))) nil)
+
+(aig2c-compile '(("foo" . (t . nil))) nil :config *bool-config*)
+(aig2c-compile '(("foo" . (nil . nil))) nil :config *bool-config*))
+
+(aig2c-compile '(("foo" . t)) nil)
+(aig2c-compile '(("foo" . t)) nil
+ :config (change-aig2c-config *aig2c-default-config*
+ :prefix "xyz"
+ :type "vector"))
+
+(aig2c-compile `(("foo" . ,(aig-and 'a 'b)))
+ `((a . "inputs.a")
+ (b . "inputs.b"))
+ :config (make-aig2c-config))
+
+
+(let* ((line1 'a)
+ (line2 'b)
+ (line3 'c)
+ (line4 (aig-not line3))
+ (line5 (aig-and line2 line4))
+ (line6 (aig-not line1))
+ (line7 (aig-and line3 line6))
+ (line8 (aig-and line7 line5)))
+ (aig2c-compile `(("out1" . ,line5)
+ ("out2" . ,line8))
+ `((a . "inputs.a")
+ (b . "inputs.b")
+ (c . "inputs.c"))))
+
+||#
+
+
diff -Nru acl2-6.2/books/centaur/aig/aiger.lisp acl2-6.3/books/centaur/aig/aiger.lisp
--- acl2-6.2/books/centaur/aig/aiger.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/aiger.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -1752,6 +1752,7 @@
(maybe-byte-p (mv-nth 7 (aiger-parse-header stream buf state))))
:rule-classes (:rewrite :type-prescription))
+(local (in-theory (disable nth-when-zp)))
(defmvtypes aiger-parse-header (nil natp natp natp natp natp natp nil nil))
(local (in-theory (disable aiger-parse-header)))
diff -Nru acl2-6.2/books/centaur/aig/base.lisp acl2-6.3/books/centaur/aig/base.lisp
--- acl2-6.2/books/centaur/aig/base.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/base.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -1,1520 +1,6 @@
-; Centaur AIG Library
-; Copyright (C) 2008-2011 Centaur Technology
-;
-; Contact:
-; Centaur Technology Formal Verification Group
-; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
-; http://www.centtech.com/
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version. This program is distributed in the hope that it will be useful but
-; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
-; more details. You should have received a copy of the GNU General Public
-; License along with this program; if not, write to the Free Software
-; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
-;
-; Original author: Sol Swords
-;
-; July 2011, Jared added lots of documentation.
-
(in-package "ACL2")
-(include-book "xdoc/top" :dir :system)
-(include-book "../misc/hons-alphorder-merge")
-
-; aig/base.lisp
-; - Semantics of AIGs (aig-eval) and FAIGs (faig-eval)
-; - Primitive AIG constructors (aig-not, aig-and, ...)
-; - Substitution operations: aig-restrict, aig-compose, aig-partial-eval
-; - FAIG versions of the substitution operations
-
-
-; BOZO consider using defprojection throughout?
-
-(defxdoc aig
- :short "Centaur AIG Library"
-
- :long "AIGs (And/Inverter Graphs) are a representation of Boolean
-functions, using only and and not operations.
-
-FAIGs (Four-valued AIGs) are a related
-concept, where two AIGs are pasted together to represent a function in
-four-valued logic.
-
-
-Motivation for AIGs
-
-There are many ways to represent Boolean functions. One alternative is
-to use BDDs, e.g., we provide a @(see ubdds) library. In comparison with
-BDDs, AIGs are:
-
-
-
-cheaper to construct, e.g., if we want to or together the functions
-@('f') and @('g'), it only takes a few conses with AIGs, whereas with BDDs we
-need to walk through @('f') and @('g') to construct a new structure (which
-might be quite large); but
-
-more expensive to compare, e.g., with BDDs we can determine if @('f') and
-@('g') are equal via pointer equality, whereas with AIGs this is a
-satisfiablity problem.
-
-
-
-This tradeoff is often worth it because you can simplify and reduce AIGs
-after they have been constructed, but before comparing them. For instance, our
-@(see bddify) algorithm converts an AIG into a BDD, and since it can often
-\"prune\" branches of the AIG that turn out to be irrelevant, it can be much
-more efficient than directly constructing BDDs. A more sophisticated tool is
-@(see abc), which provides various kinds of rewriting and reductions on AIGs.
-These reductions can be used before calling a SAT solver or @('bddify') to make
-the input AIGs much smaller and easier to process.
-
-Another alternative would be to use a richer language such as Lisp-style
-s-expressions, where operations other than and and not could be
-used directly. On the surface, this approach would appear to be more compact,
-e.g., we can represent @('(or a b)') as a single operation instead of as
-something like @('(not (and (not a) (not b)))').
-
-But another critical part of memory efficiency is structure sharing. That
-is, suppose that we already need @('(not a)') and @('(not b)') elsewhere in the
-function. With s-expressions, these terms would have nothing in common with
-@('(or a b)'), but with AIGs we can reuse the existing parts of
-@('(not (and (not a) (not b)))').
-
-
-Representation of AIGs
-
-We always construct AIGs with @(see hons) so that existing pieces of AIGs
-will be automatically reused. We represent AIGs as arbitrary cons trees, which
-we interpret as follows:
-
-
-
-@('T') represents the constant-true function.
-
-@('NIL') represents the constant-false function.
-
-Any other atom represents a Boolean variable (i.e., an input to the
-function.)
-
-A cons of the form @('(A . NIL)') represents the negation of @('A').
-
-Any other cons, @('(A . B)'), represents the conjunction of @('A') and
-@('B').
-
-
-
-This meaning of cons trees is given by the evaluation function @(see
-aig-eval), which returns the (Boolean) value of an AIG under some particular
-assignment to its variables. Note that every ACL2 object is a well-formed AIG
-under this definition.
-
-
-Library Functions
-
-We provide some basic, low-level @(see aig-constructors) for building
-AIGs (and , or , etc.). We prove these operations correct with
-respect to @(see aig-eval).
-
-There are also higher-level operations such as @(see aig-restrict) and @(see
-aig-compose) allow you to substitute into AIGs.
-
-It is often important to know which variables occur in an AIG. One way to
-do this is with @(see aig-vars).
-
-The @(see bddify) algorithm provides a way to construct a BDD from an AIG.
-This is also used as the basis for an efficient @(see GL) symbolic counterpart
-of @(see aig-eval).
-
-BOZO other things that we haven't released yet.
")
-
-
-
-; -----------------------------------------------------------------------------
-;
-; EVALUATING AIGS
-;
-; -----------------------------------------------------------------------------
-
-(defsection aig-env-lookup-missing-output
- :parents (aig-eval)
- :short "Stub for warnings about missing variables in AIG evaluation."
-
- :long "This stub is called when @(see aig-eval) encounters a variable in
-the AIG that has no binding in the environment. It is generally configured
-with @(see aig-env-lookup-missing-action).
"
-
- (defstub aig-env-lookup-missing-output (name) nil))
-
-
-(defsection aig-env-lookup-missing-action
- :parents (aig-eval)
- :short "Configure warnings about missing variables in AIG evaluation."
-
- :long "Ordinarily @(see aig-eval) treats any variables that are not bound
-in the environment as having value @('t'). But a missing bindings could be the
-result of a bug in your program, so by default @('aig-eval') is set up to print
-a warning if this happens.
-
-@(call aig-env-lookup-missing-action) allows you to control whether these
-warnings are printed, and also whether @(see break$) should be called. The
-valid @('action')s are:
-
-
- @('nil'), silently bind the variable to @('t'),
- @(':warn') (the default), print a warning but do not @('break$'), and
- @(':break'), to print the warning and then call @('break$').
- "
-
- (defconst *aig-env-lookup-warn-missing-binding*
- ;; Even with the stub and defattach, it is useful to have this "constant"
- ;; so that, in raw lisp, we can use a let-binding to disable missing output
- ;; warnings temporarily, e.g., so that if a SAT solver produces an
- ;; incomplete counterexample, we don't print warnings when we check it.
- ;; Doing this with defattach directly would be hard/impossible due to
- ;; attachment being an event.
- t)
-
- (defun aig-env-lookup-missing-quiet (name)
- (declare (xargs :guard t) (ignore name))
- nil)
-
- (defun aig-env-lookup-missing-complain (name)
- (declare (xargs :guard t))
- (and *aig-env-lookup-warn-missing-binding*
- (cw "WARNING: Missing variable binding ~x0 in AIG-ENV-LOOKUP; ~
- assigning T~%"
- name)))
-
- (local (in-theory (disable (break$))))
-
- (defun aig-env-lookup-missing-break (name)
- (declare (xargs :guard t))
- (and *aig-env-lookup-warn-missing-binding*
- (prog2$ (cw "WARNING: Missing variable binding ~x0 in ~x1; assigning ~
- T. To avoid this break, run ~x2, where action is NIL or ~
- :WARN.~%"
- name
- 'aig-env-lookup
- '(aig-env-lookup-missing-action action))
- (break$))))
-
- (defmacro aig-env-lookup-missing-action (val)
- (case val
- ((nil) '(defattach aig-env-lookup-missing-output
- aig-env-lookup-missing-quiet))
- (:warn '(defattach aig-env-lookup-missing-output
- aig-env-lookup-missing-complain))
- (:break '(defattach aig-env-lookup-missing-output
- aig-env-lookup-missing-break))
- (t (er hard 'aig-env-lookup-missing-action
- "Expected argument NIL, :WARN, or :BREAK.~%"))))
-
- (aig-env-lookup-missing-action :warn))
-
-
-;;(defsection aig-cases
-;; :parents (aig)
-;; :short "Control-flow macro to split into cases on what kind of AIG you have
-;;encountered."
-;; :long "@(def aig-cases)"
-
-;; (defmacro aig-cases (x &key true false var inv and)
-;; `(let ((aig-cases-var ,x))
-;; (cond
-;; ((eq aig-cases-var t) ,true)
-;; ((eq aig-cases-var nil) ,false)
-;; ((atom aig-cases-var) ,var)
-;; ((eq (cdr aig-cases-var) nil) ,inv)
-;; (t ,and)))))
-
-(defsection aig-cases
- :parents (aig)
- :short "Control-flow macro to split into cases on what kind of AIG you have
-encountered."
- :long "@(def aig-cases)"
-
- (defmacro aig-cases (x &key true false var inv and)
- `(let ((aig-cases-var ,x))
- (cond
- ((atom aig-cases-var)
- (cond ((eq aig-cases-var t) ,true)
- ((eq aig-cases-var nil) ,false)
- (t ,var)))
- ((eq (cdr aig-cases-var) nil) ,inv)
- (t ,and)))))
-
-
-
-(defsection aig-eval
- :parents (aig)
- :short "@(call aig-eval) evaluates @('x'), an @(see aig), under the
-environment @('env'), producing a Boolean result."
-
- :long "The @('env') should be a fast alist (see @(see fast-alists)) that
-binds variables in the AIG to values. Typically it should bind every variable
-in the AIG to a Boolean value.
-
-This function is @(see memoize)d. You should typically free its memo table
-after you are done with whatever @('env') you are using, to avoid excessive
-memory usage. (We don't use @(':forget t') because you often want to evaluate
-several related AIGs.)
-
-Unbound variables are given the default value @('t') instead of @('nil')
-because this makes theorems about @(see faig) evaluation work out more
-nicely (it makes unbound FAIG variables evaluate to @('X')).
-
-This function essentially defines the semantics of AIGs.
"
-
- ;; [Jared] BOZO it might be good to add a check that the variables are indeed
- ;; bound to Booleans.
-
- (defun aig-env-lookup (x env)
- (declare (xargs :guard t))
- (let ((look (hons-get x env)))
- (if look
- ;; [Jared] I was once tempted to change this to produce an always
- ;; Boolean result, since it would seem nicer to do that here than in
- ;; aig-eval. But this function is also used in AIG-COMPOSE, and it
- ;; is not valid to Boolean-fix it there.
- (cdr look)
- (mbe :logic t
- :exec
- (if *aig-env-lookup-warn-missing-binding*
- (prog2$ (aig-env-lookup-missing-output x)
- t)
- t)))))
-
- (defun aig-eval (x env)
- (declare (xargs :guard t))
- (aig-cases x
- :true t
- :false nil
- :var (and (aig-env-lookup x env) t)
- :inv (not (aig-eval (car x) env))
- :and (and (aig-eval (car x) env)
- (aig-eval (cdr x) env))))
-
- ;; [Jared] note, changed memoization condition from just (consp x) to exclude
- ;; not nodes; this matches aig-vars and I think is probably what we want.
- (memoize 'aig-eval :condition '(and (consp x) (cdr x))))
-
-
-(defsection aig-eval-list
- :parents (aig-eval)
- :short "@(call aig-eval-list) evaluates a list of AIGs."
-
- ;; BOZO formal is named benv right now, eventually rename to env but we need
- ;; to patch up GL so it doesn't care about formals named env.
- (defun aig-eval-list (x benv)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (cons (aig-eval (car x) benv)
- (aig-eval-list (cdr x) benv)))))
-
-
-(defsection aig-eval-alist
- :parents (aig-eval)
- :short "@(call aig-eval-alist) evaluates an AIG Alist (an alist binding keys
-to AIGs)."
-
- :long "The alist @('x') does not need to be fast, and we produce an
-ordinary (slow) alist as a result.
"
-
- (defun aig-eval-alist (x env)
- (declare (xargs :guard t))
- (cond ((atom x)
- nil)
- ((atom (car x))
- ;; Bad-alist convention
- (aig-eval-alist (cdr x) env))
- (t
- (cons (cons (caar x) (aig-eval (cdar x) env))
- (aig-eval-alist (cdr x) env))))))
-
-
-
-(defsection aig-eval-alists
- :parents (aig-eval)
- :short "Evaluate a list of AIG Alists."
-
- (defun aig-eval-alists (x env)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (cons (aig-eval-alist (car x) env)
- (aig-eval-alists (cdr x) env)))))
-
-
-
-
-; -----------------------------------------------------------------------------
-;
-; COLLECTING AIG VARIABLES
-;
-; -----------------------------------------------------------------------------
-
-(defsection aig-vars
- :parents (aig)
- :short "@(call aig-vars) returns the list of variables used in the AIG
-@('X')."
-
-;; BOZO the :long here refers to the unreleased sexpr library, but I don't want
-;; to redo all that documentation for AIGs.
-
- :long "This is one scheme for collecting variables from an AIG. We
-memoize the whole computation and return ordered lists so that merging is
-linear. This can be very expensive. See @(see 4v-sexpr-vars) for an analagous
-discussion.
"
-
- (defun aig-vars (x)
- (declare (xargs :guard t
- :verify-guards nil))
- (aig-cases x
- :true nil
- :false nil
- :var (mbe :logic (sets::insert x nil)
- :exec (hons x nil))
- :inv (aig-vars (car x))
- :and (mbe :logic (sets::union (aig-vars (car x))
- (aig-vars (cdr x)))
- :exec (hons-alphorder-merge (aig-vars (car x))
- (aig-vars (cdr x))))))
-
- (defthm atom-listp-aig-vars
- (atom-listp (aig-vars x)))
-
- (defthm true-listp-aig-vars
- (true-listp (aig-vars x))
- :rule-classes :type-prescription)
-
- (defthm setp-aig-vars
- (sets::setp (aig-vars x))
- :hints(("Goal" :in-theory (enable* (:ruleset sets::primitive-rules)))))
-
- (verify-guards aig-vars
- :hints(("Goal" :in-theory (enable* (:ruleset sets::primitive-rules)))))
-
- (memoize 'aig-vars :condition '(and (consp x) (cdr x))))
-
-
-
-
-; -----------------------------------------------------------------------------
-;
-; AIG CONSTRUCTION
-;
-; -----------------------------------------------------------------------------
-
-(defxdoc aig-constructors
- :parents (aig)
- :short "Low-level functions for constructing AIGs.")
-
-
-
-(defsection aig-not
- :parents (aig-constructors)
- :short "@(call aig-not) constructs an AIG representing @('(not x)')."
-
- :long "This could be implemented as @('(hons x nil)'), but we at least
-take care to fold constants and avoid creating double negatives.
"
-
- (defund aig-not (x)
- (declare (xargs :guard t))
- (cond ((eq x nil) t)
- ((eq x t) nil)
- ((and (consp x) (eq (cdr x) nil))
- (car x))
- (t
- (hons x nil))))
-
- (local (in-theory (enable aig-not)))
-
- (defthm aig-eval-not
- (equal (aig-eval (aig-not x) env)
- (not (aig-eval x env)))))
-
-
-
-(defsection aig-and
- :parents (aig-constructors)
- :short "@(call aig-and) constructs an AIG representing @('(and x y)')."
-
- :long "This could have been implemented as @('(hons x y)'), but we take
-care to fold constants and reduce @('x & x') and @('x & ~x').
"
-
- (defund aig-and (x y)
- (declare (xargs :guard t))
- (cond
- ((or (eq x nil) (eq y nil)) nil)
- ((eq x t) y)
- ((eq y t) x)
- ((hons-equal x y) x)
- ((and (consp y) (eq (cdr y) nil)
- (hons-equal (car y) x))
- nil)
- ((and (consp x) (eq (cdr x) nil)
- (hons-equal (car x) y))
- nil)
- (t (hons x y))))
-
- (local (in-theory (enable aig-and)))
-
- (defthm aig-eval-and
- (equal (aig-eval (aig-and x y) env)
- (and (aig-eval x env)
- (aig-eval y env))))
-
- (defthm aig-and-constants
- (and (equal (aig-and nil x) nil)
- (equal (aig-and x nil) nil)
- (equal (aig-and x t) x)
- (equal (aig-and t x) x))))
-
-
-
-(defsection aig-or
- :parents (aig-constructors)
- :short "@(call aig-or) constructs an AIG representing @('(or x y)')."
-
- (defund aig-or (x y)
- (declare (xargs :guard t))
- (aig-not (aig-and (aig-not x) (aig-not y))))
-
- (local (in-theory (enable aig-or)))
-
- (defthm aig-eval-or
- (equal (aig-eval (aig-or x y) env)
- (or (aig-eval x env)
- (aig-eval y env)))))
-
-
-
-(defsection aig-xor
- :parents (aig-constructors)
- :short "@(call aig-xor) constructs an AIG representing @('(xor x y)')."
-
- (defund aig-xor (x y)
- (declare (xargs :guard t))
- (aig-or (aig-and x (aig-not y))
- (aig-and (aig-not x) y)))
-
- (local (in-theory (enable aig-xor)))
-
- (defthm aig-eval-xor
- (equal (aig-eval (aig-xor x y) env)
- (xor (aig-eval x env)
- (aig-eval y env)))))
-
-
-
-(defsection aig-iff
- :parents (aig-constructors)
- :short "@(call aig-iff) constructs an AIG representing @('(iff x y)')."
-
- (defund aig-iff (x y)
- (declare (xargs :guard t))
- (aig-or (aig-and x y)
- (aig-and (aig-not x) (aig-not y))))
-
- (local (in-theory (enable aig-iff)))
-
- (defthm aig-eval-iff
- (equal (aig-eval (aig-iff x y) env)
- (iff (aig-eval x env)
- (aig-eval y env)))))
-
-
-
-(defsection aig-implies
- :parents (aig-constructors)
- :short "@(call aig-implies) constructs an AIG representing @('(implies x
- y)')."
-
- (defund aig-implies (x y)
- (declare (xargs :guard t))
- (aig-not (aig-and x (aig-not y))))
-
- (local (in-theory (enable aig-implies)))
-
- (defthm aig-eval-implies
- (equal (aig-eval (aig-implies x y) env)
- (implies (aig-eval x env)
- (aig-eval y env)))))
-
-
-
-(defsection aig-ite
- :parents (aig-constructors)
- :short "@(call aig-ite) constructs an AIG representing @('(if a b c)')."
-
- (defund aig-ite (a b c)
- (declare (xargs :guard t))
- (cond ((hons-equal b c)
- b)
- ((eq b t)
- (aig-or a c))
- (t
- (aig-or (aig-and a b)
- (aig-and (aig-not a) c)))))
-
- (local (in-theory (enable aig-ite)))
-
- (defthm aig-eval-ite
- (iff (aig-eval (aig-ite a b c) env)
- (if (aig-eval a env)
- (aig-eval b env)
- (aig-eval c env)))))
-
-
-(defsection aig-not-list
- :parents (aig-constructors)
- :short "@(call aig-not-list) negates every AIG in the list @('x')."
-
- (defun aig-not-list (x)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (cons (aig-not (car X))
- (aig-not-list (cdr x))))))
-
-
-(defsection aig-and-list
- :parents (aig-constructors)
- :short "@(call aig-and-list) ands together all of the AIGs in the list
-@('x')."
-
- (defun aig-and-list (x)
- (declare (xargs :guard t))
- (if (atom x)
- t
- (aig-and (car x)
- (aig-and-list (cdr x))))))
-
-
-(defsection aig-or-list
- :parents (aig-constructors)
- :short "@(call aig-or-list) ors together all of the AIGs in the list @('x')."
-
- (defun aig-or-list (x)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (aig-or (car x) (aig-or-list (cdr x))))))
-
-
-(defsection aig-and-lists
- :parents (aig-constructors)
- :short "@(call aig-and-lists) pairwise and s together the AIGs from the
-lists @('x') and @('y')."
-
- (defun aig-and-lists (x y)
- (if (or (atom x) (atom y))
- nil
- (cons (aig-and (car x) (car y))
- (aig-and-lists (cdr x) (cdr y))))))
-
-
-(defsection aig-or-lists
- :parents (aig-constructors)
- :short "@(call aig-or-lists) pairwise or s together the AIGs from the
-lists @('x') and @('y')."
-
- (defun aig-or-lists (x y)
- (declare (xargs :guard t))
- (if (or (atom x) (atom y))
- nil
- (cons (aig-or (car x) (car y))
- (aig-or-lists (cdr x) (cdr y))))))
-
-
-(defsection aig-iff-lists
- :parents (aig-constructors)
- :short "@(call aig-iff-lists) pairwise iff s together the AIGs from the
-lists @('x') and @('y')."
-
- (defun aig-iff-lists (x y)
- (declare (xargs :guard t))
- (if (or (atom x) (atom y))
- nil
- (cons (aig-iff (car x) (car y))
- (aig-iff-lists (cdr x) (cdr y))))))
-
-
-(defsection aig-xor-lists
- :parents (aig-constructors)
- :short "@(call aig-xor-lists) pairwise xor s together the AIGs from the
-lists @('x') and @('y')."
-
- (defun aig-xor-lists (x y)
- (declare (xargs :guard t))
- (if (or (atom x) (atom y))
- nil
- (cons (aig-xor (car x) (car y))
- (aig-xor-lists (cdr x) (cdr y))))))
-
-
-(defsection aig-implies-lists
- :parents (aig-constructors)
- :short "@(call aig-implies-lists) pairwise implies together the AIGs
-from the lists @('x') and @('y')."
-
- (defun aig-implies-lists (x y)
- (declare (xargs :guard t))
- (if (or (atom x) (atom y))
- nil
- (cons (aig-implies (car x) (car y))
- (aig-implies-lists (cdr x) (cdr y))))))
-
-
-
-
-; -----------------------------------------------------------------------------
-;
-; SUBSTITUTION INTO AIGS
-;
-; -----------------------------------------------------------------------------
-
-(defsection aig-restrict
- :parents (aig)
- :short "@(call aig-restrict) performs variable substitution throughout the
-AIG @('x'), replacing any variables bound in @('sigma') with their
-corresponding values."
-
- :long "@('sigma') should be a fast alist; its name is intended to evoke
-the notion of substitution lists in logic. Any variables that are not
-mentioned in @('sigma') are left unchanged.
-
-This function is @(see memoize)d. You should typically free its memo table
-after you are done with whatever @('sigma') you are using, to avoid excessive
-memory usage. (We don't use @(':forget t') because you often want to restrict
-several related AIGs.)
-
-When all of the variables in @('x') are bound in @('sigma'), and all of the
-values are Boolean, this is equivalent to @(see aig-eval).
-
-Some related functions are @(see aig-compose) and @(see
-aig-partial-eval).
"
-
- (defun aig-restrict (x sigma)
- (declare (xargs :guard t))
- (aig-cases x
- :true t
- :false nil
- :var (let ((a (hons-get x sigma)))
- (if a
- (cdr a)
- x))
- :inv (aig-not (aig-restrict (car x) sigma))
- :and (let ((a (aig-restrict (car x) sigma)))
- (and a (aig-and a (aig-restrict (cdr x) sigma))))))
-
- (memoize 'aig-restrict :condition '(and (consp x) (cdr x))))
-
-
-(defsection aig-restrict-list
- :parents (aig-restrict)
- :short "@(call aig-restrict-list) substitutes into a list of AIGs."
-
- (defun aig-restrict-list (x sigma)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (cons (aig-restrict (car x) sigma)
- (aig-restrict-list (cdr x) sigma)))))
-
-
-(defsection aig-restrict-alist
- :parents (aig-restrict)
- :short "@(call aig-restrict-alist) substitutes into an AIG Alist (an alist
-binding keys to AIGs)."
-
- :long "The alist @('x') does not need to be fast, and we produce an
-ordinary (slow) alist as a result.
"
-
- (defun aig-restrict-alist (x sigma)
- (declare (xargs :guard t))
- (cond ((atom x)
- nil)
- ((atom (car x))
- ;; Bad-alist convention
- (aig-restrict-alist (cdr x) sigma))
- (t
- (cons (cons (caar x)
- (aig-restrict (cdar x) sigma))
- (aig-restrict-alist (cdr x) sigma)))))
-
- (defthm alistp-of-aig-restrict-alist
- (alistp (aig-restrict-alist x sigma))))
-
-
-(defsection aig-restrict-alists
- :parents (aig-restrict)
- :short "@(call aig-restrict-alists) substitutes into a list of AIG Alists."
-
- (defun aig-restrict-alists (x sigma)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (cons (aig-restrict-alist (car x) sigma)
- (aig-restrict-alists (cdr x) sigma)))))
-
-
-
-
-; -----------------------------------------------------------------------------
-;
-; AIG COMPOSITION
-;
-; -----------------------------------------------------------------------------
-
-(defsection aig-compose
- :parents (aig)
- :short "@(call aig-compose) performs variable substitution throughout the AIG
-@('x'), unconditionally replacing every variable in @('x') with its
-binding in @('sigma')."
-
- :long "@('sigma') should be a fast alist; its name is intended to evoke
-the notion of substitution lists in logic.
-
-This function is @(see memoize)d. You should typically free its memo table
-after you are done with whatever @('sigma') you are using, to avoid excessive
-memory usage. (We don't use @(':forget t') because you often want to compose
-several related AIGs.)
-
-This operation is similar to @(see aig-restrict), except that whereas
-@('aig-restrict') leaves unbound variables alone, @('aig-compose') replaces
-them with @('t'). (This has the logically nice property that the variables
-after composition are just the variables in the AIGs of @('sigma').)
"
-
- (defun aig-compose (x sigma)
- (declare (xargs :guard t))
- (aig-cases x
- :true t
- :false nil
- :var (aig-env-lookup x sigma)
- :inv (aig-not (aig-compose (car x) sigma))
- :and (let ((a (aig-compose (car x) sigma)))
- (and a (aig-and a (aig-compose (cdr x) sigma))))))
-
- (memoize 'aig-compose :condition '(and (consp x) (cdr x))))
-
-
-(defsection aig-compose-list
- :parents (aig-compose)
- :short "@(call aig-compose-list) composes into a list of AIGs."
-
- (defun aig-compose-list (x sigma)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (cons (aig-compose (car x) sigma)
- (aig-compose-list (cdr x) sigma)))))
-
-
-(defsection aig-compose-alist
- :parents (aig-compose)
- :short "@(call aig-compose-alist) composes into an AIG Alist (an alist
-binding keys to AIGs)."
-
- :long "The alist @('x') does not need to be fast, and we produce an
-ordinary (slow) alist as a result.
"
-
- (defun aig-compose-alist (x sigma)
- (declare (xargs :guard t))
- (cond ((atom x)
- nil)
- ((atom (car x))
- ;; Bad alist convention
- (aig-compose-alist (cdr x) sigma))
- (t
- (cons (cons (caar x)
- (aig-compose (cdar x) sigma))
- (aig-compose-alist (cdr x) sigma))))))
-
-
-(defsection aig-compose-alists
- :parents (aig-compose)
- :short "@(call aig-compose-alists) composes into a list of AIG Alists."
-
- (defn aig-compose-alists (x sigma)
- (if (atom x)
- nil
- (cons (aig-compose-alist (car x) sigma)
- (aig-compose-alists (cdr x) sigma)))))
-
-
-
-; -----------------------------------------------------------------------------
-;
-; PARTIALLY EVALUATING AIGS
-;
-; -----------------------------------------------------------------------------
-
-(defsection aig-partial-eval
- :parents (aig)
- :short "@(call aig-partial-eval) evaluates @('x'), an AIG, under the partial
-environment @('env'), producing a new AIG as a result."
-
- :long "@('env') should be a fast alist that binds some of the variables in
-the AIG to Boolean values.
-
-This function is @(see memoize)d. You should typically free its memo table
-after you are done with whatever @('env') you are using, to avoid excessive
-memory usage. (We don't use @(':forget t') because you often want to evaluate
-several related AIGs.)
-
-In ordinary AIG evaluation with @(see aig-eval), any variables that are
-missing from @('env') are just assumed to have a default value. Because of
-this, every variable can be given a Boolean value and we can evaluate the whole
-AIG to produce a Boolean result.
-
-In partial evaluation, variables that aren't bound in @('env') are left
-alone. Because of this, the result of a partial evaluation is a
-new (presumably smaller) AIG, instead of a Boolean.
-
-Another way to do partial evaluations is with @(see aig-restrict). The only
-difference between @('aig-restrict') and @('aig-partial-eval') is that
-@('aig-partial-eval') Boolean-fixes the values in the alist as it looks them
-up. This has logically nice properties, e.g., since we never replace a
-variable by a subtree, only by a Boolean, we know unconditionally that the
-variables of the resulting AIG are a subset of the variables of the
-original.
"
-
- (defun aig-partial-eval (x env)
- (declare (xargs :guard t))
- (aig-cases x
- :true t
- :false nil
- :var (let ((a (hons-get x env)))
- (if a (and (cdr a) t) x))
- :inv (aig-not (aig-partial-eval (car x) env))
- :and (let ((a (aig-partial-eval (car x) env)))
- (and a
- (aig-and a (aig-partial-eval (cdr x) env))))))
-
- ;; [Jared] note: this had no memoize condition, so I added the usual one.
-
- (memoize 'aig-partial-eval :condition '(and (consp x) (cdr x))))
-
-
-(defsection aig-partial-eval-list
- :parents (aig-partial-eval)
- :short "@(call aig-partial-eval-list) partially evaluates a list of AIGs."
-
- (defun aig-partial-eval-list (x env)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (cons (aig-partial-eval (car x) env)
- (aig-partial-eval-list (cdr x) env)))))
-
-
-(defsection aig-partial-eval-alist
- :parents (aig-partial-eval)
- :short "@(call aig-partial-eval-alist) partially evaluates an AIG Alist (an
-alist binding keys to AIGs)."
-
- :long "The alist @('x') does not need to be fast, and we produce an
-ordinary (slow) alist as a result.
"
-
- (defun aig-partial-eval-alist (x env)
- (declare (xargs :guard t))
- (cond ((atom x)
- nil)
- ((atom (car x))
- ;; Bad-alist convention
- (aig-partial-eval-alist (cdr x) env))
- (t
- (cons (cons (caar x)
- (aig-partial-eval (cdar x) env))
- (aig-partial-eval-alist (cdr x) env)))))
-
- (defthm alistp-of-aig-partial-eval-alist
- (alistp (aig-partial-eval-alist x env))))
-
-
-
-
-; -----------------------------------------------------------------------------
-;
-; FOUR-VALUED AIG OPERATIONS
-;
-; -----------------------------------------------------------------------------
-
-; [Jared] it would be nice to move the FAIG stuff out into a separate file.
-
-(defxdoc faig
- :short "A representation of a four-valued function using two AIGs."
-
- :long "A FAIG (Four-valued AIG) combines two @(see aig)s together
-to represent a function with four possible values. Such functions can be
-useful in hardware verification.
-
-We represent an FAIG as the cons of two AIGs, which are called the
-onset and offset of the FAIG. Our FAIG evaluation function,
-@(see faig-eval), just evaluates these two AIGs, separately, using ordinary
-@(see aig-eval), and conses together the resulting Boolean values. So, the
-four possible values of an FAIG are:
-
-
-
-@('(nil . nil)'), which we call Z,
-
-@('(t . nil)'), which we call True,
-
-@('(nil . t)'), which we call False, and
-
-@('(t . t)'), which we call X.
-
-
-
-We generally think of the onset as being a Boolean functions that should
-evaluate to @('T') when the wire is being driven to 1. The offset is similar,
-but indicates whether the wire is being driven to 0. So, the Z value
-represents a situation where the wire is completely undriven, and the X value
-represents a bad case where the wire is simultaneously driven to both True and
-False.
-
-Hons convention. We ordinarly construct all AIGs with @(see hons), but we
-don't bother to hons the FAIG conses that put these AIGs together.
-
-BOZO discuss vu-faigs too.
")
-
-
-; [Jared] BOZO consider a warning as in aig-eval for when faig-eval,
-; faig-restrict, etc., are used on non-consp arguments.
-
-(defsection faig-eval
- :parents (faig)
- :short "@(call faig-eval) evaluates @('x'), a @(see faig), under the
-environment @('env'), producing a pair of Boolean values."
-
- :long "See @(see aig-eval); the @('env') should be a fast alist and you
-will want to clear the memoize table for @('aig-eval') when you are done using
-the @('env').
"
-
- (defun faig-eval (x env)
- (declare (xargs :guard t))
- (if (atom x)
- '(t . t)
- (cons (aig-eval (car x) env)
- (aig-eval (cdr x) env)))))
-
-
-(defsection faig-eval-list
- :parents (faig-eval)
- :short "@(call faig-eval-list) evaluates a list of FAIGs."
-
- (defun faig-eval-list (x env)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (cons (faig-eval (car x) env)
- (faig-eval-list (cdr x) env)))))
-
-
-(defsection faig-eval-alist
- :parents (faig-eval)
- :short "@(call faig-eval-list) evaluates an FAIG alist (an alist binding
-keys to FAIGs)."
-
- :long "The alist @('x') does not need to be fast, and we produce an
-ordinary (slow) alist as a result.
"
-
- (defun faig-eval-alist (x env)
- (declare (xargs :guard t))
- (cond ((atom x)
- nil)
- ((atom (car x))
- ;; Bad alist convention
- (faig-eval-alist (cdr x) env))
- (t
- (cons (cons (caar x)
- (faig-eval (cdar x) env))
- (faig-eval-alist (cdr x) env))))))
-
-
-
-
-(defsection faig-restrict
- :parents (faig)
- :short "@(call faig-restrict) performs variable substitution throughout the
-FAIG @('x'), replacing any variables bound in @('sigma') with their
-corresponding values."
-
- :long "See @(see aig-restrict); the @('env') should be a fast alist and
-you will want to clear the memoize table for @('aig-restrict') when you are
-done using the @('env').
"
-
- (defun faig-restrict (x sigma)
- (declare (xargs :guard t))
- (if (atom x)
- '(t . t)
- (cons (aig-restrict (car x) sigma)
- (aig-restrict (cdr x) sigma)))))
-
-
-(defsection faig-restrict-alist
- :parents (faig-restrict)
- :short "@(call faig-restrict-alist) substitutes into an FAIG alist (an alist
-binding keys to FAIGs)."
-
- :long "The alist @('x') does not need to be fast, and we produce an
-ordinary (slow) alist as a result.
"
-
- (defun faig-restrict-alist (x sigma)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (let ((rest (faig-restrict-alist (cdr x) sigma)))
- (if (atom (car x))
- ;; Bad alist convention
- rest
- (cons (cons (caar x) (faig-restrict (cdar x) sigma))
- rest))))))
-
-
-(defsection faig-restrict-alists
- :parents (faig-restrict)
- :short "@(call faig-restrict-alists) substitutes into a list of FAIG alists."
-
- (defun faig-restrict-alists (x sigma)
- (if (atom x)
- nil
- (cons (faig-restrict-alist (car x) sigma)
- (faig-restrict-alists (cdr x) sigma)))))
-
-
-
-
-(defsection faig-compose
- :parents (faig)
- :short "@(call faig-compose) performs variable substitution throughout the
-FAIG @('x'), unconditionally replacing every variable in @('x') with its
-binding in @('sigma')."
-
- :long "See @(see aig-compose); the @('sigma') should be a fast alist and
-you will want to clear the memoize table for @('aig-compose') when you are done
-using the @('env').
"
-
- (defun faig-compose (x sigma)
- (declare (xargs :guard t))
- (if (atom x)
- '(t . t)
- (cons (aig-compose (car x) sigma)
- (aig-compose (cdr x) sigma)))))
-
-
-(defsection faig-compose-alist
- :parents (faig)
- :short "@(call faig-compose-alist) composes into an FAIG Alist (an alist
-binding keys to FAIGs)."
-
- :long "The alist @('x') does not need to be fast, and we produce an
-ordinary (slow) alist as a result.
"
-
- (defun faig-compose-alist (x sigma)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (let ((rest (faig-compose-alist (cdr x) sigma)))
- (if (atom (car x))
- ;; Bad alist convention
- rest
- (cons (cons (caar x) (faig-compose (cdar x) sigma))
- rest))))))
-
-
-
-
-(defsection faig-partial-eval
- :parents (faig)
- :short "@(call faig-partial-eval) evaluates @('x'), an FAIG, under the
-partial environment @('env'), producing a new FAIG as a result."
-
- :long "See @(see aig-partial-eval); the @('env') should be a fast alist
-and you will want to clear the memoize table for @('aig-partial-eval') when you
-are done using the @('env').
"
-
- (defun faig-partial-eval (x env)
- (declare (xargs :guard t))
- (if (atom x)
- '(t . t)
- (cons (aig-partial-eval (car x) env)
- (aig-partial-eval (cdr x) env)))))
-
-
-(defsection faig-partial-eval-alist
- :parents (faig-partial-eval)
- :short "@(call faig-partial-eval-alist) partially evaluates an FAIG alist (an
-alist binding keys to FAIGs)."
-
- :long "The alist @('x') does not need to be fast, and we produce an
-ordinary (slow) alist as a result.
"
-
- (defun faig-partial-eval-alist (x env)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (let ((rest (faig-partial-eval-alist (cdr x) env)))
- (if (atom (car x))
- ;; Bad alist convention
- rest
- (cons (cons (caar x) (faig-partial-eval (cdar x) env))
- rest))))))
-
-
-(defsection faig-partial-eval-alists
- :parents (faig-partial-eval)
- :short "@(call faig-partial-eval-alists) partially evaluates a list of FAIG
-alists."
-
- (defund faig-partial-eval-alists (x env)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (cons (faig-partial-eval-alist (car x) env)
- (faig-partial-eval-alists (cdr x) env)))))
-
-
-
-
-(defsection faig-fix
- :parents (faig)
- :short "@(call faig-fix) is the identity for FAIGs, but coerces atoms to
-@('(t . t)'), i.e., X."
-
- :long "This is sometimes when reasoning about FAIG operations.
"
-
- (defun faig-fix (x)
- (declare (xargs :guard t))
- (if (consp x) x '(t . t))))
-
-
-(defsection faig-fix-list
- :parents (faig-fix)
- :short "@(call faig-fix-list) fixes every element of a list with @(see
-faig-fix)."
-
- (defun faig-fix-list (x)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (cons (faig-fix (car x))
- (faig-fix-list (cdr x))))))
-
-
-(defsection faig-fix-alist
- :parents (faig-fix)
- :short "@(call faig-fix-alist) fixes every value in an alist with @(see
-faig-fix)."
-
- (defun faig-fix-alist (x)
- (declare (xargs :guard t))
- (cond ((atom x)
- nil)
- ((atom (car x))
- ;; Bad-alist convention
- (faig-fix-alist (cdr x)))
- (t
- (cons (cons (caar x) (faig-fix (cdar x)))
- (faig-fix-alist (cdr x)))))))
-
-
-
-
-
-
-;; [Jared] These might be more properly part of EMOD/ESIM
-
-(defun aig-eval-pat (pat x al)
- (declare (xargs :guard t))
- (if pat
- (if (atom pat)
- (aig-eval x al)
- (cons (aig-eval-pat (car pat) (ec-call (car x)) al)
- (aig-eval-pat (cdr pat) (ec-call (cdr x)) al)))
- nil))
-
-(defn faig-eval-pat (pat x al)
- (if pat
- (if (atom pat)
- (faig-eval x al)
- (cons (faig-eval-pat (car pat) (ec-call (car x)) al)
- (faig-eval-pat (cdr pat) (ec-call (cdr x)) al)))
- nil))
-
-(defn faig-restrict-pat (pat fpat al)
- (if pat
- (if (atom pat)
- (faig-restrict fpat al)
- (cons (faig-restrict-pat (car pat) (ec-call (car fpat)) al)
- (faig-restrict-pat (cdr pat) (ec-call (cdr fpat)) al)))
- nil))
-
-(defn faig-compose-pat (pat fpat al)
- (if pat
- (if (atom pat)
- (faig-compose fpat al)
- (cons (faig-compose-pat (car pat) (ec-call (car fpat)) al)
- (faig-compose-pat (cdr pat) (ec-call (cdr fpat)) al)))
- nil))
-
-(defn faig-partial-eval-pat (pat fpat al)
- (if pat
- (if (atom pat)
- (faig-partial-eval fpat al)
- (cons (faig-partial-eval-pat (car pat) (ec-call (car fpat)) al)
- (faig-partial-eval-pat (cdr pat) (ec-call (cdr fpat)) al)))
- nil))
-
-
-
-
-
-;; [Jared] Can we get rid of this stuff?
-
-(defn faigp (x) (consp x))
-
-(defn faig-listp (x)
- (if (consp x)
- (and (faigp (car x))
- (faig-listp (cdr x)))
- (null x)))
-
-(in-theory (disable faig-listp))
-
-(defn aig-p (x)
- (aig-cases
- x
- :true t
- :false t
- :var t
- :inv (and (aig-p (car x))
- (hons-equal (aig-not (car x)) x))
- :and (and (aig-p (car x))
- (aig-p (cdr x))
- (hons-equal (aig-and (car x) (cdr x)) x))))
-
-(memoize 'aig-p :condition '(and (consp x) (cdr x)))
-
-(defn faig-patternp (pat x)
- (if pat
- (if (atom pat)
- (and (consp x)
- (aig-p (car x))
- (aig-p (cdr x)))
- (and (consp x)
- (faig-patternp (car pat) (car x))
- (faig-patternp (cdr pat) (cdr x))))
- t))
-
-
-
-
-
-
-
-
-
-;; [Jared] Removed these things...
-
-
-;; Note that these next two functions are provably equal to T.
-;; (defn aigp (x)
-;; (or
-;; (atom x)
-;; (and (consp x) (null (cdr x)))
-;; (and (aigp (car x)) (aigp (cdr x))))
-;; )
-
-;; (defn aig-listp (x)
-;; (if (consp x)
-;; (and
-;; (aigp (car x))
-;; (aig-listp (cdr x)))
-;; t))
-
-
-;; [Jared] this was never used anywhere, i think it's not necessary since
-;; aig-compose uses aig-env-lookup
-
-;; (defconst *aig-compose-warn-missing-binding* t)
-
-
-
-
-
-;; [jared] this macro stuff was just used in one old mmx property checking
-;; thing it might be reasonable to put in xxxjoin style macros for aig-and,
-;; aig-or, etc.; could also implement the lazy evaluation stuff like in ubdds,
-;; if desired.
-
-;; ;---- some macros for aig-or/aig-and/...
-;; ;do we want to rebalance it (make it less deep and smaller)?
-;; ; would rebalancing have any impact on zz-sat performance?
-;; (defn aig-and-fn (lst)
-;; (if (consp lst)
-;; (if (consp (cdr lst))
-;; (list
-;; 'aig-and
-;; (car lst)
-;; (aig-and-fn (cdr lst)))
-;; (car lst))
-;; t)
-;; )
-
-;; (defmacro aig-and-macro (&rest args) (aig-and-fn args))
-
-;; (defn aig-or-fn (lst)
-;; (if (consp lst)
-;; (if (consp (cdr lst))
-;; (list
-;; 'aig-or
-;; (car lst)
-;; (aig-or-fn (cdr lst)))
-;; (car lst))
-;; nil)
-;; )
-
-;; (defmacro aig-or-macro (&rest args) (aig-or-fn args))
-
-;; (defn one-hot-fn (lst)
-;; (if (consp lst)
-;; (if (consp (cdr lst))
-;; `(aig-or
-;; (aig-and
-;; ,(car lst)
-;; (aig-not ,(aig-or-fn (cdr lst))))
-;; (aig-and
-;; (aig-not ,(car lst))
-;; ,(one-hot-fn (cdr lst))))
-;; (car lst))
-;; nil
-;; )
-;; )
-
-;; (defmacro one-hot (&rest args) (one-hot-fn args))
-
-
-
-;; [Jared] looks like this was part of an experiment in transistor/propagate
-;; at one point, but it doesn't seem to be used anymore
-
-;; (defun aig-env-lookup-nil (x al)
-;; (declare (Xargs :guard t))
-;; (let ((look (hons-get x al)))
-;; (if look
-;; (cdr look)
-;; (prog2$ (and *aig-env-lookup-warn-missing-binding*
-;; (aig-env-lookup-missing-output x))
-;; nil))))
-
-;; (defn aig-compose-nil (x al)
-;; (aig-cases
-;; x
-;; :true t
-;; :false nil
-;; :var (aig-env-lookup-nil x al)
-;; :inv (aig-not (aig-compose-nil (car x) al))
-;; :and (let ((a (aig-compose-nil (car x) al)))
-;; (and a (aig-and a (aig-compose-nil (cdr x) al))))))
-
-;; (memoize 'aig-compose-nil :condition '(and (consp x) (cdr x)))
-
-;; (defn aig-compose-nil-alist (x-alst al)
-;; (if (atom x-alst)
-;; nil
-;; (if (atom (car x-alst))
-;; (aig-compose-nil-alist (cdr x-alst) al)
-;; (cons (cons (caar x-alst)
-;; (aig-compose-nil (cdar x-alst) al))
-;; (aig-compose-nil-alist (cdr x-alst) al)))))
-
-;; (defn aig-compose-nil-list (x al)
-;; (if (atom x)
-;; nil
-;; (cons (aig-compose-nil (car x) al)
-;; (aig-compose-nil-list (cdr x) al))))
-
-
-
-
-;; (defn faig-compose-nil (x comp-al)
-;; (if (atom x)
-;; '(t . t)
-;; (cons (aig-compose-nil (car x) comp-al)
-;; (aig-compose-nil (cdr x) comp-al))))
-
-;; (defn faig-compose-nil-pat (pat fpat al)
-;; (if pat
-;; (if (atom pat)
-;; (faig-compose-nil fpat al)
-;; (cons (faig-compose-nil-pat (car pat) (ec-call (car fpat)) al)
-;; (faig-compose-nil-pat (cdr pat) (ec-call (cdr fpat)) al)))
-;; nil))
-
-;; (defn faig-compose-nil-alist (al comp-al)
-;; (if (atom al)
-;; nil
-;; (let ((rest (faig-compose-nil-alist (cdr al) comp-al)))
-;; (if (atom (car al))
-;; rest
-;; (cons (cons (caar al) (faig-compose-nil (cdar al) comp-al))
-;; rest)))))
-
-
-
-
-
-
-
-
-;; [Jared] This doesn't seem to be used for anything...
-
-;; ;; Translate Lisp-like terms into AIGs.
-;; (mutual-recursion
-;; (defun logic-to-aig (tree)
-;; (declare (xargs :measure (acl2-count tree)
-;; :guard t))
-;; (if (atom tree)
-;; tree
-;; (case (car tree)
-;; ((and or xor iff) (logic-to-aig-list (car tree) (cdr tree)))
-;; (nand (aig-not (logic-to-aig-list 'and (cdr tree))))
-;; (nor (aig-not (logic-to-aig-list 'or (cdr tree))))
-;; (implies (and (eql (len tree) 3)
-;; (aig-or (aig-not (logic-to-aig (cadr tree)))
-;; (logic-to-aig (caddr tree)))))
-;; (if (and (eql (len tree) 4)
-;; (aig-ite (logic-to-aig (cadr tree))
-;; (logic-to-aig (caddr tree))
-;; (logic-to-aig (cadddr tree)))))
-;; (not (and (eql (len tree) 2)
-;; (aig-not (logic-to-aig (cadr tree))))))))
-;; (defun logic-to-aig-list (op trees)
-;; (declare (xargs :measure (acl2-count trees)
-;; :guard t))
-;; (if (atom trees)
-;; (case op
-;; (xor nil)
-;; (iff t)
-;; (and t)
-;; (or nil))
-;; (let ((first (logic-to-aig (car trees)))
-;; (rest (logic-to-aig-list op (cdr trees))))
-;; (case op
-;; (xor (aig-xor first rest))
-;; (iff (aig-iff first rest))
-;; (and (aig-and first rest))
-;; (or (aig-or first rest)))))))
-
-;; (memoize 'logic-to-aig :condition '(consp tree))
-
+; cert_param: (reloc_stub)
+(include-book "aig-base")
+(include-book "faig-base")
diff -Nru acl2-6.2/books/centaur/aig/bddify-correct.lisp acl2-6.3/books/centaur/aig/bddify-correct.lisp
--- acl2-6.2/books/centaur/aig/bddify-correct.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/bddify-correct.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -33,8 +33,6 @@
(set-inhibit-warnings "theory")
(set-waterfall-parallelism nil) ; for defthm aig-bddify-x-weakening-ok-point
-(local (in-theory (disable append-of-nil)))
-
;; --------- UBDDP-VAL-ALISTP
diff -Nru acl2-6.2/books/centaur/aig/bddify.lisp acl2-6.3/books/centaur/aig/bddify.lisp
--- acl2-6.2/books/centaur/aig/bddify.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/bddify.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -29,7 +29,8 @@
(in-package "ACL2")
-(include-book "base")
+(include-book "aig-base")
+(include-book "faig-base")
(include-book "tools/bstar" :dir :system)
(include-book "tools/mv-nth" :dir :system)
(include-book "misc/hons-help2" :dir :system)
@@ -812,12 +813,12 @@
(def-with-bddify aig-eval)
(def-with-bddify faig-eval)
(def-with-bddify aig-eval-list)
-(def-with-bddify aig-eval-pat)
(def-with-bddify aig-eval-alist)
(def-with-bddify faig-eval-list)
-(def-with-bddify faig-eval-pat)
(def-with-bddify faig-eval-alist)
+
+
;; Now we apply these to various shapes of AIG-EVAL.
(local
(progn
@@ -828,26 +829,6 @@
al tries mwa))
(faig-eval-list-with-bddify pairs al tries mwa)))
-
- (defthm aig-eval-pat-to-aig-eval-list
- (equal (aig-list-to-pat
- pat
- (aig-eval-list-with-bddify
- (pat-to-aig-list pat x acc)
- al tries mwa))
- (mv (aig-eval-pat-with-bddify pat x al tries mwa)
- (aig-eval-list-with-bddify acc al tries mwa))))
-
-
-
- (defthm faig-eval-pat-is-faig-eval-list
- (equal (b* ((faig-list (pat-to-aig-list pat x acc))
- (pair-eval (faig-eval-list-with-bddify faig-list al tries mwa)))
- (aig-list-to-pat pat pair-eval))
- (mv (faig-eval-pat-with-bddify pat x al tries mwa)
- (faig-eval-list-with-bddify acc al tries mwa))))
-
-
(defthm aig-eval-alist-is-aig-eval-list
(equal (pairlis$ (strip-pair-cars aig-al)
(aig-eval-list-with-bddify
@@ -855,7 +836,6 @@
al tries mwa))
(aig-eval-alist-with-bddify aig-al al tries mwa)))
-
(defthm faig-eval-alist-is-faig-eval-list
(equal (pairlis$ (strip-pair-cars aig-al)
(faig-eval-list-with-bddify
@@ -869,10 +849,8 @@
(in-theory (disable aig-eval-with-bddify
aig-eval-list-with-bddify
- aig-eval-pat-with-bddify
aig-eval-alist-with-bddify
faig-eval-list-with-bddify
- faig-eval-pat-with-bddify
faig-eval-alist-with-bddify))))
@@ -902,38 +880,7 @@
al tries mwa)))
:rule-classes nil)
-(defthm aig-eval-pat-in-terms-of-aig-eval-list
- (equal (aig-eval-pat-with-bddify pat x al tries mwa)
- (mv-let (ev rest)
- (aig-list-to-pat
- pat
- (aig-eval-list-with-bddify
- (pat-to-aig-list pat x nil)
- al tries mwa))
- (declare (ignore rest))
- ev))
- :rule-classes nil)
-
-;; (defthm faig-eval-pat-in-terms-of-faig-eval-list1
-;; (equal (faig-eval-pat-with-bddify pat x al tries mwa)
-;; (b* ((faig-list (pat-to-aig-list pat x acc))
-;; (pair-eval (faig-eval-list-with-bddify
-;; faig-list al tries mwa))
-;; ((mv ev &) (aig-list-to-pat pat pair-eval)))
-;; ev))
-;; :hints(("Goal" :in-theory (disable faig-eval-list-to-aig-eval-list)))
-;; :rule-classes nil)
-
-(defthm faig-eval-pat-in-terms-of-faig-eval-list
- (equal (faig-eval-pat-with-bddify pat x al tries mwa)
- (b* ((faig-list (pat-to-aig-list pat x nil))
- (pair-eval (faig-eval-list-with-bddify
- faig-list al tries mwa))
- ((mv ev &) (aig-list-to-pat pat pair-eval)))
- ev))
- :hints(("Goal" :in-theory (disable faig-eval-list-to-aig-eval-list)))
- :rule-classes nil)
(defthm aig-eval-alist-in-terms-of-aig-eval-list
(equal (aig-eval-alist-with-bddify aig-al al tries mwa)
@@ -968,26 +915,6 @@
(aig-list-to-faig-list aigs)
exact)))
-(defun aig-bddify-pat (tries pat x al maybe-wash-args)
- (b* (((mv bdds aigs exact)
- (aig-bddify-list
- tries
- (pat-to-aig-list pat x nil)
- al maybe-wash-args))
- ((mv bdds &) (aig-list-to-pat pat bdds))
- ((mv aigs &) (aig-list-to-pat pat aigs)))
- (mv bdds aigs exact)))
-
-(defun faig-bddify-pat (tries pat x al maybe-wash-args)
- (b* (((mv bdds aigs exact)
- (faig-bddify-list
- tries
- (pat-to-aig-list pat x nil)
- al maybe-wash-args))
- ((mv bdds &) (aig-list-to-pat pat bdds))
- ((mv aigs &) (aig-list-to-pat pat aigs)))
- (mv bdds aigs exact)))
-
(defun aig-bddify-alist (tries x al maybe-wash-args)
(b* (((mv bdds aigs exact)
diff -Nru acl2-6.2/books/centaur/aig/best-aig.lisp acl2-6.3/books/centaur/aig/best-aig.lisp
--- acl2-6.2/books/centaur/aig/best-aig.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/best-aig.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -20,54 +20,72 @@
; Sol Swords
(in-package "ACL2")
-(include-book "tools/bstar" :dir :system)
-(include-book "tools/mv-nth" :dir :system)
-(include-book "finite-set-theory/osets/sets" :dir :system)
+(include-book "cutil/define" :dir :system)
+(include-book "std/osets/top" :dir :system)
(include-book "centaur/vl/util/cwtime" :dir :system)
-; Given two AIGs, A and B, we say that A is "better" than B if:
-;
-; (1) A has fewer unique AND nodes than B, or
-; (2) A,B have the same number of unique AND nodes, but A has fewer
-; total nodes than B.
-;
-; We introduce two main functions.
-;
-; 1. (AIG-LIST-BEST X) is given a non-empty AIG List and returns the best AIG
-; within it.
-;
-; 2. (AIG-LIST-LIST-BEST X) is given a list of non-empty AIG Lists, say (L1 L2
-; ... Ln), and returns (B1 B2 ... Bn) where Bi is the best AIG from each Li.
-;
-; Logically AIG-LIST-LIST-BEST is just the ordinary "map" or projection of
-; AIG-LIST-BEST, but it takes advantage of more structure sharing and
-; memoization than the naive projection would and hence may be much more
-; efficient.
-;
-; Implementation.
-;
-; It is tricky to directly count "unique nodes" in a memoized way, but there
-; is a very easy way to do it indirectly.
-;
-; First, we assign a number to every unique AIG node in sight, which (assuming
-; constant-time hashing) is linear in the sizes of the input AIGs. We call
-; these numbers labels.
-;
-; Next, we can write memoized functions to gather the sets of labels for all of
-; the AND nodes within an AIG, and similarly for all of the nodes. We just use
-; regular ordered sets to represent these sets. Importantly, these collection
-; functions can be easily memoized.
-;
-; Finally, to count the number of ANDs (or all nodes) in an AIG, we just
-; collect the labels for its ANDs (or all nodes) and see how many labels were
-; found.
-
-(defund aig-label-nodes (x free map)
- "Returns (MV FREE' MAP')"
- (declare (xargs :guard (natp free) :verify-guards nil))
- ;; X is the AIG to traverse.
- ;; FREE is the smallest label that hasn't been assigned to any node yet.
- ;; MAP is the fast alist from AIG nodes to labels that we're constructing.
+(defsection best-aig
+ :parents (aig-other)
+ :short "Algorithms for choosing \"better\" (smaller) AIGs."
+
+ :long "Given two AIGs, A and B, we say that A is \"better\" than B if:
+
+
+ A has fewer unique AND nodes than B, or
+ A,B have the same number of unique AND nodes, but A has fewer
+ total nodes than B.
+
+
+We provide two main functions for choosing good AIGs:
+
+
+
+@(see aig-list-best) chooses the best AIG from a non-empty list of
+AIGs.
+
+@(see aig-list-list-best) is given a list of non-empty AIG Lists, say
+@('(L1 L2 ... Ln)'), and returns @('(B1 B2 ... Bn)'), where each @('Bi') is the
+best AIG from the corresponding @('Li').
+
+
+
+You could just implement @(see aig-list-list-best) as an ordinary \"map\" or
+projection of @(see aig-list-best). But @('aig-list-list-best') is written in
+a slightly smarter way than this, so that it can share the labels and
+memoization results across all of the AIGs in all of the lists.
+
+Implementation
+
+It is tricky to directly count \"unique nodes\" in a memoized way, but there
+is a very easy way to do it indirectly.
+
+First, we assign a number to every unique AIG node in sight, which (assuming
+constant-time hashing) is linear in the sizes of the input AIGs. We call these
+numbers labels.
+
+Next, we can write memoized functions to gather the sets of labels for all
+of the AND nodes within an AIG, and similarly for all of the nodes. We just
+use regular ordered sets to represent these sets. Importantly, these
+collection functions can be easily memoized.
+
+Finally, to count the number of ANDs (or all nodes) in an AIG, we just
+collect the labels for its ANDs (or all nodes) and see how many labels were
+found.
+
+BOZO it would probably be much better to use @(see sbitsets) to represent
+label sets. If we ever need to speed this up, that's probably the first thing
+to try.
")
+
+(define aig-label-nodes
+ :parents (best-aig)
+ :short "Assign unique numbers (labels) to the nodes of an AIG."
+ ((x "A single AIG to traverse")
+ (free "Smallest label that hasn't been assigned to any node, yet."
+ natp)
+ (map "Fast alist from AIG nodes to labels (which we're constructing)."))
+ :returns (mv (free "Updated free index" natp :rule-classes :type-prescription)
+ (map "Updated map."))
+ :verify-guards nil
(b* (((when (atom x))
(mv (lnfix free) map))
((when (hons-get x map))
@@ -76,143 +94,143 @@
((mv free map) (aig-label-nodes (cdr x) free map))
(map (hons-acons x free map))
(free (+ 1 free)))
- (mv free map)))
-
-(defthm natp-of-aig-label-nodes
- (natp (mv-nth 0 (aig-label-nodes x free map)))
- :rule-classes :type-prescription
- :hints(("Goal" :in-theory (enable aig-label-nodes))))
-
-(verify-guards aig-label-nodes)
-
-
-
-(defund aig-list-label-nodes (x free map)
- "Returns (MV FREE' MAP')"
- (declare (xargs :guard (natp free) :verify-guards nil))
- ;; Extends AIG-LABEL-NODES to an AIG List.
- (if (atom x)
- (mv (nfix free) map)
- (b* (((mv free map) (aig-label-nodes (car x) free map))
- ((mv free map) (aig-list-label-nodes (cdr x) free map)))
- (mv free map))))
-
-(defthm natp-of-aig-list-label-nodes
- (natp (mv-nth 0 (aig-list-label-nodes x free map)))
- :rule-classes :type-prescription
- :hints(("Goal" :in-theory (enable aig-list-label-nodes))))
-
-(verify-guards aig-list-label-nodes)
-
-
-
-(defund aig-list-list-label-nodes (x free map)
- "Returns (MV FREE' MAP')"
- (declare (xargs :guard (natp free) :verify-guards nil))
- ;; Extends AIG-LABEL-NODES to an AIG List List.
- (if (atom x)
- (mv (nfix free) map)
- (b* (((mv free map) (aig-list-label-nodes (car x) free map))
- ((mv free map) (aig-list-list-label-nodes (cdr x) free map)))
- (mv free map))))
-
-(defthm natp-of-aig-list-list-label-nodes
- (natp (mv-nth 0 (aig-list-list-label-nodes x free map)))
- :rule-classes :type-prescription
- :hints(("Goal" :in-theory (enable aig-list-list-label-nodes))))
-
-(verify-guards aig-list-list-label-nodes)
-
+ (mv free map))
+ ///
+ (verify-guards aig-label-nodes))
+
+(define aig-list-label-nodes
+ :parents (best-aig)
+ :short "Extends @(see aig-label-nodes) to an AIG list."
+ ((x "AIG list to traverse.")
+ (free natp)
+ map)
+ :returns (mv (free natp :rule-classes :type-prescription)
+ map)
+ (b* (((when (atom x))
+ (mv (nfix free) map))
+ ((mv free map) (aig-label-nodes (car x) free map)))
+ (aig-list-label-nodes (cdr x) free map)))
+
+(define aig-list-list-label-nodes
+ :parents (best-aig)
+ :short "Extends @(see aig-label-nodes) to an AIG list list."
+ ((x "AIG list list to traverse.")
+ (free natp)
+ map)
+ :returns (mv (free natp :rule-classes :type-prescription)
+ map)
+ (b* (((when (atom x))
+ (mv (nfix free) map))
+ ((mv free map) (aig-list-label-nodes (car x) free map)))
+ (aig-list-list-label-nodes (cdr x) free map)))
-(defund aig-collect-andnode-labels (x map)
- "Returns INDEX-SET"
- (declare (xargs :guard t))
- ;; X is an AIG.
- ;; MAP is the mapping from AIG nodes to labels.
- ;; We collect the set of labels for all AND nodes in X.
- (cond ((atom x)
- nil)
- ((not (cdr x))
- (aig-collect-andnode-labels (car x) map))
- (t
- (let ((x-label (cdr (hons-get x map)))
- (car-labels (aig-collect-andnode-labels (car x) map))
- (cdr-labels (aig-collect-andnode-labels (cdr x) map)))
- (sets::insert x-label (sets::union car-labels cdr-labels))))))
-
-(memoize 'aig-collect-andnode-labels :condition '(and (consp x) (cdr x)))
-
-(defthm setp-of-aig-collect-andnode-labels
- (sets::setp (aig-collect-andnode-labels x map))
- :hints(("Goal" :in-theory (enable aig-collect-andnode-labels))))
-(defund aig-count-andnode-labels (x map)
- (declare (xargs :guard t))
+(define aig-collect-andnode-labels
+ :parents (best-aig)
+ :short "Collect the labels for AND nodes in an AIG. (memoized)"
+ ((x "A single AIG")
+ (map "Mapping of AIG nodes to labels."))
+ :returns (label-set "Ordered set of labels for all AND nodes in X."
+ sets::setp)
+ (b* (((when (atom x))
+ nil)
+ ((unless (cdr x))
+ (aig-collect-andnode-labels (car x) map))
+ (x-label (cdr (hons-get x map)))
+ (car-labels (aig-collect-andnode-labels (car x) map))
+ (cdr-labels (aig-collect-andnode-labels (cdr x) map)))
+ (sets::insert x-label (sets::union car-labels cdr-labels)))
+ ///
+ (memoize 'aig-collect-andnode-labels :condition '(and (consp x) (cdr x))))
+
+(define aig-count-andnode-labels
+ :parents (best-aig)
+ ((x "A single AIG.")
+ (map "Mapping of AIG nodes to labels."))
+ :returns (count natp :rule-classes :type-prescription)
(sets::cardinality (aig-collect-andnode-labels x map)))
-
-(defund aig-collect-labels (x map)
- "Returns INDEX-SET"
- (declare (xargs :guard t))
- ;; X is an AIG.
- ;; MAP is the mapping from AIG nodes to labels.
- ;; We collect the set of labels for all nodes in X.
- (cond ((atom x)
- nil)
- (t
- (let ((x-label (cdr (hons-get x map)))
- (car-labels (aig-collect-labels (car x) map))
- (cdr-labels (aig-collect-labels (cdr x) map)))
- (sets::insert x-label
- (sets::union car-labels cdr-labels))))))
-
-(memoize 'aig-collect-labels :condition '(and (consp x) (cdr x)))
-
-(defthm setp-of-aig-collect-labels
- (sets::setp (aig-collect-labels x map))
- :hints(("Goal" :in-theory (enable aig-collect-labels))))
-
-(defund aig-count-labels (x map)
- (declare (xargs :guard t))
+(define aig-collect-labels
+ :parents (best-aig)
+ :short "Collect the labels of ALL nodes in an AIG. (memoized)"
+ ((x "A single AIG")
+ (map "Mapping of AIG nodes to labels."))
+ :returns (label-set "Ordered set of labels for all nodes in X."
+ sets::setp)
+ (b* (((when (atom x))
+ nil)
+ (x-label (cdr (hons-get x map)))
+ (car-labels (aig-collect-labels (car x) map))
+ (cdr-labels (aig-collect-labels (cdr x) map)))
+ (sets::insert x-label
+ (sets::union car-labels cdr-labels)))
+ ///
+ (memoize 'aig-collect-labels :condition '(and (consp x) (cdr x))))
+
+(define aig-count-labels
+ :parents (best-aig)
+ ((x "A single AIG.")
+ (map "Mapping of AIG nodes to labels."))
+ :returns (count natp :rule-classes :type-prescription)
(sets::cardinality (aig-collect-labels x map)))
-
-(defund aig-list-best-aux1 (x best best-ands map)
- (declare (xargs :guard (natp best-ands)))
- (if (atom x)
- best
- (b* ((ands (aig-count-andnode-labels (car x) map)))
- (if (or (< ands best-ands)
- (and (= best-ands ands)
- (< (aig-count-labels (car x) map)
- (aig-count-labels best map))))
- (aig-list-best-aux1 (cdr x) (car x) ands map)
- (aig-list-best-aux1 (cdr x) best best-ands map)))))
-
-(defund aig-list-best-aux (x map)
- (declare (xargs :guard t))
+(define aig-list-best-aux1
+ :parents (best-aig)
+ :short "Main loop for finding the best AIG."
+ ((x "An AIG list.")
+ (best "Best AIG we've seen so far.")
+ (best-ands "How many unique AND nodes in our best AIG so far."
+ natp)
+ (map "Mapping of AIG nodes to labels."))
+ :returns
+ (new-best "Best AIG in X, or @('best') it's better than everything in X.")
+ (b* (((when (atom x))
+ best)
+ (ands (aig-count-andnode-labels (car x) map))
+ ((when (or (< ands best-ands)
+ (and (= best-ands ands)
+ (< (aig-count-labels (car x) map)
+ (aig-count-labels best map)))))
+ ;; The car is better than best.
+ (aig-list-best-aux1 (cdr x) (car x) ands map)))
+ ;; Best is better than the car.
+ (aig-list-best-aux1 (cdr x) best best-ands map)))
+
+(define aig-list-best-aux
+ :parents (best-aig)
+ ((x "A non-empty list of AIGs.")
+ (map "Mapping of AIG nodes to labels."))
+ :returns (best "Best AIG in X.")
(if (atom x)
- (er hard? 'aig-list-best-aux "Expected at least one aig.")
+ ;; BOZO this is kind of a lousy thing to do.
+ (raise "Expected at least one aig.")
(aig-list-best-aux1 (cdr x)
(car x)
(aig-count-andnode-labels (car x) map)
map)))
-(defund aig-list-list-best-aux (x map)
- (declare (xargs :guard t))
+(define aig-list-list-best-aux
+ :parents (best-aig)
+ ((x "An AIG List List. Shouldn't contain any empty lists.")
+ (map "Mapping of AIG nodes to labels."))
+ :returns
+ (best-list "A list containing the best AIG from each list in @('x').")
(if (atom x)
nil
(cons (aig-list-best-aux (car x) map)
(aig-list-list-best-aux (cdr x) map))))
-
-(defund aig-list-best (x)
- ; X is an AIG List.
- (declare (xargs :guard t))
+(define aig-list-best
+ :parents (best-aig)
+ :short "Top level function for choosing the best AIG out of a list."
+ ((x "An AIG List, which should be non-empty."))
+ :returns (best "The best AIG in @('x').")
+ :long "This is easy to use: it handles all of the details of freeing the
+ fast alists and memo tables it uses.
"
(b* (((mv ?free map) (cwtime (aig-list-label-nodes x 0 nil)
:mintime 1/2))
(ret (cwtime (aig-list-best-aux x map)
@@ -222,9 +240,16 @@
(clear-memoize-table 'aig-collect-labels)
ret))
-(defund aig-list-list-best (x)
- ; X is an AIG List List.
- (declare (xargs :guard t))
+(define aig-list-list-best
+ :parents (best-aig)
+ :short "Top-level function for choosing the best AIGs from a list of AIG
+ lists."
+ ((x "An AIG List List, say @('(L1 L2 ... Ln)'. These should each be
+ non-empty."))
+ :returns (best "An AIG List, say @('(B1 B2 ... Bn)'), where each @('Bi') is
+ the best AIG from the corresponding @('Li').")
+ :long "This is easy to use: it handles all of the details of freeing the
+ fast alists and memo tables it uses.
"
(b* (((mv ?free map) (cwtime (aig-list-list-label-nodes x 0 nil)
:mintime 1))
(ret (cwtime (aig-list-list-best-aux x map)
diff -Nru acl2-6.2/books/centaur/aig/eval-restrict.lisp acl2-6.3/books/centaur/aig/eval-restrict.lisp
--- acl2-6.2/books/centaur/aig/eval-restrict.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/eval-restrict.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -23,10 +23,11 @@
(in-package "ACL2")
-(include-book "base")
+(include-book "aig-base")
(include-book "aig-equivs")
-(include-book "three-four")
(include-book "aig-vars")
+(include-book "faig-constructors") ;; bozo?
+(include-book "faig-equivs") ;; bozo?
(in-theory (disable aig-env-lookup))
(in-theory (disable aig-restrict))
@@ -119,13 +120,6 @@
(defsection aig-eval-alist-thms
:extension aig-eval-alist
- (defthm hons-assoc-equal-aig-eval-alist
- (equal (hons-assoc-equal key (aig-eval-alist x env))
- (and (hons-assoc-equal key x)
- (cons key
- (aig-eval (cdr (hons-assoc-equal key x)) env))))
- :hints(("Goal" :induct t)))
-
(defcong aig-alist-equiv alist-equiv (aig-eval-alist x env) 1
:hints((witness)))
@@ -157,13 +151,6 @@
(local (in-theory (enable aig-restrict)))
- (defthm aig-eval-of-aig-restrict
- (equal (aig-eval (aig-restrict x al1) al2)
- (aig-eval x (append (aig-eval-alist al1 al2) al2)))
- :hints(("Goal"
- :induct t
- :in-theory (enable aig-env-lookup))))
-
(defcong aig-equiv aig-equiv (aig-restrict x al) 1
:hints((witness :ruleset aig-equiv-witnessing)))
@@ -766,7 +753,7 @@
(defmacro prove-faig-congruences (f args)
`(progn . ,(prove-faig-congruences-fn (len args) f args)))
-(prove-faig-congruences t-aig-fix (a))
+(prove-faig-congruences f-aig-unfloat (a))
(prove-faig-congruences t-aig-not (a))
(prove-faig-congruences f-aig-not (a))
(prove-faig-congruences t-aig-and (a b))
@@ -781,29 +768,8 @@
(prove-faig-congruences f-aig-ite (c a b))
(prove-faig-congruences t-aig-ite* (c a b))
(prove-faig-congruences f-aig-ite* (c a b))
-(prove-faig-congruences t-aig-buf (c a))
+(prove-faig-congruences f-aig-zif (c a b))
+(prove-faig-congruences t-aig-tristate (c a))
(prove-faig-congruences f-aig-pullup (a))
-(prove-faig-congruences f-aig-bi-buf (c a b))
-
-
-
-
-;; Pat stuff, could maybe move to EMOD/ESIM books...
-
-(defthm faig-eval-pat-of-faig-restrict-pat
- (equal (faig-eval-pat pat (faig-restrict-pat pat aigs al1) al2)
- (faig-eval-pat pat aigs (append (aig-eval-alist al1 al2) al2)))
- :hints(("Goal" :induct t)))
-
-(defthm faig-eval-pat-of-faig-partial-eval-pat
- (equal (faig-eval-pat pat (faig-partial-eval-pat pat aigs al1) al2)
- (faig-eval-pat pat aigs (append al1 al2)))
- :hints(("Goal" :induct t)))
-(defthm faig-eval-pat-of-faig-compose-pat
- (equal (faig-eval-pat pat (faig-compose-pat pat aigs al1) al2)
- (faig-eval-pat pat aigs (aig-eval-alist al1 al2)))
- :hints(("Goal" :induct t)))
-(defcong aig-env-equiv equal (faig-eval-pat pat x env) 3
- :hints(("Goal" :induct t)))
diff -Nru acl2-6.2/books/centaur/aig/faig-base.lisp acl2-6.3/books/centaur/aig/faig-base.lisp
--- acl2-6.2/books/centaur/aig/faig-base.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/aig/faig-base.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,271 @@
+; Centaur AIG Library
+; Copyright (C) 2008-2011 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+;
+; July 2011, Jared added lots of documentation.
+; August 2013, Jared split base.lisp into aig-base.lisp and faig-base.lisp
+
+(in-package "ACL2")
+(include-book "aig-base")
+
+(defxdoc faig
+ :parents (boolean-reasoning)
+ :short "A @(see hons)-based representation of four-valued functions as
+pairs of @(see aig)s."
+
+ :long "A FAIG (Four-valued AIG) combines two @(see aig)s together
+to represent a function with four possible values. Such functions can be
+useful in hardware verification.
+
+We represent an FAIG as the cons of two AIGs, which are called the
+onset and offset of the FAIG. Our FAIG evaluation function,
+@(see faig-eval), just evaluates these two AIGs, separately, using ordinary
+@(see aig-eval), and conses together the resulting Boolean values. So, the
+four possible values of an FAIG are:
+
+
+@('(nil . nil)'), which we call Z,
+@('(t . nil)'), which we call True,
+@('(nil . t)'), which we call False, and
+@('(t . t)'), which we call X.
+
+
+We generally think of the onset as being a Boolean functions that should
+evaluate to @('T') when the wire is being driven to 1. The offset is similar,
+but indicates whether the wire is being driven to 0. So, the Z value
+represents a situation where the wire is completely undriven, and the X value
+represents a bad case where the wire is simultaneously driven to both True and
+False.
+
+Hons convention. We ordinarly construct all AIGs with @(see hons), but we
+don't bother to hons the FAIG conses that put these AIGs together.
")
+
+
+(defsection faig-constants
+ :parents (faig)
+ :short "The four @(see FAIG) values, representing true, false, X, and Z."
+
+ (defmacro faig-x () ''(t . t))
+ (defmacro faig-z () ''(nil . nil))
+ (defmacro faig-t () ''(t . nil))
+ (defmacro faig-f () ''(nil . t)))
+
+
+
+; [Jared] BOZO consider a warning as in aig-eval for when faig-eval,
+; faig-restrict, etc., are used on non-consp arguments.
+
+(define faig-eval (x env)
+ :parents (faig)
+ :short "@(call faig-eval) evaluates @('x'), a @(see faig), under the
+environment @('env'), producing a pair of Boolean values."
+ :long "See @(see aig-eval); the @('env') should be a fast alist and you
+will want to clear the memoize table for @('aig-eval') when you are done using
+the @('env').
"
+ :enabled t
+ (if (atom x)
+ '(t . t)
+ (cons (aig-eval (car x) env)
+ (aig-eval (cdr x) env))))
+
+(define faig-eval-list (x env)
+ :parents (faig-eval)
+ :short "@(call faig-eval-list) evaluates a list of FAIGs."
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (faig-eval (car x) env)
+ (faig-eval-list (cdr x) env))))
+
+(define faig-eval-alist (x env)
+ :parents (faig-eval)
+ :short "@(call faig-eval-list) evaluates an FAIG alist (an alist binding
+keys to FAIGs)."
+ :long "The alist @('x') does not need to be fast, and we produce an
+ordinary (slow) alist as a result.
"
+ :enabled t
+ (cond ((atom x)
+ nil)
+ ((atom (car x))
+ ;; Bad alist convention
+ (faig-eval-alist (cdr x) env))
+ (t
+ (cons (cons (caar x)
+ (faig-eval (cdar x) env))
+ (faig-eval-alist (cdr x) env)))))
+
+(define faig-restrict (x sigma)
+ :parents (faig)
+ :short "@(call faig-restrict) performs variable substitution throughout the
+FAIG @('x'), replacing any variables bound in @('sigma') with their
+corresponding values."
+ :long "See @(see aig-restrict); the @('env') should be a fast alist and
+you will want to clear the memoize table for @('aig-restrict') when you are
+done using the @('env').
"
+ :enabled t
+ (if (atom x)
+ '(t . t)
+ (cons (aig-restrict (car x) sigma)
+ (aig-restrict (cdr x) sigma))))
+
+(define faig-restrict-alist (x sigma)
+ :parents (faig-restrict)
+ :short "@(call faig-restrict-alist) substitutes into an FAIG alist (an alist
+binding keys to FAIGs)."
+ :long "The alist @('x') does not need to be fast, and we produce an
+ordinary (slow) alist as a result.
"
+ :enabled t
+ (b* (((when (atom x))
+ nil)
+ (rest (faig-restrict-alist (cdr x) sigma))
+ ((when (atom (car x)))
+ ;; Bad alist convention
+ rest))
+ (cons (cons (caar x) (faig-restrict (cdar x) sigma))
+ rest)))
+
+(define faig-restrict-alists (x sigma)
+ :parents (faig-restrict)
+ :short "@(call faig-restrict-alists) substitutes into a list of FAIG alists."
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (faig-restrict-alist (car x) sigma)
+ (faig-restrict-alists (cdr x) sigma))))
+
+(define faig-compose (x sigma)
+ :parents (faig)
+ :short "@(call faig-compose) performs variable substitution throughout the
+FAIG @('x'), unconditionally replacing every variable in @('x') with its
+binding in @('sigma')."
+ :long "See @(see aig-compose); the @('sigma') should be a fast alist and
+you will want to clear the memoize table for @('aig-compose') when you are done
+using the @('env').
"
+ :enabled t
+ (if (atom x)
+ '(t . t)
+ (cons (aig-compose (car x) sigma)
+ (aig-compose (cdr x) sigma))))
+
+(define faig-compose-alist (x sigma)
+ :parents (faig)
+ :short "@(call faig-compose-alist) composes into an FAIG Alist (an alist
+binding keys to FAIGs)."
+ :long "The alist @('x') does not need to be fast, and we produce an
+ordinary (slow) alist as a result.
"
+ :enabled t
+ (b* (((when (atom x))
+ nil)
+ (rest (faig-compose-alist (cdr x) sigma))
+ ((when (atom (car x)))
+ ;; Bad alist convention
+ rest))
+ (cons (cons (caar x) (faig-compose (cdar x) sigma))
+ rest)))
+
+(define faig-partial-eval (x env)
+ :parents (faig)
+ :short "@(call faig-partial-eval) evaluates @('x'), an FAIG, under the
+partial environment @('env'), producing a new FAIG as a result."
+ :long "See @(see aig-partial-eval); the @('env') should be a fast alist
+and you will want to clear the memoize table for @('aig-partial-eval') when you
+are done using the @('env').
"
+ :enabled t
+ (if (atom x)
+ '(t . t)
+ (cons (aig-partial-eval (car x) env)
+ (aig-partial-eval (cdr x) env))))
+
+(define faig-partial-eval-alist (x env)
+ :parents (faig-partial-eval)
+ :short "@(call faig-partial-eval-alist) partially evaluates an FAIG alist (an
+alist binding keys to FAIGs)."
+ :long "The alist @('x') does not need to be fast, and we produce an
+ordinary (slow) alist as a result.
"
+ :enabled t
+ (b* (((when (atom x))
+ nil)
+ (rest (faig-partial-eval-alist (cdr x) env))
+ ((when (atom (car x)))
+ ;; Bad alist convention
+ rest))
+ (cons (cons (caar x) (faig-partial-eval (cdar x) env))
+ rest)))
+
+(define faig-partial-eval-alists (x env)
+ :parents (faig-partial-eval)
+ :short "@(call faig-partial-eval-alists) partially evaluates a list of FAIG
+alists."
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (faig-partial-eval-alist (car x) env)
+ (faig-partial-eval-alists (cdr x) env))))
+
+(define faig-fix (x)
+ :parents (faig)
+ :short "@(call faig-fix) is the identity for FAIGs, but coerces atoms to
+@('(t . t)'), i.e., X."
+ :long "This is sometimes when reasoning about FAIG operations, and, e.g.,
+allows for permissive guards on @(see faig-constructors), etc.
"
+ :enabled t
+ ;; inline this one since it's used in the faig b* binder, and hence just
+ ;; about everywhere that faigs are being constructed or dealt with
+ :inline t
+ (if (consp x)
+ x
+ (faig-x)))
+
+(define faig-fix-list (x)
+ :parents (faig-fix)
+ :short "@(call faig-fix-list) fixes every element of a list with @(see
+faig-fix)."
+ :enabled t
+ (if (atom x)
+ nil
+ (cons (faig-fix (car x))
+ (faig-fix-list (cdr x)))))
+
+(define faig-fix-alist (x)
+ :parents (faig-fix)
+ :short "@(call faig-fix-alist) fixes every value in an alist with @(see
+faig-fix)."
+ :enabled t
+ (cond ((atom x)
+ nil)
+ ((atom (car x))
+ ;; Bad-alist convention
+ (faig-fix-alist (cdr x)))
+ (t
+ (cons (cons (caar x) (faig-fix (cdar x)))
+ (faig-fix-alist (cdr x))))))
+
+(def-b*-binder faig
+ ":doc-section B*-BINDERS
+Binds two variables to the onset and offset, respectively, of the
+faig-fix of the given expression.~/~/~/"
+ (declare (xargs :guard (and (true-listp args)
+ (equal (len args) 2)
+ (true-listp forms)
+ (equal (len forms) 1))))
+ `(b* (((mv ,(first args) ,(second args))
+ (let ((x (faig-fix ,(car forms))))
+ (mv (car x) (cdr x)))))
+ ,rest-expr))
+
diff -Nru acl2-6.2/books/centaur/aig/faig-constructors.lisp acl2-6.3/books/centaur/aig/faig-constructors.lisp
--- acl2-6.2/books/centaur/aig/faig-constructors.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/aig/faig-constructors.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,423 @@
+; Centaur AIG Library
+; Copyright (C) 2008-2011 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+;
+; July 2011, Jared added some documentation and merged in the
+; faig-op-commutativity theorems.
+
+(in-package "ACL2")
+(include-book "faig-base")
+
+(defxdoc faig-constructors
+ :parents (faig)
+ :short "Low-level functions for constructing @(see faig)s."
+
+ :long "These functions construct new FAIGs from existing ones. They
+typically @(see hons)ing up some new onset and offset @(see aig)s by using the
+using @(see aig-constructors) like @(see aig-and) and @(see aig-not), and then
+@(see cons) those new onset/offset AIGs together to form a new FAIG.
+
+Most of these functions are geared toward modeling hardware. For instance,
+@(see f-aig-and) is intended to produce a new FAIG that captures the
+four-valued logic semantics of an AND gate.
+
+Note: the details about how X and Z are handled by these functions are
+often subtle and this documentation doesn't really explain why these
+functions work the way they do. However , for most functions here there
+are corresponding @(see 4v-operations), and the documentation there typically
+does explaining the X/Z behavior.
+
+
+Three-valued (T-) vs. Four-valued (F-) constructors
+
+There is an important optimization you can make when modeling hardware gates
+as FAIGs. In particular, it is often possible to construct more
+efficient (smaller) FAIGs to represent the gate's output when you know that the
+gate's inputs cannot evaluate to Z.
+
+In CMOS designs, this property—never evaluating to Z—holds for
+the outputs of most logic gates. Accordingly, it's true for most inputs
+to other gates. For example, suppose you are trying to model a circuit like
+this:
+
+@({
+ |\\ b
+ ---| >o---+
+ |/ | ____
+ +------| \\
+ |\ | and )---
+ ---| >o----------|____/ o
+ |/ a
+})
+
+Here, we know that wires @('a') and @('b') can never have the value Z,
+because they are produced by NOT gates. Accordingly, when we want to create
+the FAIG corresponding to @('o'), we can use an optimized, less-general
+implementation of the and gate, where we assume that our inputs are
+non-Z.
+
+Of course, some logic gates (e.g., tri-state buffers) can produce Z
+valued outputs, so occasionally these sorts of optimizations aren't possible.
+Because of this, we typically have two versions of each FAIG constructor:
+
+
+
+@('t-aig-*') functions make the assumption that their inputs are can never
+evaluate to Z. These are generally more efficient, and will produce smaller
+AIGs that are easier to analyze with SAT solvers.
+
+@('f-aig-*') functions do not make this assumption. This makes them more
+general purpose and able to operate on any FAIG inputs, at the cost of larger
+AIGs.
+
+
+
+Rulesets
+
+For historic reasons these functions are left enabled. There are two
+useful @(see rulesets) you can use to disable them:
+
+
+@('f-aig-defs') has all of the @('f-') constructors.
+@('t-aig-defs') has all of the @('t-') constructors.
+ ")
+
+
+; Macro to prove the FAIG constructors commute over FAIG-EVAL.
+
+(defun pfoc-faig-eval-args (args)
+ (if (atom args)
+ nil
+ (cons (list 'faig-eval (car args) 'env)
+ (pfoc-faig-eval-args (cdr args)))))
+
+(defun pfoc-arg-casesplit-list (args)
+ (if (atom args)
+ nil
+ (list* `(and stable-under-simplificationp
+ '(:cases ((aig-eval (car ,(car args)) env))))
+ `(and stable-under-simplificationp
+ '(:cases ((aig-eval (cdr ,(car args)) env))))
+ (pfoc-arg-casesplit-list (cdr args)))))
+
+(defmacro prove-faig-op-commutes (op args)
+ `(defthm ,(intern-in-package-of-symbol
+ (concatenate 'string "FAIG-EVAL-OF-" (symbol-name op))
+ op)
+ (equal (faig-eval (,op . ,args) env)
+ (,op . ,(pfoc-faig-eval-args args)))
+ :hints ,(pfoc-arg-casesplit-list args)))
+
+(define f-aig-unfloat (a)
+ :parents (faig-constructors)
+ :short "@(call f-aig-unfloat) converts floating (Z) values to unknown (X)
+values."
+ :long "See @(see 4v-unfloat); this is the analogous function for
+FAIGs.
"
+ :enabled t
+ (b* (((faig a1 a0) a))
+ (cons (aig-not (aig-and a0 (aig-not a1)))
+ (aig-not (aig-and a1 (aig-not a0)))))
+ ///
+ (prove-faig-op-commutes f-aig-unfloat (a)))
+
+
+(define t-aig-not (a)
+ :parents (faig-constructors)
+ :short "@(call t-aig-not) negates the FAIG @('a'), assuming that it cannot
+evaluate to Z."
+ :inline t
+ :enabled t
+ (b* (((faig a1 a0) a))
+ (cons a0 a1))
+ ///
+ (prove-faig-op-commutes t-aig-not (a)))
+
+(define f-aig-not (a)
+ :parents (faig-constructors)
+ :short "@(call f-aig-not) negates the FAIG @('a')."
+ :enabled t
+ (b* (((faig a1 a0) a))
+ (cons (aig-not (aig-and a1 (aig-not a0)))
+ (aig-not (aig-and a0 (aig-not a1)))))
+ ///
+ (prove-faig-op-commutes f-aig-not (a)))
+
+
+(define t-aig-and (a b)
+ :parents (faig-constructors)
+ :short "@(call t-aig-and) and s together the FAIGs @('a') and @('b'),
+assuming they cannot evaluate to Z."
+ :enabled t
+ (b* (((faig a1 a0) a)
+ ((faig b1 b0) b))
+ (cons (aig-and a1 b1)
+ (aig-or a0 b0)))
+ ///
+ (prove-faig-op-commutes t-aig-and (a b)))
+
+(define f-aig-and (a b)
+ :parents (faig-constructors)
+ :short "@(call f-aig-and) and s together the FAIGs @('a') and @('b')."
+ :enabled t
+ (b* ((a (f-aig-unfloat a))
+ (b (f-aig-unfloat b)))
+ (t-aig-and a b))
+ ///
+ (prove-faig-op-commutes f-aig-and (a b)))
+
+
+(define t-aig-or (a b)
+ :parents (faig-constructors)
+ :short "@(call t-aig-or) or s together the FAIGs @('a') and @('b'),
+assuming they cannot evaluate to Z."
+ :enabled t
+ (b* (((faig a1 a0) a)
+ ((faig b1 b0) b))
+ (cons (aig-or a1 b1)
+ (aig-and a0 b0)))
+ ///
+ (prove-faig-op-commutes t-aig-or (a b)))
+
+(define f-aig-or (a b)
+ :parents (faig-constructors)
+ :short "@(call f-aig-or) or s together the FAIGs @('a') and @('b')."
+ :enabled t
+ (b* ((a (f-aig-unfloat a))
+ (b (f-aig-unfloat b)))
+ (t-aig-or a b))
+ ///
+ (prove-faig-op-commutes f-aig-or (a b)))
+
+
+(define t-aig-xor (a b)
+ :parents (faig-constructors)
+ :short "@(call t-aig-xor) xor s together the FAIGs @('a') and @('b'),
+assuming they cannot evaluate to Z."
+ :enabled t
+ (t-aig-or (t-aig-and a (t-aig-not b))
+ (t-aig-and (t-aig-not a) b))
+ ///
+ (prove-faig-op-commutes t-aig-xor (a b)))
+
+(define f-aig-xor (a b)
+ :parents (faig-constructors)
+ :short "@(call f-aig-xor) xor s together the FAIGs @('a') and @('b')."
+ :enabled t
+ (b* ((a (f-aig-unfloat a))
+ (b (f-aig-unfloat b)))
+ (t-aig-xor a b))
+ ///
+ (prove-faig-op-commutes f-aig-xor (a b)))
+
+
+(define t-aig-iff (a b)
+ :parents (faig-constructors)
+ :short "@(call t-aig-iff) iff s together the FAIGs @('a') and @('b'),
+assuming they cannot evaluate to Z."
+ :enabled t
+ (t-aig-or (t-aig-and a b)
+ (t-aig-and (t-aig-not a) (t-aig-not b)))
+ ///
+ (prove-faig-op-commutes t-aig-iff (a b)))
+
+(define f-aig-iff (a b)
+ :parents (faig-constructors)
+ :short "@(call f-aig-iff) iff s together the FAIGs @('a') and @('b')."
+ :enabled t
+ (b* ((a (f-aig-unfloat a))
+ (b (f-aig-unfloat b)))
+ (t-aig-iff a b))
+ ///
+ (prove-faig-op-commutes f-aig-iff (a b)))
+
+
+(define t-aig-ite (c a b)
+ :parents (faig-constructors)
+ :short "@(call t-aig-ite) constructs a (less conservative) FAIG representing
+@('(if c a b)'), assuming these input FAIGs cannot evaluate to Z."
+ :long "This is a less-conservative version of @(see t-aig-ite*) that emits
+@('a') in the case that @('c') is unknown but @('a = b'). See @(see 4v-ite)
+for discussion related to this issue.
"
+ :enabled t
+ (b* (((faig a1 a0) a)
+ ((faig b1 b0) b)
+ ((faig c1 c0) c))
+ (cons (aig-or (aig-and c1 a1) (aig-and c0 b1))
+ (aig-or (aig-and c1 a0) (aig-and c0 b0))))
+ ///
+ (prove-faig-op-commutes t-aig-ite (c a b)))
+
+(define f-aig-ite (c a b)
+ :parents (faig-constructors)
+ :short "@(call f-aig-ite) constructs a (less conservative) FAIG representing
+@('(if c a b)')."
+ :long "This is a less-conservative version of @(see f-aig-ite*) that emits
+@('a') in the case that @('c') is unknown but @('a = b'). See @(see 4v-ite)
+for discussion related to this issue.
"
+ :enabled t
+ (b* ((c (f-aig-unfloat c))
+ (a (f-aig-unfloat a))
+ (b (f-aig-unfloat b)))
+ (t-aig-ite c a b))
+ ///
+ (prove-faig-op-commutes f-aig-ite (c a b)))
+
+
+(define t-aig-ite* (c a b)
+ :parents (faig-constructors)
+ :short "@(call t-aig-ite*) constructs a (more conservative) FAIG representing
+@('(if c a b)'), assuming these input FAIGs cannot evaluate to Z."
+ :long "This is a more-conservative version of @(see t-aig-ite) that emits
+@('X') in the case that @('c') is unknown, even when @('a = b'). See @(see
+4v-ite) for discussion related to this issue.
"
+ :enabled t
+ (b* (((faig a1 a0) a)
+ ((faig b1 b0) b)
+ ((faig c1 c0) c)
+ (x (aig-and c1 c0)))
+ (cons (aig-or x (aig-or (aig-and c1 a1) (aig-and c0 b1)))
+ (aig-or x (aig-or (aig-and c1 a0) (aig-and c0 b0)))))
+ ///
+ (prove-faig-op-commutes t-aig-ite* (c a b)))
+
+(define f-aig-ite* (c a b)
+ :parents (faig-constructors)
+ :short "@(call f-aig-ite*) constructs a (more conservative) FAIG representing
+@('(if c a b)'), assuming these input FAIGs cannot evaluate to Z."
+ :long "This is a more-conservative version of @(see f-aig-ite) that emits
+@('X') in the case that @('c') is unknown, even when @('a = b'). See @(see
+4v-ite) for discussion related to this issue.
"
+ :enabled t
+ (b* ((c (f-aig-unfloat c))
+ (a (f-aig-unfloat a))
+ (b (f-aig-unfloat b)))
+ (t-aig-ite* c a b))
+ ///
+ (prove-faig-op-commutes f-aig-ite* (c a b)))
+
+(define f-aig-zif (c a b)
+ :parents (faig-constructors)
+ :short "@(call f-aig-zif) constructs an FAIG representing a kind of pass gate
+style mux."
+ :long "This mainly exists to support @(see 4v-zif) in sexpr-to-faig
+conversion.
"
+ :enabled t
+ (b* ((c (f-aig-unfloat c)))
+ (t-aig-ite* c a b))
+ ///
+ (prove-faig-op-commutes f-aig-zif (c a b)))
+
+(define f-aig-res (x y)
+ :parents (faig-constructors)
+ :short "@(call f-aig-res) constructs a FAIG that represents the result of
+connecting two (independently driven) wires together."
+ :long "See @(see 4v-res) to understand what this is doing. This is just
+the @(see faig) equivalent.
"
+ :enabled t
+ (b* (((faig x1 x0) x)
+ ((faig y1 y0) y))
+ (cons (aig-or x1 y1) (aig-or x0 y0)))
+ ///
+ (prove-faig-op-commutes f-aig-res (a b)))
+
+
+;; Theorem: no F-AIG-UNFLOAT needed around the answer of f-aig-ite.
+;; (thm
+;; (and
+;; (iff (aig-eval (car (f-aig-unfloat (t-aig-ite (f-aig-unfloat c)
+;; (f-aig-unfloat a)
+;; (f-aig-unfloat b))))
+;; al)
+;; (aig-eval (car (t-aig-ite (f-aig-unfloat c)
+;; (f-aig-unfloat a)
+;; (f-aig-unfloat b)))
+;; al))
+;; (iff (aig-eval (cdr (f-aig-unfloat (t-aig-ite (f-aig-unfloat c)
+;; (f-aig-unfloat a)
+;; (f-aig-unfloat b))))
+;; al)
+;; (aig-eval (cdr (t-aig-ite (f-aig-unfloat c)
+;; (f-aig-unfloat a)
+;; (f-aig-unfloat b)))
+;; al))))
+
+(define t-aig-tristate (c a)
+ :parents (faig-constructors)
+ :short "@(call t-aig-tristate) constructs an FAIG representing a tri-state
+buffer whose inputs are known to be non-X."
+ :long "See also @(see 4v-tristate).
+
+Onset of output:
+@({
+ (not (or (and (not c.on) c.off)
+ (and c.on (not c.off) (not a.on) a.off)))
+})
+
+Offset of output:
+@({
+ (not (or (and (not c.on) c.off)
+ (and c.on (not c.off) a.off (not a.on))))
+})"
+ (b* (((faig a1 a0) a)
+ ((faig c1 c0) c)
+ (float (aig-and (aig-not c1) c0))
+ (set (aig-and c1 (aig-not c0)))
+ (on (aig-and (aig-not a0) a1))
+ (off (aig-and (aig-not a1) a0)))
+ (cons (aig-and (aig-not float) (aig-not (aig-and set off)))
+ (aig-and (aig-not float) (aig-not (aig-and set on)))))
+ ///
+ (prove-faig-op-commutes t-aig-tristate (c a)))
+
+(define f-aig-pullup (a)
+ :parents (faig-constructors)
+ :short "@(call f-aig-pullup) constructs an FAIG representing a pullup
+resistor."
+ (b* (((faig a1 a0) a)
+ (a-not-aig-floating (aig-or a1 a0))
+ (a-floating (aig-not a-not-aig-floating)))
+ (cons (aig-or a-floating a1) a0))
+ ///
+ (prove-faig-op-commutes f-aig-pullup (a)))
+
+
+(def-ruleset f-aig-defs
+ '(f-aig-unfloat
+ f-aig-not
+ f-aig-and
+ f-aig-or
+ f-aig-xor
+ f-aig-iff
+ f-aig-res
+ f-aig-ite
+ f-aig-ite*
+ f-aig-zif
+ t-aig-tristate
+ f-aig-pullup))
+
+(def-ruleset t-aig-defs
+ '(t-aig-and
+ t-aig-iff
+ t-aig-ite
+ t-aig-ite*
+ t-aig-not
+ t-aig-or
+ t-aig-xor))
+
diff -Nru acl2-6.2/books/centaur/aig/faig-equivs.lisp acl2-6.3/books/centaur/aig/faig-equivs.lisp
--- acl2-6.2/books/centaur/aig/faig-equivs.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/aig/faig-equivs.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,56 @@
+; Centaur AIG Library
+; Copyright (C) 2008-2011 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "ACL2")
+(include-book "aig-equivs")
+(include-book "faig-base")
+(set-verify-guards-eagerness 0)
+
+
+(defsection faig-equiv
+ :parents (faig)
+ :short "We say the FAIGs @('X') and @('Y') are equivalent when they always
+evaluate to the same value, per @(see faig-eval)."
+
+ (def-universal-equiv faig-equiv
+ :qvars env
+ :equiv-terms ((equal (faig-eval x env)))
+ :defquant t
+ :witness-dcls ((declare (xargs :guard t))))
+
+ (verify-guards faig-equiv))
+
+
+(defsection faig-alist-equiv
+ :parents (faig)
+ :short "We say the FAIG Alists @('X') and @('Y') are equivalent when they
+bind the same keys to equivalent FAIGs, in the sense of @(see faig-equiv)."
+
+ (def-universal-equiv faig-alist-equiv
+ :qvars k
+ :equiv-terms ((iff (hons-assoc-equal k x))
+ (faig-equiv (cdr (hons-assoc-equal k x))))
+ :defquant t
+ :witness-dcls ((declare (xargs :guard t))))
+
+ (verify-guards faig-alist-equiv)
+
+ (defrefinement alist-equiv faig-alist-equiv
+ :hints ((witness))))
diff -Nru acl2-6.2/books/centaur/aig/faig-purebool-p.lisp acl2-6.3/books/centaur/aig/faig-purebool-p.lisp
--- acl2-6.2/books/centaur/aig/faig-purebool-p.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/aig/faig-purebool-p.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,343 @@
+; Centaur AIG Library
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original authors: Jared Davis
+; Sol Swords
+
+(in-package "ACL2")
+(include-book "aig-sat")
+(include-book "faig-base")
+
+(local (in-theory (disable faig-eval)))
+
+(defsection faig-purebool-p
+ :parents (faig)
+ :short "Does a FAIG always evaluate to a purely Boolean value, i.e., is it
+never X or Z?"
+
+ :long "When an FAIG is known to be purely Boolean, then there is not much
+reason to represent it as an FAIG—we might as well throw its offset away
+and just work with its onset as an AIG.
+
+When you are dealing with nice, well-behaved, RTL-level circuits that don't
+use any fancy low-level, four-valued sorts of things like tri-state buffers,
+this can be a useful optimization. For instance, it may reduce the complexity
+of SAT queries, or carry out other kinds of analysis where you don't have to
+think about four-valuedness.
+
+@(call faig-purebool-p) is a logically nice, but non-executable way to
+express pure Boolean-ness. See also @(see faig-purebool-check), which can be
+executed; it uses a SAT solver to answer the question.
+
+@(def faig-purebool-p)"
+
+ (defun-sk faig-purebool-p (x)
+ (forall (env)
+ (or (equal (faig-eval x env) (faig-t))
+ (equal (faig-eval x env) (faig-f)))))
+
+ (verify-guards faig-purebool-p))
+
+
+(define faig-purebool-aig ((x "A single FAIG."))
+ :parents (faig-purebool-p)
+ :short "An AIG that captures exactly when the FAIG X is Boolean valued."
+ :long "This is useful mainly to implement @(see faig-purebool-check).
"
+ :returns aig
+ (b* ((x (faig-fix x))
+ (onset (car x))
+ (offset (cdr x)))
+ (aig-or (aig-and onset (aig-not offset))
+ (aig-and offset (aig-not onset))))
+ ///
+ (local (defthm l0
+ (implies (not (aig-eval (faig-purebool-aig x) env))
+ (not (faig-purebool-p x)))
+ :hints(("Goal"
+ :in-theory (e/d (faig-eval)
+ (faig-purebool-p
+ faig-purebool-p-necc))
+ :use ((:instance faig-purebool-p-necc
+ (env env)))))))
+
+ (local (defthm l1
+ (implies (not (faig-purebool-p x))
+ (not (aig-eval (faig-purebool-aig x)
+ (faig-purebool-p-witness x))))
+ :hints(("Goal"
+ :in-theory (e/d (faig-eval)
+ (faig-purebool-p))
+ :use ((:instance faig-purebool-p))))))
+
+ (local (in-theory (disable faig-purebool-aig)))
+
+ (local (defthm l2
+ (implies (faig-purebool-p x)
+ (aig-eval (faig-purebool-aig x) env))))
+
+ (defthmd faig-purebool-p-as-aig-eval
+ (equal (faig-purebool-p x)
+ (aig-eval (faig-purebool-aig x)
+ (faig-purebool-p-witness x))))
+
+ (defthm faig-purebool-p-monotonicity
+ (implies (not (aig-eval (faig-purebool-aig x) env))
+ (not (aig-eval (faig-purebool-aig x)
+ (faig-purebool-p-witness x))))))
+
+
+
+(define faig-purebool-check
+ :parents (faig-purebool-p)
+ :short "An executable version of @(see faig-purebool-p) using SAT."
+ ((x "The FAIG to check.")
+ &key
+ ((config satlink::config-p) 'satlink::*default-config*))
+ :returns (mv (fail booleanp :rule-classes :type-prescription
+ "If true, calling the SAT solver failed and the other
+ answers are meaningless.")
+
+ (purebool booleanp :rule-classes :type-prescription
+ "Does this FAIG always evaluate to purely Boolean?")
+
+ (alist "When this FAIG is not purely Boolean: an example
+ environment for @(see faig-eval) that drives it to
+ X or Z."))
+
+ (b* ((aig (faig-purebool-aig x))
+ ((mv status alist) (aig-sat (aig-not aig) :config config))
+ ((when (eq status :sat))
+ (mv nil nil alist))
+ ((when (eq status :unsat))
+ (mv nil t nil)))
+ (mv t nil nil))
+
+ ///
+ (local (defthm l0
+ (b* (((mv fail purebool ?alist)
+ (faig-purebool-check x :config config)))
+ (implies (and (not fail)
+ (not purebool))
+ (not (faig-purebool-p x))))
+ :hints(("Goal"
+ :in-theory (e/d (faig-purebool-p-as-aig-eval)
+ (aig-sat-when-sat))
+ :use ((:instance aig-sat-when-sat
+ (aig (aig-not (faig-purebool-aig x)))))))))
+
+ (local (defthm l1
+ (b* (((mv fail purebool ?alist)
+ (faig-purebool-check x :config config)))
+ (implies (and (not fail)
+ purebool)
+ (faig-purebool-p x)))
+ :hints(("Goal"
+ :in-theory (e/d (faig-purebool-p-as-aig-eval)
+ (aig-sat-when-unsat))
+ :use ((:instance aig-sat-when-unsat
+ (aig (aig-not (faig-purebool-aig x)))
+ (env (faig-purebool-p-witness x))))))))
+
+ (defthm faig-purebool-check-correct
+ (b* (((mv fail purebool ?alist)
+ (faig-purebool-check x :config config)))
+ (implies (not fail)
+ (equal purebool
+ (faig-purebool-p x))))
+ :hints(("Goal"
+ :use ((:instance l0)
+ (:instance l1)))))
+
+ (local (defthm l2
+ (b* (((mv fail purebool alist)
+ (faig-purebool-check x :config config)))
+ (implies (and (not fail)
+ (not purebool))
+ (and (not (equal (faig-eval x alist) (faig-f)))
+ (not (equal (faig-eval x alist) (faig-t))))))
+ :hints(("Goal"
+ :in-theory (e/d (faig-purebool-p-as-aig-eval
+ faig-purebool-aig
+ faig-eval)
+ (aig-sat-when-sat))
+ :use ((:instance aig-sat-when-sat
+ (aig (aig-not (faig-purebool-aig x)))))))))
+
+ (defthm faig-purebool-counterexample-correct
+ (b* (((mv fail ?purebool alist)
+ (faig-purebool-check x :config config)))
+ (implies (and (not fail)
+ (not (faig-purebool-p x)))
+ (and (not (equal (faig-eval x alist) (faig-f)))
+ (not (equal (faig-eval x alist) (faig-t))))))
+ :hints(("Goal"
+ :in-theory (disable faig-purebool-check-correct
+ faig-purebool-check)
+ :use ((:instance l1))))))
+
+
+
+
+
+(cutil::deflist faig-purebool-list-p (x)
+ (faig-purebool-p x)
+ :guard t
+ :parents (faig-purebool-p)
+ :short "Do a list of FAIGs always evaluate to purely Boolean values, i.e.,
+are they never X or Z?"
+
+ :long "This is a logically nice, but non-executable way to express pure
+Boolean-ness. See also @(see faig-purebool-list-check), which can be executed;
+it uses a SAT solver to answer the question.
")
+
+
+(define faig-purebool-list-witness (x)
+ (cond ((atom x)
+ nil)
+ ((faig-purebool-p (car x))
+ (faig-purebool-list-witness (cdr x)))
+ (t
+ (faig-purebool-p-witness (car x))))
+ ///
+ (defthm faig-purebool-list-witness-when-atom
+ (implies (atom x)
+ (equal (faig-purebool-list-witness x)
+ nil)))
+
+ (defthm faig-purebool-list-witness-of-cons
+ (equal (faig-purebool-list-witness (cons a x))
+ (if (faig-purebool-p a)
+ (faig-purebool-list-witness x)
+ (faig-purebool-p-witness a)))))
+
+
+(define faig-purebool-list-aig ((x "An FAIG List"))
+ :returns (aig)
+ :parents (faig-purebool-list-p)
+ :short "An AIG that captures exactly when a list of FAIGs always evaluate to
+purely Boolean values."
+ :long "This is useful mainly to implement @(see
+faig-purebool-list-check).
"
+ (if (atom x)
+ t
+ (aig-and (faig-purebool-aig (car x))
+ (faig-purebool-list-aig (cdr x))))
+ ///
+
+ (local (defthm l0
+ (implies (not (aig-eval (faig-purebool-list-aig x) env))
+ (not (faig-purebool-list-p x)))
+ :hints(("Goal"
+ :in-theory (enable faig-purebool-p-as-aig-eval)))))
+
+ (local (defthm l1
+ (implies (not (faig-purebool-list-p x))
+ (not (aig-eval (faig-purebool-list-aig x)
+ (faig-purebool-list-witness x))))
+ :hints(("Goal"
+ :induct (len x)
+ :in-theory (e/d (faig-purebool-list-witness
+ faig-purebool-p-as-aig-eval))))))
+
+ (local (in-theory (disable faig-purebool-list-aig)))
+
+ (local (defthm l2
+ (implies (faig-purebool-list-p x)
+ (aig-eval (faig-purebool-list-aig x) env))))
+
+ (defthmd faig-purebool-list-p-as-aig-eval
+ (equal (faig-purebool-list-p x)
+ (aig-eval (faig-purebool-list-aig x)
+ (faig-purebool-list-witness x)))
+ :hints(("Goal" :cases ((faig-purebool-list-p x)))))
+
+ (defthm faig-purebool-list-p-monotonicity
+ (implies (not (aig-eval (faig-purebool-list-aig x) env))
+ (not (aig-eval (faig-purebool-list-aig x)
+ (faig-purebool-list-witness x))))))
+
+
+
+
+
+(define faig-purebool-list-check
+ :parents (faig-purebool-list-p)
+ :short "An executable version of @(see faig-purebool-list-p) using SAT."
+ ((x "The FAIG List to check.")
+ &key
+ ((config satlink::config-p) 'satlink::*default-config*))
+ :returns (mv (fail booleanp :rule-classes :type-prescription
+ "If true, calling the SAT solver failed and the other
+ answers are meaningless.")
+
+ (purebool-list booleanp :rule-classes :type-prescription
+ "Do these FAIGs always evaluate to purely Boolean?")
+
+ (alist "When these FAIGs are not purely Boolean: an example
+ environment for @(see faig-eval-list) that drives
+ some FAIG to X or Z."))
+
+ (b* ((aig (faig-purebool-list-aig x))
+ ((mv status alist) (aig-sat (aig-not aig) :config config))
+ ((when (eq status :sat))
+ (mv nil nil alist))
+ ((when (eq status :unsat))
+ (mv nil t nil)))
+ (mv t nil nil))
+
+ ///
+ (local (defthm l0
+ (b* (((mv fail purebool-list ?alist)
+ (faig-purebool-list-check x :config config)))
+ (implies (and (not fail)
+ (not purebool-list))
+ (not (faig-purebool-list-p x))))
+ :hints(("Goal"
+ :in-theory (e/d (faig-purebool-list-p-as-aig-eval)
+ (aig-sat-when-sat))
+ :use ((:instance aig-sat-when-sat
+ (aig (aig-not (faig-purebool-list-aig x)))))))))
+
+ (local (defthm l1
+ (b* (((mv fail purebool-list ?alist)
+ (faig-purebool-list-check x :config config)))
+ (implies (and (not fail)
+ purebool-list)
+ (faig-purebool-list-p x)))
+ :hints(("Goal"
+ :in-theory (e/d (faig-purebool-list-p-as-aig-eval)
+ (aig-sat-when-unsat))
+ :use ((:instance aig-sat-when-unsat
+ (aig (aig-not (faig-purebool-list-aig x)))
+ (env (faig-purebool-list-witness x))))))))
+
+ (defthm faig-purebool-list-check-correct
+ (b* (((mv fail purebool-list ?alist)
+ (faig-purebool-list-check x :config config)))
+ (implies (not fail)
+ (equal purebool-list
+ (faig-purebool-list-p x))))
+ :hints(("Goal"
+ :use ((:instance l0)
+ (:instance l1)))))
+
+ ;; BOZO could eventually prove that the alist returned does indeed drive at
+ ;; least some FAIG to X or Z.
+
+ )
+
diff -Nru acl2-6.2/books/centaur/aig/g-aig-eval.lisp acl2-6.3/books/centaur/aig/g-aig-eval.lisp
--- acl2-6.2/books/centaur/aig/g-aig-eval.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/g-aig-eval.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -104,6 +104,17 @@
x hyp)))
(hons-assoc-equal key x)))))
+(defthm deps-of-gobj-alist-to-bfr-alist
+ (implies (and (not (gl::gobj-depends-on k p x))
+ (atom-key-gobj-val-alistp x))
+ (and (not (gl::pbfr-list-depends-on
+ k p (alist-vals (mv-nth 0 (gobj-alist-to-bfr-alist x hyp)))))
+ (not (gl::pbfr-depends-on
+ k p (mv-nth 1 (gobj-alist-to-bfr-alist x hyp))))))
+ :hints(("Goal" :induct (gobj-alist-to-bfr-alist x hyp)
+ :in-theory (enable gl::pbfr-list-depends-on)
+ :expand ((gl::gobj-depends-on k p x)))))
+
@@ -257,7 +268,7 @@
(local (in-theory (disable atom-key-gobj-val-alistp
suffixp ; car-member-when-suffix
- faig-bddify-pat)))))
+ )))))
@@ -270,6 +281,10 @@
(cons (gl::g-boolean (car x))
(g-boolean-list (cdr x)))))
+(defthm deps-of-g-boolean-list
+ (implies (not (gl::pbfr-list-depends-on k p x))
+ (not (gl::gobj-depends-on k p (g-boolean-list x)))))
+
(local
(progn
@@ -322,6 +337,70 @@
:bdd (aig-q-compose x al)
:aig (aig-compose x al)))
+(local (defthm bfr-aig-q-compose
+ (implies (not (gl::bfr-mode))
+ (equal (aig-q-compose x fal)
+ (AIG-CASES
+ X
+ :TRUE T
+ :FALSE NIL
+ :VAR (AIG-ENV-LOOKUP X FAL)
+ :INV (gl::bfr-not (AIG-Q-COMPOSE (CAR X) FAL))
+ :AND (LET ((A (AIG-Q-COMPOSE (CAR X) FAL)))
+ (AND A
+ (gl::bfr-binary-and A (AIG-Q-COMPOSE (CDR X)
+ FAL)))))))
+ :hints(("Goal" :in-theory (enable gl::bfr-not gl::bfr-binary-and)))
+ :rule-classes ((:definition :controller-alist ((aig-q-compose t
+ nil))))))
+
+(defthm deps-of-hons-assoc-equal
+ (implies (not (gl::pbfr-list-depends-on k p (alist-vals al)))
+ (not (gl::pbfr-depends-on k p (cdr (hons-assoc-equal x al)))))
+ :hints(("Goal" :in-theory (enable hons-assoc-equal
+ gl::pbfr-list-depends-on))))
+
+(defthm deps-of-aig-env-lookup
+ (implies (not (gl::pbfr-list-depends-on k p (alist-vals al)))
+ (not (gl::pbfr-depends-on k p (aig-env-lookup x al))))
+ :hints(("Goal" :in-theory (enable aig-env-lookup))))
+
+(defthm deps-of-aig-q-compose
+ (implies (and (not (gl::pbfr-list-depends-on k p (alist-vals al)))
+ (not (gl::bfr-mode)))
+ (not (gl::pbfr-depends-on k p (aig-q-compose x al))))
+ :hints (("goal" :induct (aig-q-compose x al))))
+
+(local (defthm bfr-aig-compose
+ (implies (gl::bfr-mode)
+ (equal (aig-compose x fal)
+ (AIG-CASES
+ X
+ :TRUE T
+ :FALSE NIL
+ :VAR (AIG-ENV-LOOKUP X FAL)
+ :INV (gl::bfr-not (AIG-COMPOSE (CAR X) FAL))
+ :AND (LET ((A (AIG-COMPOSE (CAR X) FAL)))
+ (AND A
+ (gl::bfr-binary-and A (AIG-COMPOSE (CDR X)
+ FAL)))))))
+ :hints(("Goal" :in-theory (enable gl::bfr-not gl::bfr-binary-and aig-compose)))
+ :rule-classes ((:definition :controller-alist ((aig-compose t
+ nil))))))
+
+(defthm deps-of-aig-compose
+ (implies (and (not (gl::pbfr-list-depends-on k p (alist-vals al)))
+ (gl::bfr-mode))
+ (not (gl::pbfr-depends-on k p (aig-compose x al))))
+ :hints (("goal" :induct (aig-compose x al)
+ :in-theory (enable (:i aig-compose)))))
+
+(defthm deps-of-aig-bfr-compose
+ (implies (not (gl::pbfr-list-depends-on k p (alist-vals al)))
+ (not (gl::pbfr-depends-on k p (aig-bfr-compose x al)))))
+
+
+
(defun aig-bfr-compose-list (x al)
(if (atom x)
nil
@@ -329,6 +408,13 @@
(aig-bfr-compose-list (cdr x) al))))
+(defthm deps-of-aig-bfr-compose-list
+ (implies (not (gl::pbfr-list-depends-on k p (alist-vals al)))
+ (not (gl::pbfr-list-depends-on k p (aig-bfr-compose-list x al))))
+ :hints(("Goal" :in-theory (e/d (gl::pbfr-list-depends-on)
+ (aig-bfr-compose)))))
+
+
(defthm bfr-eval-of-aig-bfr-compose
(equal (bfr-eval (aig-bfr-compose x al) env)
@@ -367,6 +453,71 @@
aig-bddify-list-ok)
:induct (len aigs))))
+
+
+
+(local
+ #!GL
+ (progn
+ (defun pbfr-list-depends-on-witness (k p x)
+ (if (atom x)
+ nil
+ (if (pbfr-semantic-depends-on k p (car x))
+ (mv-let (env v)
+ (pbfr-semantic-depends-on-witness k p (car x))
+ (list env v))
+ (pbfr-list-depends-on-witness k p (cdr x)))))
+
+ (defthm pbfr-list-depends-on-witness-iff
+ (implies (not (bfr-mode))
+ (iff (pbfr-list-depends-on-witness k p x)
+ (pbfr-list-depends-on k p x)))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on
+ pbfr-depends-on))))
+
+ (defthm pbfr-list-depends-on-by-witness
+ (implies (and (acl2::rewriting-negative-literal
+ `(pbfr-list-depends-on ,k ,p ,x))
+ (not (bfr-mode)))
+ (equal (pbfr-list-depends-on k p x)
+ (mv-let (env v) (pbfr-list-depends-on-witness k p x)
+ (and (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k v env))
+ (not (equal (bfr-eval-list x (bfr-param-env p (bfr-set-var k v env)))
+ (bfr-eval-list x (bfr-param-env p env))))))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on
+ pbfr-depends-on
+ bfr-eval-list))
+ (and stable-under-simplificationp
+ '(:expand ((pbfr-semantic-depends-on k p (car x)))))))))
+
+(defthm bfr-eval-alist-when-set-non-dep
+ (implies (and (not (gl::pbfr-list-depends-on k p (alist-vals bfr-al)))
+ (gl::bfr-eval p env)
+ (gl::bfr-eval p (gl::bfr-set-var k v env)))
+ (equal (gl::bfr-eval-alist
+ bfr-al (gl::bfr-param-env p (gl::bfr-set-var k v env)))
+ (gl::bfr-eval-alist
+ bfr-al (gl::bfr-param-env p env))))
+ :hints(("Goal" :in-theory (enable gl::pbfr-list-depends-on alist-vals))))
+
+
+
+(defthm deps-of-aig-bfrify-list
+ (mv-let (res exact)
+ (aig-bfrify-list tries aigs bfr-al maybe-wash-args)
+ (implies (and exact
+ (not (gl::pbfr-list-depends-on k p (alist-vals bfr-al))))
+ (not (gl::pbfr-list-depends-on k p res))))
+ :hints(("Goal" :in-theory (disable aig-bfrify-list)
+ :cases ((gl::bfr-mode)))
+ (cond ((member-equal '(not (gl::bfr-mode)) clause)
+ '(:in-theory (enable aig-bfrify-list
+ gl::pbfr-list-depends-on
+ gl::pbfr-depends-on
+ gl::bfr-depends-on
+ gl::bfr-from-param-space)))))
+ :otf-flg t)
@@ -420,6 +571,13 @@
(gl::g-apply 'aig-eval-list (gl::gl-list x al))))))
+(defthm deps-of-aig-eval-list-symbolic
+ (implies (and (not (gl::gobj-depends-on k p x))
+ (not (gl::gobj-depends-on k p al)))
+ (not (gl::gobj-depends-on k p (aig-eval-list-symbolic
+ x al tries maybe-wash-args hyp clk)))))
+
+
@@ -437,8 +595,10 @@
(make-event
`(defun ,(gl-fnsym 'aig-eval-list-with-bddify)
- (x al tries maybe-wash-args hyp clk)
- (declare (xargs :guard t))
+ (x al tries maybe-wash-args hyp clk config gl::bvar-db state)
+ (declare (xargs :guard t
+ :stobjs (gl::bvar-db state))
+ (ignore config gl::bvar-db state))
(aig-eval-list-symbolic x al tries maybe-wash-args hyp clk)))
@@ -455,7 +615,7 @@
(make-event
`(acl2::without-waterfall-parallelism
(gl::def-eval-g aig-eval-ev
- ,(list* 'aig-eval-list
+ ,(list* 'aig-eval-list 'if 'cons
(cdar (table-alist 'gl::g-apply-table (w state))))))))
(local
@@ -524,6 +684,13 @@
aig-bddify-list))
:do-not-induct t))))
+(local (in-theory (disable aig-eval-list-symbolic)))
+
+(gl::def-gobj-dependency-thm
+ aig-eval-list-with-bddify
+ :hints`(("Goal" :in-theory (e/d (,gl::gfn)
+ (gl::gobj-depends-on)))))
+
(gl::def-g-correct-thm ;; g-aig-eval-list-with-bddify-correct
aig-eval-list-with-bddify aig-eval-ev
:hints `(("goal" :in-theory (e/d (aig-eval-list-with-bddify)
@@ -536,8 +703,6 @@
(gl::set-preferred-def aig-eval-with-bddify
aig-eval-in-terms-of-aig-eval-list)
-(gl::set-preferred-def aig-eval-pat-with-bddify
- aig-eval-pat-in-terms-of-aig-eval-list)
(gl::set-preferred-def aig-eval-alist-with-bddify
aig-eval-alist-in-terms-of-aig-eval-list)
@@ -545,8 +710,6 @@
faig-eval-in-terms-of-faig-eval-list)
(gl::set-preferred-def faig-eval-list-with-bddify
faig-eval-list-in-terms-of-aig-eval-list)
-(gl::set-preferred-def faig-eval-pat-with-bddify
- faig-eval-pat-in-terms-of-faig-eval-list)
(gl::set-preferred-def faig-eval-alist-with-bddify
faig-eval-alist-in-terms-of-faig-eval-list)
@@ -556,17 +719,11 @@
(gl::set-preferred-def aig-eval-list aig-eval-list-in-terms-of-with-bddify)
(table gl::override-props 'aig-eval-list '((recursivep . nil)))
-(gl::set-preferred-def aig-eval-pat aig-eval-pat-in-terms-of-with-bddify)
-(table gl::override-props 'aig-eval-pat '((recursivep . nil)))
-
(gl::set-preferred-def faig-eval faig-eval-in-terms-of-with-bddify)
(gl::set-preferred-def faig-eval-list faig-eval-list-in-terms-of-with-bddify)
(table gl::override-props 'faig-eval-list '((recursivep . nil)))
-(gl::set-preferred-def faig-eval-pat faig-eval-pat-in-terms-of-with-bddify)
-(table gl::override-props 'faig-eval-pat '((recursivep . nil)))
-
(gl::set-preferred-def aig-eval-alist aig-eval-alist-in-terms-of-with-bddify)
(table gl::override-props 'aig-eval-alist '((recursivep . nil)))
diff -Nru acl2-6.2/books/centaur/aig/induction.lisp acl2-6.3/books/centaur/aig/induction.lisp
--- acl2-6.2/books/centaur/aig/induction.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/induction.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -78,7 +78,7 @@
:induct (check-property-strong updates prop curr-st inputs))
(and stable-under-simplificationp
(cond
- ((member-equal
+ ((member-equal
'(AIG-EVAL PROP (binary-APPEND CURR-ST (CAR INPUTS)))
clause)
'(:use ((:instance check-ag-property-necc
@@ -98,7 +98,7 @@
(if (consp rest)
rest
(list nil)))))))))))))
-
+
(defun-sk unsat-p (x)
@@ -173,9 +173,9 @@
;; initialization, then check-property is always true.
;; One subtlety: here the initial state may be partial, i.e. an alist that does
;; not bind all the state variables. In this case the full initial state
-;; applied is determined by the first input vector.
+;; applied is determined by the first input vector.
(defthm inductive-invariant-impl-check-property
- (implies (and
+ (implies (and
;; The variables of the invariant must be state variables, not inputs
(subsetp-equal (aig-vars invar)
(alist-keys updates))
@@ -193,7 +193,7 @@
:in-theory (disable unsat-p))))
(defthm inductive-invariant-impl-check-ag-property
- (implies (and
+ (implies (and
;; The variables of the invariant must be state variables, not inputs
(subsetp-equal (aig-vars invar)
(alist-keys updates))
@@ -209,7 +209,7 @@
(check-ag-property updates prop initst)))
(defthm inductive-invariant-impl-check-property-strong
- (implies (and
+ (implies (and
;; The variables of the invariant must be state variables, not inputs
(subsetp-equal (aig-vars invar)
(alist-keys updates))
diff -Nru acl2-6.2/books/centaur/aig/misc.lisp acl2-6.3/books/centaur/aig/misc.lisp
--- acl2-6.2/books/centaur/aig/misc.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/misc.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -21,100 +21,45 @@
(in-package "ACL2")
-(include-book "base")
+(include-book "aig-base")
(include-book "centaur/misc/equal-sets" :dir :system)
(include-book "tools/mv-nth" :dir :system)
(include-book "misc/gentle" :dir :system)
(include-book "misc/hons-help" :dir :system)
(local (include-book "std/alists/alistp" :dir :system))
-(local (include-book "eval-restrict"))
+; (local (include-book "eval-restrict"))
-(local (in-theory (disable append-of-nil)))
+;; (local (in-theory (disable append-of-nil)))
-(defn aig-print (x)
- (declare (xargs :verify-guards nil))
- (aig-cases
- x
- :true t
- :false nil
- :var x
- :inv `(not ,(aig-print (car x)))
- :and (let* ((a (aig-print (car x)))
- (d (aig-print (cdr x))))
- `(and ,@(if (and (consp a) (eq (car a) 'and))
- (cdr a)
- (list a))
- ,@(if (and (consp d) (eq (car d) 'and))
- (cdr d)
- (list d))))))
-
-;; (local
-;; (defthm true-listp-append
-;; (implies (true-listp b)
-;; (true-listp (append a b)))))
-(local
- (defthm true-listp-cdr-aig-print
- (implies (and (consp (aig-print x))
- (eq (car (aig-print x)) 'and))
- (true-listp (cdr (aig-print x))))))
-
-(verify-guards aig-print)
-
-(memoize 'aig-print :condition '(consp x))
+
+;; BOZO misplaced
+
+(local (defthm true-listp-of-make-fal
+ (implies (true-listp name)
+ (true-listp (make-fal al name)))))
+
+(defthm make-fal-is-append
+ (implies (alistp x)
+ (equal (make-fal x y) (append x y))))
+
+(defthm aig-eval-alist-append
+ (equal (aig-eval-alist (append a b) env)
+ (append (aig-eval-alist a env)
+ (aig-eval-alist b env))))
-;; Forms an AIG from an ACL2-like term.
-(mutual-recursion
- (defun expr-to-aig (expr)
- (declare (Xargs :guard t
- :measure (+ 1 (* 2 (acl2-count expr)))))
- (if (atom expr)
- expr
- (let ((fn (car expr))
- (args (cdr expr)))
- (cond
- ((and (eq fn 'not) (= (len args) 1))
- (aig-not (expr-to-aig (car args))))
- ((eq fn 'and) (expr-to-aig-args 'and t args))
- ((eq fn 'or) (expr-to-aig-args 'or nil args))
- ((eq fn 'nand) (aig-not (expr-to-aig-args 'and t args)))
- ((eq fn 'nor) (aig-not (expr-to-aig-args 'or nil args)))
- ((and (eq fn 'iff) (= (len args) 2))
- (aig-iff (expr-to-aig (car args))
- (expr-to-aig (cadr args))))
- ((and (eq fn 'xor) (= (len args) 2))
- (aig-xor (expr-to-aig (car args))
- (expr-to-aig (cadr args))))
- ((and (eq fn 'implies) (= (len args) 2))
- (aig-or (aig-not (expr-to-aig (car args)))
- (expr-to-aig (cadr args))))
- ((and (eq fn 'if) (= (len args) 3))
- (aig-ite (expr-to-aig (car args))
- (expr-to-aig (cadr args))
- (expr-to-aig (caddr args))))
- (t (prog2$ (er hard? 'expr-to-aig "Malformed: ~x0~%" expr)
- nil))))))
- (defun expr-to-aig-args (op final exprs)
- (declare (xargs :guard t
- :measure (* 2 (acl2-count exprs))))
- (if (atom exprs)
- final
- (let ((first (expr-to-aig (car exprs)))
- (rest (expr-to-aig-args op final (cdr exprs))))
- (case op
- (and (aig-and first rest))
- (or (aig-or first rest)))))))
-
-(defun faig-vars-pat (pat aigs)
- (if pat
- (if (atom pat)
- (list :signal pat
- (aig-vars (car aigs))
- (aig-vars (cdr aigs)))
- (cons (faig-vars-pat (car pat) (car aigs))
- (faig-vars-pat (cdr pat) (cdr aigs))))
- nil))
+
+
+;; (defun faig-vars-pat (pat aigs)
+;; (if pat
+;; (if (atom pat)
+;; (list :signal pat
+;; (aig-vars (car aigs))
+;; (aig-vars (cdr aigs)))
+;; (cons (faig-vars-pat (car pat) (car aigs))
+;; (faig-vars-pat (cdr pat) (cdr aigs))))
+;; nil))
;; Extracts necessary variable assignments from an AIG by breaking down its
@@ -258,29 +203,33 @@
(make-fal (assign-var-list falses nil)
nil))))
-(local (defthm true-listp-of-make-fal
- (implies (true-listp name)
- (true-listp (make-fal al name)))))
-
(local (defthm true-listp-of-aig-extract-assigns-alist
(true-listp (aig-extract-assigns-alist x))))
-(defthm make-fal-is-append
- (implies (alistp x)
- (equal (make-fal x y) (append x y))))
(defthm alistp-aig-extract-assigns-alist
(alistp (aig-extract-assigns-alist x)))
-(defthm aig-eval-alist-append
- (equal (aig-eval-alist (append a b) env)
- (append (aig-eval-alist a env)
- (aig-eval-alist b env))))
-
(defthm aig-eval-alist-aig-extract-assigns-alist
(equal (aig-eval-alist (aig-extract-assigns-alist x) env)
(aig-extract-assigns-alist x)))
+(defthm assign-var-list-lookup
+ (equal (hons-assoc-equal k (assign-var-list x v))
+ (and (member k x)
+ (cons k v)))
+ :hints(("Goal" :in-theory (enable assign-var-list hons-assoc-equal member))))
+
+(local (defthm hons-assoc-equal-of-append
+ (equal (hons-assoc-equal k (append x y))
+ (or (hons-assoc-equal k x)
+ (hons-assoc-equal k y)))))
+
+(defthmd aig-extract-assigns-alist-lookup-boolean
+ (booleanp (cdr (hons-assoc-equal k (aig-extract-assigns-alist x))))
+ :hints(("Goal" :in-theory (enable aig-extract-assigns-alist)))
+ :rule-classes :type-prescription)
+
(defthm aig-extract-assigns-restrict
;; (implies (aig-eval x env)
@@ -344,6 +293,12 @@
:hints (("goal" :use ((:instance aig-extract-iterated-assigns-restrict
(env nil))))))
+(defthmd aig-extract-iterated-assigns-alist-lookup-boolean
+ (booleanp (cdr (hons-assoc-equal k (aig-extract-iterated-assigns-alist x clk))))
+ :hints(("Goal" :in-theory (enable aig-extract-iterated-assigns-alist
+ aig-extract-assigns-alist-lookup-boolean)))
+ :rule-classes :type-prescription)
+
(memoize 'aig-extract-iterated-assigns-alist
:recursive nil)
diff -Nru acl2-6.2/books/centaur/aig/portcullis.acl2 acl2-6.3/books/centaur/aig/portcullis.acl2
--- acl2-6.2/books/centaur/aig/portcullis.acl2 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/portcullis.acl2 2013-09-30 17:53:11.000000000 +0000
@@ -19,8 +19,8 @@
; Original author: Sol Swords
(in-package "ACL2")
-(ld "centaur/vl/package.lsp" :dir :system)
-(ld "centaur/vl/other-packages.lsp" :dir :system)
+(include-book "centaur/vl/portcullis" :dir :system)
+(include-book "centaur/satlink/portcullis" :dir :system)
+(include-book "centaur/aignet/portcullis" :dir :system)
(ld "fsm-pkg.lsp")
; cert-flags: ? t :ttags :all
-(certify-book "portcullis" ? t :ttags :all)
diff -Nru acl2-6.2/books/centaur/aig/random-sim.lisp acl2-6.3/books/centaur/aig/random-sim.lisp
--- acl2-6.2/books/centaur/aig/random-sim.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/random-sim.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -24,123 +24,116 @@
;; Functions for performing fixnum-length data-parallel simulations on AIGs.
;; Much slower than AIGPU, you can be sure :-)
(include-book "aig-equivs")
-(include-book "misc")
+(include-book "system/random" :dir :system)
(include-book "centaur/bitops/equal-by-logbitp" :dir :system)
(local (include-book "centaur/bitops/ihs-extensions" :dir :system))
(local (include-book "ihs/quotient-remainder-lemmas" :dir :system))
-(local (include-book "data-structures/list-defthms" :dir :system))
-(local (include-book "eval-restrict"))
(set-state-ok t)
(local (in-theory (enable* arith-equiv-forwarding)))
(local (in-theory (disable aig-vars)))
-(defthm state-p1-of-random
- (implies (force (state-p1 state))
- (state-p1 (mv-nth 1 (random$ limit state))))
- :hints(("Goal" :in-theory (enable random$ read-acl2-oracle))))
-
-
-(defund random-list-aux (n limit acc state)
- (declare (xargs :guard (and (natp n)
- (posp limit))))
- (if (zp n)
- (mv acc state)
- (b* (((mv x1 state) (random$ limit state)))
- (random-list-aux (- n 1) limit (cons x1 acc) state))))
-
-(defthm state-p1-of-random-list-aux
- (implies (force (state-p1 state))
- (state-p1 (mv-nth 1 (random-list-aux n limit acc state))))
- :hints(("Goal" :in-theory (enable random-list-aux))))
-
-
-
-(defund random-list (n limit state)
- ;; Generate N random integers in [0, limit)
- (declare (xargs :guard (and (natp n)
- (posp limit))))
- (random-list-aux n limit nil state))
-
-(defthm state-p1-of-random-list
- (implies (force (state-p1 state))
- (state-p1 (mv-nth 1 (random-list n limit state))))
- :hints(("Goal" :in-theory (enable random-list))))
-
-
-
-(defun n-random-60-bit-nats (n state)
- ;; Generate N random integers in [0, 2^60)
- ;; We just leave this enabled.
- (declare (xargs :guard (natp n)))
+(defxdoc aig-random-sim
+ :parents (aig-other)
+ :short "Functions for randomly vector simulations of Hons @(see aig)s."
+
+ :long "Simulating AIGs on random vectors is useful in algorithms such as
+fraiging ,
+to look for nodes that are probably equivalent and might be merged.
+
+Our hons-based @(see aig) representation is not especially efficient or
+well-suited for carrying out random simulations, and nowadays @(see aignet) is
+a much faster alternative. Nevertheless, we have developed various routines
+for vector-simulations of Hons AIGs.
+
+Note that some of these routines make use of 60-bit natural numbers, which
+are fixnums on 64-bit CCL and SBCL. They may perform quite badly on other
+Lisps with smaller fixnum ranges.
")
+
+
+(define n-random-60-bit-nats ((n natp "How many to generate.") state)
+ :parents (aig-random-sim)
+ :short "Generate a list of 60-bit naturals."
+ :long "We just leave this enabled.
"
+ :enabled t
(random-list n (ash 1 60) state))
-(defund init-random-state (vars state)
- ;; Fast alist binding each variable to a random integer in [0, 2^60)
- (declare (xargs :guard t))
- (b* (((mv nums state)
- (n-random-60-bit-nats (len vars) state)))
- (mv (make-fal (ec-call (pairlis$ vars nums)) nil)
- state)))
-
-(defthm state-p1-of-init-random-state
- (implies (force (state-p1 state))
- (state-p1 (mv-nth 1 (init-random-state vars state))))
- :hints(("Goal" :in-theory (enable init-random-state))))
-
-
-
-(defconst *60-bit-mask* (1- (ash 1 60)))
-
-(encapsulate
- ()
- (local (include-book "arithmetic/top-with-meta" :dir :system))
- (defthm logbitp-of-60-bit-mask
- (implies (natp i)
- (equal (logbitp i *60-bit-mask*)
- (< i 60)))
- :hints (("goal" :in-theory (enable logbitp**)))))
-
-
-(defun 60-bit-fix (x)
- (declare (xargs :guard t :verify-guards nil))
+(define init-random-state
+ :parents (aig-random-sim)
+ :short "Create a fast alist binding each variable to a random 60-bit natural."
+ (vars state)
+ :returns (mv fal state)
+ (b* ((vars (mbe :logic (list-fix vars)
+ :exec (if (true-listp vars)
+ vars
+ (list-fix vars))))
+ ((mv nums state)
+ (n-random-60-bit-nats (length vars) state)))
+ (mv (make-fast-alist (pairlis$ vars nums))
+ state))
+ ///
+ (defthm state-p1-of-init-random-state
+ (implies (force (state-p1 state))
+ (state-p1 (mv-nth 1 (init-random-state vars state))))))
-; Old definition:
-;
-; (the (signed-byte 61)
-; (if (integerp x)
-; (logand x (the (signed-byte 61) *60-bit-mask*))
-; 0)))
-;
-; The new definition is slightly faster because we avoid the lookup of the
-; *60-bit-mask*.
-;
-; We could make this almost twice as fast by redefining it under the hood as
-; (if (typep x '(signed-byte 61)) x 0), but I had some trouble getting this to
-; properly inline, and probably it's best to avoid a ttag for such a minor
-; optimization.
+(defsection *60-bit-mask*
+ :parents (aig-random-sim)
+ :short "The largest 60-bit natural, all ones."
+ (defconst *60-bit-mask* (1- (ash 1 60)))
+
+ (local (include-book "arithmetic/top-with-meta" :dir :system))
+
+ (defthm logbitp-of-60-bit-mask
+ (implies (natp i)
+ (equal (logbitp i *60-bit-mask*)
+ (< i 60)))
+ :hints (("goal" :in-theory (enable logbitp**)))))
+
+
+(define 60-bit-fix (x)
+ :parents (aig-random-sim)
+ :short "Coerce an object to a 60-bit natural."
+ :long "A previous definition for this function was:
+
+@({
+ (the (signed-byte 61)
+ (if (integerp x)
+ (logand x (the (signed-byte 61) *60-bit-mask*))
+ 0))
+})
+
+But the new definition is slightly faster because we avoid the lookup of the
+@(see *60-bit-mask*).
+
+We could make this almost twice as fast by redefining it under the hood as
+@('(if (typep x '(signed-byte 61)) x 0)'), but I had some trouble getting this
+to properly inline, and probably it's best to avoid a ttag for such a minor
+optimization.
"
+
+ :inline t
+ :enabled t
+ :guard-hints(("Goal" :in-theory (disable logand-with-bitmask)))
(if (integerp x)
(the (signed-byte 61) (logand x (- (ash 1 60) 1)))
0))
-(verify-guards 60-bit-fix
- :hints(("Goal" :in-theory (disable logand-with-bitmask))))
-
-
-(defun aig-vecsim60 (aig alst)
- ;; We do a 60-bit wide evaluation of AIG under ALST, which should bind the
- ;; variables of AIG to 60-bit integers. (If there are any missing or invalid
- ;; bindings in ALST, we just 60-bit-fix them.)
- (declare (xargs :guard t
- :verify-guards nil))
+(define aig-vecsim60
+ :parents (aig-random-sim)
+ :short "Do a 60-bit wide evaluation of an AIG."
+ ((aig "The AIG to simulate.")
+ (alst "An alist that should bind the variables of @('aig') to 60-bit
+ naturals. If there are any missing or invalid bindings, we
+ just @(see 60-bit-fix) them."))
+ :verify-guards nil
(cond ((atom aig)
(cond ((eq aig nil)
0)
((eq aig t)
- -1)
+ -1) ;; BOZO shouldn't we return *60-bit-mask*???
(t
(let ((look (hons-get aig alst)))
(if look
@@ -148,8 +141,8 @@
-1)))))
((not (cdr aig))
(the (signed-byte 61)
- (lognot (the (signed-byte 61)
- (aig-vecsim60 (car aig) alst)))))
+ (lognot (the (signed-byte 61)
+ (aig-vecsim60 (car aig) alst)))))
(t
(let ((a (aig-vecsim60 (car aig) alst)))
(mbe
@@ -157,63 +150,72 @@
:exec (if (= (the (signed-byte 61) a) 0)
0
(the (signed-byte 61)
- (logand (the (signed-byte 61) a)
- (the (signed-byte 61)
- (aig-vecsim60 (cdr aig) alst))))))))))
-
-(defthm aig-vecsim60-60-bits
- (signed-byte-p 61 (aig-vecsim60 aig alst))
- :hints(("Goal" :in-theory (disable logand-with-bitmask))))
-
-(verify-guards aig-vecsim60)
+ (logand (the (signed-byte 61) a)
+ (the (signed-byte 61)
+ (aig-vecsim60 (cdr aig) alst)))))))))
+ ///
+ (defthm aig-vecsim60-60-bits
+ (signed-byte-p 61 (aig-vecsim60 aig alst))
+ :hints(("Goal" :in-theory (disable logand-with-bitmask))))
+
+ (verify-guards aig-vecsim60)
+
+ (memoize 'aig-vecsim60 :condition '(and (consp aig) (cdr aig))))
-(memoize 'aig-vecsim60 :condition '(and (consp aig) (cdr aig)))
-(defun logbitp-env60 (i alst)
- ;; Given an ALST binding variables to 60-bit integers as in aig-vecsim60, we
- ;; extract the ordinary, Boolean-valued alist by using the Ith bit of each
- ;; variable.
- (if (atom alst)
- nil
- (if (atom (car alst))
- (logbitp-env60 i (cdr alst))
- (cons (cons (caar alst)
- (if (natp i)
- (if (< i 60)
- (logbitp i (cdar alst))
- nil)
- (logbitp 0 (cdar alst))))
- (logbitp-env60 i (cdr alst))))))
-
-(local
- (progn
- (local (include-book "arithmetic/top-with-meta" :dir :system))
-
- (defthm hons-assoc-equal-logbitp-env60
- (equal (cdr (hons-assoc-equal v (logbitp-env60 i alst)))
- (if (natp i)
- (and (< i 60)
- (logbitp i (cdr (hons-assoc-equal v alst))))
- (logbitp 0 (cdr (hons-assoc-equal v alst)))))
- :hints(("Goal" :in-theory (enable hons-assoc-equal))))
+(define logbitp-env60 (i alst)
+ :parents (aig-random-sim)
+ :short "Given an ALST binding variables to 60-bit integers as in @(see
+aig-vecsim60), we extract an ordinary, Boolean-valued alist by using the Ith
+bit of each variable."
+ :verify-guards nil ;; Not meant to be executed
+ (cond ((atom alst)
+ nil)
+ ((atom (car alst))
+ (logbitp-env60 i (cdr alst)))
+ (t
+ (cons (cons (caar alst)
+ (if (natp i)
+ (if (< i 60)
+ (logbitp i (cdar alst))
+ nil)
+ (logbitp 0 (cdar alst))))
+ (logbitp-env60 i (cdr alst))))))
- (defthm hons-assoc-equal-logbitp-env60-iff
- (iff (hons-assoc-equal v (logbitp-env60 i alst))
- (hons-assoc-equal v alst)))
+(local (include-book "arithmetic/top-with-meta" :dir :system))
- (defthm logbitp-env60-non-natp
- (implies (not (natp i))
- (equal (logbitp-env60 i alst)
- (logbitp-env60 0 alst))))))
+(encapsulate
+ ()
+ (local (in-theory (enable logbitp-env60)))
-(defthm logbitp-of-aig-vecsim60
- (equal (aig-eval aig (logbitp-env60 i alst))
- (logbitp i (aig-vecsim60 aig alst)))
- :hints (("Goal" :induct (aig-vecsim60 aig alst)
- :in-theory (enable natp aig-env-lookup))
- (and stable-under-simplificationp
- '(:cases ((natp i))))))
+ (local
+ (progn
+ (defthm hons-assoc-equal-logbitp-env60
+ (equal (cdr (hons-assoc-equal v (logbitp-env60 i alst)))
+ (if (natp i)
+ (and (< i 60)
+ (logbitp i (cdr (hons-assoc-equal v alst))))
+ (logbitp 0 (cdr (hons-assoc-equal v alst)))))
+ :hints(("Goal" :in-theory (enable hons-assoc-equal))))
+
+ (defthm hons-assoc-equal-logbitp-env60-iff
+ (iff (hons-assoc-equal v (logbitp-env60 i alst))
+ (hons-assoc-equal v alst)))
+
+ (defthm logbitp-env60-non-natp
+ (implies (not (natp i))
+ (equal (logbitp-env60 i alst)
+ (logbitp-env60 0 alst))))))
+
+ (defthm logbitp-of-aig-vecsim60
+ (equal (aig-eval aig (logbitp-env60 i alst))
+ (logbitp i (aig-vecsim60 aig alst)))
+ :hints (("Goal" :induct (aig-vecsim60 aig alst)
+ :in-theory (enable natp aig-env-lookup
+ aig-vecsim60))
+ (and stable-under-simplificationp
+ '(:cases ((natp i)))))))
@@ -248,7 +250,8 @@
:use ((:instance aig-equiv-necc
(env (aig-vecsim60-diff a b vecs))
(x a) (y b)))
- :in-theory (disable aig-equiv-implies-equal-aig-eval-1))))
+ ;:in-theory (disable aig-equiv-implies-equal-aig-eval-1)
+ )))
@@ -909,6 +912,7 @@
:do-not '(generalize fertilize)
:induct (aig-rsim60 aig renv)
:in-theory (enable aig-rsim60 aig-vars aig-eval aig-env-lookup
+ aig-vecsim60
subsetp-equal
logbitp-of-loghead-split)))))
@@ -968,7 +972,8 @@
(aig-vars b))
renv))
(x a) (y b)))
- :in-theory (disable aig-equiv-implies-equal-aig-eval-1)))))
+ ;:in-theory (disable aig-equiv-implies-equal-aig-eval-1)
+ ))))
(defsection aig-rsim60-bind-variable
diff -Nru acl2-6.2/books/centaur/aig/three-four.lisp acl2-6.3/books/centaur/aig/three-four.lisp
--- acl2-6.2/books/centaur/aig/three-four.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/three-four.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -23,375 +23,6 @@
(in-package "ACL2")
-(include-book "base")
-(include-book "tools/bstar" :dir :system)
-(include-book "tools/rulesets" :dir :system)
-
-(defconst *4x* (hons t t))
-(defconst *4z* (hons nil nil))
-(defconst *4t* (hons t nil))
-(defconst *4f* (hons nil t))
-
-
-(def-b*-binder faig
- ":doc-section B*-BINDERS
-Binds two variables to the onset and offset, respectively, of the faig-fix
-of the given expression.~/~/~/"
- (declare (xargs :guard (and (true-listp args)
- (equal (len args) 2)
- (true-listp forms)
- (equal (len forms) 1))))
- `(b* (((mv ,(first args) ,(second args))
- (let ((x (faig-fix ,(car forms))))
- (mv (car x) (cdr x)))))
- ,rest-expr))
-
-
-(defxdoc faig-constructors
- :parents (faig)
- :short "Low-level functions for constructing FAIGs."
-
- :long "In many cases, it is possible to more efficiently construct FAIGs
-when it is known that the input FAIGs cannot evaluate to Z. This is something
-that holds of the outputs of most logic gates, e.g., a NOT gate might produce
-an X, but it will never produce a Z.
-
-Because of this, we have two versions of most of our FAIG constructors. The
-@('t-aig-*') functions make the assumption that their inputs are non-floating
-and can never evaluate to Z, and are more efficient. The @('f-aig-*')
-functions do not make this assumption and can operate on any FAIG inputs, but
-are not as efficient and yield larger FAIGs.
")
-
-
-
-
-; Macro to prove the FAIG constructors commute over FAIG-EVAL.
-
-(defun pfoc-faig-eval-args (args)
- (if (atom args)
- nil
- (cons (list 'faig-eval (car args) 'env)
- (pfoc-faig-eval-args (cdr args)))))
-
-(defun pfoc-arg-casesplit-list (args)
- (if (atom args)
- nil
- (list* `(and stable-under-simplificationp
- '(:cases ((aig-eval (car ,(car args)) env))))
- `(and stable-under-simplificationp
- '(:cases ((aig-eval (cdr ,(car args)) env))))
- (pfoc-arg-casesplit-list (cdr args)))))
-
-(defmacro prove-faig-op-commutes (op args)
- `(defthm ,(intern-in-package-of-symbol
- (concatenate 'string "FAIG-EVAL-OF-" (symbol-name op))
- op)
- (equal (faig-eval (,op . ,args) env)
- (,op . ,(pfoc-faig-eval-args args)))
- :hints ,(pfoc-arg-casesplit-list args)))
-
-
-
-
-
-(defsection t-aig-fix
- ;; BOZO should probably rename this to f-aig-unfloat
- :parents (faig-constructors)
- :short "Unfloat operation, converts floating (Z) values to unknown (X)
-values."
- :long "See also @(see 4v-unfloat); this is the analagous function for
-FAIGs.
"
-
- (defn t-aig-fix (a)
- (b* (((faig a1 a0) a))
- (cons (aig-not (aig-and a0 (aig-not a1)))
- (aig-not (aig-and a1 (aig-not a0))))))
-
- (prove-faig-op-commutes t-aig-fix (a)))
-
-
-
-(defsection t-aig-not
- :parents (faig-constructors)
- :short "@(call t-aig-not) negates the FAIG @('a'), assuming that it cannot
-evaluate to Z."
-
- (defn t-aig-not (a)
- (b* (((faig a1 a0) a))
- (cons a0 a1)))
-
- (prove-faig-op-commutes t-aig-not (a)))
-
-
-(defsection f-aig-not
- :parents (faig-constructors)
- :short "@(call f-aig-not) negates the FAIG @('a')."
-
- (defn f-aig-not (a)
- (b* (((faig a1 a0) a))
- (cons (aig-not (aig-and a1 (aig-not a0)))
- (aig-not (aig-and a0 (aig-not a1))))))
-
- (prove-faig-op-commutes f-aig-not (a)))
-
-
-
-(defsection t-aig-and
- :parents (faig-constructors)
- :short "@(call t-aig-and) and s together the FAIGs @('a') and @('b'),
-assuming they cannot evaluate to Z."
-
- (defn t-aig-and (a b)
- (b* (((faig a1 a0) a)
- ((faig b1 b0) b))
- (cons (aig-and a1 b1)
- (aig-or a0 b0))))
-
- (prove-faig-op-commutes t-aig-and (a b)))
-
-(defsection f-aig-and
- :parents (faig-constructors)
- :short "@(call f-aig-and) and s together the FAIGs @('a') and @('b')."
-
- (defn f-aig-and (a b)
- (let ((a (t-aig-fix a))
- (b (t-aig-fix b)))
- (t-aig-and a b)))
-
- (prove-faig-op-commutes f-aig-and (a b)))
-
-
-
-(defsection t-aig-or
- :parents (faig-constructors)
- :short "@(call t-aig-or) or s together the FAIGs @('a') and @('b'),
-assuming they cannot evaluate to Z."
-
- (defn t-aig-or (a b)
- (b* (((faig a1 a0) a)
- ((faig b1 b0) b))
- (cons (aig-or a1 b1)
- (aig-and a0 b0))))
-
- (prove-faig-op-commutes t-aig-or (a b)))
-
-(defsection f-aig-or
- :parents (faig-constructors)
- :short "@(call f-aig-or) or s together the FAIGs @('a') and @('b')."
-
- (defn f-aig-or (a b)
- (let ((a (t-aig-fix a))
- (b (t-aig-fix b)))
- (t-aig-or a b)))
-
- (prove-faig-op-commutes f-aig-or (a b)))
-
-
-
-(defsection t-aig-xor
- :parents (faig-constructors)
- :short "@(call t-aig-xor) xor s together the FAIGs @('a') and @('b'),
-assuming they cannot evaluate to Z."
-
- (defn t-aig-xor (a b)
- (t-aig-or (t-aig-and a (t-aig-not b))
- (t-aig-and (t-aig-not a) b)))
-
- (prove-faig-op-commutes t-aig-xor (a b)))
-
-(defsection f-aig-xor
- :parents (faig-constructors)
- :short "@(call f-aig-xor) xor s together the FAIGs @('a') and @('b')."
-
- (defn f-aig-xor (a b)
- (let ((a (t-aig-fix a))
- (b (t-aig-fix b)))
- (t-aig-xor a b)))
-
- (prove-faig-op-commutes f-aig-xor (a b)))
-
-
-
-(defsection t-aig-iff
- :parents (faig-constructors)
- :short "@(call t-aig-iff) iff s together the FAIGs @('a') and @('b'),
-assuming they cannot evaluate to Z."
-
- (defn t-aig-iff (a b)
- (t-aig-or (t-aig-and a b)
- (t-aig-and (t-aig-not a) (t-aig-not b))))
-
- (prove-faig-op-commutes t-aig-iff (a b)))
-
-
-(defsection f-aig-iff
- :parents (faig-constructors)
- :short "@(call f-aig-iff) iff s together the FAIGs @('a') and @('b')."
-
- (defn f-aig-iff (a b)
- (let ((a (t-aig-fix a))
- (b (t-aig-fix b)))
- (t-aig-iff a b)))
-
- (prove-faig-op-commutes f-aig-iff (a b)))
-
-
-
-
-(defsection t-aig-ite
- :parents (faig-constructors)
- :short "@(call t-aig-ite) constructs a (less conservative) FAIG representing
-@('(if c a b)'), assuming these input FAIGs cannot evaluate to Z."
-
- :long "This is a less-conservative version of @(see t-aig-ite*) that emits
-@('a') in the case that @('c') is unknown but @('a = b'). See @(see 4v-ite)
-for discussion related to this issue.
"
-
- (defn t-aig-ite (c a b)
- (b* (((faig a1 a0) a)
- ((faig b1 b0) b)
- ((faig c1 c0) c))
- (cons (aig-or (aig-and c1 a1)
- (aig-and c0 b1))
- (aig-or (aig-and c1 a0)
- (aig-and c0 b0)))))
-
- (prove-faig-op-commutes t-aig-ite (c a b)))
-
-(defsection f-aig-ite
- :parents (faig-constructors)
- :short "@(call f-aig-ite) constructs a (less conservative) FAIG representing
-@('(if c a b)')."
-
- :long "This is a less-conservative version of @(see f-aig-ite*) that emits
-@('a') in the case that @('c') is unknown but @('a = b'). See @(see 4v-ite)
-for discussion related to this issue.
"
-
- (defn f-aig-ite (c a b)
- (let* ((c (t-aig-fix c))
- (a (t-aig-fix a))
- (b (t-aig-fix b)))
- (t-aig-ite c a b)))
-
- (prove-faig-op-commutes f-aig-ite (c a b)))
-
-
-
-(defsection t-aig-ite*
- :parents (faig-constructors)
- :short "@(call t-aig-ite*) constructs a (more conservative) FAIG representing
-@('(if c a b)'), assuming these input FAIGs cannot evaluate to Z."
-
- :long "This is a more-conservative version of @(see t-aig-ite) that emits
-@('X') in the case that @('c') is unknown, even when @('a = b'). See @(see
-4v-ite) for discussion related to this issue.
"
-
- (defn t-aig-ite* (c a b)
- (b* (((faig a1 a0) a)
- ((faig b1 b0) b)
- ((faig c1 c0) c)
- (x (aig-and c1 c0)))
- (cons (aig-or x (aig-or (aig-and c1 a1)
- (aig-and c0 b1)))
- (aig-or x (aig-or (aig-and c1 a0)
- (aig-and c0 b0))))))
-
- (prove-faig-op-commutes t-aig-ite* (c a b)))
-
-(defsection f-aig-ite*
- :parents (faig-constructors)
- :short "@(call f-aig-ite*) constructs a (more conservative) FAIG representing
-@('(if c a b)'), assuming these input FAIGs cannot evaluate to Z."
-
- :long "This is a more-conservative version of @(see f-aig-ite) that emits
-@('X') in the case that @('c') is unknown, even when @('a = b'). See @(see
-4v-ite) for discussion related to this issue.
"
-
- (defn f-aig-ite* (c a b)
- (let* ((c (t-aig-fix c))
- (a (t-aig-fix a))
- (b (t-aig-fix b)))
- (t-aig-ite* c a b)))
-
- (prove-faig-op-commutes f-aig-ite* (c a b)))
-
-
-
-
-(defn f-aig-res (x y)
- (b* (((faig x1 x0) x)
- ((faig y1 y0) y))
- (cons (aig-or x1 y1)
- (aig-or x0 y0))))
-
-(prove-faig-op-commutes f-aig-res (a b))
-
-(defn f-aig-wire (a b)
- (f-aig-res a b))
-
-
-
-
-
-;; Theorem: no T-AIG-FIX needed around the answer of f-aig-ite.
-;; (thm
-;; (and
-;; (iff (aig-eval (car (t-aig-fix (t-aig-ite (t-aig-fix c)
-;; (t-aig-fix a)
-;; (t-aig-fix b))))
-;; al)
-;; (aig-eval (car (t-aig-ite (t-aig-fix c)
-;; (t-aig-fix a)
-;; (t-aig-fix b)))
-;; al))
-;; (iff (aig-eval (cdr (t-aig-fix (t-aig-ite (t-aig-fix c)
-;; (t-aig-fix a)
-;; (t-aig-fix b))))
-;; al)
-;; (aig-eval (cdr (t-aig-ite (t-aig-fix c)
-;; (t-aig-fix a)
-;; (t-aig-fix b)))
-;; al))))
-
-
-(defn t-aig-buf (c a)
- ;; onset of output is (not (or (and (not con) coff) (and con (not coff) (not aon) aoff)))
- ;; offset of output is (not (or (and (not con) coff) (and con (not coff) aoff (not aon))))
- (b* (((faig a1 a0) a)
- ((faig c1 c0) c)
- (float (aig-and (aig-not c1) c0))
- (set (aig-and c1 (aig-not c0)))
- (on (aig-and (aig-not a0) a1))
- (off (aig-and (aig-not a1) a0)))
- (cons (aig-and (aig-not float) (aig-not (aig-and set off)))
- (aig-and (aig-not float) (aig-not (aig-and set on))))))
-
-(prove-faig-op-commutes t-aig-buf (c a))
-
-
-(defn f-aig-pullup (a)
- (b* (((faig a1 a0) a)
- (a-not-aig-floating (aig-or a1 a0))
- (a-floating (aig-not a-not-aig-floating)))
- (cons (aig-or a-floating a1) a0)))
-
-(prove-faig-op-commutes f-aig-pullup (a))
-
-
-(defn f-aig-bi-buf (cntl in bus)
- (f-aig-wire (t-aig-buf cntl in) bus))
-
-(prove-faig-op-commutes f-aig-bi-buf (c a b))
-
-(def-ruleset f-aig-defs
- '(t-aig-fix f-aig-not f-aig-and f-aig-or f-aig-xor f-aig-iff
- f-aig-res f-aig-ite f-aig-ite*
- t-aig-buf f-aig-pullup f-aig-bi-buf))
-
-(def-ruleset t-aig-defs
- '(t-aig-and t-aig-iff t-aig-ite t-aig-ite* t-aig-not t-aig-or t-aig-xor))
-
-
-
-
+;; cert_param: (reloc_stub)
+(include-book "faig-constructors")
diff -Nru acl2-6.2/books/centaur/aig/top.lisp acl2-6.3/books/centaur/aig/top.lisp
--- acl2-6.2/books/centaur/aig/top.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/aig/top.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,194 @@
+; Centaur AIG Library
+; Copyright (C) 2008-2011 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original authors: Sol Swords
+; Jared Davis
+
+(in-package "ACL2")
+(include-book "accumulate-nodes-vars")
+(include-book "aig2c")
+(include-book "aig-base")
+(include-book "aig-equivs")
+(include-book "aiger")
+(include-book "aig-print")
+(include-book "aig-sat")
+; Avoid dependence of this top.lisp book on glucose, so that running the
+; command " make everything USE_QUICKLISP=1" with ACL2(h) will build the
+; manual:
+; (include-book "aig-sat-tests")
+(include-book "aig-vars-ext")
+(include-book "aig-vars-fast")
+(include-book "aig-vars")
+(include-book "bddify-correct")
+(include-book "bddify")
+(include-book "best-aig")
+(include-book "eval-restrict")
+(include-book "faig-base")
+(include-book "faig-constructors")
+(include-book "faig-equivs")
+(include-book "faig-purebool-p")
+(include-book "g-aig-eval")
+(include-book "induction")
+(include-book "misc")
+(include-book "portcullis")
+(include-book "random-sim")
+
+
+(defxdoc aig
+ :parents (boolean-reasoning)
+ :short "A @(see hons)-based And-Inverter
+Graph (AIG) library for representing and manipulating Boolean functions."
+
+ :long "Introduction
+
+And-Inverter Graphs are a way to represent Boolean functions using only the
+operations and and not .
+
+This AIG library, found in @('centaur/aig'), is sometimes called the
+Hons-AIG library to distinguish it from another AIG library, @(see
+aignet). Very briefly:
+
+
+ Hons-AIGs are simpler, easier to work with, and easier to reason about.
+ @(see aignet) is faster.
+
+
+We won't say anything more about Aignet here. A much more detailed
+comparison of the libraries is available in: Jared Davis and Sol Swords. Verified AIG Algorithms in
+ACL2. In ACL2 Workshop 2013. May, 2013. EPTCS 114. Pages 95-110.
+
+
+Representation of AIGs
+
+We always construct AIGs with @(see hons) so that existing pieces of AIGs
+will be automatically reused. We represent AIGs as arbitrary cons trees, which
+we interpret as follows:
+
+
+
+@('T') represents the constant-true function.
+
+@('NIL') represents the constant-false function.
+
+Any other atom represents a Boolean variable (i.e., an input to the
+function.)
+
+A cons of the form @('(A . NIL)') represents the negation of @('A').
+
+Any other cons, @('(A . B)'), represents the conjunction of @('A') and
+@('B').
+
+
+
+Note that every ACL2 object is a well-formed AIG under this definition.
+
+This meaning of cons trees is given by the evaluation function @(see
+aig-eval), which returns the (Boolean) value of an AIG under some particular
+assignment to its variables. This function naturally induces an equivalence
+relation, @(see aig-equiv): two AIGs are semantically equivalent if they have
+the same evaluation under every possible variable assignment.
+
+You might wonder why we would restrict ourselves to using only and
+and not ? On the surface, using a richer language like S-expressions
+might seem more compact. For instance, with S-expressions we could represent
+@('(or a b)') is much smaller looking than its and/not equivalent:
+@('(not (and (not a) (not b)))').
+
+But another critical part of memory efficiency is structure sharing. That
+is, suppose that we already need @('(not a)') and @('(not b)') elsewhere in the
+function. With s-expressions, these terms would have nothing in common with
+@('(or a b)'), but with AIGs we can reuse the existing parts of
+@('(not (and (not a) (not b)))').
+
+
+Library Functions
+
+Besides the @(see aig-semantics) functions like @(see aig-eval) and @(see
+aig-equiv), the real core of the library includes:
+
+
+
+Basic, low-level @(see aig-constructors) for building
+AIGs (and , or , etc.). We prove these operations correct with
+respect to @(see aig-eval).
+
+Somewhat higher-level @(see aig-substitution) operations, like @(see
+aig-restrict), @(see aig-compose), and @(see aig-partial-eval).
+
+Operations for collecting the variables from an AIG, such as @(see
+aig-vars).
+
+
+
+We provide some tools to \"solve\" AIGs. Historically we have heavily used
+the @(see bddify) algorithm, which constructs a BDD from an AIG. More
+recently, @(see aig-sat) provides a nice alternative using @(see aignet) and
+@(see satlink) to give the problem to a SAT solver.
+
+Beyond this, the rest of the library is a hodgepodge of @(see aig-other)
+algorithms for working with AIGs.
+
+
+AIGs versus BDDs
+
+Another option for representing Boolean functions would be to use BDDs . In comparison with BDDs, AIGs are:
+
+
+
+cheaper to construct, e.g., if we want to or together the functions
+@('f') and @('g'), it only takes a few conses with AIGs, whereas with BDDs we
+need to walk through @('f') and @('g') to construct a new structure (which
+might be quite large); but
+
+more expensive to compare, e.g., with BDDs we can determine if @('f') and
+@('g') are equal via pointer equality, whereas with AIGs this is a
+satisfiability problem.
+
+
+
+This tradeoff is often worth it. For instance, it can often be more faster
+to construct an AIG and then @(see bddify) it than to just directly build the
+BDD. Why? With the whole AIG visible, the bddify algorithm can often
+\"prune\" branches of the AIG that turn out to be irrelevant, and hence avoid
+constructing large parts of the BDD that aren't really needed.
+
+
+
+
+")
+
+(defxdoc aig-substitution
+ :parents (aig)
+ :short "AIG operations for carrying out substitutions, compositions, and
+ partial evaluations.")
+
+(defxdoc aig-constructors
+ :parents (aig)
+ :short "Low-level functions for constructing AIGs.")
+
+(defxdoc aig-other
+ :parents (aig)
+ :short "Various hard-to-categorize algorithms for working with AIGs.")
+
+(defxdoc aig-semantics
+ :parents (aig)
+ :short "Functions related to the semantic meaning of AIGs, e.g., @(see
+aig-eval) and @(see aig-equiv).")
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/aig/vuaig.lisp acl2-6.3/books/centaur/aig/vuaig.lisp
--- acl2-6.2/books/centaur/aig/vuaig.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/vuaig.lisp 1970-01-01 00:00:00.000000000 +0000
@@ -1,265 +0,0 @@
-; Centaur AIG Library
-; Copyright (C) 2008-2011 Centaur Technology
-;
-; Contact:
-; Centaur Technology Formal Verification Group
-; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
-; http://www.centtech.com/
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version. This program is distributed in the hope that it will be useful but
-; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
-; more details. You should have received a copy of the GNU General Public
-; License along with this program; if not, write to the Free Software
-; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
-;
-; Original author: Sol Swords
-
-(in-package "ACL2")
-(include-book "three-four")
-
-; vuaig.lisp -- Jared split this out of three-four.lisp; I don't think we're
-; actually using this stuff...
-
-
-;; VUAIG: Pairs of AIGs of the form , encoding 1/0/X/F as
-;; follows:
-;; V U | meaning
-;; ---------|----------
-;; t nil | 1
-;; nil nil | 0
-;; t t | X
-;; nil t | F
-
-;; fix to three-valued, i.e. coerce F to X
-(defn vuaig-tfix (x)
- (b* (((faig v u) x))
- (cons (aig-or v u) u)))
-
-(defn vuaig-not (x)
- (b* (((faig v u) x))
- (cons (aig-or (aig-not v) u) u)))
-
-(defn vuaig-and (x y)
- (b* (((faig vx ux) x)
- ((faig vy uy) y))
- (let ((x (aig-or (aig-and ux uy)
- (aig-or (aig-and ux vy)
- (aig-and uy vx)))))
- (cons (aig-or (aig-and vx vy) x) x))))
-
-
-(defn vuaig-or (x y)
- (b* (((faig vx ux) x)
- ((faig vy uy) y))
- (let ((x (aig-or (aig-and ux uy)
- (aig-or (aig-and ux (aig-not vy))
- (aig-and uy (aig-not vx))))))
- (cons (aig-or (aig-or vx vy) x) x))))
-
-(defn vuaig-xor (x y)
- (b* (((faig vx ux) x)
- ((faig vy uy) y))
- (let ((x (aig-or ux uy)))
- (cons (aig-or (aig-xor vx vy) x) x))))
-
-(defn vuaig-iff (x y)
- (b* (((faig vx ux) x)
- ((faig vy uy) y))
- (let ((x (aig-or ux uy)))
- (cons (aig-or (aig-iff vx vy) x) x))))
-
-(defn vuaig-res (x y)
- (b* (((faig vx ux) x)
- ((faig vy uy) y))
- (cons (aig-or vx vy)
- (aig-or (aig-or (aig-and (aig-not (aig-or ux uy))
- (aig-xor vx vy))
- (aig-and ux uy))
- (aig-or (aig-and ux vx)
- (aig-and uy vy))))))
-
-
-(defn vuaig-ite (c a b)
- (b* (((faig va ua) a)
- ((faig vb ub) b)
- ((faig vc uc) c))
- (let* ((x (aig-or (aig-or (aig-and uc ua)
- (aig-and uc ub))
- (aig-or (aig-and uc (aig-xor va vb))
- (aig-ite vc ua ub)))))
- (cons (aig-or (aig-ite vc va vb) x) x))))
-
-
-(defn vuaig-tbuf (c a)
- (b* (((faig va ua) a)
- ((faig vc uc) c))
- (let* ((float (aig-and (aig-not vc) (aig-not uc)))
- (x (aig-or uc (aig-and ua (aig-not float)))))
- (cons (aig-or (aig-and va (aig-not float)) x)
- (aig-or uc (aig-or (aig-not vc) ua))))))
-
-(defn vuaig-pullup (a)
- (b* (((faig va ua) a)
- (floating (aig-and (aig-not va) ua)))
- (cons (aig-or va floating)
- (aig-and ua (aig-not floating)))))
-
-
-(defn vuaig-bi-buf (cntl in bus)
- (vuaig-res (vuaig-tbuf cntl in) bus))
-
-(defun to-vu (code)
- (case code
- (1 '(t . nil))
- (0 '(nil . nil))
- (x '(t . t))
- (z '(nil . t))))
-
-(defun from-vu (vu)
- (cond ((equal vu '(t . nil)) 1)
- ((equal vu '(nil . nil)) 0)
- ((equal vu '(t . t)) 'x)
- ((equal vu '(nil . t)) 'z)))
-
-(defun to-fv (code)
- (case code
- (1 '(t . nil))
- (0 '(nil . t))
- (x '(t . t))
- (z '(nil . nil))))
-
-(defun from-fv (vu)
- (cond ((equal vu '(t . nil)) 1)
- ((equal vu '(nil . nil)) 'z)
- ((equal vu '(t . t)) 'x)
- ((equal vu '(nil . t)) 0)))
-
-
-
-
-
-
-
-
-(defn vxz (v x z)
- (cons v (and (or z x) (cons x z))))
-
-(defmacro patbind-vxz (args forms rest-expr)
- `(b* ((,(car args) (ec-call (car ,(car forms))))
- (patbind-vxz-xz-do-not-use (ec-call (cdr ,(car forms))))
- (,(cadr args) (ec-call (car patbind-vxz-xz-do-not-use)))
- (,(caddr args) (ec-call (cdr patbind-vxz-xz-do-not-use))))
- (check-vars-not-free
- (patbind-vxz-xz-do-not-use)
- ,rest-expr)))
-
-
-(defn vxzaig-tfix (a)
- (b* (((vxz v x z) a))
- (vxz v (aig-or z x) nil)))
-
-(defn vxzaig-not (a)
- (b* (((vxz v x z) a))
- (vxz (aig-not v) (aig-or z x) nil)))
-
-(defn vxzaig-and (a b)
- (b* (((vxz va xa za) a)
- ((vxz vb xb zb) b)
- (xa (aig-or za xa))
- (xb (aig-or zb xb))
- (x (aig-or (aig-and xa xb)
- (aig-or (aig-and xa vb)
- (aig-and xb va)))))
- (vxz (aig-and va vb) x nil)))
-
-
-(defn vxzaig-or (a b)
- (b* (((vxz va xa za) a)
- ((vxz vb xb zb) b)
- (xa (aig-or za xa))
- (xb (aig-or zb xb))
- (x (aig-or (aig-and xa xb)
- (aig-or (aig-and xa (aig-not vb))
- (aig-and xb (aig-not va))))))
- (vxz (aig-or va vb) x nil)))
-
-(defn vxzaig-xor (a b)
- (b* (((vxz va xa za) a)
- ((vxz vb xb zb) b)
- (xa (aig-or za xa))
- (xb (aig-or zb xb))
- (x (aig-or xa xb)))
- (vxz (aig-xor va vb) x nil)))
-
-(defn vxzaig-iff (a b)
- (b* (((vxz va xa za) a)
- ((vxz vb xb zb) b)
- (xa (aig-or za xa))
- (xb (aig-or zb xb))
- (x (aig-or xa xb)))
- (vxz (aig-iff va vb) x nil)))
-
-(defn vxzaig-res (a b)
- (b* (((vxz va xa za) a)
- ((vxz vb xb zb) b)
- (za (aig-and za (aig-not xa)))
- (zb (aig-and zb (aig-not xb)))
- (z (aig-and za zb)))
- (vxz (aig-ite za vb va)
- (aig-or (aig-or xa xb)
- (aig-and (aig-not (aig-or za zb))
- (aig-xor va vb))) z)))
-
-(defn vxzaig-ite (c a b)
- (b* (((vxz vc xc zc) c)
- ((vxz va xa za) a)
- ((vxz vb xb zb) b)
- (- (cw "~x0 ~x1 ~x2 ~x3 ~x4 ~x5 ~x6 ~x7 ~x8~%"
- vc xc zc va xa za vb xb zb))
- (xc (aig-or zc xc))
- (xa (aig-or za xa))
- (xb (aig-or zb xb)))
- (vxz (aig-ite vc va vb)
- (aig-ite xc (aig-or (aig-or xa xb)
- (aig-xor va vb))
- (aig-ite vc xa xb))
- nil)))
-
-(defn vxzaig-tbuf (c a)
- (b* (((vxz vc xc zc) c)
- ((vxz va xa za) a)
- (xc (aig-or zc xc))
- (xa (aig-or za xa)))
- (vxz va (aig-or xc (aig-and vc xa))
- (aig-ite xc
- (aig-not xa)
- (aig-not vc)))))
-
-
-
-(defun from-vxz (a)
- (b* (((vxz v x z) a))
- (if x 'x (if z 'z (if v 1 0)))))
-
-
-
-
-
-(defconst *vu1* (hons t nil)) ; *4t*
-(defconst *vu0* (hons nil nil)) ; *4u*
-
-
-(defconst *vuT* *vu1*)
-(defconst *vuF* *vu0*)
-(defconst *vuX* (hons t t)) ; *4x*
-(defconst *vuZ* (hons nil t)) ; *4f*
-(defconst *vuU* (hons nil t)) ; *4f*
-
-
-
-
-
diff -Nru acl2-6.2/books/centaur/aig/witness.acl2 acl2-6.3/books/centaur/aig/witness.acl2
--- acl2-6.2/books/centaur/aig/witness.acl2 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/witness.acl2 1970-01-01 00:00:00.000000000 +0000
@@ -1,24 +0,0 @@
-; Centaur AIG Library
-; Copyright (C) 2008-2011 Centaur Technology
-;
-; Contact:
-; Centaur Technology Formal Verification Group
-; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
-; http://www.centtech.com/
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version. This program is distributed in the hope that it will be useful but
-; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
-; more details. You should have received a copy of the GNU General Public
-; License along with this program; if not, write to the Free Software
-; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
-;
-; Original author: Sol Swords
-
-(in-package "ACL2")
-(ld "tools/flag-package.lsp" :dir :system)
-; cert-flags: ? t :ttags :all
-(certify-book "witness" ? t :ttags :all)
diff -Nru acl2-6.2/books/centaur/aig/witness.lisp acl2-6.3/books/centaur/aig/witness.lisp
--- acl2-6.2/books/centaur/aig/witness.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/aig/witness.lisp 1970-01-01 00:00:00.000000000 +0000
@@ -1,219 +0,0 @@
-; Centaur AIG Library
-; Copyright (C) 2008-2011 Centaur Technology
-;
-; Contact:
-; Centaur Technology Formal Verification Group
-; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
-; http://www.centtech.com/
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version. This program is distributed in the hope that it will be useful but
-; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
-; more details. You should have received a copy of the GNU General Public
-; License along with this program; if not, write to the Free Software
-; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
-;
-; Original author: Sol Swords
-
-(in-package "ACL2")
-
-(include-book "misc/hons-help2" :dir :system)
-(include-book "base")
-
-(include-book "clause-processors/term-patterns" :dir :system)
-(include-book "clause-processors/join-thms" :dir :system)
-
-
-(defmacro aig-patterns ()
- '(get-term-patterns aig))
-
-(defmacro set-aig-patterns (val)
- `(set-term-patterns aig ,val))
-
-(defmacro add-aig-pat (val)
- `(add-term-pattern aig ,val))
-
-(defmacro add-aig-pats (&rest val)
- `(add-term-patterns aig . ,val))
-
-(defmacro add-aig-fn-pat (val)
- `(add-fn-term-pattern aig ,val))
-
-(defmacro add-aig-fn-pats (&rest val)
- `(add-fn-term-patterns aig . ,val))
-
-(set-aig-patterns nil)
-
-(add-aig-fn-pats
- aig-and aig-not aig-or aig-xor aig-iff aig-ite aig-restrict aig-partial-eval)
-
-(add-aig-pats 't 'nil)
-
-(defun aig-termp (x aig-terms pats)
- (or (member-equal x aig-terms)
- (match-term-pattern x pats)))
-
-
-
-(defevaluator aig-cp-ev aig-cp-evl
- ((aig-eval a b) (equal a b) (not a)
- (implies a b)
- (if a b c)))
-
-(def-join-thms aig-cp-ev)
-
-
-
-
-
-(mutual-recursion
- (defun collect-aig-eval-vals (term)
- (cond ((atom term) nil)
- ((eq (car term) 'quote) nil)
- ((member-eq (car term)
- '(aig-eval
- aig-eval-pat
- aig-eval-list
- aig-eval-alist
- faig-eval-pat
- faig-eval-list
- faig-eval-alist))
- (and (eql (len term) 3)
- (list (nth 2 term))))
- (t (collect-aig-eval-vals-list (cdr term)))))
- (defun collect-aig-eval-vals-list (clause)
- (if (atom clause)
- nil
- (union-equal (collect-aig-eval-vals (car clause))
- (collect-aig-eval-vals-list (cdr clause))))))
-
-
-(include-book "tools/flag" :dir :system)
-(flag::make-flag collect-aig-eval-vals-flag collect-aig-eval-vals
- :flag-mapping ((collect-aig-eval-vals . term)
- (collect-aig-eval-vals-list . list)))
-
-(defthm pseudo-term-listp-union-equal
- (implies (and (pseudo-term-listp x) (pseudo-term-listp y))
- (pseudo-term-listp (union-equal x y))))
-
-(defthm-collect-aig-eval-vals-flag pseudo-term-listp-collect-aig-eval-vals
- (term (implies (pseudo-termp term)
- (pseudo-term-listp (collect-aig-eval-vals term))))
- (list (implies (pseudo-term-listp clause)
- (pseudo-term-listp (collect-aig-eval-vals-list clause))))
- :hints (("goal" :induct (collect-aig-eval-vals-flag flag term clause))
- ("Subgoal *1/6" :expand (collect-aig-eval-vals-list clause))))
-
-
-(defun aig-eval-vals (clause)
- (let ((collect (collect-aig-eval-vals-list clause)))
- (or collect '(arbitrary-vals))))
-
-(defthm aig-eval-vals-pseudo-term-listp
- (implies (pseudo-term-listp clause)
- (pseudo-term-listp (aig-eval-vals clause))))
-
-(in-theory (disable aig-eval-vals))
-
-(defun instantiate-aig-evals (a b vals)
- (if (atom vals)
- nil
- (cons `(not (equal (aig-eval ,a ,(car vals))
- (aig-eval ,b ,(car vals))))
- (instantiate-aig-evals a b (cdr vals)))))
-
-(defthm instantiate-aig-evals-correct
- (implies (and ;;(pseudo-termp x)
- ;;(pseudo-termp y)
- ;;(alistp a)
- (equal (aig-cp-ev x a)
- (aig-cp-ev y a)))
- (not (aig-cp-ev (disjoin (instantiate-aig-evals x y vals)) a)))
- :hints (("goal" :induct (instantiate-aig-evals a b vals))))
-
-(defthm pseudo-term-listp-instantiate-aig-evals
- (implies (and (pseudo-term-listp vals)
- (pseudo-termp a)
- (pseudo-termp b))
- (pseudo-term-listp (instantiate-aig-evals a b vals))))
-
-(in-theory (disable instantiate-aig-evals))
-
-(defun instantiate-equals-with-aig-evals (clause vals aig-terms patterns)
- (if (atom clause)
- nil
- (let* ((rst-clause (instantiate-equals-with-aig-evals
- (cdr clause) vals aig-terms patterns))
- (lit (car clause)))
- (mv-let (a b)
- (case-match lit
- (('not ('equal a b))
- (mv a b))
- (a (mv a ''nil))
- (& (mv nil nil)))
- (if (and (aig-termp a aig-terms patterns)
- (aig-termp b aig-terms patterns))
- (cons (disjoin (instantiate-aig-evals a b vals))
- rst-clause)
- (cons lit rst-clause))))))
-
-(defthm instantiate-equals-with-aig-evals-correct
- (implies (and ;;(pseudo-term-listp clause)
- ;;(alistp a)
- (aig-cp-ev (disjoin (instantiate-equals-with-aig-evals
- clause vals aig-terms patterns))
- a))
- (aig-cp-ev (disjoin clause) a))
- :hints (("goal" :induct (instantiate-equals-with-aig-evals
- clause vals aig-terms patterns))))
-
-
-
-(defthm pseudo-term-listp-instantiate-equals-with-aig-evals
- (implies (and (pseudo-term-listp clause)
- (pseudo-term-listp vals))
- (pseudo-term-listp (instantiate-equals-with-aig-evals
- clause vals aig-terms patterns))))
-
-
-(defun aig-eval-cp (clause hints)
- (let* ((aig-terms (car hints))
- (patterns (cadr hints))
- (vals (aig-eval-vals clause))
- (clause (instantiate-equals-with-aig-evals
- clause vals aig-terms patterns)))
- (list clause)))
-
-(in-theory (disable instantiate-equals-with-aig-evals
- collect-aig-eval-vals-list))
-
-(defthm aig-eval-cp-correct
- (implies (and (pseudo-term-listp clause)
- (alistp a)
- (aig-cp-ev (conjoin-clauses
- (aig-eval-cp clause hints))
- a))
- (aig-cp-ev (disjoin clause) a))
- :rule-classes :clause-processor)
-
-(defmacro aig-reasoning (&key or-hint)
- (declare (ignorable or-hint))
- `(if stable-under-simplificationp
- (er-progn
- ;; This just lets us collect the clauses on which this hint is used.
- (assign aig-eval-cp-clauses
- (cons clause
- (and (boundp-global
- 'aig-eval-cp-clauses state)
- (@ aig-eval-cp-clauses))))
- (let ((cphint `(:clause-processor
- (aig-eval-cp clause (list nil ',(get-term-patterns aig))))))
- (value ,(if or-hint
- '`(:or ,cphint (:no-thanks t))
- 'cphint))))
- (value nil)))
-
diff -Nru acl2-6.2/books/centaur/aignet/aig-sat.lisp acl2-6.3/books/centaur/aignet/aig-sat.lisp
--- acl2-6.2/books/centaur/aignet/aig-sat.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/aignet/aig-sat.lisp 1970-01-01 00:00:00.000000000 +0000
@@ -1,89 +0,0 @@
-; AIGNET - And-Inverter Graph Networks
-; Copyright (C) 2013 Centaur Technology
-;
-; Contact:
-; Centaur Technology Formal Verification Group
-; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
-; http://www.centtech.com/
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version. This program is distributed in the hope that it will be useful but
-; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
-; more details. You should have received a copy of the GNU General Public
-; License along with this program; if not, write to the Free Software
-; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
-;
-; Original author: Sol Swords
-
-(in-package "AIGNET")
-
-(include-book "aig-cnf")
-(include-book "centaur/satlink/top" :dir :system)
-
-(local (include-book "centaur/satlink/cnf-basics" :dir :system))
-
-(local (in-theory (disable nth update-nth aig-eval)))
-
-(define aig-sat ((aig "any old aig")
- &key
- ((config satlink::config-p) 'satlink::*default-config*))
- :returns (mv (status "one of :sat, :unsat, or :failed")
- (env "alist binding aig vars to t/nil, when sat"))
- :guard-debug t
- (b* (;; Locally create arrays to work with
- ((local-stobjs satlink::env$ sat-lits aignet)
- (mv status env satlink::env$ sat-lits aignet))
-
- ;; Convert the AIG into a CNF formula, using fancy AIGNET algorithm
- ((mv cnf ?lit vars sat-lits aignet)
- (aig->cnf aig sat-lits aignet))
-
- ((mv result satlink::env$)
- (satlink::sat cnf satlink::env$ :config config))
-
- ((unless (eq result :sat))
- (mv result nil satlink::env$ sat-lits aignet))
-
- (env (aig-cnf-vals->env satlink::env$ vars sat-lits aignet)))
-
- (mv :sat env satlink::env$ sat-lits aignet))
-
- ///
- (defthm aig-sat-when-sat
- (implies (eq (mv-nth 0 (aig-sat aig :config config)) :sat)
- (aig-eval aig (mv-nth 1 (aig-sat aig :config config)))))
-
- (defthm aig-sat-when-unsat
- (implies (aig-eval aig env)
- (not (equal (mv-nth 0 (aig-sat aig :config config)) :unsat)))
- :hints (("goal" :use ((:instance aig-satisfying-assign-induces-aig->cnf-satisfying-assign
- (sat-lits (create-sat-lits))
- (aignet (acl2::create-aignet))))
- :in-theory (disable aig-satisfying-assign-induces-aig->cnf-satisfying-assign)))))
-
-
-
-#||
-
-(in-package "ACL2")
-
-(tshell-ensure)
-
-(aignet::aig-sat nil)
-(aignet::aig-sat 'x)
-
-(aignet::aig-sat (aig-and 'x 'y))
-
-(aignet::aig-sat (aig-ite 'x 'y 'z))
-
-(aignet::aig-sat (aig-and
- (aig-ite 'x 'y 'z)
- (aig-ite 'x (aig-not 'y) (aig-not 'z))))
-
-(aignet::aig-sat '(1 2 3 4 5 2))
-
-
-||#
diff -Nru acl2-6.2/books/centaur/aignet/aignet-absstobj.lisp acl2-6.3/books/centaur/aignet/aignet-absstobj.lisp
--- acl2-6.2/books/centaur/aignet/aignet-absstobj.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/aignet/aignet-absstobj.lisp 2013-09-30 17:53:15.000000000 +0000
@@ -703,43 +703,48 @@
next-state node for a given register ID: @(def lookup-reg->nxst)")
+; [Jared] changed parents here; previously everything below had
+; aignet-programming as another parent, but this topic was never defined. it
+; may have been intended to be aignet-impl, but I think it's reasonable to just
+; not include it for now.
+
(defxdoc num-nodes
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Total number of nodes in an aignet"
:long "
Logically, @('(+ 1 (node-count aignet))'), (where @('node-count') is the
same as @('len')), since the empty aignet implicitly has a constant node.
")
(defxdoc num-ins
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Number of primary input nodes in an aignet"
:long "
Logically, @('(stype-count :pi aignet)')
")
(defxdoc num-regs
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Number of register nodes in an aignet"
:long "
Logically, @('(stype-count :reg aignet)')
")
(defxdoc num-outs
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Number of primary output nodes in an aignet"
:long "
Logically, @('(stype-count :po aignet)')
")
(defxdoc num-nxsts
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Number of next-state nodes in an aignet"
:long "
Logically, @('(stype-count :nxst aignet)')
")
(defxdoc num-gates
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Number of AND gate nodes in an aignet"
:long "
@@ -748,43 +753,43 @@
:long "")
(defxdoc fanin-litp
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Checks whether a literal is appropriate as a fanin to another node"
:long "
AKA aignet-litp (but fanin-litp is the executable version). True iff
the literal's ID is in bounds and belongs to a non-output, non-next-state node.
")
(defxdoc id-existsp
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Checks whether an ID is in bounds for an aignet"
:long "AKA aignet-idp. True iff the ID is less than @('(num-nodes aignet)').
")
(defxdoc innum->id
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Gets the ID of the node with the given PI number"
:long "Logically, @('(node-count (lookup-stype n :pi aignet))')
")
(defxdoc outnum->id
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Gets the ID of the node with the given PO number"
:long "Logically, @('(node-count (lookup-stype n :po aignet))')
")
(defxdoc regnum->id
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Gets the ID of the node with the given register number"
:long "Logically, @('(node-count (lookup-stype n :reg aignet))')
")
(defxdoc id->type
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Gets the type code of the node with the given ID"
:long "Logically, @('(typecode (ctype (stype (car (lookup-id id aignet)))))').
")
(defxdoc io-id->regp
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Gets the register bit of the node with the given ID"
:long "Logically, @('(regp (stype (car (lookup-id id aignet))))')
")
(defxdoc io-id->ionum
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Gets the IO number of the node with the given ID"
:long "Logically,
@({
@@ -796,7 +801,7 @@
")
(defxdoc co-id->fanin
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Gets the fanin of a next-state or primary output node"
:long "Logically,
@({
@@ -808,7 +813,7 @@
itself.
")
(defxdoc gate-id->fanin0
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Gets the 0th fanin of an AND gate node"
:long "Logically,
@({
@@ -820,7 +825,7 @@
output node.
")
(defxdoc gate-id->fanin1
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Gets the 1st fanin of an AND gate node"
:long "Logically,
@({
@@ -832,12 +837,12 @@
output node.
")
(defxdoc reg-id->nxst
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Finds the next-state node associated with a register ID, if it exists"
:long "Logically, @('(node-count (lookup-reg->nxst id aignet))')
")
(defxdoc nxst-id->reg
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Gets the register ID associated with a next-state node"
:long "Logically,
@({
@@ -851,22 +856,22 @@
reg-id->nxst)) rather than the other way around.
")
(defxdoc id->phase
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Finds the value of the node under the all-0 simulation"
:long "
")
(defxdoc aignet-add-in
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Adds a primary input node to the aignet"
:long "Logically, @('(cons (pi-node) aignet)').
")
(defxdoc aignet-add-reg
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Adds a register node to the aignet"
:long "Logically, @('(cons (reg-node) aignet)').
")
(defxdoc aignet-add-gate
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Adds an AND gate node to the aignet"
:long "Logically,
@({
@@ -877,7 +882,7 @@
unconditionally.
")
(defxdoc aignet-add-out
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Adds a primary output node to the aignet"
:long "Logically,
@({
@@ -887,7 +892,7 @@
unconditionally.
")
(defxdoc aignet-set-nxst
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Adds a next-state node to the aignet"
:long "Logically,
@({
@@ -898,14 +903,14 @@
network is preserved unconditionally.
")
(defxdoc aignet-init
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Clears the aignet, ensuring minimum sizes for arrays"
:long "Logically, just returns NIL. The resulting aignet contains only
the implicit constant-0 node. The sizes given are used to adjust arrays in the
implementation.
")
(defxdoc aignet-clear
- :parents (aignet-logic aignet-programming)
+ :parents (aignet-logic)
:short "Clears the aignet"
:long "Logically, just returns NIL. The resulting aignet contains only the
implicit constant-0 node.
")
diff -Nru acl2-6.2/books/centaur/aignet/cnf.lisp acl2-6.3/books/centaur/aignet/cnf.lisp
--- acl2-6.2/books/centaur/aignet/cnf.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/aignet/cnf.lisp 2013-09-30 17:53:15.000000000 +0000
@@ -53,14 +53,14 @@
It's when we add additional constraints to the CNF that it may become
unsatisfiable. So suppose we want to show that some cube among the nodes of
-the circuit is unsat -- say, A & B & ~C. We first convert their subcircuits to
-CNF and then add the three singleton clauses. Now, suppose that we have some
-assignment to the CIs that satisfies A & B & ~C. That induces a satisfying
-assignment for the generated part of the CNF where (in particular) the literals
-corresponding to A, B, and ~C are assigned true. That makes the three
-singleton clauses also true, so the whole CNF is satisfied. Therefore, if we
-prove the CNF unsatisfiable, then we've proven that no assignment to the CIs
-can simultaneously satisfy A & B & ~C.
+the circuit is unsat -- say, @('A & B & ~C'). We first convert their
+subcircuits to CNF and then add the three singleton clauses. Now, suppose that
+we have some assignment to the CIs that satisfies @('A & B & ~C'). That
+induces a satisfying assignment for the generated part of the CNF where (in
+particular) the literals corresponding to A, B, and ~C are assigned true. That
+makes the three singleton clauses also true, so the whole CNF is satisfied.
+Therefore, if we prove the CNF unsatisfiable, then we've proven that no
+assignment to the CIs can simultaneously satisfy @('A & B & ~C').
Now the counterexample case. We want to show that any satisfying assignment
of the CNF is a satisfying assignment for whatever circuit constraints we've
@@ -94,7 +94,7 @@
vals object. We'll show that this satisfies
cnf/aignet-evals-agree and that the CNF assignment
satisfies the generated CNF.
-
+
When actually converting an aignet to CNF, we of course process the AIG
recursively. We do this in chunks, where each chunk is either:
@@ -103,8 +103,8 @@
a mux.
For both of these cases, we prove that the chunk we've just added preserves the
-correctness criterion we've described.
-
+correctness criterion we've described.
+
")
;; (local (defun trivial-worse-than-or-equal (term1 term2)
diff -Nru acl2-6.2/books/centaur/aignet/copying.lisp acl2-6.3/books/centaur/aignet/copying.lisp
--- acl2-6.2/books/centaur/aignet/copying.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/aignet/copying.lisp 2013-09-30 17:53:15.000000000 +0000
@@ -17,8 +17,7 @@
sets::double-containment
sets::sets-are-true-lists
make-list-ac)))
-
-(local (include-book "centaur/misc/equal-by-nths" :dir :system))
+(local (include-book "std/lists/nth" :dir :system))
(local (acl2::use-trivial-ancestors-check))
diff -Nru acl2-6.2/books/centaur/aignet/from-hons-aig.lisp acl2-6.3/books/centaur/aignet/from-hons-aig.lisp
--- acl2-6.2/books/centaur/aignet/from-hons-aig.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/aignet/from-hons-aig.lisp 2013-09-30 17:53:15.000000000 +0000
@@ -22,9 +22,9 @@
(include-book "construction")
(include-book "misc/hons-help" :dir :system)
(include-book "centaur/aig/aig-vars-fast" :dir :system)
-(include-book "centaur/aig/base" :dir :system)
+(include-book "centaur/aig/aig-base" :dir :system)
(local (include-book "arithmetic/top-with-meta" :dir :system))
-
+(local (include-book "std/lists/nthcdr" :dir :system))
;; Translating from Hons AIGs to aignets.
;; We need a memoization table so that we don't revisit AIG nodes we've already
diff -Nru acl2-6.2/books/centaur/aignet/prune.lisp acl2-6.3/books/centaur/aignet/prune.lisp
--- acl2-6.2/books/centaur/aignet/prune.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/aignet/prune.lisp 2013-09-30 17:53:15.000000000 +0000
@@ -15,7 +15,7 @@
sets::double-containment
sets::sets-are-true-lists
make-list-ac)))
-(local (include-book "centaur/misc/equal-by-nths" :dir :system))
+(local (include-book "std/lists/nth" :dir :system))
(local (acl2::use-trivial-ancestors-check))
diff -Nru acl2-6.2/books/centaur/aignet/semantics.lisp acl2-6.3/books/centaur/aignet/semantics.lisp
--- acl2-6.2/books/centaur/aignet/semantics.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/aignet/semantics.lisp 2013-09-30 17:53:15.000000000 +0000
@@ -42,12 +42,13 @@
sets::sets-are-true-lists
make-list-ac)))
-(local (include-book "centaur/misc/equal-by-nths" :dir :system))
+(local (include-book "std/lists/nth" :dir :system))
(set-waterfall-parallelism nil) ; currently unknown why we need to disable
; waterfall-parallelism; something to examine
(local (in-theory (disable true-listp-update-nth
+ acl2::nth-when-zp
acl2::nth-with-large-index)))
(local (defthmd equal-1-to-bitp
@@ -78,8 +79,9 @@
(defmacro out-type () 3)
(defxdoc aignet
- :short "AIGNET is an and-inverter graph implementation: a representation for
-both Boolean functions and finite-state machines."
+ :parents (acl2::boolean-reasoning)
+ :short "An efficient, @(see acl2::stobj)-based And-Inverter Graph (AIG)
+representation for Boolean functions and finite-state machines."
:long
"An and-inverter graph (AIG) at its most basic is a DAG whose nodes are either
AND gates, outputs, or inputs. Outputs have 1 descendant, ANDs have 2, and
@@ -1069,6 +1071,7 @@
(local (in-theory (disable acl2::bfix-when-not-1
acl2::nfix-when-not-natp)))
(local (in-theory (enable acl2::make-list-ac-redef)))
+ (local (in-theory (disable acl2::make-list-ac-removal)))
(acl2::def2darr frames
:prefix frames
@@ -1126,32 +1129,32 @@
;; out-of-bounds IDs are false
0)
(type (id->type id aignet)))
- (aignet-case
- type
- :gate (b* ((f0 (gate-id->fanin0 id aignet))
- (f1 (gate-id->fanin1 id aignet)))
- (mbe :logic (eval-and-of-lits-seq
- k f0 f1 frames initsts aignet)
- :exec (b-and (b-xor (id-eval-seq k (lit-id f0)
- frames
- initsts aignet)
- (lit-neg f0))
- (b-xor (id-eval-seq k (lit-id f1)
- frames
- initsts aignet)
- (lit-neg f1)))))
- :in (let ((ionum (io-id->ionum id aignet)))
- (if (int= (io-id->regp id aignet) 1)
- (if (zp k)
- (get-bit ionum initsts)
- (id-eval-seq (1- k)
- (reg-id->nxst id aignet)
- frames initsts aignet))
- (frames-get2 k ionum frames)))
- :out (b* ((f (co-id->fanin id aignet)))
- (lit-eval-seq
- k f frames initsts aignet))
- :const 0))))
+ (aignet-case
+ type
+ :gate (b* ((f0 (gate-id->fanin0 id aignet))
+ (f1 (gate-id->fanin1 id aignet)))
+ (mbe :logic (eval-and-of-lits-seq
+ k f0 f1 frames initsts aignet)
+ :exec (b-and (b-xor (id-eval-seq k (lit-id f0)
+ frames
+ initsts aignet)
+ (lit-neg f0))
+ (b-xor (id-eval-seq k (lit-id f1)
+ frames
+ initsts aignet)
+ (lit-neg f1)))))
+ :in (let ((ionum (io-id->ionum id aignet)))
+ (if (int= (io-id->regp id aignet) 1)
+ (if (zp k)
+ (get-bit ionum initsts)
+ (id-eval-seq (1- k)
+ (reg-id->nxst id aignet)
+ frames initsts aignet))
+ (frames-get2 k ionum frames)))
+ :out (b* ((f (co-id->fanin id aignet)))
+ (lit-eval-seq
+ k f frames initsts aignet))
+ :const 0))))
(in-theory (disable id-eval-seq lit-eval-seq eval-and-of-lits-seq))
(local (in-theory (enable id-eval-seq lit-eval-seq eval-and-of-lits-seq)))
@@ -1163,25 +1166,25 @@
;; out-of-bounds IDs are false
0)
(type (id->type id aignet)))
- (aignet-case
- type
- :gate (b* ((f0 (gate-id->fanin0 id aignet))
- (f1 (gate-id->fanin1 id aignet)))
- (list
- (id-eval-seq-ind
- k (lit-id f0) aignet)
- (id-eval-seq-ind
- k (lit-id f1) aignet)))
- :in (if (int= (io-id->regp id aignet) 1)
- (if (zp k)
- 0
- (id-eval-seq-ind
- (1- k) (reg-id->nxst id aignet) aignet))
- 0)
- :out (b* ((f (co-id->fanin id aignet)))
- (id-eval-seq-ind
- k (lit-id f) aignet))
- :const 0)))
+ (aignet-case
+ type
+ :gate (b* ((f0 (gate-id->fanin0 id aignet))
+ (f1 (gate-id->fanin1 id aignet)))
+ (list
+ (id-eval-seq-ind
+ k (lit-id f0) aignet)
+ (id-eval-seq-ind
+ k (lit-id f1) aignet)))
+ :in (if (int= (io-id->regp id aignet) 1)
+ (if (zp k)
+ 0
+ (id-eval-seq-ind
+ (1- k) (reg-id->nxst id aignet) aignet))
+ 0)
+ :out (b* ((f (co-id->fanin id aignet)))
+ (id-eval-seq-ind
+ k (lit-id f) aignet))
+ :const 0)))
(defcong nat-equiv equal (id-eval-seq k id frames initvals aignet) 1
:hints (("goal" :induct (id-eval-seq-ind k id aignet))))
@@ -1199,9 +1202,9 @@
:in-theory (disable id-eval-seq lit-eval-seq))
(and stable-under-simplificationp
'(:expand ((:free (k aignet)
- (id-eval-seq k id frames initvals aignet))
+ (id-eval-seq k id frames initvals aignet))
(:free (lit aignet)
- (lit-eval-seq k lit frames initvals aignet)))))))
+ (lit-eval-seq k lit frames initvals aignet)))))))
(defcong nat-equiv equal (lit-eval-seq k lit frames initvals aignet) 1
:hints (("goal" :expand ((lit-eval-seq k lit frames initvals aignet)))))
@@ -1211,7 +1214,7 @@
:hints (("goal" :expand ((lit-eval-seq k lit frames initvals aignet)))))
(defcong list-equiv equal (lit-eval-seq k lit frames initvals aignet) 5
:hints (("goal" :expand ((:free (aignet)
- (lit-eval-seq k lit frames initvals aignet))))))
+ (lit-eval-seq k lit frames initvals aignet))))))
(defcong nat-equiv equal (eval-and-of-lits-seq k lit1 lit2 frames initvals aignet) 1
:hints (("goal" :expand ((eval-and-of-lits-seq k lit1 lit2 frames initvals aignet)))))
@@ -1223,7 +1226,7 @@
:hints (("goal" :expand ((eval-and-of-lits-seq k lit1 lit2 frames initvals aignet)))))
(defcong list-equiv equal (eval-and-of-lits-seq k lit1 lit2 frames initvals aignet) 6
:hints (("goal" :expand ((:free (aignet)
- (eval-and-of-lits-seq k lit1 lit2 frames initvals aignet))))))
+ (eval-and-of-lits-seq k lit1 lit2 frames initvals aignet))))))
(defthm bitp-of-lit-eval-seq
@@ -1238,7 +1241,7 @@
(bitp (id-eval-seq k id frames initsts aignet))
:hints (("goal" :expand ((id-eval-seq k id frames initsts aignet)
(:free (id)
- (id-eval-seq (+ -1 k) id frames initsts aignet))))))
+ (id-eval-seq (+ -1 k) id frames initsts aignet))))))
(verify-guards id-eval-seq)
@@ -1266,9 +1269,9 @@
:hints (("goal" :induct (id-eval-ind id aignet)
:expand ((:free (k) (id-eval-seq k id frames initsts aignet))
(:free (invals regvals)
- (id-eval id invals regvals aignet))
+ (id-eval id invals regvals aignet))
(:free (k lit)
- (lit-eval-seq k lit invals regvals aignet)))
+ (lit-eval-seq k lit invals regvals aignet)))
:in-theory (e/d (lit-eval
eval-and-of-lits)
(id-eval-seq
@@ -1320,7 +1323,7 @@
(equal (lit-eval-seq k lit frames initvals new)
(lit-eval-seq k lit frames initvals orig)))
:hints (("goal" :expand ((:free (aignet)
- (lit-eval-seq k lit frames initvals aignet))))))
+ (lit-eval-seq k lit frames initvals aignet))))))
(defthm frame-regvals-of-non-reg/nxst-extension
(implies (and (aignet-extension-binding)
@@ -1335,11 +1338,11 @@
(acl2::equal-by-nths-hint))))
(defthm frame-regvals-when-zp
- (implies (zp k)
- (bits-equiv (frame-regvals k frames initvals aignet)
- (take (num-regs aignet) initvals)))
- :hints(("Goal" :in-theory (enable bits-equiv
- nth-of-frame-regvals-split)))))
+ (implies (zp k)
+ (bits-equiv (frame-regvals k frames initvals aignet)
+ (take (num-regs aignet) initvals)))
+ :hints(("Goal" :in-theory (enable bits-equiv
+ nth-of-frame-regvals-split)))))
diff -Nru acl2-6.2/books/centaur/aignet/to-hons-aig.lisp acl2-6.3/books/centaur/aignet/to-hons-aig.lisp
--- acl2-6.2/books/centaur/aignet/to-hons-aig.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/aignet/to-hons-aig.lisp 2013-09-30 17:53:15.000000000 +0000
@@ -20,7 +20,7 @@
(in-package "AIGNET")
(include-book "semantics")
-(include-book "centaur/aig/base" :dir :system)
+(include-book "centaur/aig/aig-base" :dir :system)
(include-book "centaur/vl/util/cwtime" :dir :system)
(local (include-book "arithmetic/top-with-meta" :dir :system))
(local (in-theory (disable nth update-nth
@@ -45,7 +45,7 @@
:slotname aig
:default-val nil)
-
+
(define id-trans-logic ((id :type (integer 0 *))
aigtrans aignet)
@@ -165,7 +165,7 @@
(equal (id-trans-logic id (aignet-translate-iter n aigtrans aignet)
aignet)
(id-trans-logic id aigtrans aignet))
- :hints((acl2::just-induct-and-expand
+ :hints((acl2::just-induct-and-expand
(aignet-translate-iter n aigtrans aignet))))
(defthm aignet-translate-iter-preserves-input-entries
@@ -178,7 +178,7 @@
(defthm aignet-trans-invariant-of-aignet-translate-iter
(aignet-trans-invariant
n (aignet-translate-iter n aigtrans aignet) aignet)
- :hints((acl2::just-induct-and-expand
+ :hints((acl2::just-induct-and-expand
(aignet-translate-iter n aigtrans aignet))
(and stable-under-simplificationp
'(:expand ((:free (aigtrans)
@@ -191,7 +191,7 @@
(defthm aignet-aigs-size-of-aignet-translate-iter
(<= (len aigtrans)
(len (aignet-translate-iter n aigtrans aignet)))
- :hints((acl2::just-induct-and-expand
+ :hints((acl2::just-induct-and-expand
(aignet-translate-iter n aigtrans aignet)))
:rule-classes :linear)
@@ -303,6 +303,3 @@
(outlist (aignet-trans-get-outs 0 aigtrans aignet))
(reglist (aignet-trans-get-nxsts 0 aigtrans aignet)))
(mv outlist (pairlis$ regnames reglist) aigtrans)))
-
-
-
diff -Nru acl2-6.2/books/centaur/aignet/vecsim.lisp acl2-6.3/books/centaur/aignet/vecsim.lisp
--- acl2-6.2/books/centaur/aignet/vecsim.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/aignet/vecsim.lisp 2013-09-30 17:53:15.000000000 +0000
@@ -25,6 +25,8 @@
(local (in-theory (disable nth update-nth sets::double-containment)))
(local (in-theory (enable* acl2::arith-equiv-forwarding)))
+(local (in-theory (disable acl2::make-list-ac-removal)))
+
(acl2::def2darr s61v
:elt-type (signed-byte 61)
:elt-typep (lambda (x) (signed-byte-p 61 x))
diff -Nru acl2-6.2/books/centaur/bitops/bits-between.lisp acl2-6.3/books/centaur/bitops/bits-between.lisp
--- acl2-6.2/books/centaur/bitops/bits-between.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/bits-between.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -21,7 +21,7 @@
(in-package "ACL2")
(include-book "xdoc/top" :dir :system)
(include-book "tools/bstar" :dir :system)
-(include-book "finite-set-theory/osets/sets" :dir :system)
+(include-book "std/osets/top" :dir :system)
(local (include-book "ihs-extensions"))
(local (include-book "std/lists/rev" :dir :system))
(local (include-book "std/lists/append" :dir :system))
diff -Nru acl2-6.2/books/centaur/bitops/bitsets.lisp acl2-6.3/books/centaur/bitops/bitsets.lisp
--- acl2-6.2/books/centaur/bitops/bitsets.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/bitsets.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -36,9 +36,9 @@
:long "
Introduction
In this library, sets of natural numbers are represented as natural numbers
-by saying @('a') is a member of the set @('X') when @('(@(see logbitp) a X)').
-For instance, the set {1, 2, 4} would be represented as the number 22. In
-binary, this number is 10110, and you can see that bits 1, 2, and 4 are each
+by saying @('a') is a member of the set @('X') when @('(logbitp a X)'). For
+instance, the set {1, 2, 4} would be represented as the number 22. In binary,
+this number is 10110, and you can see that bits 1, 2, and 4 are each
\"true\".
This representation enjoys certain efficiencies. In particular, operations
@@ -82,13 +82,13 @@
The basic bitsets library can be loaded with:
@({
- (include-book \"bitops/bitsets\" :dir :cbooks)
+ (include-book \"centaur/bitops/bitsets\" :dir :system)
})
An optimized version (that requires additional ttags) can be loaded with:
@({
- (include-book \"bitops/bitsets-opt\" :dir :cbooks)
+ (include-book \"centaur/bitops/bitsets-opt\" :dir :system)
})
@@ -110,34 +110,34 @@
Bitset Constructors
- @('(@(see bitset-singleton) a)') Constructs the set @('{ a
+ @('(bitset-singleton a)') Constructs the set @('{ a
}') Execution: @('(ash 1 a)')
-@('(@(see bitset-insert) a X)')
+@('(bitset-insert a X)')
Constructs the set @('X U {a}')
Execution: @('(logior (ash 1 a) x)')
-@('(@(see bitset-list) a b ...)')
+@('(bitset-list a b ...)')
Constructs the set @('{a, b, ...}')
Execution: repeated @('bitset-insert')s
-@('(@(see bitset-list*) a b ... X)')
+@('(bitset-list* a b ... X)')
Constructs the set @('X U {a, b, ...}')
Execution: repeated @('bitset-insert')s
-@('(@(see bitset-delete) a X)')
+@('(bitset-delete a X)')
Constructs the set @('X - {a}')
Execution: @('(logandc1 (ash 1 a) x)')
-@('(@(see bitset-union) X Y)')
+@('(bitset-union X Y)')
Constructs the set @('X U Y')
Execution: @('(logior x y)')
-@('(@(see bitset-intersect) X Y)')
+@('(bitset-intersect X Y)')
Constructs the set @('X \\intersect Y')
Execution: @('(logand x y)')
-@('(@(see bitset-difference) X Y)')
+@('(bitset-difference X Y)')
Constructs the set @('X - Y')
Execution: @('(logandc1 y x)')
@@ -145,19 +145,19 @@
Inspecting Bitsets
-@('(@(see bitset-memberp) a X)')
+@('(bitset-memberp a X)')
Determine whether @('a') is a member of the set @('X')
Execution: @('(logbitp a x)')
-@('(@(see bitset-intersectp) X Y)')
+@('(bitset-intersectp X Y)')
Determines whether @('X') and @('Y') have any common members
Execution: @('(logtest x y)')
-@('(@(see bitset-subsetp) X Y)')
+@('(bitset-subsetp X Y)')
Determines whether @('X') is a subset of @('Y')
Execution: @('(= 0 (logandc2 y x))')
-@('(@(see bitset-cardinality) X)')
+@('(bitset-cardinality X)')
Determines the cardinality of @('X')
Execution: @('(logcount x)')
@@ -166,7 +166,7 @@
Enumerating Bitset Members
-@('(@(see bitset-members) X)')
+@('(bitset-members X)')
Constructs an ordinary ordered set with the elements of X.
Expensive: must cons together all of the set elements.
@@ -249,7 +249,7 @@
It is simple enough to convert a bitset into an ordered set: since the @(see
integer-length) of @('x') gives us an upper bound on its elements, we just need
-to walk up to this bound and collect all @('i') such that @('(@(see logbitp) i
+to walk up to this bound and collect all @('i') such that @('(logbitp i
x)').
The definition below uses @(see bits-between) to do just this. However,
@@ -584,7 +584,7 @@
:short "@(call bitset-singleton) constructs the singleton set @('{a}')."
:long "
This is perhaps slightly more efficient than the equivalent,
- @('(@(see bitset-insert) A 0)').
"
+ @('(bitset-insert A 0)')."
(definlined bitset-singleton (a)
(declare (xargs :guard (natp a)))
diff -Nru acl2-6.2/books/centaur/bitops/cert.acl2 acl2-6.3/books/centaur/bitops/cert.acl2
--- acl2-6.2/books/centaur/bitops/cert.acl2 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/cert.acl2 2013-09-30 17:53:11.000000000 +0000
@@ -19,6 +19,6 @@
; Original author: Jared Davis
(in-package "ACL2")
-(ld "finite-set-theory/osets/sets.defpkg" :dir :system)
-(ld "cutil/package.lsp" :dir :system)
+(include-book "std/osets/portcullis" :dir :system)
+(include-book "cutil/portcullis" :dir :system)
; cert-flags: ? t :ttags :all
diff -Nru acl2-6.2/books/centaur/bitops/congruences.lisp acl2-6.3/books/centaur/bitops/congruences.lisp
--- acl2-6.2/books/centaur/bitops/congruences.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/congruences.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -69,10 +69,14 @@
;; Since we're normalizing to logsquash of loghead, propagate a logsquash
;; context inside loghead:
+;; This is its own removal rule.
(def-context-rule logsquash-of-loghead-context
(equal (logsquash n (loghead m (logsquash n x)))
(logsquash n (loghead m x)))
:fnname logsquash$inline)
+(in-theory (disable apply-context-for-logsquash$inline))
+
+(in-theory (enable logsquash-of-loghead-context))
;; ;; Logbitp induces both a logsquash and loghead context.
;; (defthm logbitp-remove-logsquash
@@ -85,6 +89,7 @@
;; (equal (logbitp n (loghead m i))
;; (logbitp n i))))
+;; Removal rule: logbitp-of-logsquash-in-bounds
(def-context-rule logbitp-induces-logsquash/loghead-context
(implies (syntaxp (not (quotep n)))
;; if n is quotep we'll prefer a logand context instead
@@ -92,25 +97,28 @@
(logbitp n i)))
:fnname logbitp)
+(in-theory (disable common-lisp::apply-context-for-logbitp))
+
;; ;; Logtail induces a logsquash context.
-;; (defthm logtail-remove-logsquash
-;; (implies (<= (nfix m) (nfix n))
-;; (equal (logtail n (logsquash m i))
-;; (logtail n i))))
+;; It also passes a (modified) loghead context.
+;; Removal rule: logtail-of-logsquash
(def-context-rule logtail-induces-logsquash-context
(equal (logtail n (logsquash n i))
(logtail n i))
:fnname logtail$inline)
-;; It also passes a (modified) loghead context.
-;; We already have logtail-of-loghead to remove this context.
+(in-theory (disable apply-context-for-logtail$inline))
+
+;; Removal rule: logtail-of-loghead
(def-context-rule logtail-pass-loghead-context
(equal (loghead n (logtail m (loghead (+ (nfix n) (nfix m)) i)))
(loghead n (logtail m i)))
:hints(("Goal" :in-theory (disable logsquash)))
:fnname loghead$inline)
+(in-theory (disable apply-context-for-loghead$inline))
+
;; Logic ops are transparent to both types of context.
@@ -120,16 +128,16 @@
(equal (loghead n (logior (loghead m a) b))
(loghead n (logior a b)))))
-(defthm logior-remove-loghead-2
- (implies (<= (nfix n) (nfix m))
- (equal (loghead n (logior a (loghead m b)))
- (loghead n (logior a b)))))
-
(def-context-rule logior-pass-loghead-context-1
(equal (loghead n (logior (loghead n a) b))
(loghead n (logior a b)))
:fnname loghead$inline)
+(defthm logior-remove-loghead-2
+ (implies (<= (nfix n) (nfix m))
+ (equal (loghead n (logior a (loghead m b)))
+ (loghead n (logior a b)))))
+
(def-context-rule logior-pass-loghead-context-2
(equal (loghead n (logior a (loghead n b)))
(loghead n (logior a b)))
@@ -139,15 +147,13 @@
(implies (<= (nfix m) (nfix n))
(equal (logsquash n (logior (logsquash m a) b))
(logsquash n (logior a b))))
- :hints(("Goal" :in-theory (enable* ihsext-inductions
- ihsext-recursive-redefs))))
+ :hints ((logbitp-reasoning)))
(defthm logior-remove-logsquash-2
(implies (<= (nfix m) (nfix n))
(equal (logsquash n (logior a (logsquash m b)))
(logsquash n (logior a b))))
- :hints(("Goal" :in-theory (enable* ihsext-inductions
- ihsext-recursive-redefs))))
+ :hints ((logbitp-reasoning)))
(def-context-rule logior-pass-logsquash-context-1
(equal (logsquash n (logior (logsquash n a) b))
@@ -180,19 +186,18 @@
(loghead n (logand a b)))
:fnname loghead$inline)
+(local (set-default-hints
+ '((logbitp-reasoning))))
+
(defthm logand-remove-logsquash-1
(implies (<= (nfix m) (nfix n))
(equal (logsquash n (logand (logsquash m a) b))
- (logsquash n (logand a b))))
- :hints(("Goal" :in-theory (enable* ihsext-inductions
- ihsext-recursive-redefs))))
+ (logsquash n (logand a b)))))
(defthm logand-remove-logsquash-2
(implies (<= (nfix m) (nfix n))
(equal (logsquash n (logand a (logsquash m b)))
- (logsquash n (logand a b))))
- :hints(("Goal" :in-theory (enable* ihsext-inductions
- ihsext-recursive-redefs))))
+ (logsquash n (logand a b)))))
(def-context-rule logand-pass-logsquash-context-1
(equal (logsquash n (logand (logsquash n a) b))
@@ -228,16 +233,12 @@
(defthm logxor-remove-logsquash-1
(implies (<= (nfix m) (nfix n))
(equal (logsquash n (logxor (logsquash m a) b))
- (logsquash n (logxor a b))))
- :hints(("Goal" :in-theory (enable* ihsext-inductions
- ihsext-recursive-redefs))))
+ (logsquash n (logxor a b)))))
(defthm logxor-remove-logsquash-2
(implies (<= (nfix m) (nfix n))
(equal (logsquash n (logxor a (logsquash m b)))
- (logsquash n (logxor a b))))
- :hints(("Goal" :in-theory (enable* ihsext-inductions
- ihsext-recursive-redefs))))
+ (logsquash n (logxor a b)))))
(def-context-rule logxor-pass-logsquash-context-1
(equal (logsquash n (logxor (logsquash n a) b))
@@ -255,6 +256,7 @@
;; (equal (loghead n (lognot (loghead m a)))
;; (loghead n (lognot a)))))
+;; Removal rule: loghead-cancel-in-lognot
(def-context-rule lognot-pass-loghead-context
(equal (loghead n (lognot (loghead n a)))
(loghead n (lognot a)))
@@ -265,6 +267,7 @@
;; (equal (logsquash n (lognot (logsquash m a)))
;; (logsquash n (lognot a)))))
+;; Removal rule: logsquash-cancel-in-lognot
(def-context-rule lognot-pass-logsquash-context
(equal (logsquash n (lognot (logsquash n a)))
(logsquash n (lognot a)))
@@ -275,44 +278,43 @@
;; Ash propagates a modified loghead/logsquash context. Right shift also
;; induces a logsquash context (same as logtail-induces-logsquash-context).
-;; This is not compatible with loghead-of-ash.
+;; This is not compatible with loghead-of-ash. But loghead-of-ash doesn't work
+;; as a context removal rule; it just pushes the outer context inside. This
+;; works because it pulls the inner context out.
(defthmd ash-of-loghead
(equal (ash (loghead m i) n)
- (loghead (+ (nfix m) (ifix n)) (ash i n)))
- :hints(("Goal" :in-theory (e/d (loghead-of-ash ifix nfix loghead**)
- (loghead-identity)))))
+ (loghead (+ (nfix m) (ifix n)) (ash i n))))
(local (in-theory (disable loghead-of-ash)))
(def-context-rule ash-propagate-loghead-context
(equal (loghead n (ash (loghead (- (nfix n) (ifix m)) i) m))
(loghead n (ash i m)))
- :hints(("Goal" :in-theory (e/d (ash-of-loghead
- ifix nfix loghead-of-loghead-split
- loghead**)
- (loghead-identity))))
:fnname loghead$inline)
(defthmd ash-of-logsquash
(equal (ash (logsquash m i) n)
- (logsquash (+ (nfix m) (ifix n)) (ash i n)))
- :hints(("Goal" :in-theory (e/d (logsquash-of-ash ifix nfix
- logsquash**)))))
+ (logsquash (+ (nfix m) (ifix n)) (ash i n))))
(def-context-rule ash-propagate-logsquash-context
(equal (logsquash n (ash (logsquash (- (nfix n) (ifix m)) i) m))
(logsquash n (ash i m)))
- :hints(("Goal" :in-theory (enable logsquash-of-ash)))
:fnname logsquash$inline)
+;; (defthm right-shift-remove-logsquash
+;; (implies (and (<= (ifix m) 0)
+;; (<= (nfix n) (- (ifix m))))
+;; (equal (ash (logsquash n i) m)
+;; (ash i m)))
+;; :hints(("Goal" :in-theory (e/d (ash-of-logsquash logsquash**)
+;; (right-shift-to-logtail)))))
+
+;; ash-of-logsquash should work as the removal rule for this too
(def-context-rule right-shift-induces-logsquash-context
(implies (<= (ifix m) 0)
(equal (ash (logsquash (- (ifix m)) i) m)
(ash i m)))
- :hints(("Goal" :in-theory (e/d ()
- (right-shift-to-logtail))
- :use ((:instance logsquash-of-ash
- (x i) (n 0)))))
+ :hints(("Goal" :in-theory (e/d (ifix nfix))))
:fnname ash)
@@ -414,66 +416,119 @@
;; Logand. This is the most general, but only works with a constant as the
;; mask. Doesn't work with add/subtract.
+;; This is useful for removal of logbitp-of-logand
+(defthm bool->bit-equal-1
+ (implies (booleanp x)
+ (equal (equal 1 (bool->bit x))
+ x))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
(def-context-rule logbitp-induces-logand-context
(implies (syntaxp (quotep n))
(equal (logbitp n (logand (ash 1 (nfix n)) m))
(logbitp n m)))
:fnname logbitp)
+(defthm logior-remove-logand
+ (implies (and (syntaxp (and (quotep n1) (quotep n2)))
+ (equal (logior n1 n2) -1))
+ (equal (logior n1 (logand n2 m))
+ (logior n1 m))))
+
(def-context-rule logior-induces-logand-context
(implies (syntaxp (quotep n))
(equal (logior n (logand (lognot n) m))
(logior n m)))
- :hints ((equal-by-logbitp-hammer))
:fnname binary-logior)
+(defthm lognot-remove-logand-context
+ (implies (and (syntaxp (and (quotep n1) (quotep n2)))
+ (equal (logand n1 (lognot n2)) 0))
+ (equal (logand n1 (lognot (logand n2 m)))
+ (logand n1 (lognot m)))))
+
(def-context-rule lognot-pass-logand-context
(implies (syntaxp (quotep n))
(equal (logand n (lognot (logand n m)))
(logand n (lognot m))))
- :hints ((equal-by-logbitp-hammer))
:fnname binary-logand)
+(defthm logior-remove-logand-context-1
+ (implies (and (syntaxp (and (quotep n1)
+ (quotep n2)))
+ (equal (logand n1 (lognot n2)) 0))
+ (equal (logand n1 (logior (logand n2 m1) m2))
+ (logand n1 (logior m1 m2)))))
+
(def-context-rule logior-pass-logand-context-1
(implies (syntaxp (quotep n))
(equal (logand n (logior (logand n m1) m2))
(logand n (logior m1 m2))))
- :hints ((equal-by-logbitp-hammer))
:fnname binary-logand)
+(defthm logior-remove-logand-context-2
+ (implies (and (syntaxp (and (quotep n1)
+ (quotep n2)))
+ (equal (logand n1 (lognot n2)) 0))
+ (equal (logand n1 (logior m2 (logand n2 m1)))
+ (logand n1 (logior m2 m1)))))
+
(def-context-rule logior-pass-logand-context-2
(implies (syntaxp (quotep n))
(equal (logand n (logior m2 (logand n m1)))
(logand n (logior m2 m1))))
- :hints ((equal-by-logbitp-hammer))
:fnname binary-logand)
+(defthm logand-remove-logand-context-1
+ (implies (and (syntaxp (and (quotep n1)
+ (quotep n2)))
+ (equal (logand n1 (lognot n2)) 0))
+ (equal (logand n1 (logand (logand n2 m1) m2))
+ (logand n1 (logand m1 m2)))))
+
(def-context-rule logand-pass-logand-context-1
(implies (syntaxp (quotep n))
(equal (logand n (logand (logand n m1) m2))
(logand n (logand m1 m2))))
- :hints ((equal-by-logbitp-hammer))
:fnname binary-logand)
+(defthm logand-remove-logand-context-2
+ (implies (and (syntaxp (and (quotep n1)
+ (quotep n2)))
+ (equal (logand n1 (lognot n2)) 0))
+ (equal (logand n1 (logand m2 (logand n2 m1)))
+ (logand n1 (logand m2 m1)))))
+
(def-context-rule logand-pass-logand-context-2
(implies (syntaxp (quotep n))
(equal (logand n (logand m2 (logand n m1)))
(logand n (logand m2 m1))))
- :hints ((equal-by-logbitp-hammer))
:fnname binary-logand)
+(defthm logxor-remove-logand-context-1
+ (implies (and (syntaxp (and (quotep n1)
+ (quotep n2)))
+ (equal (logand n1 (lognot n2)) 0))
+ (equal (logand n1 (logxor (logand n2 m1) m2))
+ (logand n1 (logxor m1 m2)))))
+
(def-context-rule logxor-pass-logand-context-1
(implies (syntaxp (quotep n))
(equal (logand n (logxor (logand n m1) m2))
(logand n (logxor m1 m2))))
- :hints ((equal-by-logbitp-hammer))
:fnname binary-logand)
+(defthm logxor-remove-logand-context-2
+ (implies (and (syntaxp (and (quotep n1)
+ (quotep n2)))
+ (equal (logand n1 (lognot n2)) 0))
+ (equal (logand n1 (logxor m2 (logand n2 m1)))
+ (logand n1 (logxor m2 m1)))))
+
(def-context-rule logxor-pass-logand-context-2
(implies (syntaxp (quotep n))
(equal (logand n (logxor m2 (logand n m1)))
(logand n (logxor m2 m1))))
- :hints ((equal-by-logbitp-hammer))
:fnname binary-logand)
@@ -518,23 +573,25 @@
:in-theory (e/d () (ash-1-removal
logand-with-negated-bitmask)))))
+(defthm ash-remove-logand-context
+ (implies (and (syntaxp (and (quotep n1)
+ (quotep n2)))
+ (equal (logand (lognot (ash n2 (ifix m))) n1) 0))
+ (equal (logand n1 (ash (logand n2 i) m))
+ (logand n1 (ash i m)))))
+
(def-context-rule ash-propagate-logand-context
(implies (syntaxp (quotep n))
(equal (logand n (ash (logand (ash n (- (ifix m))) i) m))
(logand n (ash i m))))
- :hints ((equal-by-logbitp-hammer))
:fnname binary-logand)
;; Rewrite a logsquash of loghead to a logand when sizes are constant:
(defthm logsquash-of-loghead-to-logand
(implies (syntaxp (and (quotep n) (quotep m)))
(equal (logsquash n (loghead m i))
- (logand (logsquash n (loghead m -1)) i)))
- :hints(("Goal" :in-theory (enable* ihsext-inductions
- ihsext-recursive-redefs)
- :induct (and (logsquash n i)
- (loghead m i)))))
+ (logand (logsquash n (loghead m -1)) i))))
(local (defthm logbitp-when-gte-integer-length
(implies (<= (integer-length n) (nfix i))
@@ -550,8 +607,27 @@
(defthmd logand-of-loghead-context-lemma
(implies (<= 0 (ifix n))
(equal (logand n (loghead (integer-length n) b))
- (logand n b)))
- :hints ((equal-by-logbitp-hammer)))
+ (logand n b))))
+
+
+
+(defthm equal-of-logands-by-equal-of-logheads
+ (implies (and (equal (loghead h a) (loghead h b))
+ (equal (logsquash h n) 0))
+ (equal (logand n a) (logand n b)))
+ :rule-classes nil)
+
+(defthm logand-minus-remove-loghead-context
+ (implies (and (syntaxp (and (quotep n)
+ (quotep h)))
+ (<= 0 (ifix n))
+ (equal (logsquash h n) 0)
+ (integerp b))
+ (equal (logand n (- (loghead h b)))
+ (logand n (- b))))
+ :hints (("goal" :use ((:instance equal-of-logands-by-equal-of-logheads
+ (a (- (loghead h b))) (b (- b))))
+ :in-theory (enable loghead-of-minus-of-loghead))))
;; Logand can create a loghead context for +/-
;; Context rules for plus/minus
@@ -568,6 +644,18 @@
:in-theory (enable loghead-of-minus-of-loghead)))
:fnname binary-logand)
+(defthm logand-plus-remove-loghead-context-1
+ (implies (and (syntaxp (and (quotep n)
+ (quotep h)))
+ (<= 0 (ifix n))
+ (equal (logsquash h n) 0)
+ (integerp b) (integerp c))
+ (equal (logand n (+ (loghead h b) c))
+ (logand n (+ b c))))
+ :hints (("goal" :use ((:instance equal-of-logands-by-equal-of-logheads
+ (a (+ (loghead h b) c)) (b (+ b c))))
+ :in-theory (enable loghead-of-plus-loghead-second))))
+
(def-context-rule logand-of-plus-context-first
(implies (and (syntaxp (quotep n))
(<= 0 (ifix n))
@@ -579,10 +667,21 @@
(b (+ a b)))
(:instance logand-of-loghead-context-lemma
(b (+ (loghead (integer-length n) a) b))))
- :in-theory (enable loghead-of-plus-loghead-first
- loghead-of-plus-loghead-second)))
+ :in-theory (enable loghead-of-plus-loghead-second)))
:fnname binary-logand)
+(defthm logand-plus-remove-loghead-context-2
+ (implies (and (syntaxp (and (quotep n)
+ (quotep h)))
+ (<= 0 (ifix n))
+ (equal (logsquash h n) 0)
+ (integerp b) (integerp c))
+ (equal (logand n (+ c (loghead h b)))
+ (logand n (+ c b))))
+ :hints (("goal" :use ((:instance equal-of-logands-by-equal-of-logheads
+ (a (+ c (loghead h b))) (b (+ c b))))
+ :in-theory (enable loghead-of-plus-loghead-second))))
+
(def-context-rule logand-of-plus-context-second
(implies (and (syntaxp (quotep n))
(<= 0 (ifix n))
@@ -608,11 +707,14 @@
apply-context-for-logtail$inline
loghead-of-logsquash-commute
logsquash-of-loghead-zero
+ logsquash-of-loghead-context
logsquash-idempotent
logsquash-of-logsquash-split
loghead-of-loghead-split
logbitp-of-logsquash-in-bounds
logbitp-of-loghead-out-of-bounds
+ logtail-of-logsquash
+ logtail-of-loghead
logior-remove-loghead-1
logior-remove-loghead-2
logior-pass-loghead-context-1
@@ -651,12 +753,19 @@
loghead-of-plus-context-2
logbitp-induces-logand-context
logior-induces-logand-context
+ lognot-remove-logand-context
lognot-pass-logand-context
+ logior-remove-logand-context-1
logior-pass-logand-context-1
+ logior-remove-logand-context-2
logior-pass-logand-context-2
+ logand-remove-logand-context-1
logand-pass-logand-context-1
+ logand-remove-logand-context-2
logand-pass-logand-context-2
+ logxor-remove-logand-context-1
logxor-pass-logand-context-1
+ logxor-remove-logand-context-2
logxor-pass-logand-context-2
logand-loghead-combine-contexts
loghead-logand-combine-contexts
@@ -664,8 +773,11 @@
logsquash-logand-combine-contexts
ash-propagate-logand-context
logsquash-of-loghead-to-logand
+ logand-minus-remove-loghead-context
logand-of-minus-context
+ logand-plus-remove-loghead-context-1
logand-of-plus-context-first
+ logand-plus-remove-loghead-context-2
logand-of-plus-context-second))
(def-ruleset! bitops-congruence-incompatible
diff -Nru acl2-6.2/books/centaur/bitops/defaults.lisp acl2-6.3/books/centaur/bitops/defaults.lisp
--- acl2-6.2/books/centaur/bitops/defaults.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/defaults.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -111,7 +111,7 @@
(defsection logcdr-default
- :parents (bigops/defaults logcdr)
+ :parents (bitops/defaults logcdr)
(defthm logcdr-default
(implies (not (integerp x))
@@ -149,7 +149,7 @@
(defsection logxor-defaults
- :parents (bitops/default logxor)
+ :parents (bitops/defaults logxor)
(defthm logxor-default-1
(implies (not (integerp x))
diff -Nru acl2-6.2/books/centaur/bitops/equal-by-logbitp.lisp acl2-6.3/books/centaur/bitops/equal-by-logbitp.lisp
--- acl2-6.2/books/centaur/bitops/equal-by-logbitp.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/equal-by-logbitp.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -30,6 +30,7 @@
(local (in-theory (disable logcons logcar logcdr integer-length)))
(include-book "ihsext-basics")
(local (include-book "arithmetic/top-with-meta" :dir :system))
+(include-book "clause-processors/witness-cp" :dir :system)
(local (defthm equal-of-logcdrs-when-equal-of-logcars
(implies (and (integerp i)
@@ -761,6 +762,9 @@
+
+
+
(defsection equal-by-logbitp-hammer
:parents (equal-by-logbitp)
:short "Drastic automation for @(see equal-by-logbitp)."
@@ -772,9 +776,10 @@
(def-ruleset! logbitp-case-splits
;; Basic logbitp case-splitting rules to enable first
- '(acl2::logbitp-of-ash-split
- acl2::logbitp-of-loghead-split
- acl2::logbitp-of-logapp-split))
+ '(logbitp-of-ash-split
+ logbitp-of-loghead-split
+ logbitp-of-logapp-split
+ logbitp-of-logsquash-split))
(def-ruleset! logbitp-case-splits+
;; Even more case splitting rules to enable after that
@@ -803,5 +808,57 @@
:no-thanks t))))
+(defsection equal-by-logbitp-witnessing
+ (definstantiate equal-by-logbitp-instancing
+ :predicate (equal x y)
+ :vars (bit)
+ :expr (equal (logbitp bit x) (logbitp bit y))
+ :hints ('(:in-theory nil)))
+
+ (defexample equal-by-logbitp-example
+ :pattern (logbitp bit x)
+ :templates (bit)
+ :instance-rules (equal-by-logbitp-instancing))
+
+ (defwitness unequal-by-logbitp-witnessing
+ :predicate (not (equal x y))
+ :expr (or (not (integerp x))
+ (not (integerp y))
+ (let ((bit (logbitp-mismatch x y)))
+ (not (equal (logbitp bit x)
+ (logbitp bit y)))))
+ :generalize (((logbitp-mismatch x y) . wbit))
+ :hints ('(:in-theory '(logbitp-mismatch-correct
+ logbitp-mismatch-under-iff
+ ifix-when-integerp))))
+
+
+ (def-witness-ruleset equal-by-logbitp-rules
+ '(equal-by-logbitp-instancing
+ equal-by-logbitp-example
+ unequal-by-logbitp-witnessing))
+
+ (defmacro logbitp-reasoning ()
+ '(let ((witness-hint
+ (witness :ruleset equal-by-logbitp-rules)))
+ (and witness-hint
+ (let* ((hint-body (cddr witness-hint))
+ (chr-forms (cadr witness-hint)))
+ `(:computed-hint-replacement
+ ,(append chr-forms
+ '((and stable-under-simplificationp
+ '(:in-theory (e/d* (acl2::logbitp-of-const-split))))
+ (and stable-under-simplificationp
+ '(:in-theory (e/d* (logbitp-case-splits
+ logbitp-when-bit
+ acl2::logbitp-of-const-split))))
+ (and stable-under-simplificationp
+ '(:in-theory (e/d* (logbitp-case-splits
+ logbitp-when-bit
+ acl2::logbitp-of-const-split
+ b-xor b-ior b-and))))))
+ . ,hint-body))))))
+
+
diff -Nru acl2-6.2/books/centaur/bitops/extra-defs.lisp acl2-6.3/books/centaur/bitops/extra-defs.lisp
--- acl2-6.2/books/centaur/bitops/extra-defs.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/extra-defs.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -21,288 +21,313 @@
(in-package "ACL2")
(local (include-book "ihsext-basics"))
(local (include-book "arithmetic/top" :dir :system))
+(include-book "cutil/define" :dir :system)
(include-book "centaur/misc/arith-equivs" :dir :system)
(include-book "ihs/logops-definitions" :dir :system)
-(include-book "xdoc/top" :dir :system)
+(local (include-book "signed-byte-p"))
-; extra-defs.lisp
-;
-; These are some functions I wanted when writing specs for integer and
-; packed-integer instructions.
+(defsection extra-defs
+ :parents (bitops)
+ :short "Additional bitwise operations."
+ :long "This is just an ad-hoc collection of low-level bit operations,
+mostly developed in support of specifying various integer and packed-integer
+instructions.
")
(local (in-theory (enable* arith-equiv-forwarding)))
-(defun nth-slice2 (n x)
- "Extract the Nth 2-bit slice of the integer X."
- (declare (xargs :guard (and (natp n)
- (integerp x))))
+
+(define nth-slice2 ((n natp)
+ (x integerp))
+ :returns (slice natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "Extract the @('n')th 2-bit slice of the integer @('x')."
+ :long "We leave this enabled; we would usually not expect to try to reason
+about it.
"
+ :enabled t
+ :inline t
(mbe :logic
(logand (ash (ifix x) (* (nfix n) -2)) (1- (expt 2 2)))
:exec
- (logand (ash x (* n -2)) #x3)))
-
-(defcong nat-equiv equal (nth-slice2 n x) 1)
-(defcong int-equiv equal (nth-slice2 n x) 2)
-
-(defun nth-slice8 (n x)
- "Extract the Nth 8-bit slice of the integer X."
- (declare (xargs :guard (and (natp n)
- (integerp x))))
+ (the (unsigned-byte 2)
+ (logand (ash x (the (integer * 0) (* n -2))) #x3)))
+ ///
+ (defcong nat-equiv equal (nth-slice2 n x) 1)
+ (defcong int-equiv equal (nth-slice2 n x) 2)
+ (defthm unsigned-byte-p-2-of-nth-slice2
+ (unsigned-byte-p 2 (nth-slice2 n x))))
+
+
+(define nth-slice8 ((n natp)
+ (x integerp))
+ :returns (slice natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "Extract the @('n')th 8-bit slice of the integer @('x')."
+ :long "We leave this enabled; we would usually not expect to try to reason
+about it.
"
+ :enabled t
+ :inline t
(mbe :logic
(logand (ash (ifix x) (* (nfix n) -8)) (1- (expt 2 8)))
:exec
- (logand (ash x (* n -8)) #xFF)))
-
-(defcong nat-equiv equal (nth-slice8 n x) 1)
-(defcong int-equiv equal (nth-slice8 n x) 2)
-
-(defun nth-slice16 (n x)
- "Extract the Nth 16-bit slice of the integer X."
- (declare (xargs :guard (and (natp n)
- (integerp x))))
+ (the (unsigned-byte 8)
+ (logand (ash x (* n -8)) #xFF)))
+ ///
+ (defcong nat-equiv equal (nth-slice8 n x) 1)
+ (defcong int-equiv equal (nth-slice8 n x) 2)
+ (defthm unsigned-byte-p-8-of-nth-slice8
+ (unsigned-byte-p 8 (nth-slice8 n x))))
+
+
+(define nth-slice16 ((n natp)
+ (x integerp))
+ :returns (slice natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "Extract the @('n')th 16-bit slice of the integer @('x')."
+ :long "We leave this enabled; we would usually not expect to try to reason
+about it.
"
+ :enabled t
+ :inline t
(mbe :logic
(logand (ash (ifix x) (* (nfix n) -16)) (1- (expt 2 16)))
:exec
- (logand (ash x (* n -16)) #xFFFF)))
-
-(defcong nat-equiv equal (nth-slice16 n x) 1)
-(defcong int-equiv equal (nth-slice16 n x) 2)
-
-
-(defun nth-slice32 (n x)
- "Extract the Nth 32-bit slice of the integer X."
- (declare (xargs :guard (and (natp n)
- (integerp x))))
+ (the (unsigned-byte 16)
+ (logand (ash x (* n -16)) #xFFFF)))
+ ///
+ (defcong nat-equiv equal (nth-slice16 n x) 1)
+ (defcong int-equiv equal (nth-slice16 n x) 2)
+ (defthm unsigned-byte-p-16-of-nth-slice16
+ (unsigned-byte-p 16 (nth-slice16 n x))))
+
+
+(define nth-slice32 ((n natp)
+ (x integerp))
+ :returns (slice natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "Extract the @('n')th 32-bit slice of the integer @('x')."
+ :long "We leave this enabled; we would usually not expect to try to reason
+about it.
"
+ :enabled t
+ :inline t
(mbe :logic
(logand (ash (ifix x) (* (nfix n) -32)) (1- (expt 2 32)))
:exec
- (logand (ash x (* n -32)) #ux_FFFF_FFFF)))
-
-(defcong nat-equiv equal (nth-slice32 n x) 1)
-(defcong int-equiv equal (nth-slice32 n x) 2)
-
-
-(defun nth-slice64 (n x)
- "Extract the Nth 64-bit slice of the integer X."
- (declare (xargs :guard (and (natp n)
- (integerp x))))
+ (the (unsigned-byte 32)
+ (logand (ash x (* n -32)) #ux_FFFF_FFFF)))
+ ///
+ (defcong nat-equiv equal (nth-slice32 n x) 1)
+ (defcong int-equiv equal (nth-slice32 n x) 2)
+ (defthm unsigned-byte-p-32-of-nth-slice32
+ (unsigned-byte-p 32 (nth-slice32 n x))))
+
+
+(define nth-slice64 ((n natp)
+ (x integerp))
+ :returns (slice natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "Extract the @('n')th 32-bit slice of the integer @('x')."
+ :long "We leave this enabled; we would usually not expect to try to reason
+about it.
"
+ :enabled t
+ :inline t
(mbe :logic
(logand (ash (ifix x) (* (nfix n) -64)) (1- (expt 2 64)))
:exec
- (logand (ash x (* n -64)) #ux_FFFF_FFFF_FFFF_FFFF)))
-
-(defcong nat-equiv equal (nth-slice64 n x) 1)
-(defcong int-equiv equal (nth-slice64 n x) 2)
-
-
-
-(defthm natp-of-nth-slice2
- (natp (nth-slice2 n x))
- :rule-classes :type-prescription)
-
-(defthm natp-of-nth-slice8
- (natp (nth-slice8 n x))
- :rule-classes :type-prescription)
-
-(defthm natp-of-nth-slice16
- (natp (nth-slice16 n x))
- :rule-classes :type-prescription)
-
-(defthm natp-of-nth-slice32
- (natp (nth-slice32 n x))
- :rule-classes :type-prescription)
-
-(defthm natp-of-nth-slice64
- (natp (nth-slice64 n x))
- :rule-classes :type-prescription)
-
-
-
-
-(defun negate-slice8 (x)
- "X is an 8-bit natural. Treat it as a signed, 8-bit value. Compute the
-two's complement negation of X, and return it as an 8-bit natural. For
-instance, (negate-slice8 3) = 253."
- (declare (xargs :guard (natp x)))
+ (the (unsigned-byte 64)
+ (logand (ash x (* n -64)) #ux_FFFF_FFFF_FFFF_FFFF)))
+ ///
+ (defcong nat-equiv equal (nth-slice64 n x) 1)
+ (defcong int-equiv equal (nth-slice64 n x) 2)
+ (defthm unsigned-byte-p-64-of-nth-slice64
+ (unsigned-byte-p 64 (nth-slice64 n x))))
+
+
+(define negate-slice8 ((x :type (unsigned-byte 8)))
+ :returns (~x natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "@(call negate-slice8) computes the 8-bit two's complement negation of
+@('x') and returns it as an 8-bit natural."
+ :long "For example, @('(negate-slice8 3) = 253').
+We leave this enabled; we would usually not expect to try to reason about
+it.
"
+ :inline t
+ :enabled t
(mbe :logic
(logand (+ 1 (lognot (nfix x))) (1- (expt 2 8)))
:exec
- (logand (+ 1 (lognot x)) #xFF)))
-
-(defcong nat-equiv equal (negate-slice8 x) 1)
-
-
-(defun negate-slice16 (x)
- "X is a 16-bit natural. Treat it as a signed, 16-bit value. Compute the
- two's complement negation of X and return it as a 16-bit natural."
- (declare (xargs :guard (natp x)))
+ (the (unsigned-byte 8)
+ (logand (the (signed-byte 9)
+ (+ 1 (the (signed-byte 9) (lognot x))))
+ #xFF)))
+ ///
+ (defcong nat-equiv equal (negate-slice8 x) 1)
+ (defthm unsigned-byte-p-8-of-negate-slice8
+ (unsigned-byte-p 8 (negate-slice8 x))))
+
+
+(define negate-slice16 ((x :type (unsigned-byte 16)))
+ :returns (~x natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "@(call negate-slice16) computes the 16-bit two's complement negation
+of @('x') and returns it as an 16-bit natural."
+ :long "We leave this enabled; we would usually not expect to try to reason
+about it.
"
+ :inline t
+ :enabled t
(mbe :logic
(logand (+ 1 (lognot (nfix x))) (1- (expt 2 16)))
:exec
- (logand (+ 1 (lognot x)) #xFFFF)))
-
-(defcong nat-equiv equal (negate-slice16 x) 1)
-
-(defun negate-slice32 (x)
- "X is a 32-bit natural. Treat it as a signed, 32-bit value. Compute the
-two's complement negation of X and return it as a 32-bit natural."
- (declare (xargs :guard (natp x)))
+ (the (unsigned-byte 16)
+ (logand (the (signed-byte 17)
+ (+ 1 (the (signed-byte 17) (lognot x))))
+ #xFFFF)))
+ ///
+ (defcong nat-equiv equal (negate-slice16 x) 1)
+ (defthm unsigned-byte-p-16-of-negate-slice16
+ (unsigned-byte-p 16 (negate-slice16 x))))
+
+
+(define negate-slice32 ((x :type (unsigned-byte 32)))
+ :returns (~x natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "@(call negate-slice32) computes the 32-bit two's complement negation
+of @('x') and returns it as an 32-bit natural."
+ :long "We leave this enabled; we would usually not expect to try to reason
+about it.
"
+ :inline t
+ :enabled t
(mbe :logic
(logand (+ 1 (lognot (nfix x))) (1- (expt 2 32)))
:exec
- (logand (+ 1 (lognot x)) #ux_FFFF_FFFF)))
-
-(defcong nat-equiv equal (negate-slice32 x) 1)
-
-(defun negate-slice64 (x)
- "X is a 64-bit natural. Treat it as a signed, 64-bit value. Compute the
-two's complement negation of X and return it as a 64-bit natural."
- (declare (xargs :guard (natp x)))
+ (the (unsigned-byte 32)
+ (logand (the (signed-byte 33)
+ (+ 1 (the (signed-byte 33) (lognot x))))
+ #ux_FFFF_FFFF)))
+ ///
+ (defcong nat-equiv equal (negate-slice32 x) 1)
+ (defthm unsigned-byte-p-32-of-negate-slice32
+ (unsigned-byte-p 32 (negate-slice32 x))))
+
+
+(define negate-slice64 ((x :type (unsigned-byte 64)))
+ :returns (~x natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "@(call negate-slice64) computes the 64-bit two's complement negation
+of @('x') and returns it as an 64-bit natural."
+ :long "We leave this enabled; we would usually not expect to try to reason
+about it.
"
+ :enabled t
(mbe :logic
(logand (+ 1 (lognot (nfix x))) (1- (expt 2 64)))
:exec
- (logand (+ 1 (lognot x)) #ux_FFFF_FFFF_FFFF_FFFF)))
+ (the (unsigned-byte 64)
+ (logand (the (signed-byte 65)
+ (+ 1 (the (signed-byte 65) (lognot x))))
+ #ux_FFFF_FFFF_FFFF_FFFF)))
+ ///
+ (defcong nat-equiv equal (negate-slice64 x) 1)
+ (defthm unsigned-byte-p-64-of-negate-slice64
+ (unsigned-byte-p 64 (negate-slice64 x))))
-(defcong nat-equiv equal (negate-slice64 x) 1)
-(defthm natp-of-negate-slice8
- (natp (negate-slice8 x))
- :rule-classes :type-prescription)
-
-(defthm natp-of-negate-slice16
- (natp (negate-slice16 x))
- :rule-classes :type-prescription)
-
-(defthm natp-of-negate-slice32
- (natp (negate-slice32 x))
- :rule-classes :type-prescription)
-
-(defthm natp-of-negate-slice64
- (natp (negate-slice64 x))
- :rule-classes :type-prescription)
-
-
-; BOZO consider extending ihsext-basics with stuff about expt-2.
-(local (defthm posp-expt-2
- (<= 0 (expt 2 width))
- :rule-classes ((:rewrite)
- (:linear)
- (:type-prescription))
- :hints(("Goal" :in-theory (enable expt)))))
-
-(local (defthm integerp-expt-2
- (implies (<= 0 width)
- (integerp (expt 2 width)))
- :rule-classes ((:rewrite)
- (:type-prescription))
- :hints(("Goal" :in-theory (enable expt)))))
+(define abs-diff ((a integerp)
+ (b integerp))
+ :returns (ans natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "@(call abs-diff) is just @('(abs (- (ifix a) (ifix b)))'), but
+optimized for @(see gl)."
+
+ :long "@('abs-diff') is similar to @('(abs (- a b))') but has better
+performance for symbolic simulations with GL: it decides whether the
+subtraction will be necessary by looking at the arguments, which tend to be
+simple and perhaps nicely interleaved, instead of by looking at the result,
+which tend to be complex since they are the combined arguments.
+
+For an @('aig-cert-mode') proof of the 64-bit @('PSADBW') instruction, using
+@('abs-diff') instead of @('(abs (- a b))') reduced the proof time from 56.2
+seconds to 37.44 seconds.
+We disable this function, but we leave enabled the following theorem:
-(defund abs-diff (a b) ;; Disabled since abs-diff-correct is nicer for reasoning.
-
- "(ABS-DIFF A B) is provably equal to (ABS (- (IFIX A) (IFIX B))).
-
-ABS-DIFF performs better than (ABS (- A B)) for symbolic simulation with GL: it
-decides whether the subtraction will be necessary by looking at the arguments,
-which tend to be simple and nicely interleaved, instead of by looking at the
-result, which tend to be complex since they are the combined arguments.
-
-For an AIG-CERT-MODE proof of the 64-bit PSADBW instruction, using ABS-DIFF
-instead of (ABS (- A B)) reduced the proof time from 56.2 seconds to 37.44
-seconds."
- (declare (xargs :guard (and (integerp a)
- (integerp b))))
- (mbe :logic
- ;; Don't be tempted to change the :logic definition to (abs (- (ifix
- ;; a) (ifix b))). GL uses :logic definitions!
- (let ((a (ifix a))
- (b (ifix b)))
- (if (<= b a)
- (- a b)
- (- b a)))
- :exec
- (if (<= b a)
- (- a b)
- (- b a))))
+@(thm abs-diff-correct)
-(defthm abs-diff-correct
- (equal (abs-diff a b)
- (abs (- (ifix a) (ifix b))))
- :hints(("Goal" :in-theory (enable abs-diff))))
-
-(defthm natp-of-abs-diff
- (natp (abs-diff a b))
- :rule-classes :type-prescription)
+We therefore would not expect to ever need to reason about @('abs-diff')
+directly.
"
+ (mbe :logic
+ ;; Don't be tempted to change the :logic definition to (abs (- (ifix a)
+ ;; (ifix b))). GL uses :logic definitions!
+ (let ((a (ifix a))
+ (b (ifix b)))
+ (if (<= b a)
+ (- a b)
+ (- b a)))
+ :exec
+ (if (<= b a)
+ (- a b)
+ (- b a)))
+ ///
+ (defthm abs-diff-correct
+ (equal (abs-diff a b)
+ (abs (- (ifix a) (ifix b))))))
-(defun setbit (n x)
- "Set X[n] := 1"
- (declare (xargs :guard (and (natp n)
- (integerp x))))
+(define setbit ((n natp "Bit position to set to 1.")
+ (x integerp "Starting value."))
+ :returns (ans integerp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "Set X[n] := 1"
+ :enabled t
(let ((n (lnfix n))
(x (lifix x)))
- (logior (ash 1 n) x)))
-
-(defcong nat-equiv equal (setbit n x) 1)
-(defcong int-equiv equal (setbit n x) 2)
+ (logior (ash 1 n) x))
+ ///
+ (defcong nat-equiv equal (setbit n x) 1)
+ (defcong int-equiv equal (setbit n x) 2))
-(defthm integerp-of-setbit
- (integerp (setbit n x))
- :rule-classes :type-prescription)
-
-(defun clearbit (n x)
- "Set X[n] := 0"
- (declare (xargs :guard (and (natp n)
- (integerp x))))
+(define clearbit ((n natp "Bit position to clear to 0.")
+ (x integerp "Starting value."))
+ :returns (ans integerp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "Set X[n] := 0"
+ :enabled t
(let ((n (lnfix n))
(x (lifix x)))
- (logand (lognot (ash 1 n)) x)))
-
-(defcong nat-equiv equal (clearbit n x) 1)
-(defcong int-equiv equal (clearbit n x) 2)
-
-(defthm integerp-of-clearbit
- (integerp (clearbit n x))
- :rule-classes :type-prescription)
+ (logand (lognot (ash 1 n)) x))
+ ///
+ (defcong nat-equiv equal (clearbit n x) 1)
+ (defcong int-equiv equal (clearbit n x) 2))
-(defun copybit (n from to)
- "Set To[n] := From[n]"
- (declare (xargs :guard (and (natp n)
- (integerp from)
- (integerp to))))
+(define copybit ((n natp "Bit position to copy.")
+ (from integerp)
+ (to integerp))
+ :returns (ans integerp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "Set To[n] := From[n]"
+ :enabled t
(if (logbitp n from)
(setbit n to)
- (clearbit n to)))
-
-(defcong nat-equiv equal (copybit n x y) 1)
-(defcong int-equiv equal (copybit n x y) 2)
-(defcong int-equiv equal (copybit n x y) 3)
-
-
-(defthm integerp-of-copybit
- (integerp (copybit n from to))
- :rule-classes :type-prescription)
+ (clearbit n to))
+ ///
+ (defcong nat-equiv equal (copybit n x y) 1)
+ (defcong int-equiv equal (copybit n x y) 2)
+ (defcong int-equiv equal (copybit n x y) 3))
-(defun notbit (n x)
- "Set X[n] := ~X[n]"
- (declare (xargs :guard (and (natp n)
- (integerp x))))
+(define notbit ((n natp "Bit position to negate.")
+ (x integerp "Starting value."))
+ :returns (ans integerp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "Set X[n] := ~X[n]"
+ :enabled t
(if (logbitp n x)
(clearbit n x)
- (setbit n x)))
-
-(defcong nat-equiv equal (notbit n x) 1)
-(defcong int-equiv equal (notbit n x) 2)
-
-(defthm integerp-of-notbit
- (integerp (notbit n x))
- :rule-classes :type-prescription)
-
+ (setbit n x))
+ ///
+ (defcong nat-equiv equal (notbit n x) 1)
+ (defcong int-equiv equal (notbit n x) 2))
(local
@@ -311,94 +336,99 @@
(< (logtail 1 src) src))
:hints(("Goal" :in-theory (e/d (logtail**))))))
-(defund bitscan-fwd (src)
- "(BITSCAN-FWD SRC) returns the bit position of the least significant bit in
-SRC that is set, or 0 when SRC is zero (and hence has no such bit)."
- (declare (xargs :guard (natp src)
- :measure (nfix src)))
+(define bitscan-fwd ((src natp))
+ :returns (position natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "@(call bitscan-fwd) returns the bit position of the least significant
+bit in @('src') that is set, or 0 when @('src') is zero (and hence has no such
+bit)."
+ :long "Examples:
+@({
+ (bitscan-fwd #b1001) = 0
+ (bitscan-fwd #b1010) = 1
+ (bitscan-fwd #b1100) = 2
+ (bitscan-fwd #b1000) = 3
+})"
(cond ((zp src) 0)
((logbitp 0 src) 0)
- (t (+ 1 (bitscan-fwd (ash src -1))))))
+ (t (+ 1 (bitscan-fwd (ash src -1)))))
+ ///
+ (local (defthmd bitscan-fwd-examples
+ ;; This is just to try to "validate the spec" by showing it produces the
+ ;; values we want for some examples.
+ (and
+ ;; Some basic examples...
+ (equal (bitscan-fwd #ub_0000_0000_0001) 0)
+ (equal (bitscan-fwd #ub_0000_0000_0010) 1)
+ (equal (bitscan-fwd #ub_0000_0000_0100) 2)
+ (equal (bitscan-fwd #ub_0000_0000_1000) 3)
+ (equal (bitscan-fwd #ub_0000_0001_0000) 4)
+ (equal (bitscan-fwd #ub_0000_0010_0000) 5)
+ (equal (bitscan-fwd #ub_0000_0100_0000) 6)
+ ;; Same examples, but with upper bits changed to 1s...
+ (equal (bitscan-fwd #ub_0100_0101_0001) 0)
+ (equal (bitscan-fwd #ub_0110_0110_1010) 1)
+ (equal (bitscan-fwd #ub_1010_0101_0100) 2)
+ (equal (bitscan-fwd #ub_1010_1110_1000) 3)
+ (equal (bitscan-fwd #ub_1111_1111_0000) 4)
+ (equal (bitscan-fwd #ub_1010_1010_0000) 5)
+ (equal (bitscan-fwd #ub_0011_1100_0000) 6))))
+
+ (defcong nat-equiv equal (bitscan-fwd src) 1))
+
+
+(define bitscan-rev ((src natp))
+ :returns (position natp :rule-classes :type-prescription)
+ :parents (extra-defs)
+ :short "@(call bitscan-rev) returns the bit position of the most significant
+bit in @('src') that is set, or 0 when @('src') is zero (and hence has no such
+bit)."
+ :long "Examples:
+@({
+ (bitscan-rev #b0001) = 0
+ (bitscan-rev #b0011) = 1
+ (bitscan-rev #b0101) = 2
+ (bitscan-rev #b1001) = 3
+})"
-(local (defthmd bitscan-fwd-examples
- ;; This is just to try to "validate the spec" by showing it produces the
- ;; values we want for some examples.
- (and
- ;; Some basic examples...
- (equal (bitscan-fwd #ub_0000_0000_0001) 0)
- (equal (bitscan-fwd #ub_0000_0000_0010) 1)
- (equal (bitscan-fwd #ub_0000_0000_0100) 2)
- (equal (bitscan-fwd #ub_0000_0000_1000) 3)
- (equal (bitscan-fwd #ub_0000_0001_0000) 4)
- (equal (bitscan-fwd #ub_0000_0010_0000) 5)
- (equal (bitscan-fwd #ub_0000_0100_0000) 6)
- ;; Same examples, but with upper bits changed to 1s...
- (equal (bitscan-fwd #ub_0100_0101_0001) 0)
- (equal (bitscan-fwd #ub_0110_0110_1010) 1)
- (equal (bitscan-fwd #ub_1010_0101_0100) 2)
- (equal (bitscan-fwd #ub_1010_1110_1000) 3)
- (equal (bitscan-fwd #ub_1111_1111_0000) 4)
- (equal (bitscan-fwd #ub_1010_1010_0000) 5)
- (equal (bitscan-fwd #ub_0011_1100_0000) 6))))
-
-(defthm natp-of-bitscan-fwd
- (natp (bitscan-fwd src))
- :rule-classes :type-prescription)
-
-(defcong nat-equiv equal (bitscan-fwd src) 1
- :hints(("Goal" :in-theory (enable bitscan-fwd))))
-
-
-(defund bitscan-rev (src)
- "(BITSCAN-REV SRC) returns the bit position of the most significant bit in
-SRC that is set, or 0 when SRC is zero (and hence has no such bit)."
- (declare (xargs :guard (natp src)
- :measure (nfix src)))
(if (zp src)
0
(let ((next (ash src -1)))
(if (= next 0)
0
- (+ 1 (bitscan-rev next))))))
-
-(defcong nat-equiv equal (bitscan-rev src) 1
- :hints(("Goal" :in-theory (enable bitscan-rev))))
-
-(local (defthmd bitscan-rev-examples
- ;; This is just to try to "validate the spec" by showing it produces the
- ;; values we want for some examples.
- (and
- ;; Some basic examples... just like bsf since only one bit is set
- (equal (bitscan-rev #ub_0000_0000_0001) 0)
- (equal (bitscan-rev #ub_0000_0000_0010) 1)
- (equal (bitscan-rev #ub_0000_0000_0100) 2)
- (equal (bitscan-rev #ub_0000_0000_1000) 3)
- (equal (bitscan-rev #ub_0000_0001_0000) 4)
- (equal (bitscan-rev #ub_0000_0010_0000) 5)
- (equal (bitscan-rev #ub_0000_0100_0000) 6)
- (equal (bitscan-rev #ub_0000_1000_0000) 7)
- (equal (bitscan-rev #ub_0001_0000_0000) 8)
- (equal (bitscan-rev #ub_0010_0000_0000) 9)
- (equal (bitscan-rev #ub_0100_0000_0000) 10)
- (equal (bitscan-rev #ub_1000_0000_0000) 11)
- ;; Same examples, but with some low bits flipped to one.
- (equal (bitscan-rev #ub_0000_0000_0001) 0)
- (equal (bitscan-rev #ub_0000_0000_0011) 1)
- (equal (bitscan-rev #ub_0000_0000_0101) 2)
- (equal (bitscan-rev #ub_0000_0000_1101) 3)
- (equal (bitscan-rev #ub_0000_0001_0101) 4)
- (equal (bitscan-rev #ub_0000_0011_0101) 5)
- (equal (bitscan-rev #ub_0000_0101_0111) 6)
- (equal (bitscan-rev #ub_0000_1101_1111) 7)
- (equal (bitscan-rev #ub_0001_1111_1111) 8)
- (equal (bitscan-rev #ub_0010_0100_0101) 9)
- (equal (bitscan-rev #ub_0101_0100_0001) 10)
- (equal (bitscan-rev #ub_1010_0101_0110) 11))))
-
-(defthm natp-of-bitscan-rev
- (natp (bitscan-rev src))
- :rule-classes :type-prescription)
-
+ (+ 1 (bitscan-rev next)))))
+ ///
+ (local (defthmd bitscan-rev-examples
+ ;; This is just to try to "validate the spec" by showing it produces the
+ ;; values we want for some examples.
+ (and
+ ;; Some basic examples... just like bsf since only one bit is set
+ (equal (bitscan-rev #ub_0000_0000_0001) 0)
+ (equal (bitscan-rev #ub_0000_0000_0010) 1)
+ (equal (bitscan-rev #ub_0000_0000_0100) 2)
+ (equal (bitscan-rev #ub_0000_0000_1000) 3)
+ (equal (bitscan-rev #ub_0000_0001_0000) 4)
+ (equal (bitscan-rev #ub_0000_0010_0000) 5)
+ (equal (bitscan-rev #ub_0000_0100_0000) 6)
+ (equal (bitscan-rev #ub_0000_1000_0000) 7)
+ (equal (bitscan-rev #ub_0001_0000_0000) 8)
+ (equal (bitscan-rev #ub_0010_0000_0000) 9)
+ (equal (bitscan-rev #ub_0100_0000_0000) 10)
+ (equal (bitscan-rev #ub_1000_0000_0000) 11)
+ ;; Same examples, but with some low bits flipped to one.
+ (equal (bitscan-rev #ub_0000_0000_0001) 0)
+ (equal (bitscan-rev #ub_0000_0000_0011) 1)
+ (equal (bitscan-rev #ub_0000_0000_0101) 2)
+ (equal (bitscan-rev #ub_0000_0000_1101) 3)
+ (equal (bitscan-rev #ub_0000_0001_0101) 4)
+ (equal (bitscan-rev #ub_0000_0011_0101) 5)
+ (equal (bitscan-rev #ub_0000_0101_0111) 6)
+ (equal (bitscan-rev #ub_0000_1101_1111) 7)
+ (equal (bitscan-rev #ub_0001_1111_1111) 8)
+ (equal (bitscan-rev #ub_0010_0100_0101) 9)
+ (equal (bitscan-rev #ub_0101_0100_0001) 10)
+ (equal (bitscan-rev #ub_1010_0101_0110) 11))))
+ (defcong nat-equiv equal (bitscan-rev src) 1))
diff -Nru acl2-6.2/books/centaur/bitops/ihsext-basics.lisp acl2-6.3/books/centaur/bitops/ihsext-basics.lisp
--- acl2-6.2/books/centaur/bitops/ihsext-basics.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/ihsext-basics.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -56,7 +56,7 @@
unsigned-byte-p-0
unsigned-byte-p-plus
difference-unsigned-byte-p
- signed-byte-p-base-cases
+ ;; signed-byte-p-base-cases
;; backchain-signed-byte-p-to-unsigned-byte-p
loghead-identity
;; loghead-0-i remove hyp
@@ -2149,6 +2149,197 @@
:hints(("Goal" :in-theory (enable* ihsext-recursive-redefs
ihsext-inductions nfix ifix)))))
+(defsection expt
+
+ (defthmd expt-2-is-ash
+ (implies (natp n)
+ (equal (expt 2 n)
+ (ash 1 n)))
+ :hints(("Goal" :in-theory (enable ash floor))))
+
+ (defthm expt-of-ifix
+ (equal (expt r (ifix i))
+ (expt r i))
+ :hints(("Goal" :in-theory (enable expt))))
+
+ (add-to-ruleset ihsext-arithmetic '(expt-2-is-ash))
+ (add-to-ruleset ihsext-basic-thms expt-of-ifix))
+
+
+
+
+(defsection unsigned-byte-p**
+
+ (local (in-theory (enable* ihsext-recursive-redefs
+ ihsext-inductions)))
+
+ (local (in-theory (enable expt-2-is-ash)))
+
+
+ (defthm unsigned-byte-p-of-n-0
+ (equal (unsigned-byte-p n 0)
+ (natp n)))
+
+ (defthm unsigned-byte-p-of-0-x
+ (equal (unsigned-byte-p 0 x)
+ (equal x 0)))
+
+ (defthmd unsigned-byte-p**
+ (equal (unsigned-byte-p bits x)
+ (and (integerp x)
+ (natp bits)
+ (if (zp bits)
+ (equal x 0)
+ (unsigned-byte-p (1- bits)
+ (logcdr x)))))
+ :rule-classes ((:definition
+ :clique (unsigned-byte-p)
+ :controller-alist ((unsigned-byte-p t t)))))
+
+ (local (in-theory (enable unsigned-byte-p**)))
+ (local (in-theory (disable unsigned-byte-p)))
+
+ (add-to-ruleset ihsext-recursive-redefs '(unsigned-byte-p**))
+
+
+ (defun unsigned-byte-p-ind (bits x)
+ (and (integerp x)
+ (natp bits)
+ (if (zp bits)
+ (equal x 0)
+ (unsigned-byte-p-ind (1- bits) (logcdr x)))))
+
+ (defthm unsigned-byte-p-induct
+ t
+ :rule-classes ((:induction
+ :pattern (unsigned-byte-p bits x)
+ :scheme (unsigned-byte-p-ind bits x))))
+
+ (defthmd unsigned-byte-p-incr
+ (implies (and (unsigned-byte-p a x)
+ (natp b)
+ (<= a b))
+ (unsigned-byte-p b x)))
+
+ (local (in-theory (enable unsigned-byte-p-incr)))
+
+ (defthmd unsigned-byte-p-logcons
+ (implies (and (unsigned-byte-p (1- b) x)
+ (natp b))
+ (unsigned-byte-p b (logcons bit x)))
+ :hints (("goal" :expand ((unsigned-byte-p b (logcons bit x))))))
+
+ (defthmd unsigned-byte-p-logcons-free
+ (implies (and (unsigned-byte-p a x)
+ (natp b)
+ (<= a (1- b)))
+ (unsigned-byte-p b (logcons bit x)))
+ :hints (("goal" :expand ((unsigned-byte-p b (logcons bit x))))))
+
+ (defthmd unsigned-byte-p-logcdr
+ (implies (and (unsigned-byte-p a x)
+ (natp b)
+ (<= a (1+ b)))
+ (unsigned-byte-p b (logcdr x))))
+
+ (add-to-ruleset ihsext-bounds-thms '(unsigned-byte-p-incr
+ unsigned-byte-p-logcons
+ unsigned-byte-p-logcons-free
+ unsigned-byte-p-logcdr))
+
+ (local (in-theory (disable unsigned-byte-p-logand
+ unsigned-byte-p-logior
+ logior-=-0)))
+
+ (defthmd unsigned-byte-p-logand-fix
+ (implies (or (unsigned-byte-p b x)
+ (unsigned-byte-p b y))
+ (unsigned-byte-p b (logand x y))))
+
+ (defun unsigned-byte-p-logior-ind (b x y)
+ (cond ((zp b) (list x y))
+ (t (unsigned-byte-p-logior-ind
+ (1- b) (logcdr x) (logcdr y)))))
+
+ (defthmd unsigned-byte-p-logior-fix
+ (equal (unsigned-byte-p b (logior x y))
+ (and (unsigned-byte-p b (ifix x))
+ (unsigned-byte-p b (ifix y))))
+ :hints (("goal" :induct (unsigned-byte-p-logior-ind b x y))))
+
+ (add-to-ruleset ihsext-basic-thms '(unsigned-byte-p-logand-fix
+ unsigned-byte-p-logior-fix))
+
+ (defthm unsigned-byte-p-of-loghead
+ (implies (and (integerp size1)
+ (<= (nfix size) size1))
+ (unsigned-byte-p size1 (loghead size i))))
+
+ (defthm unsigned-byte-p-of-logtail
+ (implies (natp size1)
+ (equal (unsigned-byte-p size1 (logtail size i))
+ (unsigned-byte-p (+ size1 (nfix size)) (ifix i))))
+ :hints (("goal" :induct (and (logtail size i)
+ (logtail size1 i)))))
+
+ (defthm unsigned-byte-p-when-unsigned-byte-p-less
+ (implies (and (unsigned-byte-p n x)
+ (natp m)
+ (<= n m))
+ (unsigned-byte-p m x)))
+
+ (encapsulate
+ nil
+ (local (defun ind (n m x)
+ (cond ((zip m) (list n x))
+ ((< m 0) (ind (1+ n) (1+ m) x))
+ (t (ind (1- n) (1- m) x)))))
+
+ (local (defthm help1
+ (implies (unsigned-byte-p n x)
+ (natp n))))
+
+
+ (local (defthm unsigned-byte-p-of-ash-worse
+ ;; "worse" because of the natp hyp, which we'll eliminate in a moment
+ (implies (and (unsigned-byte-p (- n (ifix m)) x)
+ (natp n))
+ (unsigned-byte-p n (ash x m)))
+ :hints(("Goal" :in-theory (e/d* (acl2::ihsext-recursive-redefs
+ acl2::ihsext-inductions
+ nfix ifix zip)
+ (unsigned-byte-p))
+ :induct (ind n m x)
+ :do-not-induct t)
+ (and stable-under-simplificationp
+ '(:expand ((ash x m)))))
+ :otf-flg t))
+
+ (defthm unsigned-byte-p-of-ash
+ (implies (unsigned-byte-p (- n (ifix m)) x)
+ (equal (unsigned-byte-p n (ash x m))
+ (natp n)))
+ :hints(("Goal"
+ :in-theory (disable unsigned-byte-p)
+ :cases ((natp n))))))
+
+ (encapsulate
+ ()
+ (local (defun my-induct (n x y)
+ (if (zp n)
+ (list n x y)
+ (my-induct (- n 1) (logcdr x) (logcdr y)))))
+
+ (defthm unsigned-byte-p-of-logxor
+ (implies (and (unsigned-byte-p n x)
+ (unsigned-byte-p n y))
+ (unsigned-byte-p n (logxor x y)))
+ :hints(("Goal"
+ :induct (my-induct n x y)
+ :in-theory (enable acl2::logxor**
+ acl2::unsigned-byte-p**))))))
+
+
(defsection logsquash**
;; Squashes to 0 the lowest N bits of I.
@@ -2193,8 +2384,6 @@
:pattern (logsquash size i)
:scheme (logbitp-ind size i))))
-
-
(add-to-ruleset ihsext-inductions '(logsquash-induct))
(defthm logsquash-of-n-0
@@ -2379,205 +2568,25 @@
(defthm logsquash-<-0
(equal (< (logsquash n x) 0)
- (< (ifix x) 0))))
+ (< (ifix x) 0)))
-
-
-
-(defsection expt
-
- (defthmd expt-2-is-ash
- (implies (natp n)
- (equal (expt 2 n)
- (ash 1 n)))
- :hints(("Goal" :in-theory (enable ash floor))))
-
- (defthm expt-of-ifix
- (equal (expt r (ifix i))
- (expt r i))
- :hints(("Goal" :in-theory (enable expt))))
-
- (add-to-ruleset ihsext-arithmetic '(expt-2-is-ash))
- (add-to-ruleset ihsext-basic-thms expt-of-ifix))
-
-
-(defsection unsigned-byte-p**
-
- (local (in-theory (enable* ihsext-recursive-redefs
- ihsext-inductions)))
-
- (local (in-theory (enable expt-2-is-ash)))
-
-
- (defthm unsigned-byte-p-of-n-0
- (equal (unsigned-byte-p n 0)
- (natp n)))
-
- (defthm unsigned-byte-p-of-0-x
- (equal (unsigned-byte-p 0 x)
- (equal x 0)))
-
- (defthmd unsigned-byte-p**
- (equal (unsigned-byte-p bits x)
- (and (integerp x)
- (natp bits)
- (if (zp bits)
- (equal x 0)
- (unsigned-byte-p (1- bits)
- (logcdr x)))))
- :rule-classes ((:definition
- :clique (unsigned-byte-p)
- :controller-alist ((unsigned-byte-p t t)))))
-
- (local (in-theory (enable unsigned-byte-p**)))
- (local (in-theory (disable unsigned-byte-p)))
-
- (add-to-ruleset ihsext-recursive-redefs '(unsigned-byte-p**))
-
-
- (defun unsigned-byte-p-ind (bits x)
- (and (integerp x)
- (natp bits)
- (if (zp bits)
- (equal x 0)
- (unsigned-byte-p-ind (1- bits) (logcdr x)))))
-
- (defthm unsigned-byte-p-induct
- t
- :rule-classes ((:induction
- :pattern (unsigned-byte-p bits x)
- :scheme (unsigned-byte-p-ind bits x))))
-
- (defthmd unsigned-byte-p-incr
- (implies (and (unsigned-byte-p a x)
- (natp b)
- (<= a b))
- (unsigned-byte-p b x)))
-
- (local (in-theory (enable unsigned-byte-p-incr)))
-
- (defthmd unsigned-byte-p-logcons
- (implies (and (unsigned-byte-p (1- b) x)
- (natp b))
- (unsigned-byte-p b (logcons bit x)))
- :hints (("goal" :expand ((unsigned-byte-p b (logcons bit x))))))
-
- (defthmd unsigned-byte-p-logcons-free
- (implies (and (unsigned-byte-p a x)
- (natp b)
- (<= a (1- b)))
- (unsigned-byte-p b (logcons bit x)))
- :hints (("goal" :expand ((unsigned-byte-p b (logcons bit x))))))
-
- (defthmd unsigned-byte-p-logcdr
- (implies (and (unsigned-byte-p a x)
- (natp b)
- (<= a (1+ b)))
- (unsigned-byte-p b (logcdr x))))
-
- (add-to-ruleset ihsext-bounds-thms '(unsigned-byte-p-incr
- unsigned-byte-p-logcons
- unsigned-byte-p-logcons-free
- unsigned-byte-p-logcdr))
-
- (local (in-theory (disable unsigned-byte-p-logand
- unsigned-byte-p-logior
- logior-=-0)))
-
- (defthmd unsigned-byte-p-logand-fix
- (implies (or (unsigned-byte-p b x)
- (unsigned-byte-p b y))
- (unsigned-byte-p b (logand x y))))
-
- (defun unsigned-byte-p-logior-ind (b x y)
- (cond ((zp b) (list x y))
- (t (unsigned-byte-p-logior-ind
- (1- b) (logcdr x) (logcdr y)))))
-
- (defthmd unsigned-byte-p-logior-fix
- (equal (unsigned-byte-p b (logior x y))
- (and (unsigned-byte-p b (ifix x))
- (unsigned-byte-p b (ifix y))))
- :hints (("goal" :induct (unsigned-byte-p-logior-ind b x y))))
-
- (add-to-ruleset ihsext-basic-thms '(unsigned-byte-p-logand-fix
- unsigned-byte-p-logior-fix))
-
- (defthm unsigned-byte-p-of-loghead
- (implies (and (integerp size1)
- (<= (nfix size) size1))
- (unsigned-byte-p size1 (loghead size i))))
+ (defthm logsquash-cancel
+ (implies (unsigned-byte-p n x)
+ (equal (logsquash n x) 0))
+ :hints(("Goal" :in-theory (disable unsigned-byte-p))))
(defthm unsigned-byte-p-of-logsquash
(implies (and (unsigned-byte-p size1 i)
(<= (nfix size) (nfix size1)))
- (unsigned-byte-p size1 (logsquash size i))))
-
- (defthm unsigned-byte-p-of-logtail
- (implies (natp size1)
- (equal (unsigned-byte-p size1 (logtail size i))
- (unsigned-byte-p (+ size1 (nfix size)) (ifix i))))
- :hints (("goal" :induct (and (logtail size i)
- (logtail size1 i)))))
-
- (defthm unsigned-byte-p-when-unsigned-byte-p-less
- (implies (and (unsigned-byte-p n x)
- (natp m)
- (<= n m))
- (unsigned-byte-p m x)))
-
- (encapsulate
- nil
- (local (defun ind (n m x)
- (cond ((zip m) (list n x))
- ((< m 0) (ind (1+ n) (1+ m) x))
- (t (ind (1- n) (1- m) x)))))
-
- (local (defthm help1
- (implies (unsigned-byte-p n x)
- (natp n))))
-
-
- (local (defthm unsigned-byte-p-of-ash-worse
- ;; "worse" because of the natp hyp, which we'll eliminate in a moment
- (implies (and (unsigned-byte-p (- n (ifix m)) x)
- (natp n))
- (unsigned-byte-p n (ash x m)))
- :hints(("Goal" :in-theory (e/d* (acl2::ihsext-recursive-redefs
- acl2::ihsext-inductions
- nfix ifix zip)
- (unsigned-byte-p))
- :induct (ind n m x)
- :do-not-induct t)
- (and stable-under-simplificationp
- '(:expand ((ash x m)))))
- :otf-flg t))
-
- (defthm unsigned-byte-p-of-ash
- (implies (unsigned-byte-p (- n (ifix m)) x)
- (equal (unsigned-byte-p n (ash x m))
- (natp n)))
- :hints(("Goal"
- :in-theory (disable unsigned-byte-p)
- :cases ((natp n))))))
-
- (encapsulate
- ()
- (local (defun my-induct (n x y)
- (if (zp n)
- (list n x y)
- (my-induct (- n 1) (logcdr x) (logcdr y)))))
-
- (defthm unsigned-byte-p-of-logxor
- (implies (and (unsigned-byte-p n x)
- (unsigned-byte-p n y))
- (unsigned-byte-p n (logxor x y)))
- :hints(("Goal"
- :induct (my-induct n x y)
- :in-theory (enable acl2::logxor**
- acl2::unsigned-byte-p**))))))
-
+ (unsigned-byte-p size1 (logsquash size i)))
+ :hints(("Goal" :in-theory (disable unsigned-byte-p))))
+ (defthm logsquash-of-ash-greater
+ (implies (<= (nfix n) (ifix i))
+ (equal (logsquash n (ash x i))
+ (ash x i)))
+ :hints (("goal" :induct (and (logsquash n b)
+ (logsquash i b))))))
(defsection signed-byte-p**
@@ -2906,8 +2915,8 @@
(add-to-ruleset ihsext-basic-thms '(unsigned-byte-p-of-logapp
signed-byte-p-of-logapp))
- (defthm logapp-zeros
- (equal (logapp i 0 0) 0))
+ ;; (defthm logapp-zeros
+ ;; (equal (logapp i 0 0) 0))
(defthm logapp-minus1s
(equal (logapp i -1 -1) -1)))
diff -Nru acl2-6.2/books/centaur/bitops/rotate.acl2 acl2-6.3/books/centaur/bitops/rotate.acl2
--- acl2-6.2/books/centaur/bitops/rotate.acl2 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/rotate.acl2 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,26 @@
+; Centaur Bitops Library
+; Copyright (C) 2010-2011 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "ACL2")
+(include-book "std/osets/portcullis" :dir :system)
+(include-book "cutil/portcullis" :dir :system)
+(include-book "centaur/gl/portcullis" :dir :system)
+; cert-flags: ? t :ttags :all
+(certify-book "rotate" ? t :ttags :all)
diff -Nru acl2-6.2/books/centaur/bitops/rotate.lisp acl2-6.3/books/centaur/bitops/rotate.lisp
--- acl2-6.2/books/centaur/bitops/rotate.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/rotate.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -23,6 +23,7 @@
(include-book "tools/bstar" :dir :system)
(include-book "ihs/logops-definitions" :dir :system)
(include-book "centaur/misc/arith-equivs" :dir :system)
+(include-book "centaur/gl/gl-mbe" :dir :system)
(local (include-book "ihsext-basics"))
(local (include-book "arithmetic/top-with-meta" :dir :system))
(local (include-book "equal-by-logbitp"))
@@ -37,6 +38,20 @@
0)
:hints(("Goal" :in-theory (enable mod floor)))))
+(local (defthm rem-is-mod
+ ;; (let ((places 20)
+ ;; (width 4))
+ ;; ;; REM finishes in 2.4 seconds, MOD in 2.8 seconds...
+ ;; (time (loop for i fixnum from 1 to 100000000 do
+ ;; (mod places width)))
+ ;; (time (loop for i fixnum from 1 to 100000000 do
+ ;; (rem places width))))
+ (implies (and (natp places)
+ (posp width))
+ (equal (rem places width)
+ (mod places width)))
+ :hints(("Goal" :in-theory (enable mod rem)))))
+
(defsection rotate-left
@@ -57,8 +72,24 @@
(let* ((width (lnfix width))
(places (lnfix places))
- (x (logand x (1- (ash 1 width)))) ; chop x down to size
- (places (mod places width)) ; e.g., 20 places --> 4 places
+ (wmask (1- (ash 1 width)))
+ (x (logand x wmask)) ; chop x down to size
+ (places (mbe :logic (mod places width) ; e.g., 20 places --> 4 places
+ :exec
+ ;; REM is slightly cheaper than MOD, but in many
+ ;; cases we can probably avoid REM entirely because
+ ;; usually we'll be rotating by some amount less
+ ;; than the width...
+ (if (< places width)
+ places
+ (rem places width))))
+ (places (gl::gl-mbe places ;; logically this is a no-op
+ ;; ensure that GL knows places is short
+ (logand places (lognot (ash -1
+ (integer-length
+ width))))
+ ;; debugging if this check failes
+ (list places width)))
(low-num (- width places)) ; e.g., 12
(mask (1- (ash 1 low-num))) ; e.g., 0000_1111_1111_1111
(xl (logand x mask)) ; e.g., 0000_BBBB_CCCC_DDDD
@@ -302,9 +333,18 @@
logbitp-of-rotate-left-split)))))))
-
(defsection rotate-right
+ (local (defthm loghead-removal-backwards
+ ;; BOZO should really fix loghead's definition instead...
+ (implies (natp width)
+ (equal (logand x (+ -1 (ash 1 width)))
+ (loghead width x)))
+ :hints((equal-by-logbitp-hint)
+ (and stable-under-simplificationp
+ '(:in-theory (enable b-and bool->bit
+ logbitp-of-loghead-split))))))
+
(defund rotate-right (x width places)
"Rotate X, a vector of some WIDTH, by PLACES places to the right.
@@ -315,14 +355,19 @@
(declare (xargs :guard (and (integerp x)
(posp width)
(natp places))))
-
;; Running example to help understand the code: suppose X is some 16-bit
;; number, say 16'b AAAA_BBBB_CCCC_DDDD, so the width is 16, and suppose we
;; want to rotate by 20 places.
(let* ((width (lnfix width))
- (x (loghead width x))
+ (x (mbe :logic (loghead width x)
+ :exec (logand x (+ -1 (ash 1 width)))))
(places (lnfix places))
- (places (mod places width)) ; e.g., 20 places --> 4 places
+ (places (mbe :logic (mod places width) ; e.g., 20 places --> 4 places
+ :exec
+ ;; As in rotate-left
+ (if (< places width)
+ places
+ (rem places width))))
(mask (1- (ash 1 places))) ; e.g., 0000_0000_0000_1111
(xl (logand x mask)) ; e.g., 0000_0000_0000_DDDD
(xh-shift (ash x (- places))) ; e.g., 0000_AAAA_BBBB_CCCC
diff -Nru acl2-6.2/books/centaur/bitops/sbitsets.lisp acl2-6.3/books/centaur/bitops/sbitsets.lisp
--- acl2-6.2/books/centaur/bitops/sbitsets.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/sbitsets.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -39,7 +39,7 @@
:long "Introduction
-In the ordinary @(see bitset) library, sets of natural numbers are encoded
+
In the ordinary @(see bitsets) library, sets of natural numbers are encoded
as bignums. This is perfectly fine when the set elements are relatively small,
but it is not an efficient way to deal with sets of large numbers. For
instance, trying to insert a number like 2^30 into an ordinary bitset will
@@ -110,7 +110,7 @@
The sbitsets library can be loaded with:
@({
- (include-book \"bitops/sbitsets\" :dir :cbooks)
+ (include-book \"centaur/bitops/sbitsets\" :dir :system)
})
Valid sparse bitsets are recognized by @(see sbitsetp), and there is a
@@ -548,7 +548,7 @@
(defsection sbitset-pair-members
:parents (sbitset-members)
:short "@(call sbitset-pair-members) extracts the members of a single @(see
-sbitset-pair)."
+sbitset-pairp)."
:long "
For instance, if the pair is @('(0 . 7)'), we produce the set
@('{0, 1, 2}'); if the set is @('(1 . 7)'), we produce @('{60, 61, 62}').
@@ -607,7 +607,7 @@
(syntaxp (term-order y x)))
(equal (sbitset-pair-offset x)
(sbitset-pair-offset y)))
- :hints((witness)))
+ :hints((set-reasoning)))
(defthm consp-of-sbitset-pair-members
(implies (force (sbitset-pairp x))
diff -Nru acl2-6.2/books/centaur/bitops/signed-byte-p.lisp acl2-6.3/books/centaur/bitops/signed-byte-p.lisp
--- acl2-6.2/books/centaur/bitops/signed-byte-p.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/signed-byte-p.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -823,3 +823,189 @@
:hints(("Goal" :in-theory (enable lognot
unsigned-byte-p
signed-byte-p))))
+
+(defthm basic-signed-byte-p-of-1+lognot
+ (implies (unsigned-byte-p n x)
+ (signed-byte-p (+ 1 n) (+ 1 (lognot x))))
+ :hints(("Goal" :in-theory (enable lognot
+ unsigned-byte-p
+ signed-byte-p))))
+
+(defthm signed-byte-p-of-decrement-when-natural-signed-byte-p
+ (implies (and (signed-byte-p n x)
+ (<= 0 x))
+ (signed-byte-p n (1- x)))
+ :hints(("Goal" :in-theory (enable signed-byte-p))))
+
+(defthm signed-byte-p-when-signed-byte-p-smaller
+ (implies (and (signed-byte-p size1 x)
+ (<= size1 (nfix size2)))
+ (signed-byte-p size2 x))
+ :hints(("Goal" :in-theory (enable signed-byte-p))))
+
+
+(encapsulate
+ ()
+ (local (defun my-induct (size1 size2 x)
+ (if (or (zp size1)
+ (zp size2))
+ (list size1 size2 x)
+ (my-induct (- size1 1)
+ (- size2 1)
+ (logcdr x)))))
+
+ (defthm signed-byte-p-when-unsigned-byte-p-smaller
+ (implies (and (unsigned-byte-p size1 x)
+ (< size1 (nfix size2)))
+ (signed-byte-p size2 x))
+ :hints(("Goal"
+ :induct (my-induct size1 size2 x)
+ :in-theory (enable* ihsext-recursive-redefs
+ ihsext-inductions)))))
+
+
+(defsection signed-byte-p-of-ash-split
+
+ (local (in-theory (enable* arith-equiv-forwarding)))
+
+ (local (defun dec-induct (n)
+ (if (zp n)
+ nil
+ (dec-induct (- n 1)))))
+
+ (local (defthm k0
+ (implies (and (signed-byte-p width x)
+ (natp n))
+ (signed-byte-p (+ width n) (ash x n)))
+ :hints(("Goal"
+ :induct (dec-induct n)
+ :in-theory (enable* ihsext-recursive-redefs)))))
+
+ (local (defthm k0-better
+ (implies (and (signed-byte-p (- width n) x)
+ (natp n))
+ (signed-byte-p width (ash x n)))
+ :hints(("Goal"
+ :in-theory (disable k0)
+ :use ((:instance k0
+ (x x)
+ (n n)
+ (width (- width n))))))))
+
+ (local (defthm k1
+ (implies (and (signed-byte-p (+ width n) (ash x n))
+ (natp n))
+ (equal (signed-byte-p width x)
+ (and (posp width)
+ (integerp x))))
+ :hints(("Goal"
+ :induct (dec-induct n)
+ :in-theory (enable* ihsext-recursive-redefs)))))
+
+ (local (defthm k1-better
+ (implies (and (signed-byte-p width (ash x n))
+ (natp n))
+ (equal (signed-byte-p (- width n) x)
+ (and (integerp x)
+ (< n width))))
+ :hints(("Goal"
+ :use ((:instance k1 (width (- width n))))))))
+
+ (local (defthm m1
+ (implies (not (integerp x))
+ (equal (signed-byte-p width (ash x n))
+ (posp width)))))
+
+ (local (defthm m2
+ (implies (not (integerp n))
+ (equal (signed-byte-p width (ash x n))
+ (signed-byte-p width (ifix x))))))
+
+ (local (defthm m3a
+ (implies (and (integerp x)
+ (natp n)
+ (< n width))
+ (equal (signed-byte-p width (ash x n))
+ (signed-byte-p (- width n) x)))
+ :hints(("Goal"
+ :use ((:instance k0-better)
+ (:instance k1-better))
+ :do-not-induct t))))
+
+ (local (defthm m3b
+ (implies (and (integerp x)
+ (integerp n)
+ (< n 0)
+ (posp width))
+ (equal (signed-byte-p width (ash x n))
+ (signed-byte-p (- width n) x)))
+ :hints(("Goal"
+ :do-not-induct t
+ :in-theory (disable signed-byte-p-of-logtail
+ right-shift-to-logtail)
+ :use ((:instance signed-byte-p-of-logtail
+ (n (- n)))
+ (:instance right-shift-to-logtail
+ (count n)
+ (i x)))))))
+
+ (local (defthm m3
+ (implies (and (integerp x)
+ (integerp n)
+ (< n width))
+ (equal (signed-byte-p width (ash x n))
+ (and (posp width)
+ (signed-byte-p (- width n) x))))
+ :hints(("Goal" :use ((:instance m3a)
+ (:instance m3b))))))
+
+ (local (defthm m4
+ (implies (and (integerp x)
+ (natp n)
+ (>= n width))
+ (equal (signed-byte-p width (ash x n))
+ (and (posp width)
+ (equal x 0))))
+ :hints(("Goal"
+ :induct (ash x n)
+ :in-theory (enable* ihsext-recursive-redefs
+ ihsext-inductions)))))
+
+ (defthm signed-byte-p-of-ash-split
+ (equal (signed-byte-p width (ash x n))
+ (and (posp width)
+ (or (zip x)
+ (if (zip n)
+ (signed-byte-p width (ifix x))
+ (signed-byte-p (- width n) x)))))
+ :hints(("Goal"
+ :do-not-induct t
+ :cases ((< n 0)
+ (< n width))))))
+
+
+
+(defsection signed-byte-p-of-loghead
+
+ (local (defthm l0
+ (implies (and (natp n)
+ (natp size)
+ (< size n))
+ (signed-byte-p n (loghead size x)))
+ :hints(("Goal"
+ :do-not-induct t
+ :in-theory (disable unsigned-byte-p-of-loghead
+ signed-byte-p-when-unsigned-byte-p-smaller)
+ :use ((:instance unsigned-byte-p-of-loghead
+ (i x)
+ (size size)
+ (size1 size))
+ (:instance signed-byte-p-when-unsigned-byte-p-smaller
+ (x (loghead size x))
+ (size1 size)
+ (size2 n)))))))
+
+ (defthm signed-byte-p-of-loghead
+ (implies (and (integerp m)
+ (< (nfix size) m))
+ (signed-byte-p m (loghead size x)))))
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/bitops/top.lisp acl2-6.3/books/centaur/bitops/top.lisp
--- acl2-6.2/books/centaur/bitops/top.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bitops/top.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -31,7 +31,9 @@
(include-book "extra-defs")
(defxdoc bitops
- :short "Centaur Bitops Library"
+ :parents (arithmetic)
+ :short "The Centaur Bitops Library is a successor to @(see ihs); it is a
+comprehensive library geared towards bit-vector arithmetic."
:long "We provide:
@@ -54,20 +56,20 @@
might try:
@({
- (local (include-book \"bitops/ihs-extensions\" :dir :cbooks))
- (local (include-book \"bitops/equal-by-logbitp\" :dir :cbooks))
+ (local (include-book \"centaur/bitops/ihs-extensions\" :dir :system))
+ (local (include-book \"centaur/bitops/equal-by-logbitp\" :dir :system))
})
For the bitsets library:
@({
- (include-book \"bitops/bitsets\" :dir :cbooks)
+ (include-book \"centaur/bitops/bitsets\" :dir :system)
})
Or for the sparse bitsets library:
@({
- (include-book \"bitops/sbitsets\" :dir :cbooks)
+ (include-book \"centaur/bitops/sbitsets\" :dir :system)
})
Copyright Information
diff -Nru acl2-6.2/books/centaur/bridge/bridge-raw.lsp acl2-6.3/books/centaur/bridge/bridge-raw.lsp
--- acl2-6.2/books/centaur/bridge/bridge-raw.lsp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/bridge/bridge-raw.lsp 2013-09-30 17:53:11.000000000 +0000
@@ -295,10 +295,6 @@
; Worker Threads --------------------------------------------------------------
-(defun json-encode (x)
- (let ((acc (json-encode-main x nil)))
- (nreverse (coerce acc 'string))))
-
(defun worker-write-return (type ret-list stream)
(case type
(:lisp (send-message "RETURN" (prin1-to-string (car ret-list)) stream))
diff -Nru acl2-6.2/books/centaur/bridge/package.lsp acl2-6.3/books/centaur/bridge/package.lsp
--- acl2-6.2/books/centaur/bridge/package.lsp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bridge/package.lsp 2013-09-30 17:53:11.000000000 +0000
@@ -26,8 +26,9 @@
(union-equal acl2::*acl2-exports*
acl2::*common-lisp-symbols-from-main-lisp-package*)
'(b* defsection defxdoc include-raw assert! definline definlined
+ define
;; to make Bridge::Bridge show up as just "Bridge" in the XDOC index
- bridge))
+ explode implode bridge))
'(include-book)))
; It's too frustrating NOT to have this be part of package.lsp
diff -Nru acl2-6.2/books/centaur/bridge/portcullis.acl2 acl2-6.3/books/centaur/bridge/portcullis.acl2
--- acl2-6.2/books/centaur/bridge/portcullis.acl2 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/bridge/portcullis.acl2 2013-09-30 17:53:11.000000000 +0000
@@ -22,8 +22,6 @@
(ld "package.lsp")
(ld "tools/flag-package.lsp" :dir :system)
-(ld "str/package.lsp" :dir :system)
-(ld "xdoc/package.lsp" :dir :system)
-
+(include-book "str/portcullis" :dir :system)
+(include-book "xdoc/portcullis" :dir :system)
; cert-flags: ? t :ttags :all
-(certify-book "portcullis" ? t :ttags :all)
diff -Nru acl2-6.2/books/centaur/bridge/to-json.lisp acl2-6.3/books/centaur/bridge/to-json.lisp
--- acl2-6.2/books/centaur/bridge/to-json.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/bridge/to-json.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -23,10 +23,10 @@
(include-book "str/cat" :dir :system)
(include-book "str/natstr" :dir :system)
(include-book "std/misc/two-nats-measure" :dir :system)
-(local (include-book "std/misc/explode-atom" :dir :system))
+(local (include-book "str/explode-atom" :dir :system))
(local (include-book "centaur/bitops/ihsext-basics" :dir :system))
(local (include-book "misc/assert" :dir :system))
-
+(local (include-book "std/typed-lists/character-listp" :dir :system))
(defsection json-encoding
:parents (bridge)
@@ -216,9 +216,9 @@
(character-listp (json-encode-weird-char x acc))))
(local (defun test (x)
- (let* ((acc (reverse (coerce "abc " 'list)))
+ (let* ((acc (reverse (explode "abc ")))
(acc (json-encode-weird-char x acc)))
- (reverse (coerce acc 'string)))))
+ (str::rchars-to-string acc))))
(local
(progn
@@ -315,16 +315,16 @@
(<= n xl)
(eql xl (length x)))
(equal (json-encode-str-aux x n xl acc)
- (json-encode-chars (nthcdr n (coerce x 'list)) acc)))
+ (json-encode-chars (nthcdr n (explode x)) acc)))
:hints(("Goal"
:in-theory (enable json-encode-str-aux
json-encode-chars)
:induct (json-encode-str-aux x n xl acc)
- :expand (json-encode-chars (nthcdr n (coerce x 'list)) acc))))
+ :expand (json-encode-chars (nthcdr n (explode x)) acc))))
(definline json-encode-str (x acc)
(declare (type string x))
- (mbe :logic (json-encode-chars (coerce x 'list) acc)
+ (mbe :logic (json-encode-chars (explode x) acc)
:exec (json-encode-str-aux x 0 (length x) acc))))
@@ -363,9 +363,9 @@
(character-listp (json-encode-atom x acc))))
(local (defun test (x)
- (let* ((acc (reverse (coerce "abc " 'list)))
+ (let* ((acc (reverse (explode "abc ")))
(acc (json-encode-atom x acc)))
- (reverse (coerce acc 'string)))))
+ (str::rchars-to-string acc))))
(local
(progn
@@ -475,10 +475,10 @@
(string-append-lst (str::strtok x '(#\Newline)))))
(local (defun test (x)
- (let* ((acc (reverse (coerce "abc " 'list)))
+ (let* ((acc (reverse (explode "abc ")))
(acc (json-encode-main x acc)))
(collapse-newlines
- (reverse (coerce acc 'string))))))
+ (str::rchars-to-string acc)))))
;; Same atom tests as above
(local
@@ -590,9 +590,9 @@
getting the characters into the right order."
(defund json-encode (x)
- "Gets nreverse optimization in bridge-raw.lsp"
+ (declare (xargs :guard t))
(let ((acc (json-encode-main x nil)))
- (reverse (coerce acc 'string))))
+ (str::rchars-to-string acc)))
(local (in-theory (enable json-encode)))
diff -Nru acl2-6.2/books/centaur/bridge/top.lisp acl2-6.3/books/centaur/bridge/top.lisp
--- acl2-6.2/books/centaur/bridge/top.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/bridge/top.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -26,6 +26,7 @@
; (depends-on "bridge-raw.lsp")
(defxdoc bridge
+ :parents (acl2::interfacing-tools)
:short "Connects ACL2 and the outside world."
:long "The ACL2 Bridge is a general mechanism for allowing other
diff -Nru acl2-6.2/books/centaur/ccl-config.lsp acl2-6.3/books/centaur/ccl-config.lsp
--- acl2-6.2/books/centaur/ccl-config.lsp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/ccl-config.lsp 2013-09-30 17:53:15.000000000 +0000
@@ -51,10 +51,17 @@
; These stack sizes apply to the first (initial) Lisp listener thread, where
; the bulk of ACL2 computations take place.
+; WARNING: This setting of stack size values only takes effect after starting a
+; new Lisp process. The typical ACL2 procedure is to save an executable using
+; save-exec after doing these assignments, which will then take effect when you
+; invoke the new executable.
+
(let ((stack-size (if (< most-positive-fixnum (expt 2 34))
(expt 2 23)
(expt 2 28))))
+; See WARNING above.
+
(setq *initial-listener-default-control-stack-size* stack-size)
(setq *initial-listener-default-value-stack-size* stack-size)
diff -Nru acl2-6.2/books/centaur/clex/arithmetic.lisp acl2-6.3/books/centaur/clex/arithmetic.lisp
--- acl2-6.2/books/centaur/clex/arithmetic.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/clex/arithmetic.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -29,6 +29,7 @@
update-nth
;; These can interfere with stobj stuff
nth-0-cons
+ nth-when-zp
nth-add1))
(local (in-theory (enable nthcdr len nth)))
@@ -53,10 +54,11 @@
(equal (nth n x)
nil)))
-(defrule nth-of-nthcdr
- (equal (nth a (nthcdr b x))
- (nth (+ (nfix a) (nfix b)) x))
- :disable (acl2::nthcdr-of-cdr))
+;; now part of std/lists
+;; (defrule nth-of-nthcdr
+;; (equal (nth a (nthcdr b x))
+;; (nth (+ (nfix a) (nfix b)) x))
+;; :disable (acl2::nthcdr-of-cdr))
(defrule nthcdr-under-iff-when-true-listp
(implies (true-listp x)
diff -Nru acl2-6.2/books/centaur/clex/charset.lisp acl2-6.3/books/centaur/clex/charset.lisp
--- acl2-6.2/books/centaur/clex/charset.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/clex/charset.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -42,8 +42,7 @@
To introduce new sets of characters, e.g., to recognize \"whitespace
characters,\" or \"hex digits,\" or whatever, we use the @(see defcharset)
macro. After defining suitable character sets, functions like @(see
-read-while-in-charset) and @(see read-until-in-charset) become quite
-useful.
+sin-match-charset*) become quite useful.
We generally treat character sets as opaque. It would be quite odd to,
e.g., allow the theorem prover to expand a character set's definition into its
@@ -310,7 +309,7 @@
:hints(("Goal"
:in-theory (enable code-in-charset-p)
:use ((:instance defcharset-lemma2
- (i (char-code x))))))))
+ (i (char-code ,x))))))))
(deflist ,foo-charlist-p (,x)
(,foo-char-p ,x)
diff -Nru acl2-6.2/books/centaur/clex/example.lisp acl2-6.3/books/centaur/clex/example.lisp
--- acl2-6.2/books/centaur/clex/example.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/clex/example.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -162,7 +162,7 @@
(defthm lex-whitespace-reconstruction
(b* (((mv tok new-sin) (lex-whitespace sin)))
(implies tok
- (equal (append (coerce (token->text tok) 'list)
+ (equal (append (explode (token->text tok))
(strin-left new-sin))
(strin-left sin))))))
@@ -190,7 +190,7 @@
(defthm lex-punctuation-reconstruction
(b* (((mv tok new-sin) (lex-punctuation sin)))
(implies tok
- (equal (append (coerce (token->text tok) 'list)
+ (equal (append (explode (token->text tok))
(strin-left new-sin))
(strin-left sin))))))
@@ -231,7 +231,7 @@
(defthm lex-id/keyword-reconstruction
(b* (((mv tok new-sin) (lex-id/keyword sin)))
(implies tok
- (equal (append (coerce (token->text tok) 'list)
+ (equal (append (explode (token->text tok))
(strin-left new-sin))
(strin-left sin))))))
@@ -241,7 +241,7 @@
:parents (example-lexer)
:short "A string with just the newline character."
(defmacro newline-string ()
- (coerce (list #\Newline) 'string)))
+ (implode (list #\Newline))))
(define lex-comment
:parents (example-lexer)
@@ -269,7 +269,7 @@
(defthm lex-comment-reconstruction
(b* (((mv tok new-sin) (lex-comment sin)))
(implies tok
- (equal (append (coerce (token->text tok) 'list)
+ (equal (append (explode (token->text tok))
(strin-left new-sin))
(strin-left sin))))))
@@ -305,7 +305,7 @@
(defthm lex1-reconstruction
(b* (((mv tok new-sin) (lex1 sin)))
(implies tok
- (equal (append (coerce (token->text tok) 'list)
+ (equal (append (explode (token->text tok))
(strin-left new-sin))
(strin-left sin))))))
@@ -364,7 +364,7 @@
(b* (((mv okp tokens ?new-sin) (lex* sin)))
(implies okp
(equal (tokenlist-all-text tokens)
- (coerce (strin-left sin) 'string))))))
+ (implode (strin-left sin)))))))
(define lex-main
@@ -399,7 +399,7 @@
(b* (((mv errmsg tokens ?new-sin) (lex-main sin)))
(implies (not errmsg)
(equal (tokenlist-all-text tokens)
- (coerce (strin-left sin) 'string))))))
+ (implode (strin-left sin)))))))
(define lex-string
diff -Nru acl2-6.2/books/centaur/clex/matchers.lisp acl2-6.3/books/centaur/clex/matchers.lisp
--- acl2-6.2/books/centaur/clex/matchers.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/clex/matchers.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -126,8 +126,8 @@
(defthm ,(intern-in-package-of-symbol (cat "NON-EMPTY-OF-" name-s ".MATCH")
name)
(b* (((mv . ,return-names) (,name . ,formals)))
- (equal (consp (coerce match 'list))
- (if match t nil))))
+ (equal (equal match "")
+ nil)))
(defthm ,(intern-in-package-of-symbol (cat name-s "-PROGRESS-WEAK")
name)
@@ -150,7 +150,7 @@
;; This very nicely takes advantage of the fact that (COERCE NIL
;; 'LIST) happens to be NIL, so we don't even need to check for a
;; match.
- (equal (append (coerce match 'list) (strin-left new-sin))
+ (equal (append (explode match) (strin-left new-sin))
(strin-left sin))))
(defthm ,(intern-in-package-of-symbol (cat name-s "-GRACEFUL-FAILURE")
@@ -227,7 +227,7 @@
(defthm non-empty-of-sin-match-everything.match
(b* (((mv ?match ?new-sin) (sin-match-everything sin)))
- (iff (consp (coerce match 'list))
+ (iff (consp (explode match))
(consp (strin-left sin)))))
(defthm sin-match-everything-progress
@@ -237,7 +237,7 @@
(defthm sin-match-everything-reconstruction
(b* (((mv match new-sin) (sin-match-everything sin)))
- (equal (append (coerce match 'list) (strin-left new-sin))
+ (equal (append (explode match) (strin-left new-sin))
(strin-left sin)))))
@@ -314,7 +314,7 @@
(equal (equal match lit)
(if match
(and (stringp lit)
- (consp (coerce lit 'list)))
+ (consp (explode lit)))
(not lit))))))
@@ -371,7 +371,8 @@
(b* (((mv match ?new-sin) (sin-match-some-lit lits sin)))
(implies match
(member match lits)))
- :hints(("Goal" :in-theory (enable sin-match-lit.match-when-ok)))))
+ :hints(("Goal" :in-theory (enable sin-match-lit.match-when-ok
+ member)))))
@@ -418,7 +419,7 @@
;; checking whether the match is one thing or another.
(b* (((mv ?match ?new-sin)
(sin-match-charset* set sin)))
- (implies (equal chars (coerce match 'list))
+ (implies (equal chars (explode match))
(equal (append chars (strin-left new-sin))
(strin-left sin)))))
@@ -434,7 +435,7 @@
(defthm chars-in-charset-p-of-sin-match-charset*.match
(b* (((mv ?match ?new-sin) (sin-match-charset* set sin)))
;; Nicely abusing that NIL coerces to NIL...
- (chars-in-charset-p (coerce match 'list) set))))
+ (chars-in-charset-p (explode match) set))))
diff -Nru acl2-6.2/books/centaur/clex/package.lsp acl2-6.3/books/centaur/clex/package.lsp
--- acl2-6.2/books/centaur/clex/package.lsp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/clex/package.lsp 2013-09-30 17:53:11.000000000 +0000
@@ -20,8 +20,8 @@
(in-package "ACL2")
-(ld "cutil/package.lsp" :dir :system)
-(ld "str/package.lsp" :dir :system)
+(include-book "cutil/portcullis" :dir :system)
+(include-book "str/portcullis" :dir :system)
(defpkg "CLEX"
(set-difference-eq
@@ -39,7 +39,8 @@
defxdoc defsection definline definlined
defabsstobj-events
unsigned-byte-p signed-byte-p
- cutil::deflist
+ unsigned-byte-listp
+ explode implode
str::cat str::natstr
nat-equiv int-equiv))
'(number-char-p digit-char-p sin)))
diff -Nru acl2-6.2/books/centaur/clex/sin.lisp acl2-6.3/books/centaur/clex/sin.lisp
--- acl2-6.2/books/centaur/clex/sin.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/clex/sin.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -26,7 +26,7 @@
(defxdoc sin
:parents (clex)
- :short "Abstract @(see stobj) for a string input stream."
+ :short "Abstract @(see acl2::stobj) for a string input stream."
:long "
The @('sin') (\"string input\") stobj allows you to efficiently,
easily process strings in a stream-like, sequential fashion, while remembering
@@ -50,7 +50,7 @@
(defsection sin$c
:parents (sin)
- :short "Concrete string input stream @(see stobj)."
+ :short "Concrete string input stream @(see acl2::stobj)."
:long "
In the implementation, we take care to ensure that all indices
satisfy @('(unsigned-byte-p 60)'), making them fixnums on Lisps such as CCL and
diff -Nru acl2-6.2/books/centaur/clex/top.lisp acl2-6.3/books/centaur/clex/top.lisp
--- acl2-6.2/books/centaur/clex/top.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/clex/top.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -24,17 +24,18 @@
(include-book "str/natstr" :dir :system)
(defsection clex
+ :parents (acl2::interfacing-tools)
:short "C entaur Lex er Library."
:long "
This is a rudimentary library for creating lexers for character
data in ACL2. It is an outgrowth and revision of lexer support routines that
-were originally developed as part of the @(see vl) library.
+were originally developed as part of the @(see vl::vl) library.
-These routines are based on ACL2 @(see characters). They are, accordingly,
-suitable for processing text in ASCII or ISO-8859-1 or some other 8-bit
-character set, but not Unicode or other wide character sets. It would
-generally be a bad idea to use CLEX to write a lexer for a language like Java
-or XML that needs Unicode support.
+These routines are based on ACL2 @(see acl2::characters). They are,
+accordingly, suitable for processing text in ASCII or ISO-8859-1 or some other
+8-bit character set, but not Unicode or other wide character sets. It
+would generally be a bad idea to use CLEX to write a lexer for a language like
+Java or XML that needs Unicode support.
Many lexical analyzers like Flex
are rather sophisticated and allow you to declare the syntax of your tokens at
@@ -47,8 +48,8 @@
-A stream input mechanism that is somewhat efficient
-and conveniently tracks your position (for good error messages).
+A stream input mechanism that is somewhat
+efficient and conveniently tracks your position (for good error messages).
A @(see defcharset) macro for describing basic character types (e.g.,
whitespace, digits, letters, etc).
diff -Nru acl2-6.2/books/centaur/defrstobj/defrstobj.lisp acl2-6.3/books/centaur/defrstobj/defrstobj.lisp
--- acl2-6.2/books/centaur/defrstobj/defrstobj.lisp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/defrstobj/defrstobj.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -32,10 +32,6 @@
(include-book "array-lemmas")
||#
-(make-event
- (let ((array-lemmas (extend-pathname (cbd) "array-lemmas" state)))
- `(defconst *array-lemmas-book* ',array-lemmas)))
-
(defun-nx non-executable-nth (n x)
;; Used in good-stp below, to get around stobj restrictions
@@ -898,7 +894,7 @@
(logic)
(set-inhibit-warnings "non-rec" "disable" "subsume") ;; implicitly local
(local (set-default-hints nil))
- (local (include-book ,*array-lemmas-book*))
+ (local (include-book "centaur/defrstobj/array-lemmas" :dir :system))
(local (in-theory
(union-theories
(union-theories (theory 'minimal-theory)
diff -Nru acl2-6.2/books/centaur/defrstobj/groundwork/array-rec.lisp acl2-6.3/books/centaur/defrstobj/groundwork/array-rec.lisp
--- acl2-6.2/books/centaur/defrstobj/groundwork/array-rec.lisp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/defrstobj/groundwork/array-rec.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -21,7 +21,7 @@
(in-package "ACL2")
(include-book "misc/records" :dir :system)
(local (include-book "misc/equal-by-g" :dir :system))
-(local (include-book "centaur/misc/equal-by-nths" :dir :system))
+(local (include-book "std/lists/nth" :dir :system))
(local (include-book "local"))
diff -Nru acl2-6.2/books/centaur/defrstobj/typed-records.lisp acl2-6.3/books/centaur/defrstobj/typed-records.lisp
--- acl2-6.2/books/centaur/defrstobj/typed-records.lisp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/defrstobj/typed-records.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -22,7 +22,7 @@
(include-book "misc/total-order" :dir :system)
(include-book "std/lists/mfc-utils" :dir :system)
(include-book "centaur/misc/introduce-var" :dir :system)
-(local (include-book "centaur/misc/equal-by-nths" :dir :system))
+(local (include-book "std/lists/nth" :dir :system))
(local (include-book "array-lemmas"))
(set-verify-guards-eagerness 2)
diff -Nru acl2-6.2/books/centaur/doc.acl2 acl2-6.3/books/centaur/doc.acl2
--- acl2-6.2/books/centaur/doc.acl2 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/doc.acl2 2013-09-30 17:53:15.000000000 +0000
@@ -23,4 +23,6 @@
(ld "vl/package.lsp")
(ld "gl/package.lsp")
; cert-flags: ? t :ttags :all :skip-proofs-okp t
-(certify-book "doc" ? t :ttags :all :skip-proofs-okp t)
+(set-deferred-ttag-notes t state)
+
+
diff -Nru acl2-6.2/books/centaur/doc.lisp acl2-6.3/books/centaur/doc.lisp
--- acl2-6.2/books/centaur/doc.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/doc.lisp 2013-09-30 17:53:15.000000000 +0000
@@ -19,7 +19,7 @@
; Original author: Jared Davis
(in-package "ACL2")
-
+(set-inhibit-warnings "ttags")
(make-event
; Disabling waterfall parallelism because the include-books are too slow with
@@ -27,161 +27,170 @@
; that ACL2(h) memoizes by default (in particular, fchecksum-obj needs to be
; memoized to include centaur/tutorial/alu16-book).
- (if (and (hons-enabledp state)
- (f-get-global 'parallel-execution-enabled state))
+ (if (and (hons-enabledp state)
+ (f-get-global 'parallel-execution-enabled state))
(er-progn (set-waterfall-parallelism nil)
(value '(value-triple nil)))
(value '(value-triple nil))))
+(include-book "misc/memory-mgmt")
+(value-triple (set-max-mem (* 10 (expt 2 30))))
-(include-book "vl/top")
-(include-book "vl/lint/lint")
-(include-book "vl/mlib/clean-concats")
-(include-book "vl/mlib/atts")
-(include-book "vl/transforms/xf-clean-selects")
-(include-book "vl/transforms/xf-propagate")
-(include-book "vl/transforms/xf-expr-simp")
-(include-book "vl/transforms/xf-inline")
+; [Jared]: I suspect the following comment may be out of date? But this
+; seems harmless enough anyway...
+;
+; The following are included automatically by the xdoc::save command below,
+; but we include them explicitly to support the hons `make' target in the
+; books/ directory (and hence the regression-hons `make' target in the
+; acl2-sources directory).
+
+(include-book "xdoc/save-fancy" :dir :system)
+(include-book "xdoc/defxdoc-raw" :dir :system)
+(include-book "xdoc/topics" :dir :system)
-(include-book "aig/aiger")
-(include-book "aig/aig-equivs")
-(include-book "aig/aig-vars")
-(include-book "aig/aig-vars-fast")
-(include-book "aig/base")
-(include-book "aig/bddify")
-(include-book "aig/bddify-correct")
-(include-book "aig/eval-restrict")
-(include-book "aig/g-aig-eval")
-(include-book "aig/induction")
-(include-book "aig/misc")
-(include-book "aig/three-four")
-(include-book "aig/witness")
-(include-book "aig/vuaig")
+(include-book "4v-sexpr/top")
+(include-book "aig/top")
-(include-book "ubdds/lite")
-(include-book "ubdds/param")
+(include-book "aignet/aig-sim")
+(include-book "aignet/copying")
+(include-book "aignet/from-hons-aig-fast")
+(include-book "aignet/prune")
+(include-book "aignet/to-hons-aig")
+(include-book "aignet/types")
+(include-book "aignet/vecsim")
(include-book "bitops/top")
+(include-book "bitops/congruences")
+(include-book "bitops/sign-extend")
+(include-book "bitops/install-bit")
+(include-book "bitops/rotate")
+(include-book "bitops/ash-bounds")
+(include-book "bitops/defaults")
+(include-book "bitops/saturate")
+(include-book "bitops/signed-byte-p")
+
+(include-book "bridge/top")
(include-book "clex/example")
-(include-book "gl/gl")
-(include-book "gl/bfr-aig-bddify")
+(include-book "cgen/top" :dir :system)
-(include-book "4v-sexpr/top")
+(include-book "defrstobj/defrstobj")
(include-book "esim/stv/stv-top")
(include-book "esim/stv/stv-debug")
(include-book "esim/esim-sexpr-correct")
+(include-book "centaur/getopt/top" :dir :system)
+(include-book "centaur/getopt/demo" :dir :system)
+(include-book "centaur/getopt/demo2" :dir :system)
-; The following are included automatically by the xdoc::save command below, but
-; we include them explicitly to support the hons `make' target in the books/
-; directory (and hence the regression-hons `make' target in the acl2-sources
-; directory).
-(include-book "../xdoc-impl/save")
-(include-book "../xdoc/defxdoc-raw")
-(include-book "../xdoc-impl/mkdir-raw")
-(include-book "../xdoc-impl/topics")
-(include-book "../xdoc-impl/extra-packages")
+(include-book "gl/gl")
+(include-book "gl/bfr-aig-bddify")
+(include-book "gl/gl-ttags")
+(include-book "gl/gobject-type-thms")
+(include-book "gl/bfr-satlink")
+(include-book "misc/top")
+(include-book "misc/smm")
+(include-book "misc/tailrec")
(include-book "misc/hons-remove-dups")
(include-book "misc/seed-random")
-(include-book "misc/equal-by-nths")
(include-book "misc/load-stobj")
(include-book "misc/load-stobj-tests")
+(include-book "misc/count-up")
-(include-book "tutorial/intro")
-(include-book "tutorial/alu16-book")
-(include-book "tutorial/counter")
+;; BOZO conflicts with something in 4v-sexpr?
-(include-book "bridge/top")
+;; (include-book "misc/remove-assoc")
+;; (include-book "misc/sparsemap")
+;; (include-book "misc/sparsemap-impl")
+(include-book "misc/stobj-swap")
-(include-book "defrstobj/defrstobj")
+(include-book "oslib/top" :dir :system)
-(include-book "misc/smm")
-(include-book "bitops/install-bit")
-(include-book "bitops/rotate")
-(include-book "misc/tailrec")
+(include-book "regex/regex-ui" :dir :system)
+
+(include-book "regression/common")
+
+(include-book "std/top" :dir :system)
+(include-book "std/lists/resize-list" :dir :system)
+(include-book "std/lists/nth" :dir :system)
+
+(include-book "ubdds/lite")
+(include-book "ubdds/param")
+
+(include-book "vcd/vcd")
+(include-book "vcd/esim-snapshot")
+(include-book "vcd/vcd-stub")
+;; BOZO causes some error with redefinition? Are we loading the right
+;; books above? What does stv-debug load?
+;; (include-book "vcd/vcd-impl")
+
+(include-book "vl/top")
+(include-book "vl/kit/top")
+(include-book "vl/mlib/clean-concats")
+(include-book "vl/mlib/atts")
+(include-book "vl/mlib/json")
+(include-book "vl/transforms/xf-clean-selects")
+(include-book "vl/transforms/xf-propagate")
+(include-book "vl/transforms/xf-expr-simp")
+(include-book "vl/transforms/xf-inline")
(include-book "vl/mlib/sub-counts")
+
+;; BOZO these are incompatible? which is right?
(include-book "vl/util/prefix-hash")
+;;(include-book "vl/util/prefixp")
-(include-book "regex/regex-ui" :dir :system)
+(include-book "vl/checkers/use-set-tool")
+
+;; BOZO uh, incompatible with lint? is this dead?
+;; (include-book "vl/lint/xf-drop-unresolved-submodules")
+(include-book "vl/mlib/lvalues-mentioning")
+(include-book "vl/mlib/rvalues")
+(include-book "vl/mlib/ram-tools")
+
+
+(include-book "hacking/all" :dir :system)
+(include-book "hints/consider-hint" :dir :system)
+(include-book "tools/do-not" :dir :system)
+
+(include-book "tutorial/intro")
+(include-book "tutorial/alu16-book")
+(include-book "tutorial/counter")
-(include-book "countereg-gen/top" :dir :system)
#||
-;; This really doesn't belong here, but I want it out of cutil/top to improve
-;; the critical path. This just tricks the dependency scanner into building these
-;; books.
-(include-book "bitops/congruences")
+;; This is a nice place to put include-book scanner hacks that trick cert.pl
+;; into certifying unit-testing books that don't actually need to be included
+;; anywhere. This just tricks the dependency scanner into building
+;; these books.
+
(include-book "defrstobj/basic-tests")
(include-book "cutil/deflist-tests" :dir :system)
(include-book "cutil/defalist-tests" :dir :system)
(include-book "cutil/defmapappend-tests" :dir :system)
(include-book "cutil/defprojection-tests" :dir :system)
+(include-book "cutil/defredundant-tests" :dir :system)
+(include-book "cutil/tools/assert-return-thms" :dir :system)
+(include-book "centaur/misc/tshell-tests" :dir :system)
-;; Here is more tricking of the dependency scanner, to avoid leaving out books
-;; under books/centaur/ from the certification process invoked by running 'make
-;; regression-hons' from the acl2-sources directory. Note that at least one of
-;; these can't be moved to outside this comment: defrstobj/groundwork/demo1
-;; gives a conflicting definition of a stobj, st.
-
-(include-book "bitops/sign-extend")
(include-book "defrstobj/groundwork/demo1")
(include-book "defrstobj/groundwork/demo2")
(include-book "defrstobj/groundwork/demo3")
(include-book "defrstobj/groundwork/demo4")
(include-book "defrstobj/groundwork/demo5")
-(include-book "misc/top")
-(include-book "ubdds/sanity-check-macros")
-(include-book "vl/checkers/use-set-tool")
-(include-book "vl/lint/xf-drop-unresolved-submodules")
-(include-book "vl/mlib/lvalues-mentioning")
-(include-book "vl/mlib/rvalues")
-(include-book "vl/util/prefixp")
-; Another useful book:
-(include-book "gl/bfr-satlink")
-
-; Let's just put down the rest of the books that were discovered missing on
-; 5/10/2013, when we certified with the legacy makefile (books/Makefile.legacy)
-; instead of the new makefile (books/Makefile).
+(include-book "ubdds/sanity-check-macros")
-(include-book "aig/best-aig")
-(include-book "aignet/aig-sim")
-(include-book "aignet/copying")
-(include-book "aignet/from-hons-aig-fast")
-(include-book "aignet/prune")
-(include-book "aignet/to-hons-aig")
-(include-book "aignet/types")
-(include-book "aignet/vecsim")
-(include-book "aig/random-sim")
-(include-book "bitops/ash-bounds")
-(include-book "bitops/defaults")
-(include-book "bitops/saturate")
-(include-book "bitops/signed-byte-p")
-(include-book "gl/gl-ttags")
-(include-book "gl/gobject-type-thms")
-(include-book "misc/count-up")
-(include-book "misc/memory-mgmt")
-(include-book "misc/remove-assoc")
-(include-book "misc/resize-list")
-(include-book "misc/sparsemap")
-(include-book "misc/sparsemap-impl")
-(include-book "misc/stobj-swap")
-(include-book "vcd/esim-snapshot")
-(include-book "vcd/vcd")
-(include-book "vcd/vcd-impl")
-(include-book "vcd/vcd-stub")
-(include-book "vl/mlib/ram-tools")
+;; BOZO why do we care about coi/records/fast?
(include-book "../coi/records/fast/log2")
(include-book "../coi/records/fast/memory")
(include-book "../coi/records/fast/memory-impl")
(include-book "../coi/records/fast/memtree")
(include-book "../coi/records/fast/private")
-(include-book "../cutil/tools/assert-return-thms")
+
(include-book "../memoize/old/case")
(include-book "../memoize/old/profile")
(include-book "../memoize/old/watch")
@@ -191,10 +200,488 @@
||#
+; Historically we had a completely ad-hoc organization that grew organically as
+; topics were added. This turned out to be a complete mess. To make the
+; manual more approachable and relevant, we now try to impose a better
+; hierarchy and add some context.
+
+(local
+ (defxdoc acl2::top
+
+; The TOP topic will be the first thing the user sees when they open the
+; manual! We localize this because you may want to write your own top topics
+; for custom manuals.
+
+ :short "User manual for the ACL2 Theorem Prover and
+the ACL2 Community Books "
+
+ :long "Introduction
+
+ACL2 is an
+interactive theorem prover. It combines a Lisp-based programming language for
+developing formal models of systems with a reasoning engine that can prove
+properties about these models. It has been used to formally verify
+many interesting systems in
+academia and industry.
+
+The ACL2 Community Books are
+the canonical set of open-source libraries (\"@(see books)\") for ACL2. They
+include lemma libraries for reasoning in many domains, macro libraries for more
+quickly writing and documenting code, interfacing tools for connecting ACL2 to
+other systems, productivity tools for better proof automation and debugging,
+and specialty libraries for areas like @(see hardware-verification).
+
+This user manual covers both ACL2 and the Community Books. It is derived by
+combining the classic @(see doc-string)s found in the ACL2 source code and some
+books with the @(see xdoc) topics found in other books. Besides just importing
+the documentation, we also rearrange the topic hierarchy to try to improve its
+organization.
+
+This manual is very much a work in progress. If you would like to
+contribute to its development, please join the acl2-books project!
"))
+
+(defsection arithmetic
+ :parents (top)
+ :short "Libraries for reasoning about basic arithmetic, bit-vector
+arithmetic, modular arithmetic, etc.")
+
+(defsection boolean-reasoning
+ :parents (top)
+ :short "Libraries related to representing and processing Boolean functions,
+geared toward large-scale automatic reasoning, e.g., via SAT solving and AIG or
+BDD packages."
+
+ :long "Introduction
+
+Boolean
+functions are widely useful throughout mathematical logic, computer
+science, and computer engineering. In formal verification, they are especially
+interesting because many high-capacity, fully automatic techniques are known
+for analyzing, comparing, and simplifying them; for instance, see binary decision
+diagrams (bdds), SAT
+solvers , and-inverter
+graphs (aigs), model
+checking , equivalence
+checking , and so forth.
+
+Libraries for Boolean Functions
+
+We have developed some libraries for working with Boolean functions, for
+instance:
+
+
+
+@(see satlink) provides a representation of conjunctive normal
+form formulas and a way to call SAT solvers from ACL2 and trust their
+results.
+
+Libraries like @(see aig) and @(see ubdds) provide @(see hons)-based AIG and
+BDD packages.
+
+@(see aignet) provides a more efficient, @(see stobj)-based AIG
+representation similar to that used by ABC .
+
+
+
+These libraries are important groundwork for the @(see gl) framework for
+bit-blasting ACL2 theorems, and may be of interest to anyone who is trying to
+develop new, automatic tools or proof techniques.
+
+Libraries for Four-Valued Logic
+
+Being able to process large-scale Boolean functions is especially important
+in @(see hardware-verification). But actually, here, to model certain circuits
+and to implement certain algorithms, it can be useful to go beyond Boolean
+functions and consider a richer logic.
+
+You might call Boolean functions or Boolean logic a two-valued logic, since
+there are just two values (true and false) that any variable can take. It is
+often useful to add a third value, usually called X, to represent an
+\"unknown\" value. In some systems, a fourth value, Z, is added to represent
+an undriven wire. For more on this, see @(see why-4v-logic).
+
+We have developed two libraries to support working in four-valued logic. Of
+these, the @(see 4v) library is somewhat higher level and is generally simpler
+and more convenient to work with. It serves as the basis of the @(see esim)
+hardware simulator. Meanwhile, the @(see faig) library is a bit lower-level
+and does not enjoy the very nice @(see 4v-monotonicity) property of @(see
+4v-sexprs). On the other hand, @(see faig)s are closer to @(see aig)s, and can
+be useful for loading expressions into @(see aignet) or @(see satlink).
+
+Related Papers
+
+Besides the documentation here, you may find the following papers
+useful:
+
+Jared Davis and Sol Swords. Verified AIG Algorithms in
+ACL2. In ACL2 Workshop 2013. May, 2013. EPTCS 114. Pages 95-110.
+
+Sol Swords and Jared Davis. Bit-Blasting ACL2 Theorems .
+In ACL2 Workshop 2011. November, 2011. EPTCS 70. Pages 84-102.
+
+Sol Swords and Warren A Hunt, Jr. A Mechanically Verified
+AIG to BDD Conversion Algorithm . In ITP 2010,LNCS 6172, Springer. Pages
+435-449.
")
+
+(defsection macro-libraries
+ :parents (top macros)
+ :short "Generally useful macros for writing more concise code, and frameworks
+for quickly introducing concepts like typed structures, typed lists, defining
+functions with type signatures, and automating other common tasks.")
+
+(defsection hardware-verification
+ :parents (top)
+ :short "Libraries for working with hardware description languages, modeling
+circuits, etc.")
+
+(defsection proof-automation
+ :parents (top)
+ :short "Tools, utilities, and strategies for dealing with particular kinds
+of proofs.")
+
+(defsection interfacing-tools
+ :parents (top)
+ :short "Libraries and tools for doing basic file
+i/o , using raw Common Lisp libraries ,
+working with the operating system , and
+interfacing with other programs .")
+
+(defsection debugging
+ :parents (top)
+ :short "Tools for debugging failed or slow proofs, or misbehaving
+functions.")
+
+(defsection macros
+ :parents (acl2)
+ :short "Macros allow you to extend the syntax of ACL2.")
+
+
+
+; Huge stupid hack. Topics that are documented with the old :DOC system can't
+; have XDOC topics for their parents. So, get them all loaded and converted
+; into proper XDOC topics, then move them around where we want them.
+
+
+(local (xdoc::import-acl2doc))
+
+#!XDOC
+(defun change-parents-fn (name new-parents all-topics)
+ (declare (xargs :mode :program))
+ (b* (((when (atom all-topics))
+ (er hard? 'change-parents-fn "Topic ~x0 was not found." name))
+ (topic (car all-topics))
+ ((unless (equal (cdr (assoc :name topic)) name))
+ (cons (car all-topics)
+ (change-parents-fn name new-parents (cdr all-topics))))
+ (topic (cons (cons :parents new-parents)
+ (delete-assoc-equal :parents topic))))
+ (cons topic (cdr all-topics))))
+
+#!XDOC
+(defmacro change-parents (name new-parents)
+ `(table xdoc 'doc
+ (change-parents-fn ',name ',new-parents
+ (get-xdoc-table world))))
+
+
+(defmacro xdoc::fix-the-hierarchy ()
+ ;; I make this a macro so I can reuse it in Centaur internal manuals.
+ `(progn
+ (xdoc::change-parents ihs (arithmetic))
+
+ (xdoc::change-parents b* (macro-libraries))
+ (xdoc::change-parents data-definitions (macro-libraries))
+ (xdoc::change-parents data-structures (macro-libraries))
+
+ (xdoc::change-parents io (interfacing-tools))
+ (xdoc::change-parents hacker (interfacing-tools))
+
+ (xdoc::change-parents witness-cp (proof-automation))
+ (xdoc::change-parents esim (hardware-verification))
+
+ (xdoc::change-parents testing (debugging))
+
+;; So I got started on that, and decided to move around a whole bunch of ACL2
+;; doc topics. Much of this would probably make more sense to do in ACL2 itself.
+
+ (xdoc::change-parents copyright (about-acl2))
+ (xdoc::change-parents version (about-acl2))
+ (xdoc::change-parents release-notes (about-acl2))
+ (xdoc::change-parents bibliography (about-acl2))
+ (xdoc::change-parents acknowledgments (about-acl2))
+ (xdoc::change-parents acl2-help (about-acl2))
+
+ (xdoc::change-parents nqthm-to-acl2 (acl2-tutorial))
+
+ (xdoc::change-parents exit (good-bye))
+ (xdoc::change-parents quit (good-bye))
+
+ (xdoc::change-parents |Pages Written Especially for the Tours| (acl2-tutorial))
+
+ (xdoc::change-parents introduction-to-the-tau-system (tau-system))
+ (xdoc::change-parents tau-data (tau-system))
+ (xdoc::change-parents tau-database (tau-system))
+
+ (xdoc::change-parents wof (io))
+ (xdoc::change-parents serialize (io))
+
+ (xdoc::change-parents guard-obligation (guard))
+ (xdoc::change-parents guard-debug (guard debugging))
+ (xdoc::change-parents verify-guards-formula (guard))
+ (xdoc::change-parents print-gv (guard debugging))
+ (xdoc::change-parents walkabout (debugging))
+ (xdoc::change-parents trace (debugging))
+ (xdoc::change-parents time-tracker (debugging))
+ (xdoc::change-parents disassemble$ (debugging))
+ (xdoc::change-parents splitter (debugging))
+ (xdoc::change-parents splitter-output (splitter))
+ (xdoc::change-parents immed-forced (splitter))
+ (xdoc::change-parents if-intro (splitter))
+ (xdoc::change-parents proof-checker (debugging))
+ (xdoc::change-parents proof-tree (debugging))
+ (xdoc::change-parents pstack (debugging))
+ (xdoc::change-parents forward-chaining-reports (debugging))
+ (xdoc::change-parents accumulated-persistence (debugging))
+ (xdoc::change-parents set-accumulated-persistence (accumulated-persistence))
+ (xdoc::change-parents show-accumulated-persistence (accumulated-persistence))
+ (xdoc::change-parents dmr (debugging))
+ (xdoc::change-parents dynamically-monitor-rewrites (dmr))
+ (xdoc::change-parents break-rewrite (debugging))
+ (xdoc::change-parents why-brr (break-rewrite))
+ (xdoc::change-parents cw-gstack (break-rewrite))
+
+ (xdoc::change-parents default-hints (hints))
+ (xdoc::change-parents override-hints (hints))
+ (xdoc::change-parents hints-and-the-waterfall (hints))
+ (xdoc::change-parents lemma-instance (hints))
+ (xdoc::change-parents induct (hints))
+ (xdoc::change-parents hands-off (hints))
+ (xdoc::change-parents expand (hints))
+ (xdoc::change-parents nonlinearp (hints linear-arithmetic))
+ (xdoc::change-parents no-thanks (hints))
+ (xdoc::change-parents backchain-limit-rw (hints))
+ (xdoc::change-parents backtrack (hints))
+ (xdoc::change-parents consideration (hints))
+ (xdoc::change-parents restrict (hints))
+ (xdoc::change-parents reorder (hints))
+ (xdoc::change-parents use (hints))
+ (xdoc::change-parents by (hints))
+ (xdoc::change-parents do-not (hints))
+ (xdoc::change-parents do-not-hint (hints))
+ (xdoc::change-parents do-not-induct (hints))
+ (xdoc::change-parents goal-spec (hints))
+ (xdoc::change-parents clause-identifier (goal-spec))
+
+
+ (xdoc::change-parents otf-flg (defthm thm xargs))
+
+ (xdoc::change-parents package-reincarnation-import-restrictions
+ (defpkg))
+
+ (xdoc::change-parents print-doc-start-column (documentation))
+ (xdoc::change-parents proof-supporters-alist (dead-events))
+
+ (xdoc::change-parents cases (hints))
+ (xdoc::change-parents custom-keyword-hints (hints))
+ (xdoc::change-parents computed-hints (hints))
+ (xdoc::change-parents using-computed-hints (computed-hints))
+ (xdoc::change-parents using-computed-hints-1 (computed-hints))
+ (xdoc::change-parents using-computed-hints-2 (computed-hints))
+ (xdoc::change-parents using-computed-hints-3 (computed-hints))
+ (xdoc::change-parents using-computed-hints-4 (computed-hints))
+ (xdoc::change-parents using-computed-hints-5 (computed-hints))
+ (xdoc::change-parents using-computed-hints-6 (computed-hints))
+ (xdoc::change-parents using-computed-hints-7 (computed-hints))
+ (xdoc::change-parents using-computed-hints-8 (computed-hints))
+
+ (xdoc::change-parents forced (force))
+ (xdoc::change-parents forcing-round (force))
+ (xdoc::change-parents enable-forcing (force))
+ (xdoc::change-parents disable-forcing (force))
+ (xdoc::change-parents immediate-force-modep (force))
+ (xdoc::change-parents enable-immediate-force-modep (force))
+ (xdoc::change-parents disable-immediate-force-modep (force))
+ (xdoc::change-parents failed-forcing (force))
+
+ (xdoc::change-parents lambda (term))
+
+ (xdoc::change-parents loop-stopper (rewrite))
+
+ (xdoc::change-parents lp (ld))
+ (xdoc::change-parents reset-ld-specials (ld))
+ (xdoc::change-parents keyword-commands (ld))
+ (xdoc::change-parents ld-error-action (ld))
+ (xdoc::change-parents ld-error-triples (ld))
+ (xdoc::change-parents ld-evisc-tuple (ld))
+ (xdoc::change-parents ld-keyword-aliases (ld))
+ (xdoc::change-parents ld-missing-input-ok (ld))
+ (xdoc::change-parents ld-post-eval-print (ld))
+ (xdoc::change-parents ld-pre-eval-filter (ld))
+ (xdoc::change-parents ld-pre-eval-print (ld))
+ (xdoc::change-parents ld-prompt (ld))
+ (xdoc::change-parents ld-query-control-alist (ld))
+ (xdoc::change-parents ld-redefinition-action (ld))
+ (xdoc::change-parents ld-skip-proofsp (ld))
+ (xdoc::change-parents ld-verbose (ld))
+ (xdoc::change-parents prompt (ld))
+ (xdoc::change-parents p! (ld))
+ (xdoc::change-parents a! (ld))
+ (xdoc::change-parents abort! (ld))
+ (xdoc::change-parents default-print-prompt (ld))
+ (xdoc::change-parents redef (ld))
+ (xdoc::change-parents redef- (ld))
+ (xdoc::change-parents redef+ (ld))
+ (xdoc::change-parents redef! (ld))
+
+ (xdoc::change-parents ignorable (declare))
+ (xdoc::change-parents ignore (declare))
+ (xdoc::change-parents optimize (declare))
+ (xdoc::change-parents type (declare))
+
+
+ (xdoc::change-parents xargs (defun))
+ (xdoc::change-parents measure (xargs))
+ (xdoc::change-parents guard-hints (xargs))
+ (xdoc::change-parents mode (xargs))
+ (xdoc::change-parents non-executable (xargs))
+ (xdoc::change-parents normalize (xargs))
+ (xdoc::change-parents stobjs (xargs))
+
+ (xdoc::change-parents stobj (programming))
+ (xdoc::change-parents defabsstobj (stobj events))
+ (xdoc::change-parents single-threaded-objects (stobj))
+
+
+ (xdoc::change-parents obdd (bdd))
+
+ (xdoc::change-parents defund (defun))
+ (xdoc::change-parents defun-inline (defun))
+ (xdoc::change-parents defund-inline (defun))
+ (xdoc::change-parents defun-notinline (defun))
+ (xdoc::change-parents defund-notinline (defun))
+ (xdoc::change-parents defun-nx (defun))
+ (xdoc::change-parents defun-mode (defun))
+
+
+ (xdoc::change-parents defabbrev (macros))
+ (xdoc::change-parents macro-args (macros))
+ (xdoc::change-parents &allow-other-keys (macro-args))
+ (xdoc::change-parents &body (macro-args))
+ (xdoc::change-parents &key (macro-args))
+ (xdoc::change-parents &optional (macro-args))
+ (xdoc::change-parents &rest (macro-args))
+ (xdoc::change-parents &whole (macro-args))
+ (xdoc::change-parents trans (macros))
+ (xdoc::change-parents trans1 (macros))
+ (xdoc::change-parents trans! (macros))
+ (xdoc::change-parents defmacro (macros events))
+ (xdoc::change-parents make-event (macros events))
+ (xdoc::change-parents untranslate-patterns (macros user-defined-functions-table))
+ (xdoc::change-parents add-macro-alias (macros switches-parameters-and-modes))
+ (xdoc::change-parents add-macro-fn (macros switches-parameters-and-modes))
+ (xdoc::change-parents macro-aliases-table (macros switches-parameters-and-modes))
+ (xdoc::change-parents remove-binop (macros switches-parameters-and-modes))
+ (xdoc::change-parents remove-macro-alias (macros switches-parameters-and-modes))
+ (xdoc::change-parents remove-macro-fn (macros switches-parameters-and-modes))
+ (xdoc::change-parents untrans-table (macros switches-parameters-and-modes))
+ (xdoc::change-parents user-defined-functions-table (macros switches-parameters-and-modes))
+
+
+
+
+ (xdoc::change-parents apropos (docs))
+
+ (xdoc::change-parents certify-book! (certify-book))
+
+ (xdoc::change-parents save-exec (interfacing-tools))
+
+ (xdoc::change-parents wormhole-data (wormhole))
+ (xdoc::change-parents wormhole-entry-code (wormhole))
+ (xdoc::change-parents wormhole-eval (wormhole))
+ (xdoc::change-parents wormhole-implementation (wormhole))
+ (xdoc::change-parents wormhole-p (wormhole))
+ (xdoc::change-parents wormhole-statusp (wormhole))
+ (xdoc::change-parents make-wormhole-status (wormhole))
+ (xdoc::change-parents get-wormhole-status (wormhole))
+ (xdoc::change-parents set-wormhole-entry-code (wormhole))
+ (xdoc::change-parents set-wormhole-data (wormhole))
+
+ (xdoc::change-parents show-bodies (definition))
+ (xdoc::change-parents set-body (events definition))
+
+ (xdoc::change-parents the-method (acl2-tutorial))
+
+ (xdoc::change-parents proof-of-well-foundedness (ordinals))
+ (xdoc::change-parents o< (ordinals))
+ (xdoc::change-parents o-p (ordinals))
+
+ (xdoc::change-parents keyword (keywordp))))
+
+(local (xdoc::fix-the-hierarchy))
+
+(local (deflabel doc-rebuild-label))
+
+(make-event
+ (b* ((state (serialize-write "xdoc.sao"
+ (xdoc::get-xdoc-table (w state))
+ :verbosep t)))
+ (value '(value-triple "xdoc.sao"))))
+
(make-event
; xdoc::save is an event, so we might have just called it directly. But for
; reasons Jared doesn't understand this is screwing up the extended manual we
; build at Centaur. So, I'm putting the save event into a make-event to try
; to localize its effects to just this book's certification.
- (er-progn (xdoc::save "./manual")
- (value `(value-triple :manual))))
+ (er-progn (xdoc::save "./manual"
+ ;; Don't import again since we just imported.
+ :import nil
+ ;; For classic mode only...
+ :expand-level 2)
+ (value `(value-triple :manual))))
+
+(local
+ (defmacro doc-rebuild ()
+
+; It is sometimes useful to make tweaks to the documentation and then quickly
+; be able to see your changes. This macro can be used to do this, as follows:
+;
+; SETUP:
+;
+; (ld "doc.lisp") ;; slow, takes a few minutes to get all the books loaded
+;
+; DEVELOPMENT LOOP: {
+;
+; 1. make documentation changes in new-doc.lsp; e.g., you can add new topics
+; there with defxdoc, or use commands like change-parents, etc.
+;
+; 2. type (doc-rebuild) to rebuild the manual with your changes; this only
+; takes 20-30 seconds
+;
+; 3. view your changes, make further edits
+;
+; }
+;
+; Finally, move your changes out of new-doc.lsp and integrate them properly
+; into the other sources, and do a proper build.
+
+ `(er-progn
+ (ubt! 'doc-rebuild-label)
+ (ld ;; newline to fool dependency scanner
+ "new-doc.lsp")
+ (make-event
+ (er-progn (xdoc::save "./manual"
+ :import nil
+ :expand-level 2)
+ (value `(value-triple :manual)))))))
diff -Nru acl2-6.2/books/centaur/esim/esim-cut.lisp acl2-6.3/books/centaur/esim/esim-cut.lisp
--- acl2-6.2/books/centaur/esim/esim-cut.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/esim/esim-cut.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,360 @@
+; ESIM Symbolic Hardware Simulator
+; Copyright (C) 2010-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+
+
+; esim-cut.lisp -- transform to cut wires in E modules
+;
+; Original authors: Jared Davis
+; Sol Swords
+
+(in-package "ACL2")
+(include-book "esim-primitives")
+(include-book "esim-paths")
+(local (include-book "esim-sexpr-support-thms"))
+(include-book "cutil/define" :dir :system)
+(include-book "cutil/defaggregate" :dir :system)
+(include-book "cutil/defprojection" :dir :system)
+(include-book "cutil/defalist" :dir :system)
+(include-book "cutil/defmapappend" :dir :system)
+(include-book "centaur/vl/toe/toe-emodwire" :dir :system)
+
+#||
+(include-book
+ "tools/defconsts" :dir :system)
+(defconsts (*esims* state)
+ (serialize-read "/n/fv2/translations/nightly/cnr/esims.sao"
+ :verbosep t))
+||#
+
+
+; We always cut only internal or output wires (it's an error to try to cut
+; an input wire.)
+;
+; Say we are cutting the wire W.
+; We need to:
+;
+; - Change whatever occ is driving W, and make it drive W instead
+;
+; - Insert two clockless flip-flops:
+;
+; The input here isn't really very important, but it gives us an easy
+; way to pull out the original value if we want it. The output is only
+; relevant if we're going to override the wire, and in that case, it
+; contains the value we're overriding it with.
+;
+; fsm_reg W (.in(W),
+; .out(W))
+;
+; This one just controls whether we're overriding W at all.
+;
+; fsm_reg W (.in(0), .out(W))
+;
+; - Insert a ZIF mux: If we're overriding, it chooses the override value we
+; want to use (a), otherwise it chooses the original value (b).
+;
+; zif_mux W (.sel(W),
+; .a(W),
+; .b(W),
+; .o(W))
+;
+; - Done. Check for name conflicts?
+
+
+; Our core transform will do this for a list of paths into some module. At any
+; point, some of these paths may be terminal.
+
+(cutil::defaggregate ecutnames
+ ((original symbolp :rule-classes :type-prescription)
+ (value symbolp :rule-classes :type-prescription)
+ (value-reg symbolp :rule-classes :type-prescription)
+ (decision-wire symbolp :rule-classes :type-prescription)
+ (decision-reg symbolp :rule-classes :type-prescription)
+ (mux symbolp :rule-classes :type-prescription)
+ ))
+
+(cutil::deflist ecutname-list-p (x)
+ (ecutnames-p x)
+ :guard t)
+
+(define ecutnames->flat-names ((x ecutnames-p))
+ (b* (((ecutnames x) x))
+ (list x.original
+ x.value
+ x.value-reg
+ x.decision-wire
+ x.decision-reg
+ x.mux)))
+
+(cutil::defmapappend ecutname-list->flat-names (x)
+ (ecutnames->flat-names x)
+ :guard (ecutname-list-p x))
+
+(define ecut-make-sym ((x symbolp)
+ (suffix stringp))
+ :returns (name symbolp)
+ ;; We originally tried not to bother to use any emodwire stuff here. That
+ ;; worked fine for most stuff (stv definition, running, etc.) But the VCD
+ ;; generation stuff relies on emodwires (for good reason, e.g., to bundle
+ ;; together wires). So, now, try to make sure our names are good emodwires,
+ ;; if they were originally.
+ (b* (((unless (vl::vl-emodwire-p x))
+ (intern-in-package-of-symbol
+ (str::cat (symbol-name x) suffix)
+ x))
+ (basename (vl::vl-emodwire->basename x))
+ (index (vl::vl-emodwire->index x))
+ (new-name (str::cat basename suffix))
+ ((when (equal new-name "NIL"))
+ ;; Stupidity, too hard...
+ (raise "This will never happen.")))
+ (vl::vl-emodwire new-name index)))
+
+(define ecut-wire-names ((x symbolp))
+ :returns (names ecutnames-p)
+ (make-ecutnames
+ :original (ecut-make-sym x "")
+ :value (ecut-make-sym x "")
+ :value-reg (ecut-make-sym x "")
+ :decision-wire (ecut-make-sym x "")
+ :decision-reg (ecut-make-sym x "")
+ :mux (ecut-make-sym x "")))
+
+(cutil::defprojection ecut-wire-list-names (x)
+ (ecut-wire-names x)
+ :guard (symbol-listp x)
+ :result-type ecutname-list-p)
+
+
+(cutil::defalist ecut-wirename-alistp (x)
+ :key (symbolp x)
+ :val (ecutnames-p x)
+ :keyp-of-nil t
+ :valp-of-nil nil)
+
+(define ecut-names-alist ((wires symbol-listp))
+ :returns (alist ecut-wirename-alistp :hyp :guard)
+ (pairlis$ wires
+ (ecut-wire-list-names wires)))
+
+(define ecut-update-output-pattern (pat
+ (name-fal ecut-wirename-alistp))
+ (if pat
+ (if (atom pat)
+ (b* ((look (hons-get pat name-fal))
+ ((unless look) pat))
+ (ecutnames->original (cdr look)))
+ (cons (ecut-update-output-pattern (car pat) name-fal)
+ (ecut-update-output-pattern (cdr pat) name-fal)))
+ nil))
+
+(define ecut-update-drivers (occs
+ (name-fal ecut-wirename-alistp))
+ (if (atom occs)
+ nil
+ (cons (chgpl :o (ecut-update-output-pattern (gpl :o (car occs))
+ name-fal)
+ (car occs))
+ (ecut-update-drivers (cdr occs) name-fal))))
+
+(define ecut-add-override-occs-1 ((wire symbolp "The original wire name")
+ (names ecutnames-p "Names to use"))
+ :returns occs
+ (b* (((ecutnames x) names)
+
+ (value-occ
+ ;; W (.in(W),
+ ;; .out(W))
+ (list :u x.value-reg
+ :op *esim-fsmreg*
+ :i `((,x.original))
+ :o `((,x.value))))
+
+ (decision-occ
+ ;; W (.in(0),
+ ;; .out(W))
+ (list :u x.decision-reg
+ :op *esim-fsmreg*
+ :i `((acl2::f))
+ :o `((,x.decision-wire))))
+
+ (mux-occ
+ ;; W (.sel(W),
+ ;; .a(W),
+ ;; .b(W),
+ ;; .o(W))
+ (list :u x.mux
+ :op *esim-zif*
+ :i `((,x.decision-wire) ;; sel
+ (,x.value) ;; a
+ (,x.original)) ;; b
+ :o `((,wire)))))
+ (list value-occ decision-occ mux-occ)))
+
+(define ecut-add-override-occs ((name-fal ecut-wirename-alistp))
+ :returns occs
+ (if (atom name-fal)
+ nil
+ (append (ecut-add-override-occs-1 (caar name-fal)
+ (cdar name-fal))
+ (ecut-add-override-occs (cdr name-fal)))))
+
+(local (defthm l0
+ (implies (ecut-wirename-alistp x)
+ (ECUTNAME-LIST-P (ALIST-VALS x)))
+ :hints(("Goal" :induct (len x)))))
+
+(define find-f-driver (occs)
+ (if (atom occs)
+ nil
+ (if (member-of-pat-flatten 'f (gpl :o (car occs)))
+ (car occs)
+ (find-f-driver (cdr occs)))))
+
+(defconst *ecut-f-driver-occ*
+ (list :o '((f))
+ :u 'ecut-f-driver-occ
+ :op *esim-f*))
+
+(define ecut-make-sure-f-is-driven-to-false (mod)
+ (b* ((driver (find-f-driver (gpl :occs mod)))
+ ((when driver)
+ (if (equal (gpl :op driver) *esim-f*)
+ mod
+ (raise "F is driven by something other than *esim-f*!"))))
+ (chgpl :occs (cons *ecut-f-driver-occ* (gpl :occs mod))
+ mod)))
+
+(define ecut-wires-in-module
+ ((wire-list "A plain list of wires that should exist in this module.")
+ (mod "The E module to transform."))
+ (b* (((when (atom wire-list))
+ mod)
+ (modname (gpl :n mod))
+ ((unless modname)
+ (raise "Expected a name on module ~x0." mod))
+ ((unless (symbol-listp wire-list))
+ (raise "Expected cut wire names to be symbols in ~x0" modname))
+ ((when (gpl :x mod))
+ (raise "In module ~x0: Can't cut wires in primitive module." modname))
+
+ (ins (pat-flatten1 (gpl :i mod)))
+ (occs (gpl :occs mod))
+ (driven (collect-signal-list :o occs))
+ (instnames (collect-signal-list :u occs)) ;; ugh
+
+ (has-inputs (hons-intersection ins wire-list))
+ ((when has-inputs)
+ (raise "In module ~x0: Can't cut input wires, such as ~x1~%"
+ modname has-inputs))
+
+ ((unless (hons-subset wire-list driven))
+ (raise "In module ~x0: trying to cut nonexistent wires: ~x1."
+ modname (hons-set-diff wire-list driven)))
+
+ (wire-dups (duplicated-members wire-list))
+ ((when wire-dups)
+ (raise "In module ~x0: told to cut multiple occurrences of ~x1"
+ modname wire-dups))
+
+ (mod (ecut-make-sure-f-is-driven-to-false mod))
+
+ (name-fal (ecut-names-alist wire-list))
+ ((with-fast name-fal))
+
+ (all-new-names (ecutname-list->flat-names (alist-vals name-fal)))
+ (all-old-names (hons-remove-duplicates (append ins driven instnames)))
+ (dups (duplicated-members (append all-new-names all-old-names)))
+ ((when dups)
+ (raise "Name clashes in ~x0: ~x1" modname dups))
+
+ (occs (ecut-update-drivers (gpl :occs mod) name-fal))
+ (occs (append (ecut-add-override-occs name-fal) occs)))
+ (chgpl :occs occs mod)))
+
+(define ecut-bind-paths (x atoms-acc subs-acc)
+ ;; Sort paths x into atoms (cuts for the current module) and submodule paths,
+ ;; and further sort the submodule paths into an alist by the immediate
+ ;; submodule name.
+ (b* (((when (atom x))
+ (mv atoms-acc subs-acc))
+ ((when (atom (car x)))
+ (ecut-bind-paths (cdr x) (cons (car x) atoms-acc) subs-acc))
+ (occname (caar x))
+ (occ-paths (cdr (hons-get occname subs-acc)))
+ (subs-acc (hons-acons occname (cons (cdar x) occ-paths) subs-acc)))
+ (ecut-bind-paths (cdr x) atoms-acc subs-acc)))
+
+(mutual-recursion
+ (defun ecut-module (paths x)
+ (declare (xargs :guard t
+ :well-founded-relation nat-list-<
+ :measure (list (acl2-count x) 2)))
+ (b* (((when (atom paths)) x)
+ ((mv atoms subpaths) (ecut-bind-paths paths nil nil))
+ (occs (ecut-occs subpaths (gpl :occs x)))
+ (- (fast-alist-free subpaths))
+ (x (chgpl :occs occs x)))
+ (ecut-wires-in-module atoms x)))
+ (defun ecut-occs (subpaths occs)
+ (declare (xargs :guard t
+ :measure (list (acl2-count occs) 1)))
+ (if (atom occs)
+ nil
+ (cons (ecut-occ subpaths (car occs))
+ (ecut-occs subpaths (cdr occs)))))
+ (defun ecut-occ (subpaths occ)
+ (declare (xargs :guard t
+ :measure (list (acl2-count occ) 3)))
+ (b* ((instname (gpl :u occ))
+ (paths (cdr (hons-get instname subpaths)))
+ ((when (atom paths)) occ))
+ (chgpl :op (ecut-module paths (gpl :op occ))
+ occ))))
+
+
+#||
+
+(defun find-module (name x)
+ (if (atom x)
+ nil
+ (if (equal (gpl :n (car x)) name)
+ (car x)
+ (find-module name (Cdr x)))))
+
+(defconst *decode16*
+ (find-module '|*decode16*| *esims*))
+
+
+
+
+(good-esim-modulep (ecut-module '(|dout[3]|) *decode16*))
+(bad-esim-modulep (ecut-module '(|dout[3]|) *decode16*))
+
+(include-book
+ "esim-sexpr")
+
+(esim-sexpr-general-nst (ecut-module '(|dout[3]|) *decode16*))
+(esim-sexpr-general-out (ecut-module '(|dout[3]|) *decode16*))
+
+(defconst *m*
+ (find-module '|*rmux2regi_en$width=1*| *esims*))
+
+(ecut-module '((|r1| . |q|)) *m*)
+(good-esim-modulep (ecut-module '((|r1| . |q[0]|)) *m*))
+
+||#
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/esim/esim-primitives.lisp acl2-6.3/books/centaur/esim/esim-primitives.lisp
--- acl2-6.2/books/centaur/esim/esim-primitives.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/esim-primitives.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -220,6 +220,23 @@
:x (:out ((|q| . (ite |clk| |d| s)))
:nst ((s . (ite |clk| |d| s)))))
+(def-esim-primitive *esim-fsmreg*
+ :short "Primitive E module for an unclocked register."
+ :long "This is an FSM-style register that always updates its state bit to
+its input value at each step.
"
+ :i ((|d|))
+ :o ((|q|))
+ :x (:out ((|q| . s))
+ :nst ((s . |d|))))
+
+(def-esim-primitive *esim-zif*
+ :short "Primitive E module for a kind of pass-gate style mux."
+ :long "This is a special kind of mux that can preserve Z values on its
+inputs, used to support experimental esim decomposition.
"
+ :i ((|sel|) (|a|) (|b|))
+ :o ((|o|))
+ :x (:out ((|o| . (zif |sel| |a| |b|)))))
+
(defsection *esim-primitives*
:parents (esim-primitives)
:short "A list of all esim primitives."
@@ -244,5 +261,7 @@
;; *esim-res*
*esim-tri*
*esim-flop*
- *esim-latch*)))
+ *esim-latch*
+ *esim-fsmreg*
+ *esim-zif*)))
diff -Nru acl2-6.2/books/centaur/esim/esim-sexpr-correct.lisp acl2-6.3/books/centaur/esim/esim-sexpr-correct.lisp
--- acl2-6.2/books/centaur/esim/esim-sexpr-correct.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/esim-sexpr-correct.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -1192,7 +1192,7 @@
keys-equiv-when-alist-keys
(:type-prescription 4v-fix$inline)
4v-sexpr-eval
- alist-equiv-append-atom
+ ;alist-equiv-append-atom
esim-fixpoint-p-occs
4v-fix))
:expand ((esim-fixpoint-p-occs mod occs (append fixpoint env) env)
@@ -1280,7 +1280,7 @@
(implies (member-equal occ occs)
(subsetp-equal (pat-flatten1 (gpl k (esim-get-occ occ mod)))
(collect-signal-list k (occs-for-names occs mod))))
- :hints (("goal" :induct t :in-theory (enable fal-extract))
+ :hints (("goal" :induct t :in-theory (enable member-equal fal-extract))
(and stable-under-simplificationp
'(:in-theory (enable gpl fal-extract)))))
@@ -1296,7 +1296,8 @@
(defthm occ-state-subset-of-occs-state
(implies (member-equal occ occs)
(subsetp-equal (pat-flatten1 (occ-state occ))
- (pat-flatten1 (occs-state occs)))))
+ (pat-flatten1 (occs-state occs))))
+ :hints(("Goal" :in-theory (enable member-equal))))
(defthm occ-state-subset-of-mod-state
(implies (and (member-equal occ (gpl :occs mod))
@@ -1715,7 +1716,7 @@
alist-equiv-append-when-keys-nil
append ; 4v-sexpr-eval-lookup-in-atom-val-alist
4v-alist-extract
- alist-equiv-append-atom
+ ;alist-equiv-append-atom
4v-sexpr-eval-possibilities
; 4v-sexpr-fixpoint-lower-boundp-atom-ups
4v-alists-agree-commute
@@ -2560,7 +2561,8 @@
(pat-flatten1 (occs-state occs))))
(member-equal occ2 occs))
(not (intersectp-equal (pat-flatten1 (occ-state occ))
- (pat-flatten1 (occ-state occ2))))))
+ (pat-flatten1 (occ-state occ2)))))
+ :hints(("Goal" :in-theory (enable member-equal))))
(defthmd state-of-occ-not-intersecting-member1
(implies (and (not (intersectp-equal (pat-flatten1 (occ-state occ))
@@ -2578,7 +2580,8 @@
(not (equal occ1 occ2)))
(not (intersectp-equal (pat-flatten1 (occ-state occ1))
(pat-flatten1 (occ-state occ2)))))
- :hints(("Goal" :in-theory (enable state-of-occ-not-intersecting-member
+ :hints(("Goal" :in-theory (enable member-equal
+ state-of-occ-not-intersecting-member
state-of-occ-not-intersecting-member1))))
(defthm states-of-diff-occs-not-intersecting-occs-of-mod
@@ -2620,7 +2623,7 @@
(pat-flatten1 (occs-state (alist-vals (fal-extract
rest-occnames (occmap mod))))))))
:hints(("Goal" :in-theory
- (e/d (fal-extract alist-vals occs-state)
+ (e/d (fal-extract alist-vals occs-state member-equal)
(good-esim-modulep occ-state gpl-u-occmap-lookup
default-car default-cdr))
:induct t)
diff -Nru acl2-6.2/books/centaur/esim/esim-sexpr-support.lisp acl2-6.3/books/centaur/esim/esim-sexpr-support.lisp
--- acl2-6.2/books/centaur/esim/esim-sexpr-support.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/esim-sexpr-support.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -24,9 +24,9 @@
(include-book "centaur/esim/plist" :dir :system)
(include-book "centaur/misc/patterns" :dir :system)
(include-book "centaur/4v-sexpr/sexpr-vars" :dir :system)
-(include-book "std/misc/explode-nonnegative-integer" :dir :system)
(include-book "std/misc/two-nats-measure" :dir :system)
(include-book "arithmetic/nat-listp" :dir :system)
+(local (include-book "str/explode-atom" :dir :system))
(set-well-founded-relation nat-list-<)
(make-event
diff -Nru acl2-6.2/books/centaur/esim/esim-spec.lisp acl2-6.3/books/centaur/esim/esim-spec.lisp
--- acl2-6.2/books/centaur/esim/esim-spec.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/esim-spec.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -1497,7 +1497,8 @@
(defthm good-occsp-nonnil
(implies (good-esim-occsp x)
- (not (member-equal nil x))))
+ (not (member-equal nil x)))
+ :hints(("Goal" :in-theory (enable member-equal))))
(defthm nonnil-vals-occmap
(implies (good-esim-occsp occs)
diff -Nru acl2-6.2/books/centaur/esim/stv/stv-compile.lisp acl2-6.3/books/centaur/esim/stv/stv-compile.lisp
--- acl2-6.2/books/centaur/esim/stv/stv-compile.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/stv/stv-compile.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -24,8 +24,9 @@
(in-package "ACL2")
(include-book "stv-util")
+(include-book "../esim-cut")
(include-book "../esim-sexpr-support")
-(include-book "../follow-backwards")
+;; (include-book "../follow-backwards")
(include-book "centaur/misc/vecs-ints" :dir :system)
(include-book "centaur/misc/tuplep" :dir :system)
(include-book "cutil/defmvtypes" :dir :system)
@@ -39,42 +40,20 @@
(make-event
; Disabling waterfall parallelism because this book allegedly uses memoization
-; while performing its proofs.
+; while performing its proofs.
- (if (and (hons-enabledp state)
- (f-get-global 'parallel-execution-enabled state))
+ (if (and (hons-enabledp state)
+ (f-get-global 'parallel-execution-enabled state))
(er-progn (set-waterfall-parallelism nil)
(value '(value-triple nil)))
(value '(value-triple nil))))
-(local (defthm atom-listp-of-append
- (implies (and (atom-listp x)
- (atom-listp y))
- (atom-listp (append x y)))
- :hints(("Goal" :in-theory (disable (force))))))
-
(local (defthm atom-listp-of-pat-flatten1
(atom-listp (pat-flatten1 x))
:hints(("Goal" :in-theory (e/d (pat-flatten1)
((force)))))))
-;; (local (defthm alist-keys-of-pairlis$
-;; (equal (alist-keys (pairlis$ x y))
-;; (list-fix x))
-;; :hints(("Goal" :in-theory (enable pairlis$)))))
-
-(local (defthm consp-when-member-of-atom-listp
- (implies (and (atom-listp x)
- (member-equal a x))
- (equal (consp a)
- nil))))
-
-(local (defthm atom-listp-when-subsetp
- (implies (and (subsetp x y)
- (atom-listp y))
- (equal (atom-listp x)
- (true-listp x)))
- :hints(("Goal" :induct (len x)))))
+(local (in-theory (enable consp-when-member-equal-of-atom-listp)))
; NOTE: throughout this code we assume the STV has already been preprocessed!
@@ -88,466 +67,36 @@
; - The input/output/internal lines have been widened (e.g., by stv-widen),
; and all share some length.
-
-(defsection stv-gensyms
+(define stv-gensyms-aux ((prefix stringp)
+ (n natp)
+ acc)
+ :returns (syms symbol-listp :hyp (symbol-listp acc))
+ :parents (stv-gensyms)
+ (b* (((when (zp n))
+ acc)
+ (n (- n 1))
+ (sym1 (intern$ (str::cat prefix "[" (str::natstr n) "]") "ACL2")))
+ (stv-gensyms-aux prefix n (cons sym1 acc)))
+ ///
+ (defthm len-of-stv-gensyms-aux
+ (equal (len (stv-gensyms-aux prefix n acc))
+ (+ (len acc) (nfix n)))))
+
+
+(define stv-gensyms ((prefix stringp)
+ (n natp))
+ :returns (syms symbol-listp)
:parents (stv-compile)
- :short "@(call stv-gensyms) produces the list of symbols @('(prefix[0]
- ... prefix[n-1])')."
-
+ :short "Generate a list of symbols, @('(foo[0] ... foo[n-1])')."
;; I originally used VL's emodwire stuff for this, but it's nice to eliminate
;; that dependency and just generate our own symbols.
-
- (defund stv-gensyms-aux (prefix n acc)
- (declare (xargs :guard (and (stringp prefix)
- (natp n))))
- (b* (((when (zp n))
- acc)
- (n (- n 1))
- (sym1 (intern$ (str::cat prefix "[" (str::natstr n) "]") "ACL2")))
- (stv-gensyms-aux prefix n (cons sym1 acc))))
-
- (defun stv-gensyms (prefix n)
- "Enumerate (prefix[0] ... prefix[n-1])"
- (declare (xargs :guard (and (stringp prefix)
- (natp n))))
- (stv-gensyms-aux prefix n nil)))
-
-
-
-
-
-; -----------------------------------------------------------------------------
-;
-; COMPILING :INITIAL LINES INTO A 4V-SEXPR-ALIST
-;
-; -----------------------------------------------------------------------------
-
-; The basic goal here *sounds* really easy: I want to let the user write down
-; names of Verilog regs, e.g., "foo.bar.baz.myreg[2:0]", and then somehow
-; figure out what E state bits correspond to this register.
-;
-; I've wrestled with this before, e.g., for "design registers." But really I'd
-; like to get away from design registers. They are sort of always getting
-; broken (when we change around how flop/latch inference stuff works), and
-; that's really irritating. And EMAPs are really big/slow/awful when we get to
-; large modules.
-;
-; Can't we just use something like the ordinary path stuff (from stv-expand)?
-; After all, this path stuff is great: it keeps everything strictly at the
-; Verilog level and uses only the information that's already embedded in the
-; module to resolve the paths.
-;
-; Well, there are a couple of things that make this hard.
-;
-; A minor problem is that latches just have one E bit, but flops need two state
-; bits. This means there isn't a nice, direct correspondence between a Verilog
-; "reg" bit and an E state bit. But let's not worry about this yet.
-;
-; A harder problem is that, at least with the current flop inference stuff, the
-; E state bits aren't really "directly connected" to wire that arises from the
-; Verilog reg. That is, if a Verilog module has a flop like:
-;
-; always @(posedge clk) q <= d;
-;
-; Then the transformed module will have something like:
-;
-; wire [n-1:0] q_temp_rhs = d;
-; wire [n-1:0] q_temp_lhs;
-; VL_N_BIT_LATCH guts (q_temp_lhs, q_temp_rhs, clk);
-; wire [n-1:0] q = q_temp_lhs;
-;
-; Notice here that the VL_N_BIT_LATCH, where the E state bits live, isn't
-; driving Q; it's driving this other temporary wire instead. There are good
-; reasons for it to work this way (e.g., it lets us handle delays and
-; truncations). But if we want to let users write things like
-; "foo.bar.baz.myreg.q", then we'll have to deal with this.
-;
-; I have come up with, I think, a very nice solution to this whole mess. This
-; solution "automatically" deals with things like the q = q_temp_lhs stuff,
-; without any special knowledge of how latch/flop inference works. This should
-; be very helpful when we want to change and extend our support for always
-; blocks. An even nicer, extremely neat thing is that the solution also lets
-; you refer to state bits in an even *less* direct way.
-;
-; To explain what I mean and why it is so good, consider a high-level module
-; that contains a module instance such as:
-;
-; // stage A signals to B...
-; myreg #(10) stageSignalsB (.q({ foo_B[5:0], bar_B, baz_B[2:0] }),
-; .d({ foo_A[5:0], bar_A, baz_A[2:0] }),
-; .clk(clk), .en1(en1), .en2(en2), ...);
-;
-; If I just gave you a way to refer to actual Verilog regs, it'd still be a
-; pain in the ass to initialize these state bits. Suppose you wanted to
-; initialize bar_B to some particular value. The actual "reg" for bar_B is
-; somewhere inside of myreg, so you'd have to write something like:
-;
-; top.sub1.sub2.stageSignalsB.q[3], or
-; top.sub1.sub2.stageSignalsB.guts.q[3], or similar.
-;
-; This is awful: you'll have to update the index every time a logic designer
-; adds something to the register or moves these wires around. The basic point
-; is: it'd be really nice to be able to refer to this state bit using the name
-; top.sub1.sub2.bar_B, instead of the name of some Verilog reg, and my solution
-; lets us do this!
-;
-; The solution is simple once we have a tool that lets us linearly follow a
-; path backwards through an E module to its "real" driver. This is pretty
-; tricky, but the tool has other uses as well. See follow-backwards.lisp for
-; the details.
-;
-; With this code in place, we can do something pretty elegant: Given a path
-; that the user says refers to a state bit, first follow it back to where it
-; originates. If it's a flop or a latch, we win: we have figured out what
-; state bit they're talking about, and we even know whether we should invert
-; it. Otherwise, we'll just cause an error because the user is trying to
-; initialize things that aren't very simply connected up to state bits, and
-; that's either crazy or just beyond the scope of what I want to think about
-; supporting.
-
-(defsection stv-forge-state-bit
- :parents (stv-compile)
- :short "Generate the name for a state bit, like @('foo!bar!baz!inst!S'),
-given a list of instance names and the name of the state bit."
-
- ;; BOZO have to keep this in sync with mod-state/occ-state
-
- (defund stv-forge-state-bit (instnames st-name)
- (declare (xargs :guard (atom st-name)))
- (if (atom instnames)
- st-name
- (acl2::prefix-atom (acl2::stringify (car instnames))
- "!"
- (stv-forge-state-bit (cdr instnames) st-name))))
-
- (local (in-theory (enable stv-forge-state-bit)))
-
- (defthm atom-of-stv-forge-state-bit
- (implies (atom st-name)
- (atom (stv-forge-state-bit instnames st-name)))))
-
-
-(cutil::defprojection stv-forge-state-bits (instnames x)
- (stv-forge-state-bit instnames x)
- :guard (atom-listp x)
- :result-type atom-listp)
-
-
-
-
-
-(defsection stv-initial-line-binding
- :parents (stv-compile)
- :short "Find the state bit(s) associated with some path and bind them to
-their initial values."
-
- :long "Signature: @(call stv-initial-line-binding) returns a sexpr
-alist.
-
-The @('path') is any path into @('mod'). It need not be canonical. We will
-follow the path with @(see follow-path-backwards), and we expect that new path
-we arrive at will be either an @(see *esim-flop*) or to an @(see *esim-latch*).
-If not, we cause a run-time error.
-
-The @('sexpr') is a sexpr that we want to use as the initial value for
-@('path'). The basic idea is to bind @('sexpr') to the state bits we have
-found. A slight twist is that, if walking from @('path') to the state bits
-took us through an inversion, then we will bind the state bits to @('(not
-sexpr)') instead. This should ensure that our initial bindings to state bits
-do indeed initialize @('path') to the desired value.
-
-If the path leads to a latch then there is just one state bit, and our alist
-will contain only a single entry.
-
-If the path leads to a flop, then there are two state bits! BOZO for
-now, we initialize BOTH state bits together. This shouldn't cause any
-problems until we want to compose together different STV runs. To support
-composition, we'll probably want an extended syntax that lets you specify
-whether the master or slave bit gets initialized.
"
-
- (defund stv-initial-line-binding (path sexpr mod)
- (declare (xargs :guard (good-esim-modulep mod)))
- (b* (((mv new-path invp) (follow-path-backwards path mod))
- (instnames (list-fix new-path))
- (wirename (final-cdr new-path))
- (submod (follow-esim-path instnames mod))
- ((unless submod)
- (er hard? 'stv-initial-line-binding
- "Error creating :initial binding for ~x0. We followed the path ~
- backward to ~x1, but this path doesn't seem valid?" path new-path))
-
- ;; Basic sanity check to make sure that the path leads to a flop/latch.
- (name (gpl :n submod))
- ((unless (or (eq name 'acl2::*esim-latch*)
- (eq name 'acl2::*esim-flop*)))
- ;; BOZO I'm just using a name-based check to see if we're at a flop
- ;; or a latch. Is this okay? Should we do something deeper?
- (er hard? 'stv-initial-line-binding
- "Error creating :initial binding for ~x0. We followed the path ~
- backward to ~x1. We expected this to be a latch or flop, but ~
- instead it is a ~x2 module." path new-path name))
-
- ((unless (eq wirename 'acl2::|q|))
- ;; Probably silly sanity check. This may be of no use. If it ever
- ;; fails, it might indicate that our flop/latch format has changed.
- (er hard? 'stv-initial-line-binding
- "Error creating :initial binding for ~x0. We followed the path ~
- backward to ~x1, and found a flop/latch whose output isn't ~
- even named acl2::|q|: ~x2?" path new-path wirename))
-
- (ebits
- ;; Gross way to come up with the actual state bits we want. Note
- ;; that the PAT-FLATTEN1 here is quite cheap: the submod is a latch
- ;; or a flop, so its mod-state is just one or two bits.
- (stv-forge-state-bits instnames (pat-flatten1 (mod-state submod))))
- (nbits (length ebits))
-
- ((unless (or (and (eq name 'acl2::*esim-latch*) (= nbits 1))
- (and (eq name 'acl2::*esim-flop*) (= nbits 2))))
- ;; Cheap, very trivial sanity check. This could save us if we do
- ;; something to the representation of latches/flops.
- (er hard? 'stv-initial-line-binding
- "Error creating :initial binding for ~x0. Wrong number of bits ~
- for flop/latch? The new-path is ~x1 and alleged ebits are ~x2."
- path new-path ebits))
-
- ((unless (subsetp-of-pat-flatten ebits (mod-state mod)))
- ;; Cheap, good sanity check to make sure that we've actually
- ;; identified state bits. Note that EBITS is only going to be one or
- ;; two bits, so even though this is O(n^2), N is very small. This
- ;; should save us from disaster if our naming conventions change.
- (er hard? 'stv-path-to-statepath
- "Error creating :initial binding for ~x0. Something has gone ~
- horribly wrong. The new-path, ~x1, seems to point to a valid ~
- flop/latch. But the bits we generated, ~x2, aren't in the ~
- mod-state for the module?" path new-path ebits))
-
- ;; Everything looks good, we got the right number of state bits,
- ;; checked that they exist, etc. Make the bindings. We invert the
- ;; sexpr if the path is inverting, so that the value on PATH will be
- ;; what the user asked for.
- (sexpr (if invp
- (hons-list 'acl2::not sexpr)
- sexpr))
- (vals (repeat sexpr nbits)))
- (pairlis$ ebits vals)))
-
- (local (in-theory (enable stv-initial-line-binding)))
-
- (defthm alistp-of-stv-initial-line-binding
- (alistp (stv-initial-line-binding path sexpr mod)))
-
- (defthm keys-of-stv-initial-line-binding-are-states
- (subsetp-equal (alist-keys (stv-initial-line-binding path sexpr mod))
- (pat-flatten1 (mod-state mod)))))
-
-
-(defsection stv-initial-line-bindings-aux
- :parents (stv-compile)
- :short "Extends @(see stv-initial-line-binding) to path/sexpr lists."
-
- (defund stv-initial-line-bindings-aux (paths sexprs mod)
- (declare (xargs :guard (and (equal (len paths) (len sexprs))
- (good-esim-modulep mod))))
- (if (atom paths)
- nil
- (append (stv-initial-line-binding (car paths) (car sexprs) mod)
- (stv-initial-line-bindings-aux (cdr paths) (cdr sexprs) mod))))
-
- (local (in-theory (enable stv-initial-line-bindings-aux)))
- (local (in-theory (disable (force))))
-
- (defthm alistp-of-stv-initial-line-bindings-aux
- (alistp (stv-initial-line-bindings-aux path sexpr mod)))
-
- (defthm keys-of-stv-initial-line-bindings-aux-are-states
- (subsetp-equal (alist-keys (stv-initial-line-bindings-aux path sexpr mod))
- (pat-flatten1 (mod-state mod)))))
+ (stv-gensyms-aux prefix n nil)
+ ///
+ (defthm len-of-stv-gensyms
+ (equal (len (stv-gensyms prefix n))
+ (nfix n))))
-(defsection stv-initial-line-bindings
- :parents (stv-compile)
- :short "Convert an :initial line into an alist binding state bits to sexprs."
-
- :long "Signature: @(call stv-initial-line-bindings) returns @('(mv
-bindings usersyms)').
-
-The @('line') is an :initial line from the STV. Note that its name should
-be a list of E paths in lsb-first order. That is, Verilog-style names shoudl
-have already been expanded away using @(see stv-expand-names) or similar.
-These paths don't need to be canonical, and they don't need to refer to state
-bits. We'll walk back from them to find the associated latch/flop that drives
-them.
-
-@('usersyms') is a fast alist that binds the names of simulation variables
-like @('opcode') to lists of bits that we generate for these symbols, i.e.,
-@('(opcode[0] ... opcode[n])'). This allows us to check for name collisions
-with generated symbols and width mismatches. That is, we will allow the same
-variable to be given to multiple inputs at multiple phases, but for that to be
-sensible these inputs had better have the same width.
-
-The @('mod') is needed to do various path lookups.
"
-
- (local (defthm len-of-bool-to-4v-sexpr-lst
- (equal (len (bool-to-4v-sexpr-lst x))
- (len x))))
-
- (local (defthm len-of-stv-gensyms-aux
- (equal (len (stv-gensyms-aux prefix n acc))
- (+ (len acc) (nfix n)))
- :hints(("Goal" :in-theory (enable stv-gensyms-aux)))))
-
- (defund stv-initial-line-bindings (line usersyms mod)
- "Returns (MV BINDINGS USERSYMS)"
- (declare (xargs :guard (good-esim-modulep mod)))
- (b* (((unless (tuplep 2 line))
- (er hard? 'stv-initial-line-bindings
- "An :initial line must have the form (name value), so this line ~
- is not valid: ~x0." line)
- (mv nil usersyms))
-
- ((list paths entry) line)
-
- ((unless (and (consp paths)
- (true-listp paths)))
- (er hard? 'stv-initial-line-bindings
- "Expected all :initial line names to be already expanded to ~
- non-empty path lists, but found ~x0." paths)
- (mv nil usersyms))
-
- (width (length paths))
-
- ((when (eq entry '_))
- ;; Special case: we'll allow blanks, but generate no bindings for them.
- (mv nil usersyms))
-
- ((mv sexprs usersyms)
- (b* (((when (natp entry))
- (or (< entry (ash 1 width))
- (er hard? 'stv-initial-line-bindings
- "At :initial line for ~x0: value ~x1 is too wide to ~
- fit into ~x2 bits!" paths entry width))
- (mv (bool-to-4v-sexpr-lst (int-to-v entry width)) usersyms))
-
- ((when (eq entry 'x))
- (mv (repeat *4vx-sexpr* width) usersyms))
-
- ((when (eq entry :ones))
- (mv (repeat *4vt-sexpr* width) usersyms))
-
- ((when (or (eq entry '~)
- (keywordp entry)
- (not (symbolp entry))))
- (er hard? 'stv-initial-line-bindings
- "At :initial line for ~x0: value ~x1 is not allowed in ~
- :initial lines." paths entry)
- (mv (repeat *4vx-sexpr* width) usersyms))
-
- (my-syms (stv-gensyms (symbol-name entry) width))
- (look (hons-get entry usersyms)))
-
- (or (not look)
- (equal (cdr look) my-syms)
- (er hard? 'stv-expand-input-entry
- "At :initial line for ~x0: variable ~x1 cannot be used ~
- here. This input is ~x2 bits wide, but ~x1 was ~
- previously used for a ~x3-bit input."
- paths entry width (len (cdr look))))
-
- (mv my-syms (if look
- usersyms
- (hons-acons entry my-syms usersyms)))))
-
- (bindings (stv-initial-line-bindings-aux paths sexprs mod)))
- (mv bindings usersyms)))
-
- (local (in-theory (enable stv-initial-line-bindings)))
-
- (defmvtypes stv-initial-line-bindings (true-listp nil))
-
- (defthm alistp-of-stv-initial-line-bindings
- (b* ((ret (stv-initial-line-bindings line usersyms mod)))
- (alistp (mv-nth 0 ret))))
-
- (defthm keys-of-stv-initial-line-bindings-are-states
- (let ((ret (stv-initial-line-bindings line usersyms mod)))
- (subsetp-equal (alist-keys (mv-nth 0 ret))
- (pat-flatten1 (mod-state mod))))))
-
-
-(defsection stv-initial-lines-to-alist
- :parents (stv-compile)
- :short "Extend @(see stv-initial-line-bindings) across all the :initial lines."
-
- (defund stv-initial-lines-to-alist (lines usersyms mod)
- "Returns (MV BINDINGS USERSYMS)"
- (declare (xargs :guard (good-esim-modulep mod)))
- (b* (((when (atom lines))
- (mv nil usersyms))
- ((mv bindings1 usersyms) (stv-initial-line-bindings (car lines) usersyms mod))
- ((mv bindings2 usersyms) (stv-initial-lines-to-alist (cdr lines) usersyms mod)))
- (mv (append bindings1 bindings2) usersyms)))
-
- (local (in-theory (disable (force))))
- (local (in-theory (enable stv-initial-lines-to-alist)))
-
- (defmvtypes stv-initial-lines-to-alist (true-listp nil))
-
- (defthm alistp-of-stv-initial-lines-to-alist
- (b* ((ret (stv-initial-lines-to-alist lines usersyms mod)))
- (alistp (mv-nth 0 ret))))
-
- (defthm keys-of-stv-initial-lines-to-alist-are-states
- (let ((ret (stv-initial-lines-to-alist lines usersyms mod)))
- (subsetp-equal (alist-keys (mv-nth 0 ret))
- (pat-flatten1 (mod-state mod)))))
-
- (defthm atom-listp-of-alist-keys-of-stv-initial-lines-to-alist
- (let ((ret (stv-initial-lines-to-alist lines usersyms mod)))
- (atom-listp (alist-keys (mv-nth 0 ret))))
- :hints(("Goal"
- :in-theory (disable stv-initial-lines-to-alist
- keys-of-stv-initial-lines-to-alist-are-states)
- :use ((:instance keys-of-stv-initial-lines-to-alist-are-states))))))
-
-
-
-(defsection stv-add-suffixes-to-initial-alist
- :parents (stv-compile)
- :short "Add .INIT suffixes to the state bits so that they can't clash with
-input signal names."
-
- (defund stv-add-suffixes-to-initial-alist (x)
- (declare (xargs :guard (atom-listp (alist-keys x))))
- (b* ((keys (alist-keys x))
- (vals (alist-vals x))
- (keys.INIT (stv-suffix-signals keys ".INIT")))
- (pairlis$ keys.INIT vals))))
-
-#||
-
-(include-book
- "stv-expand")
-
-(defconst *s0*
- (make-stvdata :inputs nil
- :outputs nil
- :internals nil
- :initial '(("mmxcntl.rsMmxSrc3_I" src3i)
- ("mmxcntl.rsMmxSrc2_I[4:2]" _)
- ("mmxcntl.rsMmxSrc2_I[0]" 1)
- ("mmxcntl.rsFeuBIBus_I[16:0]" bibus))))
-
-(defconst *s1*
- (stv-expand *s0* |*mmx*|))
-
-(b* (((mv alist ?usersyms)
- (stv-initial-lines-to-alist (stvdata->initial *s1*) nil |*mmx*|)))
- (stv-add-suffixes-to-initial-alist alist))
-
-
-||#
-
; -----------------------------------------------------------------------------
;
@@ -555,18 +104,15 @@
;
; -----------------------------------------------------------------------------
-(defsection stv-expand-input-entry
+(define stv-expand-input-entry
:parents (stv-compile)
:short "Convert a single user-level input value (e.g., 17, X, abus, etc) into
a list of @(see 4v-sexprs)."
- :long "Signature: @(call stv-expand-input-entry) returns @('(mv
-new-val gensyms usersyms)').
-
-This function basically defines what each value in an :input line means. We
-transform each such value into a list of @(see 4v-sexprs). These are the
-sexprs that will be given to this input during this phase. At a high level,
-our expansion strategy is:
+ :long "This function basically defines what each value in an :input line
+means. We transform each such value into a list of @(see 4v-sexprs). These
+are the sexprs that will be given to this input during this phase. At a high
+level, our expansion strategy is:
@@ -590,184 +136,170 @@
Simulation variables . A simulation variable like @('opcode') is
turned into a list like @('(|opcode[0]| ... |opcode[n]|)').
-
-
-To support this strategy, this function takes a number of inputs.
-
-
-
-@('name') is the name of this input, and should be a list of E input bits
-in lsb-first order. (That is, Verilog-style names should have already been
-expanded away using @(see stv-expand-names) or similar.)
-
-@('width') is the pre-computed width of this input, i.e., it must be
-exactly equal to @('(len name)').
-
-@('pnum') is the current phase number (and starts at 0). We use this to
-know what suffix to put onto the generated variable names for @('_') values,
-e.g., @('|foo[0].P4|')
-
-@('entry') is the actual entry we are trying to expand. For instance, it
-might be @('5'), @(':ones'), @('_'), or whatever else the user wrote down for
-this input at this phase number.
-
-@('gensyms') is a flat list of all the names we have generated so far for
-@('_') entries, which we may extend. This allows us to check for name
-collisions later on.
-
-@('usersyms') is a fast alist that binds the names of simulation variables
-like @('opcode') to lists of bits that we generate for these symbols, i.e.,
-@('(opcode[0] ... opcode[n])'). This allows us to check for name collisions
-with generated symbols and width mismatches. That is, we will allow the same
-variable to be given to multiple inputs at multiple phases, but for that to be
-sensible these inputs had better have the same width.
-
-@('prev-val') is the sexpr list that this signal expanded to in the
-previous phase, or NIL if this is the first phase of the simulation. We use
-this to figure out the new value of a @('~') entry.
-
"
- (defund stv-expand-input-entry (name width pnum entry gensyms usersyms prev-val)
- (declare (xargs :guard (and (atom-listp name)
- (consp name)
- (natp pnum)
- (equal width (len name)))))
- (b* (((when (natp entry))
- (or (< entry (ash 1 width))
- (er hard? 'stv-expand-input-entry
- "Phase ~x0 for ~x1: value ~x2 is too wide to fit in ~x3 ~
- bits!" pnum name entry width))
- (mv (bool-to-4v-sexpr-lst (int-to-v entry width)) gensyms usersyms))
-
- ((when (eq entry 'x))
- (mv (repeat *4vx-sexpr* width) gensyms usersyms))
-
- ((when (eq entry :ones))
- (mv (repeat *4vt-sexpr* width) gensyms usersyms))
-
- ((when (eq entry '~))
- (or (= width 1)
- (er hard? 'stv-expand-input-entry
- "Phase ~x0 for ~x1: value ~~ is not legal here. It can ~
- only be used in one-bit inputs, but this input is ~x2 bits ~
- wide." pnum name width))
- (or prev-val
- (er hard? 'stv-expand-input-entry
- "Phase ~x0 for ~x1: value ~~ is not legal here. It must be ~
- preceeded by a constant true or false, so it cannot be ~
- used at the start of a line." pnum name))
- (or (equal prev-val (list *4vt-sexpr*))
- (equal prev-val (list *4vf-sexpr*))
- (er hard? 'stv-expand-input-entry
- "Phase ~x0 for ~x1: value ~~ is not legal here. It must be ~
- preceeded by a constant true or false, but the previous ~
- value was ~x2." pnum name prev-val))
- (mv (if (equal prev-val (list *4vt-sexpr*))
- (list *4vf-sexpr*)
- (list *4vt-sexpr*))
- gensyms usersyms))
-
- ((when (eq entry '_))
- (let ((my-syms (stv-suffix-signals name (str::cat ".P" (str::natstr pnum)))))
- (mv my-syms
- (append my-syms gensyms)
- usersyms)))
-
- ((unless (and (symbolp entry)
- (not (keywordp entry))))
- (er hard? 'stv-expand-input-entry
- "Phase ~x0 for ~x1: value ~x2 is not legal for input lines of ~
- symbolic test vectors. See :xdoc symbolic-test-vector-format ~
- for help." pnum name entry)
- (mv (repeat *4vx-sexpr* width) gensyms usersyms))
-
- (my-syms (stv-gensyms (symbol-name entry) width))
- (look (hons-get entry usersyms)))
-
- (or (not look)
- (equal (cdr look) my-syms)
- (er hard? 'stv-expand-input-entry
- "Phase ~x0 for ~x1: variable ~x2 cannnot be used here. This ~
- input is ~x3 bits wide, but ~x2 was previously used for a ~
- ~x4-bit input." pnum name entry width (len (cdr look))))
- (mv my-syms gensyms (if look
- usersyms
- (hons-acons entry my-syms usersyms)))))
-
- (local (in-theory (enable stv-expand-input-entry)))
-
+ ((name (and (atom-listp name)
+ (consp name))
+ "The name of this input, and should be a list of E input bits in
+ lsb-first order. (That is, Verilog-style names should have already
+ been expanded away using @(see stv-expand-names) or similar.)")
+
+ (width (equal width (len name))
+ "Just the pre-computed width of this input.")
+
+ (pnum natp
+ "The current phase number (and starts at 0). We use this to know what
+ suffix to put onto the generated variable names for @('_') values,
+ e.g., @('|foo[0].P4|').")
+
+ (entry "The actual entry we are trying to expand. For instance, it might be
+ @('5'), @(':ones'), @('_'), or whatever else the user wrote down for
+ this input at this phase number.")
+
+ (gensyms "A flat list of all the names we have generated so far for @('_')
+ entries, which we may extend. This allows us to check for name
+ collisions later on.")
+
+ (usersyms "A fast alist that binds the names of simulation variables like
+ @('opcode') to lists of bits that we generate for these symbols,
+ i.e., @('(opcode[0] ... opcode[n])'). This allows us to check
+ for name collisions with generated symbols and width mismatches.
+ That is, we will allow the same variable to be given to multiple
+ inputs at multiple phases, but for that to be sensible these
+ inputs had better have the same width.")
+
+ (prev-val "The sexpr list that this signal expanded to in the previous
+ phase, or NIL if this is the first phase of the simulation. We
+ use this to figure out the new value of a @('~') entry."))
+
+ :returns (mv new-val gensyms usersyms)
+
+ (b* (((when (natp entry))
+ (or (< entry (ash 1 width))
+ (raise "Phase ~x0 for ~x1: value ~x2 is too wide to fit in ~x3 ~
+ bits!" pnum name entry width))
+ (mv (bool-to-4v-sexpr-lst (int-to-v entry width)) gensyms usersyms))
+
+ ((when (eq entry 'x))
+ (mv (repeat *4vx-sexpr* width) gensyms usersyms))
+
+ ((when (eq entry :ones))
+ (mv (repeat *4vt-sexpr* width) gensyms usersyms))
+
+ ((when (eq entry '~))
+ (or (= width 1)
+ (raise "Phase ~x0 for ~x1: value ~~ is not legal here. It can ~
+ only be used in one-bit inputs, but this input is ~x2 ~
+ bits wide." pnum name width))
+ (or prev-val
+ (raise "Phase ~x0 for ~x1: value ~~ is not legal here. It must ~
+ be preceeded by a constant true or false, so it cannot be ~
+ used at the start of a line." pnum name))
+ (or (equal prev-val (list *4vt-sexpr*))
+ (equal prev-val (list *4vf-sexpr*))
+ (raise "Phase ~x0 for ~x1: value ~~ is not legal here. It must ~
+ be preceeded by a constant true or false, but the ~
+ previous value was ~x2." pnum name prev-val))
+ (mv (if (equal prev-val (list *4vt-sexpr*))
+ (list *4vf-sexpr*)
+ (list *4vt-sexpr*))
+ gensyms usersyms))
+
+ ((when (eq entry '_))
+ (let ((my-syms (stv-suffix-signals name (str::cat ".P" (str::natstr pnum)))))
+ (mv my-syms
+ (append my-syms gensyms)
+ usersyms)))
+
+ ((unless (and (symbolp entry)
+ (not (keywordp entry))))
+ (raise "Phase ~x0 for ~x1: value ~x2 is not legal for input lines of ~
+ symbolic test vectors. See :xdoc symbolic-test-vector-format ~
+ for help." pnum name entry)
+ (mv (repeat *4vx-sexpr* width) gensyms usersyms))
+
+ (my-syms (stv-gensyms (symbol-name entry) width))
+ (look (hons-get entry usersyms)))
+
+ (or (not look)
+ (equal (cdr look) my-syms)
+ (raise "Phase ~x0 for ~x1: variable ~x2 cannnot be used here. This ~
+ input is ~x3 bits wide, but ~x2 was previously used for a ~
+ ~x4-bit input." pnum name entry width (len (cdr look))))
+ (mv my-syms gensyms (if look
+ usersyms
+ (hons-acons entry my-syms usersyms))))
+ ///
(defthm true-listp-of-stv-expand-input-entry-gensyms
- (let ((ret (stv-expand-input-entry name width pnum entry gensyms usersyms prev-val)))
- (implies (true-listp gensyms)
- (true-listp (mv-nth 1 ret))))))
+ (implies (true-listp gensyms)
+ (b* (((mv ?new-val gensyms ?usersyms)
+ (stv-expand-input-entry name width pnum entry
+ gensyms usersyms prev-val)))
+ (true-listp gensyms)))))
-(defsection stv-expand-input-entries
+(define stv-expand-input-entries
:parents (stv-compile)
:short "Extend @(see stv-expand-input-entry) across a line."
-
- (defund stv-expand-input-entries (name width pnum entries gensyms usersyms prev-val)
- "Returns (MV NEW-ENTRIES GENSYMS USERSYMS)"
- (declare (xargs :guard (and (atom-listp name)
- (consp name)
- (natp pnum)
- (equal width (len name))
- (true-listp entries))))
- (b* (((when (atom entries))
- (mv nil gensyms usersyms))
- ((mv new-car gensyms usersyms)
- (stv-expand-input-entry name width pnum (car entries)
- gensyms usersyms prev-val))
- ((mv new-cdr gensyms usersyms)
- (stv-expand-input-entries name width (+ 1 pnum) (cdr entries)
- gensyms usersyms new-car)))
- (mv (cons new-car new-cdr) gensyms usersyms)))
-
- (local (in-theory (enable stv-expand-input-entries)))
-
+ ((name (and (atom-listp name)
+ (consp name)))
+ (width (equal width (len name)))
+ (pnum natp)
+ (entries true-listp)
+ gensyms
+ usersyms
+ prev-val)
+ :returns (mv new-entries gensyms usersyms)
+
+ (b* (((when (atom entries))
+ (mv nil gensyms usersyms))
+ ((mv new-car gensyms usersyms)
+ (stv-expand-input-entry name width pnum (car entries)
+ gensyms usersyms prev-val))
+ ((mv new-cdr gensyms usersyms)
+ (stv-expand-input-entries name width (+ 1 pnum) (cdr entries)
+ gensyms usersyms new-car)))
+ (mv (cons new-car new-cdr) gensyms usersyms))
+ ///
(defmvtypes stv-expand-input-entries (true-listp nil nil))
(defthm true-listp-of-stv-expand-input-entries-gensyms
- (let ((ret (stv-expand-input-entries name width pnum entries gensyms usersyms prev-val)))
- (implies (true-listp gensyms)
- (true-listp (mv-nth 1 ret))))))
+ (implies (true-listp gensyms)
+ (b* (((mv ?new-entries gensyms ?usersyms)
+ (stv-expand-input-entries name width pnum entries
+ gensyms usersyms prev-val)))
+ (true-listp gensyms)))))
-(defsection stv-expand-input-lines
+(define stv-expand-input-lines
:parents (stv-compile)
:short "Extend @(see stv-expand-input-entry) across a list of lines."
-
- (defund stv-expand-input-lines (lines gensyms usersyms)
- "Returns (MV NEW-LINES GENSYMS USERSYMS)"
- (declare (xargs :guard (true-list-listp lines)))
- (b* (((when (atom lines))
- (mv nil gensyms usersyms))
- (line1 (car lines))
- ((cons name1 entries1) line1)
-
- ((unless (and (consp name1)
- (atom-listp name1)))
- (er hard? 'stv-expand-input-lines
- "Expected all input line names to be already expanded to ~
- non-empty lists of E bits, but found ~x0." name1)
- (mv nil gensyms usersyms))
-
- ((mv new-entries1 gensyms usersyms)
- (stv-expand-input-entries name1 (len name1) 0 entries1 gensyms usersyms nil))
- (new-car (cons name1 new-entries1))
- ((mv new-cdr gensyms usersyms)
- (stv-expand-input-lines (cdr lines) gensyms usersyms)))
- (mv (cons new-car new-cdr) gensyms usersyms)))
-
- (local (in-theory (enable stv-expand-input-lines)))
-
+ ((lines true-list-listp)
+ gensyms
+ usersyms)
+ :returns (mv (new-lines true-list-listp)
+ gensyms
+ usersyms)
+ (b* (((when (atom lines))
+ (mv nil gensyms usersyms))
+ (line1 (car lines))
+ ((cons name1 entries1) line1)
+
+ ((unless (and (consp name1)
+ (atom-listp name1)))
+ (raise "Expected all input line names to be already expanded to ~
+ non-empty lists of E bits, but found ~x0." name1)
+ (mv nil gensyms usersyms))
+
+ ((mv new-entries1 gensyms usersyms)
+ (stv-expand-input-entries name1 (len name1) 0 entries1 gensyms usersyms nil))
+ (new-car (cons name1 new-entries1))
+ ((mv new-cdr gensyms usersyms)
+ (stv-expand-input-lines (cdr lines) gensyms usersyms)))
+ (mv (cons new-car new-cdr) gensyms usersyms))
+ ///
(defmvtypes stv-expand-input-lines (true-listp nil nil))
- (defthm true-list-listp-of-stv-expand-input-lines
- (let ((ret (stv-expand-input-lines lines gensyms usersyms)))
- (true-list-listp (mv-nth 0 ret))))
-
(defthm true-listp-of-stv-expand-input-lines-gensyms
(let ((ret (stv-expand-input-lines lines gensyms usersyms)))
(implies (true-listp gensyms)
@@ -781,25 +313,39 @@
;
; -----------------------------------------------------------------------------
-(defsection stv-restrict-alist
+(define stv-restrict-alist-aux ((name atom-listp)
+ (phase natp)
+ entries
+ acc)
+ :returns (acc alistp :hyp (alistp acc))
+ :parents (stv-restrict-alist)
+ (b* (((when (atom entries))
+ acc)
+ (name-at-phase (stv-suffix-signals name (str::cat ".P" (str::natstr phase))))
+ (val-at-phase (car entries))
+ (acc (safe-pairlis-onto-acc name-at-phase val-at-phase acc)))
+ (stv-restrict-alist-aux name (+ 1 phase) (cdr entries) acc)))
+
+(define stv-restrict-alist
:parents (stv-compile)
:short "Construct an alist binding fully-general input names (for all phases)
to @(see 4v-sexprs) derived from the symbolic test vector."
- :long "@(call stv-restrict-alist) produces an alist.
-
-@('lines') are the output from @(see stv-expand-input-lines). We expect
-that the lines have been widened, had their names resolved into E bits, and had
-their entries turned into 4v-sexpr lists.
-
-@('acc') is an alist that we extend. Typically it is the alist that has the
-@(':initial') bindings.
-
-We construct an ordinary (slow) alist that binds the input names we are
-going to use in our fully-general simulation to their bindings according to the
-symbolic test vector. This is a single alist that includes the bindings for
-the variables at all phases, plus (presumably, via acc) any initial bindings
-for state bits.
+ ((lines true-list-listp
+ "The output from @(see stv-expand-input-lines). That is, these
+ should STV input lines that have already been widened, had their
+ names resolved into E bits, and had their entries turned into
+ 4v-sexpr lists.")
+ (acc "An alist that we extend. Typically it is the alist that has the
+ @(':initial') bindings."))
+
+ :returns (restrict-alist alistp :hyp (alistp acc))
+
+ :long "We construct an ordinary (slow) alist that binds the input names we
+are going to use in our fully-general @(see esim) simulation to their bindings
+according to the symbolic test vector. This is a single alist that includes
+the bindings for the variables at all phases, plus (presumably, via acc) any
+initial bindings for state bits.
The sexprs in this alist will often be constants (e.g., when natural
numbers, @(':ones'), @('x'), or @('~') values are used), but they can also have
@@ -809,27 +355,14 @@
with @(see 4v-sexpr-restrict) to specialize the fully general simulation,
effectively \"assuming\" the STV.
"
- (defund stv-restrict-alist-aux (name phase entries acc)
- (declare (xargs :guard (and (atom-listp name)
- (natp phase))))
- (b* (((when (atom entries))
- acc)
- (name-at-phase (stv-suffix-signals name (str::cat ".P" (str::natstr phase))))
- (val-at-phase (car entries))
- (acc (safe-pairlis-onto-acc name-at-phase val-at-phase acc)))
- (stv-restrict-alist-aux name (+ 1 phase) (cdr entries) acc)))
-
- (defund stv-restrict-alist (lines acc)
- (declare (xargs :guard (true-list-listp lines)))
(b* (((when (atom lines))
acc)
(line1 (car lines))
((cons name entries) line1)
((unless (atom-listp name))
- (er hard? 'stv-restrict-alist
- "Name should be a list of E bits, but is ~x0." name))
+ (raise "Name should be a list of E bits, but is ~x0." name))
(acc (stv-restrict-alist-aux name 0 entries acc)))
- (stv-restrict-alist (cdr lines) acc))))
+ (stv-restrict-alist (cdr lines) acc)))
@@ -839,135 +372,113 @@
;
; -----------------------------------------------------------------------------
-(defsection stv-expand-output-entry
+(define stv-expand-output-entry
:parents (stv-compile)
:short "Convert a single user-level output/internal value (e.g., _, result)
into a list of @(see 4v-sexprs)."
- :long "Signature: @(call stv-expand-output-entry) returns @('(mv
-new-val usersyms)').
-
-The only valid entries for output lines are @('_') (for signals we don't
-care about) and simulation variables. Here, we just leave any @('_') values
-alone, but we replace simulation variables with lists of new variables that we
-generate from their names. That is, a simulation variable like @('result')
-will be converted into a list of bits like @('(result[0] ... result[4])').
-
-We are given:
-
-
-
-@('name') is the name of this output. It should be a list of E input bits
-in lsb-first order. That is, Verilog-style names should have already been
-expanded away using @(see stv-expand-names) or similar.
-
-@('width') is the pre-computed width of this output. It must be exactly
-equal to @('(len name)'). This lets us know how many variables to generate
-when we hit a simulation variable.
-
-@('pnum') is the current phase number (and starts at 0). This is
-semantically irrelevant; we use it only to generate better error messages.
-
-@('entry') is the actual entry we are trying to expand, i.e., it's what the
-user wrote down for this output at this phase. To be well-formed, the entry
-needs to be @('_') or a simulation variable, but the user can write down
-anything so we have to check that it is valid.
-
-@('usersyms') is a fast alist binding simulation variables to the lists of
-bits that we've generated to represent them. We assume this only contains the
-output simulation variables. This lets us make sure that output variables
-aren't being reused.
+ :long "The only valid entries for output lines are @('_') (for signals we
+don't care about) and simulation variables. Here, we just leave any @('_')
+values alone, but we replace simulation variables with lists of new variables
+that we generate from their names. That is, a simulation variable like
+@('result') will be converted into a list of bits like @('(result[0]
+... result[4])').
"
+
+ ((name (and (true-listp name)
+ (consp name))
+ "The name of this output. It should be a list of E input bits in
+ lsb-first order. That is, Verilog-style names should have already
+ been expanded away using @(see stv-expand-names) or similar.")
+
+ (width (equal width (len name))
+ "Just the pre-computed width of this output. It must be exactly
+ equal to @('(len name)'). This lets us know how many variables to
+ generate when we hit a simulation variable.")
+
+ (pnum natp
+ "The current phase number (and starts at 0). This is semantically
+ irrelevant; we use it only to generate better error messages.")
+
+ (entry "The actual entry we are trying to expand, i.e., it's what the user
+ wrote down for this output at this phase. To be well-formed, the
+ entry needs to be @('_') or a simulation variable, but the user can
+ write down anything so we have to check that it is valid.")
+
+ (usersyms "A fast alist binding simulation variables to the lists of bits
+ that we've generated to represent them. We assume this only
+ contains the output simulation variables. This lets us make sure
+ that output variables aren't being reused."))
+
+ :returns (mv new-val usersyms)
+
+ (b* (((when (or (natp entry)
+ (eq entry 'x)
+ (eq entry '~)
+ (keywordp entry)
+ (not (symbolp entry))))
+ (raise "Phase ~x0 for ~x1: value ~x2 is not legal for :output lines."
+ pnum name entry)
+ (mv nil usersyms))
+
+ ((when (eq entry '_))
+ ;; That's fine, just leave it alone.
+ (mv entry usersyms))
+
+ ;; Else, a simulation variable. It had better not be used yet.
+ (look (hons-get entry usersyms))
+ ((when look)
+ (raise "Phase ~x0 for ~x1: variable ~x2 is already in use, so it ~
+ cannot be used again." pnum name entry)
+ (mv nil usersyms))
+
+ ;; Okay it wasn't used. Make its symbols and such.
+ (my-syms (stv-gensyms (symbol-name entry) width))
+ (usersyms (hons-acons entry my-syms usersyms)))
+ (mv my-syms usersyms)))
- "
-
- (defund stv-expand-output-entry (name width pnum entry usersyms)
- "Returns (MV NEW-VAL USERSYMS)"
- (declare (xargs :guard (and (true-listp name)
- (consp name)
- (natp pnum)
- (equal width (len name)))))
- (b* (((when (or (natp entry)
- (eq entry 'x)
- (eq entry '~)
- (keywordp entry)
- (not (symbolp entry))))
- (er hard? 'stv-expand-output-entry
- "Phase ~x0 for ~x1: value ~x2 is not legal for :output lines."
- pnum name entry)
- (mv nil usersyms))
-
- ((when (eq entry '_))
- ;; That's fine, just leave it alone.
- (mv entry usersyms))
-
- ;; Else, a simulation variable. It had better not be used yet.
- (look (hons-get entry usersyms))
- ((when look)
- (er hard? 'stv-expand-output-entry
- "Phase ~x0 for ~x1: variable ~x2 is already in use, so it ~
- cannot be used again." pnum name entry)
- (mv nil usersyms))
-
- ;; Okay it wasn't used. Make its symbols and such.
- (my-syms (stv-gensyms (symbol-name entry) width))
- (usersyms (hons-acons entry my-syms usersyms)))
- (mv my-syms usersyms))))
-
-
-(defsection stv-expand-output-entries
+(define stv-expand-output-entries
:parents (stv-compile)
:short "Extend @(see stv-expand-output-entry) across a line."
+ ((name (and (true-listp name) (consp name)))
+ (width (equal width (len name)))
+ (pnum natp)
+ (entries true-listp)
+ usersyms)
+ :returns (mv (new-entries true-listp :rule-classes :type-prescription)
+ usersyms)
+ (b* (((when (atom entries))
+ (mv nil usersyms))
+ ((mv new-car usersyms)
+ (stv-expand-output-entry name width pnum (car entries) usersyms))
+ ((mv new-cdr usersyms)
+ (stv-expand-output-entries name width (+ 1 pnum) (cdr entries) usersyms)))
+ (mv (cons new-car new-cdr) usersyms)))
- (defund stv-expand-output-entries (name width pnum entries usersyms)
- "Returns (MV NEW-ENTRIES USERSYMS)"
- (declare (xargs :guard (and (true-listp name)
- (consp name)
- (natp pnum)
- (equal width (len name))
- (true-listp entries))))
- (b* (((when (atom entries))
- (mv nil usersyms))
- ((mv new-car usersyms)
- (stv-expand-output-entry name width pnum (car entries) usersyms))
- ((mv new-cdr usersyms)
- (stv-expand-output-entries name width (+ 1 pnum) (cdr entries) usersyms)))
- (mv (cons new-car new-cdr) usersyms)))
-
- (defmvtypes stv-expand-output-entries (true-listp nil)))
-
-
-(defsection stv-expand-output-lines
+(define stv-expand-output-lines
:parents (stv-compile)
:short "Extend @(see stv-expand-output-entry) across a list of lines."
- (defund stv-expand-output-lines (lines usersyms)
- "Returns (MV NEW-LINES USERSYMS)"
- (declare (xargs :guard (true-list-listp lines)))
- (b* (((when (atom lines))
- (mv nil usersyms))
- (line1 (car lines))
- ((cons name1 entries1) line1)
-
- ((unless (and (consp name1)
- (atom-listp name1)))
- (er hard? 'stv-expand-output-lines
- "Expected :output line names to be already expanded to non-empty ~
- lists of E bits, but found ~x0." name1)
- (mv nil usersyms))
-
- ((mv new-entries1 usersyms)
- (stv-expand-output-entries name1 (len name1) 0 entries1 usersyms))
-
- (new-car (cons name1 new-entries1))
- ((mv new-cdr usersyms)
- (stv-expand-output-lines (cdr lines) usersyms)))
- (mv (cons new-car new-cdr) usersyms)))
-
- (local (in-theory (enable stv-expand-output-lines)))
-
- (defthm true-list-listp-of-stv-expand-output-lines
- (let ((ret (stv-expand-output-lines lines usersyms)))
- (true-list-listp (mv-nth 0 ret)))))
+ ((lines true-list-listp) usersyms)
+ :returns (mv (new-lines true-list-listp)
+ usersyms)
+ (b* (((when (atom lines))
+ (mv nil usersyms))
+ (line1 (car lines))
+ ((cons name1 entries1) line1)
+
+ ((unless (and (consp name1)
+ (atom-listp name1)))
+ (raise "Expected :output line names to be already expanded to ~
+ non-empty lists of E bits, but found ~x0." name1)
+ (mv nil usersyms))
+
+ ((mv new-entries1 usersyms)
+ (stv-expand-output-entries name1 (len name1) 0 entries1 usersyms))
+
+ (new-car (cons name1 new-entries1))
+ ((mv new-cdr usersyms)
+ (stv-expand-output-lines (cdr lines) usersyms)))
+ (mv (cons new-car new-cdr) usersyms)))
@@ -980,59 +491,50 @@
; These are almost the same as output lines. The only difference is that we
; need to canonicalize their paths.
-(defsection stv-expand-internal-line
+(define stv-expand-internal-line
:parents (stv-compile)
+ ((line true-listp)
+ usersyms
+ (mod good-esim-modulep))
+ :returns (mv (new-line true-listp :rule-classes :type-prescription)
+ usersyms)
+ (b* (((cons name entries) line)
+ ((unless (and (consp name)
+ (true-listp name)))
+ (raise "Expected :internal line names to be already expanded to ~
+ non-empty lists of E paths, but found ~x0." name)
+ (mv nil usersyms))
+
+ ;; The ESIM simulation only involves canonical paths, so to be able to
+ ;; extract the right paths we need to canonicalize these paths.
+ ((mv okp new-name) (fast-canonicalize-paths name mod))
+ ((unless okp)
+ (raise "Failed to canonicalize all the paths for ~x0." name)
+ (mv nil usersyms))
+ ((mv new-entries usersyms)
+ (stv-expand-output-entries new-name (len new-name) 0 entries usersyms))
+ (new-line (cons new-name new-entries)))
+ (mv new-line usersyms))
+ :prepwork
+ ((local (defthm fast-canonicalize-paths-1-under-iff
+ (iff (mv-nth 1 (fast-canonicalize-paths paths mod))
+ (consp paths))
+ :hints(("Goal" :in-theory (enable fast-canonicalize-paths)))))))
- (local (defthm fast-canonicalize-paths-1-under-iff
- (iff (mv-nth 1 (fast-canonicalize-paths paths mod))
- (consp paths))
- :hints(("Goal" :in-theory (enable fast-canonicalize-paths)))))
-
- (defund stv-expand-internal-line (line usersyms mod)
- "Returns (MV NEW-LINE USERSYMS)"
- (declare (xargs :guard (and (true-listp line)
- (good-esim-modulep mod))))
- (b* (((cons name entries) line)
-
- ((unless (and (consp name)
- (true-listp name)))
- (er hard? 'stv-expand-internal-lines
- "Expected :internal line names to be already expanded to non-empty ~
- lists of E paths, but found ~x0." name)
- (mv nil usersyms))
-
- ;; The ESIM simulation only involves canonical paths, so to be able to
- ;; extract the right paths we need to canonicalize these paths.
- ((mv okp new-name) (fast-canonicalize-paths name mod))
- ((unless okp)
- (er hard? 'stv-expand-internal-lines
- "Failed to canonicalize all the paths for ~x0." name)
- (mv nil usersyms))
-
- ((mv new-entries usersyms)
- (stv-expand-output-entries new-name (len new-name) 0 entries usersyms))
-
- (new-line (cons new-name new-entries)))
- (mv new-line usersyms)))
-
- (defmvtypes stv-expand-internal-line (true-listp nil)))
-
-
-(defsection stv-expand-internal-lines
+(define stv-expand-internal-lines
:parents (stv-compile)
:short "Extend @(see stv-expand-internal-line) across a list of lines."
+ ((lines true-list-listp)
+ (usersyms)
+ (mod good-esim-modulep))
+ :returns (mv (new-lines true-list-listp)
+ usersyms)
+ (b* (((when (atom lines))
+ (mv nil usersyms))
+ ((mv line1 usersyms) (stv-expand-internal-line (car lines) usersyms mod))
+ ((mv lines2 usersyms) (stv-expand-internal-lines (cdr lines) usersyms mod)))
+ (mv (cons line1 lines2) usersyms)))
- (defund stv-expand-internal-lines (lines usersyms mod)
- "Returns (MV NEW-LINES USERSYMS)"
- (declare (xargs :guard (and (true-list-listp lines)
- (good-esim-modulep mod))))
- (b* (((when (atom lines))
- (mv nil usersyms))
- ((mv line1 usersyms) (stv-expand-internal-line (car lines) usersyms mod))
- ((mv lines2 usersyms) (stv-expand-internal-lines (cdr lines) usersyms mod)))
- (mv (cons line1 lines2) usersyms)))
-
- (defmvtypes stv-expand-internal-lines (true-list-listp nil)))
; -----------------------------------------------------------------------------
@@ -1041,18 +543,39 @@
;
; -----------------------------------------------------------------------------
-(defsection stv-extraction-alists
+(define stv-nth-extraction-alist
+ :parents (stv-extraction-alists)
+ :short "Add the bindings for name to entryN to the NTH-ALIST-ACC"
+ ((n natp)
+ (lines true-list-listp "A list of (name entry1 ... entryK)")
+ (nth-alist-acc alistp))
+ (b* (((when (atom lines))
+ nth-alist-acc)
+ (line1 (car lines))
+ ((cons name entries) line1)
+ (entry (nth n entries))
+ ((when (eq entry '_))
+ ;; Don't care about this output at this time. Keep going.
+ (stv-nth-extraction-alist n (cdr lines) nth-alist-acc))
+ (nth-alist-acc (safe-pairlis-onto-acc name entry nth-alist-acc)))
+ (stv-nth-extraction-alist n (cdr lines) nth-alist-acc)))
+
+(define stv-extraction-alists
:parents (stv-compile)
:short "Alists explaining what signals we want to extract from the simulation
after each phase."
+ ((n natp "Initially this is the total number of phases.
+ It will counts down from the max phase to 0.")
+
+ (lines true-list-listp "Constant. Expanded output or internals lines.")
+
+ (alists-acc "Accumulator, initially nil."))
- :long "@(call stv-extraction-alists) takes the total number of phases, the
-output or internal lines (which we assume have already been expanded), and an
-accumulator which should initially be @('nil').
-
-It returns a list of alists that say, after each step, which output bits we
-want to collect, and how we want to name them. The basic idea is that if we have
-a list of outputs like this:
+ :returns (alists-acc "A list of alists that say, after each step, which
+ output bits we want to collect, and how to name them."
+ true-listp :hyp (true-listp alists-acc))
+
+ :long "The basic idea is that if we have a list of outputs lines like:
@({
(foo _ _ a _)
@@ -1085,32 +608,317 @@
phase, the names of the output signals we want to extract from the simulation,
and which bit of which simulation variable the name corresponds to."
- (defund stv-nth-extraction-alist (n lines nth-alist-acc)
- "Lines are (name entry1 ... entryK)
- Add the bindings for name to entryN to the NTH-ALIST-ACC"
- (declare (xargs :guard (and (natp n)
- (true-list-listp lines))))
- (b* (((when (atom lines))
- nth-alist-acc)
- (line1 (car lines))
- ((cons name entries) line1)
- (entry (nth n entries))
- ((when (eq entry '_))
- ;; Don't care about this output at this time. Keep going.
- (stv-nth-extraction-alist n (cdr lines) nth-alist-acc))
- (nth-alist-acc (safe-pairlis-onto-acc name entry nth-alist-acc)))
- (stv-nth-extraction-alist n (cdr lines) nth-alist-acc)))
-
- (defund stv-extraction-alists (n lines alists-acc)
- "N counts down from the max phase to zero. Lines are constant.
- We return the list of binding alists, in the proper phase order."
- (declare (xargs :guard (and (natp n)
- (true-list-listp lines))))
- (let* ((nth-alist (stv-nth-extraction-alist n lines nil))
- (alists-acc (cons nth-alist alists-acc)))
- (if (zp n)
- alists-acc
- (stv-extraction-alists (- n 1) lines alists-acc)))))
+ (let* ((nth-alist (stv-nth-extraction-alist n lines nil))
+ (alists-acc (cons nth-alist alists-acc)))
+ (if (zp n)
+ alists-acc
+ (stv-extraction-alists (- n 1) lines alists-acc))))
+
+
+
+; -----------------------------------------------------------------------------
+;
+; COMPILING :OVERRIDE LINES
+;
+; -----------------------------------------------------------------------------
+
+(define stv-append-alist-keys ((lines))
+ :returns (name-bits "Flat list of paths from the car of each line."
+ true-listp :rule-classes :type-prescription)
+ (if (atom lines)
+ nil
+ (append-without-guard (and (consp (car lines)) (caar lines))
+ (stv-append-alist-keys (cdr lines)))))
+
+(define stv-cut-module
+ ((override-paths "Already expanded path to every signal we want to override.
+ These are paths to real wire in the module, e.g., foo
+ instead of foo or similar."
+ true-listp)
+ (mod good-esim-modulep))
+ :returns (new-mod good-esim-modulep "The cut module." :hyp :guard)
+ (b* ((new-mod (ecut-module override-paths mod))
+ ((unless (good-esim-modulep new-mod))
+ (raise "Ecut failed to produce a good esim module: ~@0"
+ (bad-esim-modulep new-mod))
+ mod))
+ new-mod))
+
+(define stv-expand-override-entry
+ ((name "The name of this override line. This will be a list of E paths."
+ (and (consp name)
+ (true-listp name)))
+ (width "Pre-computed width of the name."
+ (equal (len name) width))
+ (pnum "Current phase number (may not be necessary for anything, but lets
+ us generate better error messages.)"
+ natp)
+ (entry "The actual entry we're trying to expand.")
+ (in-usersyms
+ "Fast alist binding simulation variables to lists of bits that we've
+ generated to represent them. We assume this contains only the input
+ variables.")
+ (out-usersyms
+ "Same, but for outputs."))
+ :returns
+ (mv (in-value-sexprs)
+ (in-decision-sexprs)
+ (out-value-vars "either a list of variables or a _")
+ (new-in-usersyms)
+ (new-out-usersyms))
+ (b* (((when (natp entry))
+ (or (< entry (ash 1 width))
+ (raise "Phase ~x0 for ~x1: value ~x2 is too wide to fit in ~x3 ~
+ bits!" pnum name entry width))
+ (mv (bool-to-4v-sexpr-lst (int-to-v entry width))
+ (repeat *4vt-sexpr* width)
+ '_
+ in-usersyms
+ out-usersyms))
+
+ ((when (eq entry 'x))
+ (mv (repeat *4vx-sexpr* width)
+ (repeat *4vt-sexpr* width)
+ '_
+ in-usersyms
+ out-usersyms))
+
+ ((when (eq entry :ones))
+ (mv (repeat *4vt-sexpr* width)
+ (repeat *4vt-sexpr* width)
+ '_
+ in-usersyms
+ out-usersyms))
+
+ ((when (eq entry '~))
+ (raise "Phase ~x0 for ~x1: value ~~ is not legal on overrides." pnum name)
+ (mv (repeat *4vx-sexpr* width)
+ (repeat *4vt-sexpr* width)
+ '_
+ in-usersyms
+ out-usersyms))
+
+ ((when (eq entry '_))
+ (mv (repeat *4vx-sexpr* width)
+ (repeat *4vf-sexpr* width)
+ '_
+ in-usersyms
+ out-usersyms))
+
+ ((unless (and (symbolp entry)
+ (not (keywordp entry))))
+ (raise "Phase ~x0 for ~x1: value ~x2 is not legal for override lines of ~
+ symbolic test vectors. See :xdoc symbolic-test-vector-format ~
+ for help." pnum name entry)
+ (mv (repeat *4vx-sexpr* width)
+ (repeat *4vt-sexpr* width)
+ '_
+ in-usersyms
+ out-usersyms))
+
+ (my-syms (stv-gensyms (symbol-name entry) width))
+ (out-look (hons-get entry out-usersyms))
+ (in-look (hons-get entry in-usersyms)))
+
+ (and out-look
+ (raise "Phase ~x0 for ~x1: variable ~x2 is already in use, so it ~
+ cannot be used again."
+ pnum name entry))
+
+ (or (not in-look)
+ (equal (cdr in-look) my-syms)
+ (raise "Phase ~x0 for ~x1: variable ~x2 cannnot be used here. This ~
+ override is ~x3 bits wide, but ~x2 was previously used for a ~
+ ~x4-bit wire." pnum name entry width (len (cdr in-look))))
+
+ (mv my-syms
+ (repeat *4vt-sexpr* width)
+ my-syms
+ (if in-look in-usersyms (hons-acons entry my-syms in-usersyms))
+ (hons-acons entry my-syms out-usersyms))))
+
+
+(define stv-expand-override-entries
+ ((name "The name of this override line. This will be a list of E paths."
+ (and (consp name)
+ (true-listp name)))
+ (width "Pre-computed width of the name."
+ (equal (len name) width))
+ (pnum "Current phase number (may not be necessary for anything, but lets
+ us generate better error messages.)"
+ natp)
+ (entries "The rest of the entries")
+ (in-usersyms
+ "Fast alist binding simulation variables to lists of bits that we've
+ generated to represent them. We assume this contains only the input
+ variables.")
+ (out-usersyms
+ "Same, but for outputs."))
+ :returns
+ (mv (in-value-entries true-listp)
+ (in-decision-entries true-listp)
+ (out-value-entries true-listp)
+ (new-in-usersyms)
+ (new-out-usersyms))
+ (b* (((when (atom entries))
+ (mv nil nil nil in-usersyms out-usersyms))
+ ((mv first-values first-decisions first-outs in-usersyms out-usersyms)
+ (stv-expand-override-entry
+ name width pnum (car entries) in-usersyms out-usersyms))
+ ((mv rest-values rest-decisions rest-outs in-usersyms out-usersyms)
+ (stv-expand-override-entries
+ name width (+ 1 pnum) (cdr entries) in-usersyms out-usersyms)))
+ (mv (cons first-values rest-values)
+ (cons first-decisions rest-decisions)
+ (cons first-outs rest-outs)
+ in-usersyms out-usersyms)))
+
+(define stv-forge-state-bit ((instnames "List of instance names")
+ (st-name atom))
+ :returns (full-name atom :hyp :guard)
+ :parents (stv-compile)
+ :short "Generate the name for a state bit, like @('foo!bar!baz!inst!S'),
+given a list of instance names and the name of the state bit."
+ ;; BOZO have to keep this in sync with mod-state/occ-state
+ (if (atom instnames)
+ st-name
+ (acl2::prefix-atom (acl2::stringify (car instnames))
+ "!"
+ (stv-forge-state-bit (cdr instnames) st-name))))
+
+(cutil::defprojection stv-forge-state-bits (instnames x)
+ (stv-forge-state-bit instnames x)
+ :guard (atom-listp x)
+ :result-type atom-listp)
+
+
+(define stv-path-to-override-value-instnames (path)
+ :returns (st-path)
+ (if (atom path)
+ (if (symbolp path)
+ (list (ecutnames->value-reg (ecut-wire-names path)))
+ (raise "end of path isn't a symbol"))
+ (cons (car path) (stv-path-to-override-value-instnames (cdr path)))))
+
+(define stv-path-to-override-value-stbit (path)
+ :returns (st)
+ (stv-forge-state-bit (stv-path-to-override-value-instnames path)
+ "S"))
+
+(define stv-path-to-override-decision-instnames (path)
+ :returns (st-path)
+ (if (atom path)
+ (if (symbolp path)
+ (list (ecutnames->decision-reg (ecut-wire-names path)))
+ (raise "end of path isn't a symbol"))
+ (cons (car path) (stv-path-to-override-decision-instnames (cdr path)))))
+
+(define stv-path-to-override-decision-stbit (path)
+ :returns (st)
+ (stv-forge-state-bit (stv-path-to-override-decision-instnames path)
+ "S"))
+
+(cutil::defprojection stv-paths-to-override-value-stbits (x)
+ (stv-path-to-override-value-stbit x)
+ :guard t)
+
+(cutil::defprojection stv-paths-to-override-decision-stbits (x)
+ (stv-path-to-override-decision-stbit x)
+ :guard t)
+
+
+
+
+
+(define stv-expand-override-lines
+ ((lines "all the override lines, names already expanded into paths"
+ true-list-listp)
+ in-usersyms out-usersyms)
+ :returns (mv (in-table true-list-listp)
+ (out-table true-list-listp)
+ new-in-usersyms new-out-usersyms)
+ (b* (((when (atom lines))
+ (mv nil nil in-usersyms out-usersyms))
+ ((cons name entries) (car lines))
+ ((unless (and (consp name) (true-listp name)))
+ (raise "Programming error: malformed name ~x0" name)
+ (mv nil nil in-usersyms out-usersyms))
+ ((mv val-entries decision-entries out-entries in-usersyms out-usersyms)
+ (stv-expand-override-entries
+ name (len name) 0 entries in-usersyms out-usersyms))
+
+ (val-stbits (stv-paths-to-override-value-stbits name))
+ (dec-stbits (stv-paths-to-override-decision-stbits name))
+
+ (in-val-line (cons val-stbits val-entries))
+ (in-dec-line (cons dec-stbits decision-entries))
+
+ (out-line (cons val-stbits out-entries))
+
+ ((mv in-table out-table in-usersyms out-usersyms)
+ (stv-expand-override-lines (cdr lines) in-usersyms out-usersyms)))
+ (mv (cons in-val-line (cons in-dec-line in-table))
+ (cons out-line out-table)
+ in-usersyms out-usersyms)))
+
+
+#||
+(stv-expand-override-lines
+ '((;; name
+ ((a b . c[0])
+ (a b . c[1]))
+ ;; entries
+ 0
+ X
+ :ones
+ a
+ b
+ 2
+ _))
+ nil
+ nil)
+||#
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#||
+
+(include-book
+ "stv-expand")
+
+(defconst *s0*
+ (make-stvdata :inputs nil
+ :outputs nil
+ :internals nil
+ :initial '(("mmxcntl.rsMmxSrc3_I" src3i)
+ ("mmxcntl.rsMmxSrc2_I[4:2]" _)
+ ("mmxcntl.rsMmxSrc2_I[0]" 1)
+ ("mmxcntl.rsFeuBIBus_I[16:0]" bibus))))
+
+(defconst *s1*
+ (stv-expand *s0* |*mmx*|))
+
+(b* (((mv alist ?usersyms)
+ (stv-initial-lines-to-alist (stvdata->initial *s1*) nil |*mmx*|)))
+ (stv-add-suffixes-to-initial-alist alist))
+
+
+||#
@@ -1120,34 +928,37 @@
;
; -----------------------------------------------------------------------------
-(defsection stv-compile
+(define stv-compile
:parents (symbolic-test-vectors)
:short "Syntactically transform a symbolic test vector, readying it for
evaluation, debugging, etc."
- :long "Signature: @(call stv-compile) returns a @(see
-compiled-stv-p).
-
-Here, @('mod') should be a valid @(see esim) module, and @('stv') should be
-an @(see stvdata-p) that has already had its lines widened and any
-Verilog-style names expanded; see for instance @(see stv-widen) and @(see
-stv-expand-names).
-
-Compiling an STV involves doing lots of error checking to ensure the STV is
-syntactically well-formed, only refers to legitimate inputs and outputs, and so
-forth. After sanity checking, our basic goal is to compile the STV into a form
-that functions like @(see stv-run) and @(see stv-debug) can efficiently
-process.
-
-In particular, after compiling an STV we obtain an @(see compiled-stv-p)
-structure that says says how many steps we need to run for, explains the
-mappings from user-level simulation variables to their internal bit-encodings,
-and and has pre-computed alists for restricting the a @(see esim) run and
-extracting the results.
-
-Compilation is a syntactic process that is relatively cheap. We memoize it
-mainly in the hopes that it will keep the various alists the same across
-multiple evaluations of an STV.
+ ((stv stvdata-p
+ "An @(see stvdata-p) that has already had its lines widened and any
+ Verilog-style names expanded; see @(see stv-widen) and @(see
+ stv-expand-names).")
+
+ (mod good-esim-modulep
+ "The @(see esim) module this STV is about."))
+
+ :returns (cstv (equal (compiled-stv-p cstv)
+ (if cstv t nil)))
+
+ :long "Compiling an STV involves doing lots of error checking to ensure
+the STV is syntactically well-formed, only refers to legitimate inputs and
+outputs, and so forth. After sanity checking, our basic goal is to compile the
+STV into a form that functions like @(see stv-run) and @(see stv-debug) can
+efficiently process.
+
+In particular, after (successfully) compiling an STV we obtain a @(see
+compiled-stv-p) structure that says says how many steps we need to run for,
+explains the mappings from user-level simulation variables to their internal
+bit-encodings, and and has pre-computed alists for restricting the a @(see
+esim) run and extracting the results.
+
+Compilation is a syntactic process that is relatively cheap. We @(see
+memoize) it mainly in the hopes of keeping the various alists we create the
+same across multiple evaluations of an STV.
Note that to reuse the same @(see esim) simulations across related STVs, our
basic approach in @(see stv-run) is to do a fully general simulation of the
@@ -1166,106 +977,113 @@
builds a list of alists that say, for each step, which output bits we want to
collect and how we want to name them.
"
- (defund stv-compile (stv mod)
- (declare (xargs :guard (and (stvdata-p stv)
- (good-esim-modulep mod))))
- (b* (((stvdata stv) stv)
- (nphases (stv-number-of-phases stv))
- ((unless (posp nphases))
- (er hard? 'stv-compile "Trying to compile an STV without any phases?"))
-
- ;; Initials and inputs...
- (in-usersyms nil)
- ((mv initial-alist in-usersyms) (stv-initial-lines-to-alist stv.initial in-usersyms mod))
- ((mv inputs gensyms in-usersyms) (stv-expand-input-lines stv.inputs nil in-usersyms))
- (restrict-alist (stv-add-suffixes-to-initial-alist initial-alist))
- (restrict-alist (stv-restrict-alist inputs restrict-alist))
- (restrict-alist (make-fast-alist restrict-alist))
-
- ;; Outputs and internals...
- (out-usersyms nil)
- ((mv outputs out-usersyms) (stv-expand-output-lines stv.outputs out-usersyms))
- ((mv internals out-usersyms) (stv-expand-internal-lines stv.internals out-usersyms mod))
- (out-extract-alists (stv-extraction-alists (- nphases 1) outputs nil))
- (int-extract-alists (stv-extraction-alists (- nphases 1) internals nil))
-
- (all-in-bits (alist-keys restrict-alist))
- ((unless (uniquep all-in-bits))
- ;; This could be really bad because you'd be shadowing one value with
- ;; another, and it could easily happen to you if you gave two
- ;; different paths on :initial things that turned out to refer to the
- ;; same state bit.
- (er hard? 'stv-compile
- "Name clash. Multiple input/initial bindings were generated for ~x0."
- (duplicated-members all-in-bits)))
-
- (in-simvars (alist-keys in-usersyms))
- (out-simvars (alist-keys out-usersyms))
- ((unless (and (uniquep in-simvars)
- (uniquep out-simvars)
- (symbol-listp in-simvars)
- (symbol-listp out-simvars)))
- (er hard? 'stv-compile
- "Programming error. in-simvars or out-simvars aren't unique ~
- symbols. This shouldn't be possible."))
-
- (illegally-reused-simvars (duplicated-members (append in-simvars out-simvars)))
- ((when illegally-reused-simvars)
- ;; This is something the user could try to do. It wouldn't *really*
- ;; be a problem, but certainly seems to indicate confusion on their
- ;; part.
- (er hard? 'stv-compile
- "Error: It is illegal to reuse the input simulation variables ~
- (from :input and :initial lines) as output simulation ~
- variables (from :output and :internal lines). Illegally ~
- reused variables: ~x0" illegally-reused-simvars))
-
- (all-bits (vl::append-domains-exec in-usersyms gensyms))
- (all-bits (vl::append-domains-exec out-usersyms all-bits))
- ((unless (uniquep all-bits))
- ;; It's hard to imagine this happening, if the in-usersyms and
- ;; out-usersyms have unique keys. But if somehow the user gave a
- ;; simulation variable name that clashed with a gensym, it'd be bad.
- (er hard? 'stv-compile "Name clash for ~x0." (duplicated-members all-bits)))
-
- (ret (make-compiled-stv
- :nphases nphases
- :restrict-alist restrict-alist
-
- ;; These have to stay separate because we have to use them to
- ;; extract from different esim outputs
- :out-extract-alists out-extract-alists
- :int-extract-alists int-extract-alists
-
- ;; I reverse these here so that they are "in the right order"
- ;; per the lines of the STV. This isn't anything that is
- ;; semantically important, but it makes things like
- ;; stv-autohyps, stv-autoins, stv->ins, etc. nicer to look at
- ;; because you see the stuff in the same order as you put it in.
- :in-usersyms (make-fast-alist (rev in-usersyms))
- :out-usersyms (make-fast-alist (rev out-usersyms))
-
- ;; These have some various uses in documentation and also in
- ;; stv-process, but probably we should work to get rid of these.
- :expanded-ins inputs
- :expanded-outs outputs
- :expanded-ints internals
- )))
-
- (fast-alist-free in-usersyms)
- (fast-alist-free out-usersyms)
- ret))
+ (b* (((stvdata stv) stv)
+ (nphases (stv-number-of-phases stv))
+ ((unless (posp nphases))
+ (raise "Trying to compile an STV without any phases?"))
+
+ (override-paths (stv-append-alist-keys stv.overrides))
+ (mod (stv-cut-module override-paths mod))
+
+ ;; Inputs...
+ (in-usersyms nil)
+ ((mv inputs gensyms in-usersyms)
+ (stv-expand-input-lines stv.inputs nil in-usersyms))
+
+ (restrict-alist nil)
+ (restrict-alist (stv-restrict-alist inputs restrict-alist))
+
+ ;; Outputs and internals...
+ (out-usersyms nil)
+ ((mv outputs out-usersyms)
+ (stv-expand-output-lines stv.outputs out-usersyms))
+ ((mv internals out-usersyms)
+ (stv-expand-internal-lines stv.internals out-usersyms mod))
+ (out-extract-alists (stv-extraction-alists (- nphases 1) outputs nil))
+ (int-extract-alists (stv-extraction-alists (- nphases 1) internals nil))
+
+ ((mv override-ins override-outs in-usersyms out-usersyms)
+ (stv-expand-override-lines stv.overrides in-usersyms out-usersyms))
+ (restrict-alist (stv-restrict-alist override-ins restrict-alist))
+ (nst-extract-alists (stv-extraction-alists (- nphases 1) override-outs nil))
+
+ (all-in-bits (alist-keys restrict-alist))
+ ((unless (uniquep all-in-bits))
+ ;; This could be really bad because you'd be shadowing one value with
+ ;; another, and it could easily happen to you if you gave two
+ ;; different paths on :initial things that turned out to refer to the
+ ;; same state bit.
+ (raise "Name clash. Multiple input/initial bindings were generated ~
+ for ~x0." (duplicated-members all-in-bits)))
+
+ (in-simvars (alist-keys in-usersyms))
+ (out-simvars (alist-keys out-usersyms))
+ ((unless (and (uniquep in-simvars)
+ (uniquep out-simvars)
+ (symbol-listp in-simvars)
+ (symbol-listp out-simvars)))
+ (raise "Programming error. in-simvars or out-simvars aren't unique ~
+ symbols. This shouldn't be possible."))
+
+ ;; (illegally-reused-simvars
+ ;; (duplicated-members (append in-simvars out-simvars)))
+ ;; ((when illegally-reused-simvars)
+ ;; ;; This is something the user could try to do. It wouldn't *really*
+ ;; ;; be a problem, but certainly seems to indicate confusion on their
+ ;; ;; part.
+ ;; (raise "Error: It is illegal to reuse the input simulation variables ~
+ ;; (from :input and :initial lines) as output simulation ~
+ ;; variables (from :output and :internal lines). Illegally ~
+ ;; reused variables: ~x0" illegally-reused-simvars))
+
+ (all-in-bits (vl::append-domains-exec in-usersyms gensyms))
+ ((unless (uniquep all-in-bits))
+ ;; It's hard to imagine this happening, but if somehow the user gave an
+ ;; input simulation variable name that clashed with a gensym, it'd be
+ ;; bad.
+ (raise "Name clash for ~x0." (duplicated-members all-in-bits)))
+
+ (override-bits
+ (stv-append-alist-keys override-ins))
+ ((unless (symbol-listp override-bits))
+ (raise "Programming error -- override-bits should be a symbol-list: ~x0"
+ override-bits))
+
+ (ret (make-compiled-stv
+ :nphases nphases
+ :restrict-alist restrict-alist
+
+ ;; These have to stay separate because we have to use them to
+ ;; extract from different esim outputs
+ :out-extract-alists out-extract-alists
+ :int-extract-alists int-extract-alists
+ :nst-extract-alists nst-extract-alists
+
+ :override-bits override-bits
+
+ ;; I reverse these here so that they are "in the right order"
+ ;; per the lines of the STV. This isn't anything that is
+ ;; semantically important, but it makes things like
+ ;; stv-autohyps, stv-autoins, stv->ins, etc. nicer to look at
+ ;; because you see the stuff in the same order as you put it in.
+ :in-usersyms (make-fast-alist (rev in-usersyms))
+ :out-usersyms (make-fast-alist (rev out-usersyms))
+
+ ;; These have some various uses in documentation and also in
+ ;; stv-process, but probably we should work to get rid of these.
+ :expanded-ins inputs
+
+ :override-paths override-paths
+ )))
+
+ (fast-alist-free in-usersyms)
+ (fast-alist-free out-usersyms)
+ ret)
+
+ ///
;; Compilation isn't necessarily slow, but memoizing it seems like a good
;; idea to make sure that all of the alists stay the same.
- (memoize 'stv-compile)
-
- (local (in-theory (enable stv-compile)))
-
- (defthm compiled-stv-p-of-stv-compile
- (equal (compiled-stv-p (stv-compile stv mod))
- (if (stv-compile stv mod)
- t
- nil))))
+ (memoize 'stv-compile))
diff -Nru acl2-6.2/books/centaur/esim/stv/stv-debug.lisp acl2-6.3/books/centaur/esim/stv/stv-debug.lisp
--- acl2-6.2/books/centaur/esim/stv/stv-debug.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/stv/stv-debug.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -28,7 +28,7 @@
(include-book "centaur/misc/tshell" :dir :system)
(include-book "../esim-vcd")
(local (include-book "centaur/vl/util/arithmetic" :dir :system))
-
+(local (include-book "system/f-put-global" :dir :system))
(local (defthm len-of-4v-sexpr-restrict-with-rw-alists
(equal (len (4v-sexpr-restrict-with-rw-alists x al))
@@ -43,157 +43,181 @@
(local (defthm cons-list-listp-of-4v-sexpr-restrict-with-rw-alists
(vl::cons-list-listp (4v-sexpr-restrict-with-rw-alists x al))))
+(local (defthm cons-listp-of-4v-sexpr-eval-alist
+ (vl::cons-listp (4v-sexpr-eval-alist x al))))
+
+(local (defthm cons-list-listp-of-4v-sexpr-eval-alists
+ (vl::cons-list-listp (4v-sexpr-eval-alists x al))))
+(define stv-combine-into-snapshots
+ :parents (stv-debug)
+ ((in-alists true-list-listp)
+ (out-alists true-list-listp)
+ (int-alists true-list-listp))
+ :guard (and (same-lengthp in-alists out-alists)
+ (same-lengthp in-alists int-alists))
+ :returns (snapshots vl::cons-list-listp
+ :hyp (and (vl::cons-list-listp in-alists)
+ (vl::cons-list-listp out-alists)
+ (vl::cons-list-listp int-alists)))
+ (b* (((when (atom in-alists))
+ nil)
+ (snapshot1 (append (car in-alists)
+ (car out-alists)
+ (car int-alists))))
+ (cons snapshot1 (stv-combine-into-snapshots (cdr in-alists)
+ (cdr out-alists)
+ (cdr int-alists)))))
+
+(define stv-make-snapshots
+ :parents (stv-debug)
+ :short "Prepare an STV for debugging by create \"snapshots\" that are ready
+to be evaluated and written to the VCD file."
+ ((pstv processed-stv-p)
+ (mod))
+ :returns (snapshots vl::cons-list-listp)
+ :long "This is computationally expensive. We memoize it so that we only
+need to make the snapshots the first time you want to debug an STV. The same
+snapshots can then be reused across as many calls of @(see stv-debug) as you
+like.
"
+
+ (b* (((processed-stv pstv) pstv)
+ ((compiled-stv cstv) pstv.compiled-stv)
+ (nphases (nfix cstv.nphases))
+ ((unless (posp nphases))
+ (raise "STV has no phases?"))
+
+ ((mv ?init-st-general
+ in-alists-general
+ ?nst-alists-general
+ out-alists-general
+ int-alists-general)
+ (time$ (stv-fully-general-simulation-debug nphases mod cstv.override-bits)
+ :msg "; stv debug simulation: ~st sec, ~sa bytes.~%"
+ :mintime 1/2)))
+
+ (with-fast-alist cstv.restrict-alist
+ (time$ (stv-combine-into-snapshots
+ (4v-sexpr-restrict-with-rw-alists in-alists-general cstv.restrict-alist)
+ (4v-sexpr-restrict-with-rw-alists out-alists-general cstv.restrict-alist)
+ (4v-sexpr-restrict-with-rw-alists int-alists-general cstv.restrict-alist))
+ :msg "; stv-debug general snapshots: ~st sec, ~sa bytes.~%"
+ :mintime 1/2)))
+ ///
+ (memoize 'stv-make-snapshots :aokp t))
(defttag writes-okp)
(remove-untouchable acl2::writes-okp nil)
-(defsection stv-make-snapshots
-
- (defund stv-combine-into-snapshots (in-alists out-alists int-alists)
- (declare (xargs :guard (and (vl::same-lengthp in-alists out-alists)
- (vl::same-lengthp in-alists int-alists)
- (true-list-listp in-alists)
- (true-list-listp out-alists)
- (true-list-listp int-alists))))
- (if (atom in-alists)
- nil
- (let ((snapshot1 (append (car in-alists)
- (car out-alists)
- (car int-alists))))
- (cons snapshot1 (stv-combine-into-snapshots (cdr in-alists)
- (cdr out-alists)
- (cdr int-alists))))))
-
- (local (defthm c0
- (implies (and (vl::cons-list-listp in-alists)
- (vl::cons-list-listp out-alists)
- (vl::cons-list-listp int-alists))
- (vl::cons-list-listp
- (stv-combine-into-snapshots in-alists out-alists int-alists)))
- :hints(("Goal" :in-theory (enable stv-combine-into-snapshots)))))
-
- (defund stv-make-snapshots (pstv)
- (declare (xargs :guard (processed-stv-p pstv)))
- (b* (((processed-stv pstv) pstv)
-
- ((compiled-stv cstv) pstv.compiled-stv)
- (nphases (nfix cstv.nphases))
- ((unless (posp nphases))
- (er hard? 'stv-process "STV has no phases?"))
-
- ((mv ?init-st-general
- in-alists-general
- ?nst-alists-general
- out-alists-general
- int-alists-general)
- (time$ (stv-fully-general-simulation-debug nphases pstv.mod)
- :msg "; stv debug simulation: ~st sec, ~sa bytes.~%"
- :mintime 1/2))
-
- (snapshots
- (with-fast-alist cstv.restrict-alist
- (time$ (stv-combine-into-snapshots
- (4v-sexpr-restrict-with-rw-alists in-alists-general cstv.restrict-alist)
- (4v-sexpr-restrict-with-rw-alists out-alists-general cstv.restrict-alist)
- (4v-sexpr-restrict-with-rw-alists int-alists-general cstv.restrict-alist))
- :msg "; stv-debug general snapshots: ~st sec, ~sa bytes.~%"
- :mintime 1/2))))
- snapshots))
-
- (memoize 'stv-make-snapshots :aokp t)
-
- (defthm cons-list-listp-of-stv-make-snapshots
- (vl::cons-list-listp (stv-make-snapshots pstv))
- :hints(("Goal" :in-theory (e/d (stv-make-snapshots)
- ((force)))))))
-
+; Added by Matt K., 9/28/2013, to get around ACL2(hp) error such as:
+; Error: Not owner of hash table #
+; David Rager points out (email, 9/28/2013) that "memoization is known
+; not to be thread-safe"; Jared Davis says this too. (Perhaps this will be
+; addressed in the future.)
+(local (unmemoize 'mod-state))
+(local (unmemoize 'occmap))
-
-(defsection stv-debug
+(define stv-debug
:parents (symbolic-test-vectors)
:short "Evaluate a symbolic test vector at particular, concrete inputs, and
generate a waveform."
-
+ ((pstv processed-stv-p)
+ input-alist
+ &key
+ ((filename stringp) '"stv.debug")
+ ((viewer (or (stringp viewer) (not viewer))) '"gtkwave")
+ (state 'state))
+ :guard-debug t
+ :returns (mv out-alist state)
:long "This macro is an extended version of @(see stv-run). In addition
to building an alist of the output simulation variables, it also writes out a
waveform that can be viewed in a VCD viewer. Note that debugging can be slow,
especially the first time before things are memoized.
"
- (defun stv-debug-fn (pstv input-alist filename viewer state)
- "Returns (MV OUT-ALIST STATE)"
- (declare (xargs :guard (processed-stv-p pstv)
- :stobjs state
- :mode :program))
- (time$
- (b* (((processed-stv pstv) pstv)
- ((compiled-stv cstv) pstv.compiled-stv)
-
- (snapshots
- (time$ (stv-make-snapshots pstv)
- :mintime 1/2
- :msg "; stv-debug snapshots: ~st sec, ~sa bytes.~%"))
-
- (in-usersyms
- ;; These should already be a fast alist, but in case the object was
- ;; serialized and reloaded or something, we'll go ahead and try to
- ;; make them fast again.
- (make-fast-alist cstv.in-usersyms))
-
- (ev-alist
- (time$ (make-fast-alist
- (stv-simvar-inputs-to-bits input-alist in-usersyms))
- :mintime 1/2
- :msg "; stv-debug ev-alist: ~st sec, ~sa bytes.~%"))
-
- (evaled-out-bits
- (time$ (make-fast-alist
- (4v-sexpr-eval-alist pstv.relevant-signals ev-alist))
- :mintime 1/2
- :msg "; stv-debug evaluating sexprs: ~st sec, ~sa bytes.~%"))
-
- (evaled-snapshots
- (time$ (4v-sexpr-eval-alists snapshots ev-alist)
- :mintime 1/2
- :msg "; stv-debug evaluating snapshots: ~st sec, ~sa bytes.~%"))
-
- (- (fast-alist-free ev-alist))
-
- (assembled-outs
- (time$ (stv-assemble-output-alist evaled-out-bits cstv.out-usersyms)
- :mintime 1/2
- :msg "; stv-debug assembling outs: ~st sec, ~sa bytes.~%"))
-
- (- (fast-alist-free evaled-out-bits))
-
- ;; Actual VCD generation
- ((mv date state) (oslib::date))
- (dump (vl::vcd-dump-main pstv.mod evaled-snapshots date))
-
- ((mv & & state) (assign acl2::writes-okp t))
- (state (time$ (vl::with-ps-file filename
- (vl::vl-ps-update-rchars dump))
- :mintime 1/2
- :msg "; vcd-dump file generation: ~st seconds, ~sa bytes.~%"))
-
- ;; Maybe launch a VCD viewer, but not if we're certifying books
- (certifying-book-p (acl2::f-get-global 'acl2::certify-book-info state))
-
- ;; BOZO we aren't really escaping filenames right or anything like that
- (- (if (and viewer (not certifying-book-p))
- (b* ((cmd (str::cat viewer " " filename)))
- (cw "; vcd-dump launching \"~s0\".~%" cmd)
- (acl2::tshell-ensure)
- (acl2::tshell-run-background cmd))
- nil)))
-
- (mv assembled-outs state))
- :msg "; stv-debug: ~st sec, ~sa bytes.~%"
- :mintime 1))
-
- (defmacro stv-debug (pstv input-alist
- &key
- (filename '"stv.debug")
- (viewer '"gtkwave"))
- `(stv-debug-fn ,pstv ,input-alist ,filename ,viewer state)))
-
+ (time$
+ (b* (((processed-stv pstv) pstv)
+ ((compiled-stv cstv) pstv.compiled-stv)
+
+ (mod-function (intern-in-package-of-symbol
+ (str::cat (symbol-name pstv.name) "-MOD")
+ pstv.name))
+ ((mv er mod)
+ (magic-ev-fncall mod-function
+ nil ;; args
+ state
+ t ;; hard error returns nil? sure why not
+ t ;; attachments allowed? sure why not
+ ))
+
+ ((when er)
+ (mv (raise "Error evaluating ~x0 to look up STV module: ~@1."
+ mod-function (if (eq er 't) "t" er))
+ state))
+ ((unless (good-esim-modulep mod))
+ (mv (raise "Error: ~x0 returned a bad ESIM module: ~@1"
+ mod-function (bad-esim-modulep mod))
+ state))
+
+ (snapshots
+ (time$ (stv-make-snapshots pstv mod)
+ :mintime 1/2
+ :msg "; stv-debug snapshots: ~st sec, ~sa bytes.~%"))
+
+ (in-usersyms
+ ;; These should already be a fast alist, but in case the object was
+ ;; serialized and reloaded or something, we'll go ahead and try to
+ ;; make them fast again.
+ (make-fast-alist cstv.in-usersyms))
+
+ (ev-alist
+ (time$ (make-fast-alist
+ (stv-simvar-inputs-to-bits input-alist in-usersyms))
+ :mintime 1/2
+ :msg "; stv-debug ev-alist: ~st sec, ~sa bytes.~%"))
+
+ (evaled-out-bits
+ (time$ (make-fast-alist
+ (4v-sexpr-eval-alist pstv.relevant-signals ev-alist))
+ :mintime 1/2
+ :msg "; stv-debug evaluating sexprs: ~st sec, ~sa bytes.~%"))
+
+ (evaled-snapshots
+ (time$ (4v-sexpr-eval-alists snapshots ev-alist)
+ :mintime 1/2
+ :msg "; stv-debug evaluating snapshots: ~st sec, ~sa bytes.~%"))
+
+ (- (fast-alist-free ev-alist))
+
+ (assembled-outs
+ (time$ (stv-assemble-output-alist evaled-out-bits cstv.out-usersyms)
+ :mintime 1/2
+ :msg "; stv-debug assembling outs: ~st sec, ~sa bytes.~%"))
+
+ (- (fast-alist-free evaled-out-bits))
+
+ ;; Actual VCD generation
+ ((mv date state) (oslib::date))
+ (dump (vl::vcd-dump-main mod evaled-snapshots date))
+
+ ((mv & & state) (assign acl2::writes-okp t))
+ (state (time$ (vl::with-ps-file filename
+ (vl::vl-ps-update-rchars dump))
+ :mintime 1/2
+ :msg "; vcd-dump file generation: ~st seconds, ~sa bytes.~%"))
+
+ ;; Maybe launch a VCD viewer, but not if we're certifying books
+ (certifying-book-p
+ (and (acl2::boundp-global 'acl2::certify-book-info state)
+ (acl2::f-get-global 'acl2::certify-book-info state)))
+
+ ;; BOZO we aren't really escaping filenames right or anything like that
+ (- (if (and viewer (not certifying-book-p))
+ (b* ((cmd (str::cat viewer " " filename)))
+ (cw "; vcd-dump launching \"~s0\".~%" cmd)
+ (acl2::tshell-ensure)
+ (acl2::tshell-run-background cmd))
+ nil)))
+
+ (mv assembled-outs state))
+ :msg "; stv-debug: ~st sec, ~sa bytes.~%"
+ :mintime 1))
diff -Nru acl2-6.2/books/centaur/esim/stv/stv-doc.lisp acl2-6.3/books/centaur/esim/stv/stv-doc.lisp
--- acl2-6.2/books/centaur/esim/stv/stv-doc.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/stv/stv-doc.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -26,18 +26,45 @@
(include-book "stv-widen")
(include-book "str/stringify" :dir :system)
(include-book "centaur/vl/util/print-htmlencode" :dir :system)
+(local (include-book "std/typed-lists/character-listp" :dir :system))
+(local (include-book "str/explode-nonnegative-integer" :dir :system))
-(defund stv-name-bits-to-xml (bits col acc)
- ;; Probably horrible way to print out individual bits, if the user writes that
- ;; sort of thing
- (declare (xargs :guard (and (true-listp bits)
- (natp col))))
+(defsection stv-doc
+ :parents (symbolic-test-vectors)
+ :short "Automatic documentation support for symbolic test vectors."
+
+ :long "Symbolic test vectors are integrated into @(see xdoc) so that you
+can generate attractive explanations of your setup. This is often useful when
+communicating with logic designers. For an example, see @(see counter-run) in
+the @(see esim-tutorial).
+
+NOTE : the topics here cover how we generate this documentation. If
+you just want to document your own STVs, you don't need to know about any of
+this—just give a @(':parents'), @(':short'), or @(':long') argument to
+@(see defstv).
+
+These functions don't do much error checking. We expect that we only are
+going to generate documentation after successfully processing the STV, so we
+generally just expect things to be well-formed at this point.
+
+The XML we generate is not documented in @(see xdoc)'s @(see xdoc::markup),
+and is not supported by tools like @(':xdoc'). How these new tags get rendered
+into HTML is controlled by, e.g., @('xdoc/fancy/render.xsl').
")
+
+(define stv-name-bits-to-xml ((bits true-listp)
+ (col natp)
+ acc)
+ :returns (acc character-listp :hyp (character-listp acc))
+ :parents (stv-doc)
+ :short "Encode the name of an STV line, when the name is a list of E bits."
+ :long "This is really horrible, but it doesn't matter since nobody would
+ever actually use a list of E bits to name their input.
"
(b* (((when (atom bits))
acc)
;; Print the name of this bit
(name1 (stringify (car bits)))
((mv col acc)
- (vl::vl-html-encode-string-aux name1 0 (length name1) col 8 acc))
+ (vl::vl-html-encode-string-aux name1 0 (length name1) (lnfix col) 8 acc))
;; Print ", " if there are more bits.
((mv col acc)
(if (atom (cdr bits))
@@ -46,14 +73,10 @@
;; Print the rest of the bit names.
(stv-name-bits-to-xml (cdr bits) col acc)))
-(defthm character-listp-of-stv-name-bits-to-xml
- (implies (and (character-listp acc)
- (natp col))
- (character-listp (stv-name-bits-to-xml bits col acc)))
- :hints(("Goal" :in-theory (enable stv-name-bits-to-xml))))
-
-(defund stv-name-to-xml (name acc)
- (declare (xargs :guard t))
+(define stv-name-to-xml (name acc)
+ :returns (acc character-listp :hyp (character-listp acc))
+ :parents (stv-doc)
+ :short "Encode the name of an STV line."
(cond ((stringp name)
;; It already looks like a Verilog name, so this is easy enough.
(b* (((mv ?col acc)
@@ -66,15 +89,14 @@
(acc (cons #\} acc)))
acc))
(t
- (er hard? 'stv-name-to-xml "Bad name for stv line: ~x0." name))))
-
-(defthm character-listp-of-stv-name-to-xml
- (implies (character-listp acc)
- (character-listp (stv-name-to-xml name acc)))
- :hints(("Goal" :in-theory (enable stv-name-to-xml))))
+ (raise "Bad name for stv line: ~x0." name))))
-(defund stv-entry-to-xml (entry expansion acc)
- (declare (xargs :guard t))
+(define stv-entry-to-xml ((entry "The value that the user gave, originally.")
+ (expansion "Its expanded out value, a sexpr list.")
+ acc)
+ :returns (acc character-listp :hyp (character-listp acc))
+ :parents (stv-doc)
+ :short "Encode a single value from an STV line."
(cond ((natp entry)
(if (< entry 10)
;; As a special nicety, write values under 10 without any
@@ -82,7 +104,7 @@
(revappend (str::natchars entry) acc)
;; For any larger constants, write them in hex. I'll use a 0x
;; prefix instead of a #x prefix, since it's probably more widely
- ;; understood.
+ ;; understood (e.g., by logic designers)
(let* ((pound-x-hex-digits (explode-atom+ entry 16 t)) ;; #x1000
(zero-x-hex-digits (cons #\0 (cdr pound-x-hex-digits)))) ;; 0x1000
(revappend zero-x-hex-digits acc))))
@@ -101,7 +123,7 @@
((equal expansion (list *4vf-sexpr*))
(cons #\0 acc))
(t
- (progn$ (er hard? 'stv-entry-to-xml "Expansion of ~ should be 1 or 0.")
+ (progn$ (raise "Expansion of ~ should be 1 or 0.")
acc))))
((eq entry '_)
@@ -118,16 +140,15 @@
acc))
(t
- (er hard? 'stv-entry-to-xml
- "Bad entry in stv line: ~x0." entry))))
+ (raise "Bad entry in stv line: ~x0." entry))))
-(defthm character-listp-of-stv-entry-to-xml
- (implies (character-listp acc)
- (character-listp (stv-entry-to-xml entry expansion acc)))
- :hints(("Goal" :in-theory (enable stv-entry-to-xml))))
-
-(defund stv-entries-to-xml (entries expansions acc)
- (declare (xargs :guard (true-listp expansions)))
+(define stv-entries-to-xml ((entries "The original entries for this line.")
+ (expansions "The expanded entries for this line."
+ true-listp)
+ acc)
+ :returns (acc character-listp :hyp (character-listp acc))
+ :parents (stv-doc)
+ :short "Encode all the values from an STV line."
(b* (((when (atom entries))
acc)
(acc (str::revappend-chars "" acc))
@@ -135,14 +156,15 @@
(acc (str::revappend-chars " " acc)))
(stv-entries-to-xml (cdr entries) (cdr expansions) acc)))
-(defthm character-listp-of-stv-entries-to-xml
- (implies (character-listp acc)
- (character-listp (stv-entries-to-xml entries expansions acc)))
- :hints(("Goal" :in-theory (enable stv-entries-to-xml))))
-
-(defund stv-line-to-xml (line expansion acc)
- (declare (xargs :guard (and (true-listp line)
- (true-listp expansion))))
+(define stv-line-to-xml
+ ((line "Original line, with name, given by the user."
+ true-listp)
+ (expansion "Fully expanded line, with name, after STV processing"
+ true-listp)
+ acc)
+ :returns (acc character-listp :hyp (character-listp acc))
+ :parents (stv-doc)
+ :short "Encode one full line from the STV into XML for XDOC."
(b* ((acc (str::revappend-chars "" acc))
(acc (str::revappend-chars "" acc))
(acc (stv-name-to-xml (car line) acc))
@@ -152,27 +174,20 @@
(acc (cons #\Newline acc)))
acc))
-(defthm character-listp-of-stv-line-to-xml
- (implies (character-listp acc)
- (character-listp (stv-line-to-xml line expansion acc)))
- :hints(("Goal" :in-theory (enable stv-line-to-xml))))
-
-(defund stv-lines-to-xml (lines expansions acc)
- (declare (xargs :guard (and (true-list-listp lines)
- (true-list-listp expansions))))
+(define stv-lines-to-xml ((lines true-list-listp)
+ (expansions true-list-listp)
+ acc)
+ :returns (acc character-listp :hyp (character-listp acc))
+ :parents (stv-doc)
(b* (((when (atom lines))
acc)
(acc (stv-line-to-xml (car lines) (car expansions) acc)))
(stv-lines-to-xml (cdr lines) (cdr expansions) acc)))
-(defthm character-listp-of-stv-lines-to-xml
- (implies (character-listp acc)
- (character-listp (stv-lines-to-xml lines expansions acc)))
- :hints(("Goal" :in-theory (enable stv-lines-to-xml))))
-
-
-(defund stv-labels-to-xml (labels acc)
- (declare (xargs :guard (symbol-listp labels)))
+(define stv-labels-to-xml ((labels symbol-listp)
+ acc)
+ :returns (acc character-listp :hyp (character-listp acc))
+ :parents (stv-doc)
(b* (((when (atom labels))
acc)
(acc (str::revappend-chars "" acc))
@@ -182,26 +197,25 @@
(acc (str::revappend-chars " " acc)))
(stv-labels-to-xml (cdr labels) acc)))
-(defthm character-listp-of-stv-labels-to-xml
- (implies (character-listp acc)
- (character-listp (stv-labels-to-xml labels acc)))
- :hints(("Goal" :in-theory (enable stv-labels-to-xml))))
-
-
+(define stv-to-xml ((stv stvdata-p)
+ (cstv compiled-stv-p)
+ (labels symbol-listp))
+ :returns (encoding (or (stringp encoding)
+ (not encoding))
+ :rule-classes :type-prescription)
+ :parents (stv-doc)
+ :short "Top-level routine to generate a nice XML description of an STV."
-(defund stv-to-xml (stv cstv labels)
- (declare (xargs :guard (and (stvdata-p stv)
- (compiled-stv-p cstv)
- (symbol-listp labels))))
(b* (;; Widen all the lines so the table will be filled.
(stv (stv-widen stv))
((stvdata stv) stv)
;; Grab the expanded input lines, since they'll have the resolved tilde
- ;; (~) entries. We don't need to expand the output or internal lines.
- (ex-ins (compiled-stv->expanded-ins cstv))
+ ;; (~) entries. We don't need to expand the output, internal, or
+ ;; override lines.
+ (ex-ins (compiled-stv->expanded-ins cstv))
((unless (true-list-listp ex-ins))
- (er hard? 'stv-to-xml "Expanded inputs aren't a true-list-listp?"))
+ (raise "Expanded inputs aren't a true-list-listp?"))
(acc nil)
(acc (str::revappend-chars "" acc))
@@ -215,12 +229,6 @@
acc))
(acc (cons #\Newline acc))
- (acc (str::revappend-chars "" acc))
- (acc (cons #\Newline acc))
- (acc (stv-lines-to-xml stv.initial nil acc))
- (acc (str::revappend-chars " " acc))
- (acc (cons #\Newline acc))
-
(acc (str::revappend-chars "" acc))
(acc (cons #\Newline acc))
(acc (stv-lines-to-xml stv.inputs ex-ins acc))
@@ -239,13 +247,14 @@
(acc (str::revappend-chars "" acc))
(acc (cons #\Newline acc))
+ (acc (str::revappend-chars "" acc))
+ (acc (cons #\Newline acc))
+ (acc (stv-lines-to-xml stv.overrides nil acc))
+ (acc (str::revappend-chars " " acc))
+ (acc (cons #\Newline acc))
+
(acc (str::revappend-chars " " acc)))
- (reverse (coerce acc 'string))))
+ (str::rchars-to-string acc)))
-(defthm stringp-of-stv-to-xml
- (or (stringp (stv-to-xml stv expansion labels))
- (not (stv-to-xml stv expansion labels)))
- :rule-classes :type-prescription
- :hints(("Goal" :in-theory (enable stv-to-xml))))
diff -Nru acl2-6.2/books/centaur/esim/stv/stv-expand.lisp acl2-6.3/books/centaur/esim/stv/stv-expand.lisp
--- acl2-6.2/books/centaur/esim/stv/stv-expand.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/stv/stv-expand.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -123,16 +123,23 @@
(equal (list name msb lsb) '("foo" 5 3)))))))
-(defsection stv-expand-name
+(define stv-expand-name
:parents (stv-expand)
:short "Expand a name from a symbolic test vector's line into explicit lists
of E bits."
- :long "Signature: @(call stv-expand-name) returns an LSB-first list
-of E bits for a non-hierarchical valid STV signal name.
+ ((x "The name that the user put at the start of some STV line.")
+ (type "Either @(':i') or @(':o') and says whether this should be the name
+ of an input or output."
+ (or (eq type :i)
+ (eq type :o)))
+ (mod "The @(see esim) module we are working in, so we can look up names."))
-As described in @(see acl2::symbolic-test-vector-format), the signal names
-for :input and :output lines can be either:
+ :returns (lsb-bits "An LSB-first list of E bits for a non-hierarchical valid
+ STV signal name, e.g., @('(|foo[0]| |foo[1]| ...)').")
+
+ :long "Recall from @(see acl2::symbolic-test-vector-format) that signal
+names for :input and :output lines can be either:
A string that names a particular input bus,
@@ -141,81 +148,68 @@
An explicit list of E bits (in LSB-first order).
-This function is given @('x'), the actual name that occurs on such a line.
-Our goal is to convert @('x') into the explicit bit list form. If @('x') is
-already a list of bits then this is trivial. Otherwise, we have to look it up
-in the module.
-
-Type is either @(':i') or @(':o') and says whether this should be the name
-of an input or output, and @('mod') is the whole E module so that we can look
-up its inputs and outputs.
-
-We do basic error checking to make sure that the name refers to valid input
-or output bits.
"
-
- (defund stv-expand-name (x type mod)
- "Returns an LSB-first list of bit names, e.g., (|foo[0]| |foo[1]| ...)."
- (declare (xargs :guard (symbolp type)))
- (b* ((pat (gpl type mod))
- (modname (gpl :n mod))
-
- ((when (stringp x))
- (b* ( ;; Note: for plain names msb/lsb will be nil.
- ((mv ?err basename msb lsb) (stv-wirename-parse x))
- ((when err)
- (er hard? 'stv-expand-name "~s0" err))
- (basename-bits (vl::esim-vl-find-io basename pat))
- ((unless basename-bits)
- (er hard? 'stv-expand-name
- "Trying to expand ~s0, but there is no ~s1 named ~s2 in ~x3."
- x
- (if (equal type :i) "input" "output")
- basename
- modname))
-
- ((unless (and msb lsb))
- ;; The input name is just "foo", so get all of the wires of
- ;; foo. This lets you refer to busses by name without having
- ;; to give their explicit indices in the STV.
- basename-bits)
-
- ;; Else, the input is "foo[5:3]" or similar, so we want to just
- ;; get bits 5-3. But put them in LSB-first order so they'll line
- ;; up with the basename-bits
- (expect-bits
- ;; Stupid hack: it would be nicer to write:
- ;; (reverse (vl-emodwires-from-msb-to-lsb basename msb lsb))
- ;; But we just reverse the lsb/msb to avoid the extra consing
- (vl::vl-emodwires-from-msb-to-lsb basename lsb msb))
- ((unless (ordered-subsetp expect-bits basename-bits))
- (er hard? 'stv-expand-name
- "Trying to expand ~s0, but the bits being asked for ~s1.~% ~
- - Found wires: ~x2 through ~x3~% ~
- - Want wires: ~x4 through ~x5."
- x
- (if (subsetp-equal expect-bits basename-bits)
- "are not in the right order"
- "are not found")
- (car basename-bits)
- (car (last basename-bits))
- (car expect-bits)
- (car (last expect-bits)))))
- expect-bits))
-
- ;; Otherwise, we should have been given a list of valid input bits.
- ((unless (symbol-listp x))
- (er hard? 'stv-expand-name
- "Invalid input name (expected string or a list of e bits), but ~
- found ~x0."
- x))
-
- (flat-pat (pat-flatten1 pat))
- ((unless (subsetp-equal x flat-pat))
- (er hard? 'stv-expand-name
- "Trying to provide bindings for ~s0 that don't exist: ~x1."
- (if (equal type :i) "inputs" "outputs")
- (set-difference-equal flat-pat x))))
- x)))
+Here, our goal is to convert any such name, @('x'), into the explicit bit
+list form. If @('x') is already a list of bits then this is trivial.
+Otherwise, we have to look it up in the module. We do basic error checking to
+make sure that the name refers to valid input or output bits.
"
+
+ (b* ((pat (gpl type mod))
+ (modname (gpl :n mod))
+
+ ((when (stringp x))
+ (b* ( ;; Note: for plain names msb/lsb will be nil.
+ ((mv ?err basename msb lsb) (stv-wirename-parse x))
+ ((when err)
+ (raise "~s0" err))
+ (basename-bits (vl::esim-vl-find-io basename pat))
+ ((unless basename-bits)
+ (raise "Trying to expand ~s0, but there is no ~s1 named ~s2 in ~
+ ~x3."
+ x
+ (if (eq type :i) "input" "output")
+ basename
+ modname))
+
+ ((unless (and msb lsb))
+ ;; The input name is just "foo", so get all of the wires of
+ ;; foo. This lets you refer to busses by name without having
+ ;; to give their explicit indices in the STV.
+ basename-bits)
+
+ ;; Else, the input is "foo[5:3]" or similar, so we want to just
+ ;; get bits 5-3. But put them in LSB-first order so they'll line
+ ;; up with the basename-bits
+ (expect-bits
+ ;; Stupid hack: it would be nicer to write:
+ ;; (reverse (vl-emodwires-from-msb-to-lsb basename msb lsb))
+ ;; But we just reverse the lsb/msb to avoid the extra consing
+ (vl::vl-emodwires-from-msb-to-lsb basename lsb msb))
+ ((unless (ordered-subsetp expect-bits basename-bits))
+ (raise "Trying to expand ~s0, but the bits being asked for ~s1.~% ~
+ - Found wires: ~x2 through ~x3~% ~
+ - Want wires: ~x4 through ~x5."
+ x
+ (if (subsetp-equal expect-bits basename-bits)
+ "are not in the right order"
+ "are not found")
+ (car basename-bits)
+ (car (last basename-bits))
+ (car expect-bits)
+ (car (last expect-bits)))))
+ expect-bits))
+
+ ;; Otherwise, we should have been given a list of valid input bits.
+ ((unless (symbol-listp x))
+ (raise "Invalid input name (expected string or a list of e bits), but ~
+ found ~x0."
+ x))
+
+ (flat-pat (pat-flatten1 pat))
+ ((unless (subsetp-equal x flat-pat))
+ (raise "Trying to provide bindings for ~s0 that don't exist: ~x1."
+ (if (eq type :i) "inputs" "outputs")
+ (set-difference-equal flat-pat x))))
+ x))
#||
@@ -230,25 +224,21 @@
-(defsection stv-expand-names-in-lines
+(define stv-expand-names-in-lines
:parents (stv-expand)
- :short "@(call stv-expand-names-in-lines) expands all of the names in a list
-of STV :input or :output lines."
-
- (defund stv-expand-names-in-lines (lines type mod)
- (declare (xargs :guard (and (or (eq type :i)
- (eq type :o))
- (true-list-listp lines))))
- (b* (((when (atom lines))
- nil)
- (line1 (car lines))
- ((cons name phases) line1)
- (new-name (stv-expand-name name type mod)))
- (cons (cons new-name phases)
- (stv-expand-names-in-lines (cdr lines) type mod))))
-
- (local (in-theory (enable stv-expand-names-in-lines)))
-
+ :short "Expands all of the names in a list of STV :input or :output lines."
+ ((lines true-list-listp)
+ (type (or (eq type :i) (eq type :o)))
+ mod)
+ :returns (new-lines)
+ (b* (((when (atom lines))
+ nil)
+ (line1 (car lines))
+ ((cons name phases) line1)
+ (new-name (stv-expand-name name type mod)))
+ (cons (cons new-name phases)
+ (stv-expand-names-in-lines (cdr lines) type mod)))
+ ///
(defthm alistp-of-stv-expand-names-in-lines
(alistp (stv-expand-names-in-lines lines type mod)))
@@ -258,7 +248,6 @@
-
; -----------------------------------------------------------------------------
;
; EXPANDING NAMES FOR :INTERNAL AND :INITIAL LINES
@@ -269,107 +258,91 @@
; E.g., the user might want to pull out or initialize some signal in the
; top-level module, or in some submodule.
-(defsection stv-hid-split
+(define stv-hid-split
:parents (stv-expand)
:short "Splits up a HID into a list of instance names and a wire name."
- (defund stv-hid-split (hid)
- "Returns (MV INSTNAMES WIRENAME) or causes an error."
- (declare (xargs :guard (and (vl::vl-expr-p hid)
- (vl::vl-hidexpr-p hid))))
- (b* (((unless (vl::vl-hid-indicies-resolved-p hid))
- (er hard? 'stv-hid-split
- "HID has unresolved indices: ~s0~%" (vl::vl-pps-expr hid))
- (mv nil ""))
- (parts (vl::vl-explode-hid hid))
- ((unless (string-listp parts))
- ;; Parts is like ("foo" "bar" 3 "baz") for foo.bar[3].baz, too hard
- (er hard? 'stv-hid-split
- "We don't currently support hierarchical identifiers that go ~
- through array instances, like foo.bar[3].baz. The HID that ~
- triggered this error was: ~s0~%" (vl::vl-pps-expr hid))
- (mv nil ""))
- ((when (< (len parts) 2))
- ;; I don't really see how this could happen. Maybe it can't happen.
- (er hard? 'stv-hid-split
- "Somehow the HID has only one piece? ~s0~%"
- (vl::vl-pps-expr hid))
- (mv nil ""))
- (instnames (butlast parts 1))
- (wirename (car (last parts))))
- (mv instnames wirename)))
-
- (local (in-theory (enable stv-hid-split)))
-
- (defthm true-listp-of-stv-hid-split
- (true-listp (mv-nth 0 (stv-hid-split hid)))
- :rule-classes :type-prescription)
-
- (local (defthm l0
- (implies (and (string-listp x)
- (consp x))
- (stringp (car (last x))))
- :hints(("Goal" :expand (last x)))))
-
- (defthm stringp-of-stv-hid-split
- (stringp (mv-nth 1 (stv-hid-split hid)))
- :rule-classes :type-prescription
- :hints(("goal" :use ((:instance l0 (x (vl::vl-explode-hid hid)))))))
+ ((hid (and (vl::vl-expr-p hid)
+ (vl::vl-hidexpr-p hid))))
+
+ :returns (mv (instnames true-listp :rule-classes :type-prescription)
+ (wirename stringp :rule-classes :type-prescription))
+ (b* (((unless (vl::vl-hid-indicies-resolved-p hid))
+ (raise "HID has unresolved indices: ~s0~%" (vl::vl-pps-expr hid))
+ (mv nil ""))
+ (parts (vl::vl-explode-hid hid))
+ ((unless (string-listp parts))
+ ;; Parts is like ("foo" "bar" 3 "baz") for foo.bar[3].baz, too hard
+ (raise "We don't currently support hierarchical identifiers that go ~
+ through array instances, like foo.bar[3].baz. The HID that ~
+ triggered this error was: ~s0~%" (vl::vl-pps-expr hid))
+ (mv nil ""))
+ ((when (< (len parts) 2))
+ ;; I don't really see how this could happen. Maybe it can't happen.
+ (raise "Somehow the HID has only one piece? ~s0~%"
+ (vl::vl-pps-expr hid))
+ (mv nil ""))
+ (instnames (butlast parts 1))
+ (wirename (car (last parts))))
+ (mv instnames wirename))
+
+ ///
(defthm string-listp-of-stv-hid-split
(string-listp (mv-nth 0 (stv-hid-split hid)))))
-(defsection stv-hid-parse
+(define stv-hid-parse
:parents (stv-expand)
:short "Match a Verilog-style plain or hierarchical name, perhaps with a bit-
or part-select on the end of it."
- :long "Signature: @(call stv-hid-parse) returns @('(mv instnames
-wirename msb-idx lsb-idx)')
-
-This is sort of misnamed because it works for normal identifiers as well as
-hierarchical identifiers.
+ :long "This is sort of misnamed; it works for normal identifiers as well
+as hierarchical identifiers.
Examples:
-
- \"foo[3]\" becomes @('(mv nil \"foo\" 3 3)')
- \"foo.bar.baz\" becomes @('(mv '(\"foo\" \"bar\") \"baz\" nil nil)')
- \"foo.bar.baz[3]\" becomes @('(mv '(\"foo\" \"bar\") \"baz\" 3 3)')
- \"foo.bar.baz[3:0]\" becomes @('(mv '(\"foo\" \"bar\") \"baz\" 3 0)')
-
-
-If the input string name isn't of an acceptable form, an error is
-caused.
"
-
- (defund stv-hid-parse (str)
- (declare (xargs :guard (stringp str)))
- (b* ((expr (vl::vl-parse-expr-from-str str))
- ((unless expr)
- (er hard? 'stv-hid-parse "Failed to parse: ~s0" str)
- (mv nil "" nil nil))
- ((mv err from msb lsb) (stv-maybe-match-select expr))
- ((when err)
- (er hard? 'stv-hid-parse "~s0" err)
- (mv nil "" nil nil))
-
- ((when (vl::vl-idexpr-p from))
- ;; This is legitimate for top-level internal wires like foo[3]; There
- ;; just aren't any instnames to follow.
- (mv nil (vl::vl-idexpr->name from) msb lsb))
-
- ((unless (vl::vl-hidexpr-p from))
- (er hard? 'stv-hid-parse "Invalid STV wire name: ~s0" str)
- (mv nil "" nil nil))
+@({
+ instnames wirename msb lsb
+ foo[3] --> nil foo 3 3
+ foo.bar.baz --> (foo bar) baz nil nil
+ foo.bar.baz[3] --> (foo bar) baz 3 3
+ foo.bar.baz[3:0] --> (foo bar) baz 3 0
+})
+
+If the input string name isn't of an acceptable form, we cause an
+error.
"
+
+ ((str stringp "The string to parse and split up."))
+
+ :returns
+ (mv (instnames true-listp :rule-classes :type-prescription)
+ (wirename stringp :rule-classes :type-prescription)
+ (msb-idx (or (not msb-idx) (natp msb-idx)) :rule-classes :type-prescription)
+ (lsb-idx (or (not lsb-idx) (natp lsb-idx)) :rule-classes :type-prescription))
+
+ (b* ((expr (vl::vl-parse-expr-from-str str))
+ ((unless expr)
+ (raise "Failed to parse: ~s0" str)
+ (mv nil "" nil nil))
+ ((mv err from msb lsb) (stv-maybe-match-select expr))
+ ((when err)
+ (raise "~s0" err)
+ (mv nil "" nil nil))
+
+ ((when (vl::vl-idexpr-p from))
+ ;; This is legitimate for top-level internal wires like foo[3]; There
+ ;; just aren't any instnames to follow.
+ (mv nil (vl::vl-idexpr->name from) msb lsb))
+
+ ((unless (vl::vl-hidexpr-p from))
+ (raise "Invalid STV wire name: ~s0" str)
+ (mv nil "" nil nil))
- ((mv instnames wirename) (stv-hid-split from)))
- (mv instnames wirename msb lsb)))
+ ((mv instnames wirename) (stv-hid-split from)))
+ (mv instnames wirename msb lsb))
- (local (in-theory (enable stv-hid-parse)))
-
- (defmvtypes stv-hid-parse
- (true-listp stringp (or (not x) (natp x)) (or (not x) (natp x))))
+ ///
(defthm string-listp-of-stv-hid-parse
(string-listp (mv-nth 0 (stv-hid-parse str))))
@@ -420,92 +393,87 @@
-(defsection stv-hid-to-paths
+(define stv-turn-bits-into-non-canonical-paths
+ :parents (stv-hid-to-paths)
+ ((instname-list true-listp
+ "e.g., (foo bar)")
+ (bits "e.g., (baz[3] baz[2] baz[1] baz[0])"))
+ :returns (merged "e.g., @({
+ ((foo bar . baz[3])
+ (foo bar . baz[2])
+ ...
+ (foo bar . baz[0]))
+ })")
+ (if (atom bits)
+ nil
+ (cons (append instname-list (car bits))
+ (stv-turn-bits-into-non-canonical-paths instname-list (cdr bits)))))
+
+
+(define stv-hid-to-paths
:parents (stv-expand)
:short "Convert a Verilog-style plain or hierarchical name (optionally with a
bit- or part-select) into an LSB-ordered list of non-canonical ESIM
paths."
- :long "@(call stv-hid-to-paths) returns a list of LSB-first ordered paths
-in the sense of @(see acl2::mod-internal-paths).
-
-
-
-@('x') is a string like @('foo'), @('foo[3:0]'), @('foo.bar.baz'),
-@('foo.bar.baz[3]'), etc. That is, it should either be a plain or hierarchical
-Verilog identifier, perhaps with a bit or part-select on the end.
-
-@('mod') is the E module that X is based in.
-
- "
-
- (defund stv-turn-bits-into-non-canonical-paths
- (instname-list ;; (foo bar)
- bits ;; (baz[3] baz[2] baz[1] baz[0])
- )
- ;; ---> ( (foo bar . baz[3])
- ;; (foo bar . baz[2])
- ;; ...
- ;; (foo bar . baz[0]) )
- (declare (xargs :guard (true-listp instname-list)))
- (if (atom bits)
- nil
- (cons (append instname-list (car bits))
- (stv-turn-bits-into-non-canonical-paths instname-list (cdr bits)))))
-
- (defund stv-hid-to-paths (x mod)
- (declare (xargs :guard (stringp x)))
- (b* (((mv instnames wirename msb lsb) (stv-hid-parse x))
-
- ;; 1. Find the submod that this HID points to.
- (instnames (intern-list-in-package-of-symbol instnames (pkg-witness "ACL2")))
- (submod (follow-esim-path instnames mod))
- ((unless submod)
- (er hard? 'stv-hid-to-paths
- "Error following path ~x0 in ~x1." x (gpl :n mod)))
-
- ;; 2. Look up this E names for this wire in the wire alist. Note that
- ;; the WALIST has the bits in MSB-First order!
- (walist (vl::esim-vl-wirealist submod))
- (lookup (hons-assoc-equal wirename walist))
- ((unless lookup)
- (er hard? 'stv-hid-to-paths
- "Can't follow ~s0: followed the instances ~x1 to an ~x2 ~
- submodule, but then there was no wire named ~s3 in the wire ~
- alist." x instnames (gpl :n submod) wirename))
- (msb-first-wires (cdr lookup))
- (lsb-first-wires (reverse msb-first-wires))
-
- ((unless (and msb lsb))
- ;; X is something like "foo" or "foo.bar.baz" with no bit- or
- ;; part-select, so the user is asking for the whole wire!
- (stv-turn-bits-into-non-canonical-paths instnames lsb-first-wires))
-
- ;; Otherwise, X is something like "foo[3]" or "foo.bar.baz[5:3]", so
- ;; we need to make sure this range is in bounds and going in the right
- ;; direction.
- (expect-bits
- ;; Stupid hack: it would be nicer to write:
- ;; (reverse (vl-emodwires-from-msb-to-lsb basename msb lsb))
- ;; But we just reverse the lsb/msb to avoid the extra consing
- (vl::vl-emodwires-from-msb-to-lsb wirename lsb msb))
-
- ;; Make sure that the bits exist and are properly ordered for this wire
- ((unless (ordered-subsetp expect-bits lsb-first-wires))
- (er hard? 'stv-hid-to-paths
- "Trying to expand ~s0, but the bits being asked for ~s1.~% ~
- - Found wires: ~x2 through ~x3~% ~
- - Want wires: ~x4 through ~x5."
- x
- (if (subsetp-equal expect-bits lsb-first-wires)
- "are not in the right order"
- "are not found")
- (car lsb-first-wires)
- (car (last lsb-first-wires))
- (car expect-bits)
- (car (last expect-bits)))))
+ ((x stringp "A string like @('foo'), @('foo[3:0]'), @('foo.bar.baz'),
+ @('foo.bar.baz[3]'), etc. That is, it should either be a plain
+ or hierarchical Verilog identifier, perhaps with a bit or
+ part-select on the end.")
+
+ (mod "The @(see esim) module that this path should be relative to."))
+
+ :returns (lsb-paths "LSB-first list of non-canonical paths for @('x'), in the
+ sense of @(see acl2::mod-internal-paths).")
+
+ (b* (((mv instnames wirename msb lsb) (stv-hid-parse x))
+
+ ;; 1. Find the submod that this HID points to.
+ (instnames (str::intern-list instnames))
+ (submod (follow-esim-path instnames mod))
+ ((unless submod)
+ (raise "Error following path ~x0 in ~x1." x (gpl :n mod)))
+
+ ;; 2. Look up this E names for this wire in the wire alist. Note that
+ ;; the WALIST has the bits in MSB-First order!
+ (walist (vl::esim-vl-wirealist submod))
+ (lookup (hons-assoc-equal wirename walist))
+ ((unless lookup)
+ (raise "Can't follow ~s0: followed the instances ~x1 to an ~x2 ~
+ submodule, but then there was no wire named ~s3 in the wire ~
+ alist." x instnames (gpl :n submod) wirename))
+ (msb-first-wires (cdr lookup))
+ (lsb-first-wires (reverse msb-first-wires))
+
+ ((unless (and msb lsb))
+ ;; X is something like "foo" or "foo.bar.baz" with no bit- or
+ ;; part-select, so the user is asking for the whole wire!
+ (stv-turn-bits-into-non-canonical-paths instnames lsb-first-wires))
+
+ ;; Otherwise, X is something like "foo[3]" or "foo.bar.baz[5:3]", so
+ ;; we need to make sure this range is in bounds and going in the right
+ ;; direction.
+ (expect-bits
+ ;; Stupid hack: it would be nicer to write:
+ ;; (reverse (vl-emodwires-from-msb-to-lsb basename msb lsb))
+ ;; But we just reverse the lsb/msb to avoid the extra consing
+ (vl::vl-emodwires-from-msb-to-lsb wirename lsb msb))
+
+ ;; Make sure that the bits exist and are properly ordered for this wire
+ ((unless (ordered-subsetp expect-bits lsb-first-wires))
+ (raise "Trying to expand ~s0, but the bits being asked for ~s1.~% ~
+ - Found wires: ~x2 through ~x3~% ~
+ - Want wires: ~x4 through ~x5."
+ x
+ (if (subsetp-equal expect-bits lsb-first-wires)
+ "are not in the right order"
+ "are not found")
+ (car lsb-first-wires)
+ (car (last lsb-first-wires))
+ (car expect-bits)
+ (car (last expect-bits)))))
- (stv-turn-bits-into-non-canonical-paths instnames expect-bits))))
+ (stv-turn-bits-into-non-canonical-paths instnames expect-bits)))
#||
@@ -543,68 +511,88 @@
;; This one is an output:
(stv-hid-to-paths "mmxdphi.logicops001.mdpmmxlogres_e" acl2::|*mmx*|)
- ;; -- good, suerior module's wire, 64-127
+ ;; -- good, superior module's wire, 64-127
||#
+(define stv-check-noncanonical-paths (paths mod)
+ :parents (stv-expand)
+ :short "Checks that the listed paths all exist in the module"
+ (b* (((when (atom paths)) nil)
+ (path (car paths))
+ (submod (follow-esim-path path mod))
+ (wirename (if (atom path) path (cdr (last path)))))
+ (if (and wirename (symbolp wirename))
+ (or (member-of-pat-flatten wirename (gpl :i submod))
+ (find-in-occs-field :o wirename (gpl :occs submod))
+ (raise "Path ~x0 does not exist" path))
+ (raise "~x0 is not a valid wirename" wirename))
+ (stv-check-noncanonical-paths (cdr paths) mod)))
+
+
+
+
+(define stv-expand-hid
+ :parents (stv-expand)
+ :short "@(call stv-expand-hid) expands a signal name when it is allowed to be
+hierarchical, i.e. a hid or a list of esim paths."
+ :returns (lsb-paths "LSB-first list of non-canonical paths for @('x'), in the
+ sense of @(see acl2::mod-internal-paths).")
+ ((name "the name at the start of the STV line")
+ mod)
+
+ (if (stringp name)
+ ;; assume it's a hid
+ (stv-hid-to-paths name mod)
+ (prog2$ (stv-check-noncanonical-paths name mod)
+ name)))
-(defsection stv-expand-hids-in-lines
+(define stv-expand-hids-in-lines
:parents (stv-expand)
:short "@(call stv-expand-hids-in-lines) expands all of the HIDs in a list of
STV internal lines into lists of esim paths."
+ ((lines true-list-listp) mod)
+ :returns (new-lines "Copy of @('lines') except with expanded names.")
- (defund stv-expand-hids-in-lines (lines mod)
- (declare (xargs :guard (true-list-listp lines)))
- (b* (((when (atom lines))
- nil)
- (line1 (car lines))
- ((cons name phases) line1)
- ((unless (stringp name))
- (er hard? 'stv-expand-hids-in-lines
- "Internals line name is not a string: ~x0" name))
- (lsb-paths (stv-hid-to-paths name mod)))
- (cons (cons lsb-paths phases)
- (stv-expand-hids-in-lines (cdr lines) mod))))
-
- (local (in-theory (enable stv-expand-hids-in-lines)))
-
+ (b* (((when (atom lines))
+ nil)
+ (line1 (car lines))
+ ((cons name phases) line1)
+ (lsb-paths (stv-expand-hid name mod)))
+ (cons (cons lsb-paths phases)
+ (stv-expand-hids-in-lines (cdr lines) mod)))
+ ///
(defthm alistp-of-stv-expand-hids-in-lines
(alistp (stv-expand-hids-in-lines lines mod)))
-
(defthm true-list-listp-of-stv-expand-hids-in-lines
(implies (true-list-listp lines)
(true-list-listp (stv-expand-hids-in-lines lines mod)))))
-(defsection stv-expand
+(define stv-expand
:parents (symbolic-test-vectors)
:short "Expand Verilog-style names throughout an STV into LSB-ordered ESIM
style paths."
+
- :long "Signature: @(call stv-expand) returns a new @(see
-stvdata-p).
+ ((stv stvdata-p)
+ mod)
+ :returns (new-stv stvdata-p :hyp :fguard
+ "Copy of @('stv') but with all names expanded.")
-This is an STV preprocessing step which can be run before or after @(see
-stv-widen). It only affects the names in each STV line.
+ :long "This is an STV preprocessing step which can be run before or after
+@(see stv-widen). It only affects the names in each STV line.
During this step, we resolve Verilog-style names like \"foo[3:0]\" and
\"foo.bar.baz[6:0],\" replacing them with LSB-ordered lists of ESIM bits or
paths. This keeps the Verilog-specific stuff out of the rest of the STV
compiler.
"
- (defund stv-expand (stv mod)
- (declare (xargs :guard (stvdata-p stv)))
- (b* (((stvdata stv) stv))
- (make-stvdata :inputs (stv-expand-names-in-lines stv.inputs :i mod)
- :outputs (stv-expand-names-in-lines stv.outputs :o mod)
- :initial (stv-expand-hids-in-lines stv.initial mod)
- :internals (stv-expand-hids-in-lines stv.internals mod))))
-
- (local (in-theory (enable stv-expand)))
-
- (defthm stvdata-p-of-stv-expand
- (implies (force (stvdata-p stv))
- (stvdata-p (stv-expand stv mod)))))
+ (b* (((stvdata stv) stv))
+ (make-stvdata :inputs (stv-expand-names-in-lines stv.inputs :i mod)
+ :outputs (stv-expand-names-in-lines stv.outputs :o mod)
+ :internals (stv-expand-hids-in-lines stv.internals mod)
+ :overrides (stv-expand-hids-in-lines stv.overrides mod))))
diff -Nru acl2-6.2/books/centaur/esim/stv/stv-run.lisp acl2-6.3/books/centaur/esim/stv/stv-run.lisp
--- acl2-6.2/books/centaur/esim/stv/stv-run.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/stv/stv-run.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -32,38 +32,22 @@
(local (include-book "centaur/vl/util/arithmetic" :dir :system))
-;; For efficient execution of stv-run in GL, we want to our clause processors
-;; to be able to natively execute these functions.
-(gl::add-clause-proc-exec-fns '(4v-sexpr-restrict-with-rw-alist
- vl::append-domains
- sets::mergesort
- sets::subset
- sets::union
- sets::difference))
-
-
-(defsection stv-simvar-inputs-to-bits
+(define stv-simvar-inputs-to-bits
:parents (stv-run)
:short "Convert the user-level input alist (which binds simulation variables
to naturals) into a bit-level alist for @(see 4v-sexpr-eval)."
- :long "@(call stv-simvar-inputs-to-bits) is given:
-
-
-
-@('user-alist'), the alist provided by the user that gives values to the
-input simulation variables. Each value should be a natural number that is in
-the range for that simulation variable.
+ ((user-alist "The alist provided by the user that gives values to the input
+ simulation variables. Each value should be a natural number that
+ is in the range for that simulation variable.")
+
+ (in-usersyms "A fast alist that binds each input simulation variable for the
+ STV with a list of variables that represent its bits; see @(see
+ stv-compile), but in particular see the @('usersyms') output of
+ @(see stv-expand-input-entry)."))
-@('in-usersyms'), a fast alist that binds each input simulation variable
-for the STV with a list of variables that represent its bits; see @(see
-stv-compile), but in particular see the @('usersyms') output of @(see
-stv-expand-input-entry).
-
-
-
-We try to translate every user-level binding, like @('(opcode . 7)'), into a
-set of bit-level bindings, say something like:
+ :long "We try to translate every user-level binding, like @('(opcode
+. 7)'), into a set of bit-level bindings, say something like:
@({
((opcode[0] . *4vt*)
@@ -88,157 +72,143 @@
the alist semantics are preserved because shadowed bindings are still shadowed
in the bit-level alist."
- (defund stv-simvar-inputs-to-bits (user-alist in-usersyms)
- (declare (xargs :guard t))
- (b* (((when (atom user-alist))
- nil)
-
- (rest (stv-simvar-inputs-to-bits (cdr user-alist) in-usersyms))
-
- ((when (atom (car user-alist)))
- ;; Bad alist convention
- (cw "stv-simvar-inputs-to-bits: skipping malformed alist entry
- ~x0.~%" (car user-alist))
- rest)
-
- (name (caar user-alist))
- (val (cdar user-alist))
- (look (hons-get name in-usersyms))
-
- ((unless look)
- (er hard? 'stv-simvar-inputs-to-bits
- "Value given for ~x0, but this is not a simulation variable."
- name)
- rest)
-
- (vars (cdr look))
- (nvars (len vars))
-
- (vals (cond ((eq val *4vx*)
- (repeat *4vx* nvars))
- ((and (natp val)
- (< val (ash 1 nvars)))
- (bool-to-4v-lst (int-to-v val nvars)))
- (t
- (progn$
- (er hard? 'stv-simvar-inputs-to-bits
- "Value ~x0 given for ~x1, but this value is not X ~
- or in range for a ~x2-bit unsigned number."
- val name nvars)
- (repeat *4vx* nvars))))))
+ (b* (((when (atom user-alist))
+ nil)
- (safe-pairlis-onto-acc vars vals rest))))
+ (rest (stv-simvar-inputs-to-bits (cdr user-alist) in-usersyms))
+ ((when (atom (car user-alist)))
+ ;; Bad alist convention
+ (cw "stv-simvar-inputs-to-bits: skipping malformed alist entry ~x0.~%"
+ (car user-alist))
+ rest)
+
+ (name (caar user-alist))
+ (val (cdar user-alist))
+ (look (hons-get name in-usersyms))
+
+ ((unless look)
+ (raise "Value given for ~x0, but this is not a simulation variable."
+ name)
+ rest)
+
+ (vars (cdr look))
+ (nvars (len vars))
+
+ (vals (cond ((eq val *4vx*)
+ (repeat *4vx* nvars))
+ ((and (natp val)
+ (< val (ash 1 nvars)))
+ (bool-to-4v-lst (int-to-v val nvars)))
+ (t
+ (progn$
+ (raise "Value ~x0 given for ~x1, but this value is not X ~
+ or in range for a ~x2-bit unsigned number."
+ val name nvars)
+ (repeat *4vx* nvars))))))
+
+ (safe-pairlis-onto-acc vars vals rest)))
+
+
+(define collect-bits-bound-to-x (keys alist)
+ :parents (stv-assemble-output-alist)
+ (b* (((when (atom keys))
+ nil)
+ (lookup (hons-get (car keys) alist))
+ ((when (eq (cdr lookup) 'x))
+ (cons (car keys)
+ (collect-bits-bound-to-x (cdr keys) alist))))
+ (collect-bits-bound-to-x (cdr keys) alist)))
-(defsection stv-assemble-output-alist
+(define stv-assemble-output-alist
:parents (stv-run)
:short "Convert the bit-level bindings from after @(see 4v-sexpr-eval) into
user-level bindings of the output simulation variables to naturals or X."
- :long "@(call stv-assemble-output-alist) is given:
-
-
-
-@('bit-out-alist'), a fast alist that binds the output simulation variable
-bit names to their @(see 4vp) constants. This alist should have been produced
-by calling @(see 4v-sexpr-eval) on the @('relevant-signals') s-expressions of a
-@(see processed-stv-p).
-
-@('out-usersyms'), an alist that binds each output simulation variable for
-the STV with a list of variables that represent its bits; see @(see
-stv-compile), but in particular see the @('usersyms') output of @(see
-stv-expand-output-entry).
-
-
-
-We recur down @('out-usersyms'). For each output variable, we look up the
-values of its bits in @('bit-out-alist'), and then try to combine these bits
-into a single integer value. If any bit is X, we just say the whole output is
-X.
"
-
- (defund collect-bits-bound-to-x (keys alist)
- (declare (xargs :guard t))
- (if (atom keys)
- nil
- (let ((lookup (hons-get (car keys) alist)))
- (if (eq (cdr lookup) 'x)
- (cons (car keys)
- (collect-bits-bound-to-x (cdr keys) alist))
- (collect-bits-bound-to-x (cdr keys) alist)))))
-
- (defund stv-assemble-output-alist (bit-out-alist out-usersyms)
- (declare (xargs :guard t))
- (b* (((when (atom out-usersyms))
- nil)
- (rest (stv-assemble-output-alist bit-out-alist (cdr out-usersyms)))
- ((when (atom (car out-usersyms)))
- (er hard? 'stv-assemble-output-alist "out-usersyms should be an alist.")
- rest)
- ((cons user-name bits) (car out-usersyms))
- (vals (vl::look-up-each-fast bits bit-out-alist))
- (true-val (4v-to-nat vals))
- (- (and (eq true-val 'x)
- (cw "Bits bound to X in ~x0: ~x1~%"
- user-name (collect-bits-bound-to-x bits bit-out-alist)))))
- (cons (cons user-name true-val) rest))))
+ ((bit-out-alist "A fast alist that binds the output simulation variable bit
+ names to their @(see 4vp) constants. This alist should have
+ been produced by calling @(see 4v-sexpr-eval) on the
+ @('relevant-signals') sexprs of a @(see processed-stv-p).")
+
+ (out-usersyms "An ordinary alist that binds each output simulation variable
+ for the STV with a list of variables that represent its bits;
+ see @(see stv-compile), but in particular see the
+ @('usersyms') output of @(see stv-expand-output-entry)"))
+
+ :long "We recur down @('out-usersyms'). For each output variable, we look
+up the values of its bits in @('bit-out-alist'), and then try to combine these
+bits into a single integer value. If any bit is X, we just say the whole
+output is X.
"
+ (b* (((when (atom out-usersyms))
+ nil)
+ (rest (stv-assemble-output-alist bit-out-alist (cdr out-usersyms)))
+ ((when (atom (car out-usersyms)))
+ (raise "out-usersyms should be an alist.")
+ rest)
+ ((cons user-name bits) (car out-usersyms))
+ (vals (vl::look-up-each-fast bits bit-out-alist))
+ (true-val (4v-to-nat vals))
+ (- (and (eq true-val 'x)
+ (cw "Bits bound to X in ~x0: ~x1~%"
+ user-name (collect-bits-bound-to-x bits bit-out-alist)))))
+ (cons (cons user-name true-val) rest)))
-(defun stv-print-alist (x)
- ;; Dumb printing utility. X is expected to be an alist binding symbols to
- ;; values. We print them out hexified and indented in a nice way.
- (declare (xargs :guard t))
+(define stv-print-alist (x)
+ :parents (stv-run)
+ :short "Dumb printing utility. X is expected to be an alist binding symbols
+ to values. We print them out hexified and indented in a nice way."
(b* (((when (atom x))
nil)
((unless (consp (car x)))
- (er hard? 'stv-print-alist
- "Malformed alist: Entry ~x0 is not a (key . val) pair.~%"
- (car x)))
+ (raise "Malformed alist: Entry ~x0 is not a (key . val) pair.~%"
+ (car x)))
((cons key val) (car x))
((unless (symbolp key))
- (er hard? 'stv-print-alist
- "Malformed alist: name is not a symbolp.~%"
- (car x)))
+ (raise "Malformed alist: name is not a symbolp.~%"
+ (car x)))
(- (cw " ~s0:~t1~s2~%" key 20 (str::hexify val))))
(stv-print-alist (cdr x))))
-
-(defsection stv-run
+(define stv-run
:parents (symbolic-test-vectors)
:short "Evaluate a symbolic test vector at particular, concrete inputs."
- :long "Signature: @(call stv-run) returns an alist that binds
-user-level outputs to natural numbers or X.
-
-The basic form of @('stv-run') only requires two inputs:
-
-
-
-The @('pstv') is an @(see processed-stv-p) that should have been produced
-by @(see stv-process).
+ ((pstv processed-stv-p
+ "The symbolic test vector to run.")
-The @('input-alist') is an alist that should bind some of the input
-simulation variables to natural numbers, or to the symbol X. Any inputs that
-aren't mentioned are implicitly bound to X.
+ (input-alist "An alist that should typically bind at least some of the input
+ simulation variables to natural numbers, or to the symbol X.
+ Any inputs that aren't mentioned are implicitly bound to X.")
+ &key
+ (skip "Advanced option to avoid computing certain outputs; see below.")
+
+ (quiet "Suppress debugging output. By default, @('stv-run') will print
+ certain debugging information. This is generally convenient in
+ @(see def-gl-thm) forms involving an @('stv-run'), and will allow
+ you to see nicely-formatted debugging info when counter-examples
+ are found. But you can use @(':quiet t') to suppress it."))
-
+ :returns (out-alist "Alist binding user-level STV outputs to either natural
+ numbers or X.")
-And in this case, the evaluation basically involves three steps:
+ :long "Evaluating an stv basically involves three steps:
We translate the @('input-alist') into bit-level bindings; see @(see
stv-simvar-inputs-to-bits).
-We evaluate the relevant output bits from the processed STV, using these
-bit-level bindings, basically by calling @(see 4v-sexpr-eval) on each output
+ Using these bit-level bindings, we evaluate the relevant output bits from
+the processed STV, basically by calling @(see 4v-sexpr-eval) on each output
bit.
-We take the evaluated output bits and merge them back into an alist that
-binds the output simulation variables to natural numbers or Xes; see @(see
-stv-assemble-output-alist).
+We take the evaluated output bits and merge them back into a user-level
+alist that binds the output simulation variables to natural numbers or Xes; see
+@(see stv-assemble-output-alist).
@@ -248,103 +218,94 @@
a module that emits several flags in addition to its result, but you don't care
about the flags for some instructions. Then, you can tell @('stv-run') to skip
computing the flags as you verify these instructions, which may lead to a big
-savings when BDDs are involved.
+savings when BDDs are involved."
-By default, @('stv-run') will print certain debugging information. This is
-generally convenient in @(see def-gl-thm) forms involving an @('stv-run'), and
-will allow you to see nicely-formatted debugging info when counter-examples are
-found. You can suppress this output with @(':quiet nil').
"
-
- (defund stv-run-fn (pstv input-alist skip quiet)
- (declare (xargs :guard (processed-stv-p pstv)))
- (time$
- (b* (((processed-stv pstv) pstv)
- ((compiled-stv cstv) pstv.compiled-stv)
-
- (- (or quiet
- (cw "STV Raw Inputs: ~x0.~%" input-alist)))
-
- (out-usersyms cstv.out-usersyms)
- (in-usersyms
- ;; These should already be a fast alist, but in case the object was
- ;; serialized and reloaded or something, we'll go ahead and try to
- ;; make them fast again.
- (make-fast-alist cstv.in-usersyms))
-
- ;; Start with all of the signals that we have in our STV. These have
- ;; the expressions for the bits of the output simulation variables.
- (sigs pstv.relevant-signals)
-
- ;; Prune away any signals that the user says he wants to skip.
- ((mv sigs out-usersyms)
- (time$ (b* (((unless skip)
- (mv sigs out-usersyms))
-
- ;; As a sanity check, complain if there are any bits
- ;; that are being skipped that don't actually exist.
- (skip (sets::mergesort skip))
- (outnames (sets::mergesort (alist-keys out-usersyms)))
- ((unless (sets::subset skip outnames))
- (b* ((bad (sets::difference skip outnames))
- ;; Don't use - or implicit progn$ on these, we want to make sure
- ;; these get evaluated during GL runs.
- (?msg (cw "Invalid skip! Not outputs: ~&0." bad))
- (?err (er hard? 'stv-run-fn "Invalid skip! Not outputs: ~&0." bad)))
- (mv sigs out-usersyms)))
-
- ;; Filter the out-usersyms down to just those that we want.
- (keep (sets::difference outnames skip))
- (out-usersyms (b* ((tmp (make-fal out-usersyms nil))
- (ret (fal-extract keep tmp)))
- (fast-alist-free tmp)
- ret))
-
- ;; Also filter the sigs down to just the bits we need.
- (keep-bits (vl::append-domains out-usersyms))
- (sigs (b* ((tmp (make-fal sigs nil))
- (ret (fal-extract keep-bits tmp)))
- (fast-alist-free tmp)
- ret)))
-
- (mv sigs out-usersyms))
- :mintime 1/2
- :msg "; stv-run skips: ~st sec, ~sa bytes."))
-
- ;; Construct the alist to evaluate with
- (ev-alist
- (time$ (make-fast-alist
- (stv-simvar-inputs-to-bits input-alist in-usersyms))
- :mintime 1/2
- :msg "; stv-run ev-alist: ~st sec, ~sa bytes.~%"))
-
- ;; Evaluate the non-skipped signals.
- (evaled-out-bits
- (time$ (make-fast-alist (4v-sexpr-simp-and-eval-alist sigs ev-alist))
- :mintime 1/2
- :msg "; stv-run out-bits: ~st sec, ~sa bytes.~%"))
-
- (- (fast-alist-free ev-alist))
-
- ;; Assemble the non-skipped outputs.
- (assembled-outs
- (time$ (stv-assemble-output-alist evaled-out-bits out-usersyms)
- :mintime 1/2
- :msg "; stv-run outs: ~st sec, ~sa bytes.~%"))
-
- (- (fast-alist-free evaled-out-bits))
-
- ;; Debugging Support
- (- (or quiet
- (progn$ (cw "~%STV Inputs:~%")
- (stv-print-alist input-alist)
- (cw "~%STV Outputs:~%")
- (stv-print-alist assembled-outs)
- (cw "~%")))))
-
- assembled-outs)
- :msg "; stv-run: ~st sec, ~sa bytes.~%"
- :mintime 1))
+ (time$
+ (b* (((processed-stv pstv) pstv)
+ ((compiled-stv cstv) pstv.compiled-stv)
+
+ (- (or quiet
+ (cw "STV Raw Inputs: ~x0.~%" input-alist)))
+
+ (out-usersyms cstv.out-usersyms)
+ (in-usersyms
+ ;; These should already be a fast alist, but in case the object was
+ ;; serialized and reloaded or something, we'll go ahead and try to
+ ;; make them fast again.
+ (make-fast-alist cstv.in-usersyms))
+
+ ;; Start with all of the signals that we have in our STV. These have
+ ;; the expressions for the bits of the output simulation variables.
+ (sigs pstv.relevant-signals)
+
+ ;; Prune away any signals that the user says he wants to skip.
+ ((mv sigs out-usersyms)
+ (time$ (b* (((unless skip)
+ (mv sigs out-usersyms))
+
+ ;; As a sanity check, complain if there are any bits
+ ;; that are being skipped that don't actually exist.
+ (skip (sets::mergesort skip))
+ (outnames (sets::mergesort (alist-keys out-usersyms)))
+ ((unless (sets::subset skip outnames))
+ (b* ((bad (sets::difference skip outnames))
+ ;; Don't use - or implicit progn$ on these, we want to make sure
+ ;; these get evaluated during GL runs.
+ (?msg (cw "Invalid skip! Not outputs: ~&0." bad))
+ (?err (er hard? 'stv-run-fn "Invalid skip! Not outputs: ~&0." bad)))
+ (mv sigs out-usersyms)))
+
+ ;; Filter the out-usersyms down to just those that we want.
+ (keep (sets::difference outnames skip))
+ (out-usersyms (b* ((tmp (make-fal out-usersyms nil))
+ (ret (fal-extract keep tmp)))
+ (fast-alist-free tmp)
+ ret))
+
+ ;; Also filter the sigs down to just the bits we need.
+ (keep-bits (vl::append-domains out-usersyms))
+ (sigs (b* ((tmp (make-fal sigs nil))
+ (ret (fal-extract keep-bits tmp)))
+ (fast-alist-free tmp)
+ ret)))
+
+ (mv sigs out-usersyms))
+ :mintime 1/2
+ :msg "; stv-run skips: ~st sec, ~sa bytes."))
+
+ ;; Construct the alist to evaluate with
+ (ev-alist
+ (time$ (make-fast-alist
+ (stv-simvar-inputs-to-bits input-alist in-usersyms))
+ :mintime 1/2
+ :msg "; stv-run ev-alist: ~st sec, ~sa bytes.~%"))
+
+ ;; Evaluate the non-skipped signals.
+ (evaled-out-bits
+ (time$ (make-fast-alist (4v-sexpr-simp-and-eval-alist sigs ev-alist))
+ :mintime 1/2
+ :msg "; stv-run out-bits: ~st sec, ~sa bytes.~%"))
+
+ (- (fast-alist-free ev-alist))
+
+ ;; Assemble the non-skipped outputs.
+ (assembled-outs
+ (time$ (stv-assemble-output-alist evaled-out-bits out-usersyms)
+ :mintime 1/2
+ :msg "; stv-run outs: ~st sec, ~sa bytes.~%"))
+
+ (- (fast-alist-free evaled-out-bits))
+
+ ;; Debugging Support
+ (- (or quiet
+ (progn$ (cw "~%STV Inputs:~%")
+ (stv-print-alist input-alist)
+ (cw "~%STV Outputs:~%")
+ (stv-print-alist assembled-outs)
+ (cw "~%")))))
+
+ assembled-outs)
+ :msg "; stv-run: ~st sec, ~sa bytes.~%"
+ :mintime 1))
- (defmacro stv-run (pstv input-alist &key skip quiet)
- `(stv-run-fn ,pstv ,input-alist ,skip ,quiet)))
diff -Nru acl2-6.2/books/centaur/esim/stv/stv-sim.lisp acl2-6.3/books/centaur/esim/stv/stv-sim.lisp
--- acl2-6.2/books/centaur/esim/stv/stv-sim.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/stv/stv-sim.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -25,12 +25,7 @@
(include-book "stv-util")
(include-book "centaur/vl/util/defs" :dir :system)
(include-book "../steps")
-
-(local (defthm atom-listp-of-append
- (implies (and (atom-listp x)
- (atom-listp y))
- (atom-listp (append x y)))
- :hints(("Goal" :in-theory (disable (force))))))
+(local (include-book "std/typed-lists/atom-listp" :dir :system))
(local (defthm atom-listp-of-pat-flatten1
(atom-listp (pat-flatten1 x))
@@ -38,172 +33,226 @@
((force)))))))
-(defsection stv-fully-general-st-alist
+(define stv-fully-general-st-alist
:parents (stv-process)
- :short "@(call stv-fully-general-st-alist) generates a single alist that will
-provide the values for the initial state of @('mod') for a fully general
-simulation."
+ :short "Create the sexpr-alist to use as the initial state for fully general
+simulations of a module."
+ ((mod "The @(see esim) module."))
+ :returns (state-alist "Alist binding every state bit @('|foo|') to
+ @('|foo.INIT|')")
- :long "We basically just bind every state bit @('|foo|') to
-@('|foo.INIT|'). These names can't clash with each other, or with those
+ :long "
These names (obviously) can't clash with each other, or with those
produced by @(see stv-fully-general-in-alists).
We memoize this to ensure we'll get the same initial state alist across
different STVs that target the same module.
"
- (defund stv-fully-general-st-alist (mod)
- (declare (xargs :guard t))
- (b* ((sts (mod-state mod))
- (flat-sts (pat-flatten sts nil))
- ((unless (symbol-listp flat-sts))
- (er hard? 'stv-fully-general-st-alist
- "Expected mod-state to produce a symbol pattern for ~x0." (gpl :n mod))))
- (pairlis$ flat-sts
- (stv-suffix-signals flat-sts ".INIT"))))
-
+ (b* ((sts (mod-state mod))
+ (flat-sts (pat-flatten sts nil))
+ ((unless (symbol-listp flat-sts))
+ (raise "Expected mod-state to produce a symbol pattern for ~x0."
+ (gpl :n mod))))
+ (pairlis$ flat-sts
+ (stv-suffix-signals flat-sts ".INIT")))
+ ///
(memoize 'stv-fully-general-st-alist))
-(defsection stv-fully-general-in-alists
- :parents (stv-process)
- :short "@(call stv-fully-general-in-alists) generates @('n') alists which we
-will use as the inputs to @('mod') to do an @('n')-phase, fully general
-simulation."
-
- :long "This is basically name mangling. For instance, at phase 5 the
-input @('|foo[3]|') will be represented by the variable @('|foo[3].P5|').
-There can't be any name clashes since we're adding a such a suffix to every
-signal.
-
-We memoize this to ensure that we'll get the same fully general alist across
-different STVs that target the same module for the same numbers of steps.
"
-
- (defund stv-fully-general-in-alist-n (n flat-ins)
- (declare (xargs :guard (and (symbol-listp flat-ins)
- (natp n))))
- (pairlis$ flat-ins
- (stv-suffix-signals flat-ins (str::cat ".P" (str::natstr n)))))
-
- (memoize 'stv-fully-general-in-alist-n)
+(define stv-fully-general-in-alist-n ((n natp)
+ (flat-ins symbol-listp))
+ :parents (stv-fully-general-in-alists)
+ :long "We memoize this to ensure that we'll get the same fully general
+alist across different STVs that target the same module for the same numbers of
+steps.
"
+
+ :returns (nth-alist vl::cons-listp)
+ (pairlis$ flat-ins
+ (stv-suffix-signals flat-ins (str::cat ".P" (str::natstr n))))
- (local (defthm c0
+ :prepwork
+ ((local (defthm c0
(vl::cons-listp (pairlis$ x y))
- :hints(("Goal" :in-theory (enable pairlis$)))))
+ :hints(("Goal" :in-theory (enable pairlis$))))))
+ ///
+ (memoize 'stv-fully-general-in-alist-n))
- (defthm cons-listp-of-stv-fully-general-in-alist-n
- (vl::cons-listp (stv-fully-general-in-alist-n n flat-ins))
- :hints(("Goal" :in-theory (enable stv-fully-general-in-alist-n))))
-
- (defund stv-fully-general-in-alists-aux (n flat-ins acc)
- (declare (xargs :guard (and (symbol-listp flat-ins)
- (natp n))))
- (let ((acc (cons (stv-fully-general-in-alist-n n flat-ins) acc)))
- (if (zp n)
- acc
- (stv-fully-general-in-alists-aux (- n 1) flat-ins acc))))
+(define stv-fully-general-in-alists-aux ((n natp)
+ (flat-ins symbol-listp)
+ acc)
+ :parents (stv-fully-general-in-alists)
+ :returns (in-alists vl::cons-list-listp :hyp (vl::cons-list-listp acc))
+ (let ((acc (cons (stv-fully-general-in-alist-n n flat-ins) acc)))
+ (if (zp n)
+ acc
+ (stv-fully-general-in-alists-aux (- n 1) flat-ins acc)))
+ ///
(defthm len-stv-fully-general-in-alists-aux
(equal (len (stv-fully-general-in-alists-aux n flat-ins acc))
- (+ 1 (nfix n) (len acc)))
- :hints(("Goal" :in-theory (enable stv-fully-general-in-alists-aux))))
+ (+ 1 (nfix n) (len acc)))))
- (defthm cons-list-listp-of-stv-fully-general-in-alists-aux
- (implies (vl::cons-list-listp acc)
- (vl::cons-list-listp (stv-fully-general-in-alists-aux n flat-ins acc)))
- :hints(("Goal" :in-theory (enable stv-fully-general-in-alists-aux))))
-
- (defund stv-fully-general-in-alists (n mod)
- (declare (xargs :guard (posp n)))
- (b* ((ins (gpl :i mod))
- (flat-ins (pat-flatten1 ins))
- ((when (mbe :logic (not (posp n)) :exec nil))
- nil)
- ((unless (symbol-listp flat-ins))
- (er hard? 'stv-fully-general-in-alists
- "Expected :i for ~x0 to be a symbol pattern." (gpl :n mod))
- (ec-call (stv-fully-general-in-alists-aux (- n 1) flat-ins nil))))
- (stv-fully-general-in-alists-aux (- n 1) flat-ins nil)))
+(define stv-fully-general-in-alists
+ :parents (stv-process)
+ :short "Create the sexpr-alists to use as the inputs for each phase of fully
+general simulations of a module."
+
+ ((n "The number of phases to simulate." posp)
+ (mod "The @(see esim) module."))
+ :returns (in-alists vl::cons-list-listp)
+
+ :long "This is basically name mangling. For instance, at phase 5 the
+input @('|foo[3]|') will be represented by the variable @('|foo[3].P5|').
+There can't be any name clashes since we're adding a such a suffix to every
+signal.
"
+
+ (b* ((ins (gpl :i mod))
+ (flat-ins (pat-flatten1 ins))
+ ((when (mbe :logic (not (posp n)) :exec nil))
+ nil)
+ ((unless (symbol-listp flat-ins))
+ (raise "Expected :i for ~x0 to be a symbol pattern." (gpl :n mod))
+ (ec-call (stv-fully-general-in-alists-aux (- n 1) flat-ins nil))))
+ (stv-fully-general-in-alists-aux (- n 1) flat-ins nil))
+ ///
(defthm len-stv-fully-general-in-alists
(equal (len (stv-fully-general-in-alists n mod))
- (nfix n))
- :hints(("Goal" :in-theory (enable stv-fully-general-in-alists))))
+ (nfix n))))
- (defthm cons-list-listp-of-stv-fully-general-in-alists
- (vl::cons-list-listp (stv-fully-general-in-alists n mod))
- :hints(("Goal" :in-theory (enable stv-fully-general-in-alists)))))
+(local (in-theory (disable good-esim-modulep)))
-(defsection stv-fully-general-simulation-run
+(define stv-run-esim
:parents (stv-process)
- :short "Run an @('n') step, fully general simulation of @('mod')."
+ ((mod "The module to run." good-esim-modulep)
+ (in-alists "A list of N alists, to be used at each phase.")
+ (state-alists "A list of N alists, to override particular state bits.")
+ (initial-state "Initial state to use."))
+ :guard (eql (len in-alists) (len state-alists))
+ :returns (mv (nsts "A list of next-state alists.")
+ (outs "A list of outputs alists."))
+ (b* (((when (atom in-alists))
+ (mv nil nil))
+ (state-alist (append-without-guard (car state-alists) initial-state))
+ ((mv nst1 out1)
+ (esim-sexpr-simp mod (car in-alists) state-alist))
+ ((mv nst-rest out-rest)
+ (stv-run-esim mod (cdr in-alists) (cdr state-alists) nst1)))
+ (mv (cons nst1 nst-rest)
+ (cons out1 out-rest))))
- :long "Signature: @(call stv-fully-general-simulation-run) returns
-@('(mv init-st in-alists nst-alists out-alists NIL)').
+(define stv-fully-general-simulation-run
+ :parents (stv-process)
+ :short "Run an @('n') step, fully general simulation of a module."
-The @('init-st') and @('in-alists') are just generated by @(see
-stv-fully-general-st-alist) and @(see stv-fully-general-in-alists),
-respectively, and are probably not very interesting.
-
-The @('nst-alists') and @('out-alists') are each lists of @('n') alists,
-representing the fully-general next states and outputs after each phase. These
-alists bind signal names to @(see 4v-sexprs) that do not have any assumptions
-about the values given to the module at each phase.
+ ((n "How many phases to simulate." posp)
+ (mod "The @(see esim) module.")
+ (override-stbits "List of override value and decision state bits"
+ symbol-listp))
+
+ :returns
+ (mv (init-st "Initial state alist that we used. This is just generated by
+ @(see stv-fully-general-st-alist) and is probably not very
+ interesting.")
+
+ (in-alists "Input alists that we used at each phase. This is just
+ generated by @(see stv-fully-general-in-alists) and is
+ probably not very interesting.")
+
+ (nst-alists "A list of @('n') alists that capture the fully general
+ next-state after each phase.")
+
+ (out-alists "A list of @('n') alists that capture the fully general
+ outputs after each phase.")
+
+ (nil "An extra output which is always @('nil'), for signature
+ compatibility with @(see stv-fully-general-simulation-debug)."))
+
+ :long "This is a fully general simulation, so the nst/out-alists bind
+signal names to @(see 4v-sexprs) in terms of the variables in the init-st and
+in-alists.
See also @(see stv-fully-general-simulation-debug), which produces the same
-alists and also produces a list of fully general alists for the internal wires
-of the modules. The extra @('nil') we return is for signature compatibility
-with the @('-debug') version.
+outputs but also captures the internal signals after each phase.
We memoize this function so that if we're reusing an STV, we can just reuse
the same general simulation repeatedly. BOZO maybe we should be memoizing the
-individual steps instead of the whole run.
"
-
- (defund stv-fully-general-simulation-run (n mod)
- "Returns (MV INIT-ST IN-ALISTS NST-ALISTS OUT-ALISTS NIL)"
- (declare (xargs :guard (posp n)))
- (b* ((in-alists (stv-fully-general-in-alists n mod))
- (init-st-alist (stv-fully-general-st-alist mod))
- ((mv nsts outs)
- (ec-call
- (esim-sexpr-simp-steps mod in-alists init-st-alist))))
- (mv init-st-alist in-alists nsts outs nil)))
+individual steps instead of the whole run, to get more cross-stv sharing."
+ (b* ((in-alists (stv-fully-general-in-alists n mod))
+ (init-st-alist (stv-fully-general-st-alist mod))
+ (override-alists (stv-fully-general-in-alists-aux (- n 1) override-stbits nil))
+ ((mv nsts outs)
+ (ec-call
+ (stv-run-esim mod in-alists override-alists init-st-alist))))
+ (mv init-st-alist in-alists nsts outs nil))
+ ///
(memoize 'stv-fully-general-simulation-run :aokp t))
-(local
- (defsection basic-esim-lemmas
- (local (in-theory (enable esim-sexpr-simp-new-probe-steps)))
- (defthm len-of-esim-sexpr-simp-new-probe-steps-0
- (equal (len (mv-nth 0 (esim-sexpr-simp-new-probe-steps mod ins st)))
- (len ins)))
-
- (defthm len-of-esim-sexpr-simp-new-probe-steps-1
- (equal (len (mv-nth 1 (esim-sexpr-simp-new-probe-steps mod ins st)))
- (len ins)))
+(define stv-run-esim-debug
+ :parents (stv-process)
+ ((mod "The module to run." (and (good-esim-modulep mod)
+ (new-good-esim-probe-modulep mod)))
+ (in-alists "A list of N alists, to be used at each phase.")
+ (state-alists "A list of N alists, to override particular state bits.")
+ (initial-state "Initial state to use."))
+ :guard (eql (len in-alists) (len state-alists))
+ :returns (mv (nsts "A list of next-state alists.")
+ (outs "A list of outputs alists.")
+ (ints "A list of internals alists."))
+ (b* (((when (atom in-alists))
+ (mv nil nil nil))
+ (state-alist (append-without-guard (car state-alists) initial-state))
+ ((mv nst1 out1 int1)
+ (esim-sexpr-simp-new-probe mod (car in-alists) state-alist))
+ ((mv nst-rest out-rest int-rest)
+ (stv-run-esim-debug mod (cdr in-alists) (cdr state-alists) nst1)))
+ (mv (cons nst1 nst-rest)
+ (cons out1 out-rest)
+ (cons int1 int-rest)))
+ ///
+ (defthm len-of-stv-run-esim-debug-0
+ (equal (len (mv-nth 0 (stv-run-esim-debug mod ins st-overrides initial-st)))
+ (len ins)))
+
+ (defthm len-of-stv-run-esim-debug-1
+ (equal (len (mv-nth 1 (stv-run-esim-debug mod ins st-overrides initial-st)))
+ (len ins)))
+
+ (defthm len-of-stv-run-esim-debug-2
+ (equal (len (mv-nth 2 (stv-run-esim-debug mod ins st-overrides initial-st)))
+ (len ins))))
- (defthm len-of-esim-sexpr-simp-new-probe-steps-2
- (equal (len (mv-nth 2 (esim-sexpr-simp-new-probe-steps mod ins st)))
- (len ins)))))
-(defsection stv-fully-general-simulation-debug
+(define stv-fully-general-simulation-debug
:parents (stv-debug)
:short "Run an @('n') step, fully general simulation of @('mod') just like
@(see stv-fully-general-simulation-run), but also gather the fully general
expressions for internal signals."
- :long "Signature: @(call stv-fully-general-simulation-debug)
-returns @('(mv init-st in-alists nst-alists out-alists int-alists)').
-
-This is practically identical to @(see stv-fully-general-simulation-run),
-except that it also gathers up and returns a list of @('int-alists') which
-contain the expressions for the internal signals of the module.
+ ((n "How many phases to simulate." posp)
+ (mod "The @(see esim) module.")
+ (override-stbits "List of override value and decision state bits"
+ symbol-listp))
+
+ :returns (mv (init-st "As in @(see stv-fully-general-simulation-run)")
+ (in-alists "As in @(see stv-fully-general-simulation-run)")
+ (nst-alists "As in @(see stv-fully-general-simulation-run)")
+ (out-alists "As in @(see stv-fully-general-simulation-run)")
+
+ (int-alists "A list of @('n') alists that capture the fully
+ general internal signals after each phase."))
+
+ :long "This is practically identical to @(see
+stv-fully-general-simulation-run), except that it also gathers up and returns a
+list of @('int-alists') which contain the expressions for the internal signals
+of the module.
These expressions are useful for generating waveforms for debugging
simulations. We could have just had @(see stv-fully-general-simulation-run)
@@ -220,204 +269,198 @@
as with the -run function, maybe we should be doing the memoization at the level
of individual steps, instead of memoizing the whole thing.
"
- (defund stv-fully-general-simulation-debug (n mod)
- ;; Same as -run, but includes internals for debugging
- "Returns (MV INIT-ST IN-ALISTS NST-ALISTS OUT-ALISTS INT-ALISTS)"
- (declare (xargs :guard (posp n)))
- (b* ((in-alists (stv-fully-general-in-alists n mod))
- (init-st-alist (stv-fully-general-st-alist mod))
- ((mv nsts outs internals)
- (ec-call (esim-sexpr-simp-new-probe-steps mod in-alists init-st-alist))))
- (mv init-st-alist in-alists nsts outs internals)))
-
+ (b* ((in-alists (stv-fully-general-in-alists n mod))
+ (init-st-alist (stv-fully-general-st-alist mod))
+ (override-alists (stv-fully-general-in-alists-aux (- n 1) override-stbits nil))
+ ((mv nsts outs internals)
+ (ec-call (stv-run-esim-debug mod in-alists override-alists init-st-alist))))
+ (mv init-st-alist in-alists nsts outs internals))
+ ///
(memoize 'stv-fully-general-simulation-debug :aokp t)
(local (in-theory (enable stv-fully-general-simulation-debug)))
(defthm len-of-stv-fully-general-simulation-debug-1
- (equal (len (mv-nth 1 (stv-fully-general-simulation-debug nphases mod)))
+ (equal (len (mv-nth 1 (stv-fully-general-simulation-debug nphases mod override-stbits)))
(nfix nphases)))
(defthm len-of-stv-fully-general-simulation-debug-2
- (equal (len (mv-nth 2 (stv-fully-general-simulation-debug nphases mod)))
+ (equal (len (mv-nth 2 (stv-fully-general-simulation-debug nphases mod override-stbits)))
(nfix nphases)))
(defthm len-of-stv-fully-general-simulation-debug-3
- (equal (len (mv-nth 3 (stv-fully-general-simulation-debug nphases mod)))
+ (equal (len (mv-nth 3 (stv-fully-general-simulation-debug nphases mod override-stbits)))
(nfix nphases)))
(defthm len-of-stv-fully-general-simulation-debug-4
- (equal (len (mv-nth 4 (stv-fully-general-simulation-debug nphases mod)))
+ (equal (len (mv-nth 4 (stv-fully-general-simulation-debug nphases mod override-stbits)))
(nfix nphases)))
(defthm cons-list-listp-of-stv-fully-general-simulation-debug-1
- (vl::cons-list-listp (mv-nth 1 (stv-fully-general-simulation-debug nphases mod)))))
+ (vl::cons-list-listp
+ (mv-nth 1 (stv-fully-general-simulation-debug nphases mod override-stbits)))))
; The final processing stuff could go in its own file, but we already have
-; everything it depends on here, so for build time this seems like the right
-; place for it.
-
+; everything it depends on here, so to optimize build time this seems like the
+; right place for it.
-(defsection stv-extract-relevant-signals
+(define stv-extract-relevant-signals
:parents (stv-process)
:short "Pull out the fully general expressions for the signals that we care
about, and bind them to the bit names of the simulation variables."
- :long "@(call stv-extract-relevant-signals) is given:
+ ((extract-alists "The @(see stv-extraction-alists) we obtained from @(see
+ stv-compile).")
+ (out-alists "The list of output alists from the fully general simulation,
+ e.g., from @(see stv-fully-general-simulation-run).")
+ (acc "An accumulator to extend, which should initially be nil."))
-
-
-@('extract-alists'), the @(see stv-extraction-alists) we obtained from
-@(see stv-compile),
+ :long "We walk down the @('extract-alists') and @('out-alists') together,
+extracting the expressions for the signals that we care about at each phase,
+and naming them with the output simulation variable bit names.
"
-@('out-alists'), the list of output alists we got from the fully general
-simulation (e.g., from @(see stv-fully-general-simulation-run)), and
+ (b* (((when (and (atom extract-alists)
+ (atom out-alists)))
+ acc)
+
+ ((when (or (atom extract-alists)
+ (atom out-alists)))
+ (raise "Should have as many extract alists as out-alists."))
+
+ (extr1 (car extract-alists))
+ (outs1 (car out-alists))
+ ((when (not extr1))
+ ;; Optimization. There is nothing to extract during this phase,
+ ;; so just go on. This is very common and lets us avoid making
+ ;; a fast-alist for the out-alist at this step.
+ (stv-extract-relevant-signals (cdr extract-alists)
+ (cdr out-alists)
+ acc))
+
+ (user-bits (alist-vals extr1))
+ (want-names (alist-keys extr1))
+ (outs1 (make-fast-alist outs1))
+ (want-exprs (vl::look-up-each-fast want-names outs1))
+ (- (fast-alist-free outs1))
+ (acc (safe-pairlis-onto-acc user-bits want-exprs acc)))
+ (stv-extract-relevant-signals (cdr extract-alists)
+ (cdr out-alists)
+ acc)))
-@('acc'), an accumulator to extend which should initially be nil.
-
+(define stv-process
+ :parents (symbolic-test-vectors)
+ :short "Process a symbolic test vector and prepare it to be run."
-We walk down the @('extract-alists') and @('out-alists') together,
-extracting the expressions for the signals that we care about at each phase,
-and naming them with the output simulation variable bit names.
"
+ ((name "A name for this STV. Used by @(see stv-debug)."
+ symbolp)
- (defund stv-extract-relevant-signals (extract-alists out-alists acc)
- (declare (xargs :guard t))
- (b* (((when (and (atom extract-alists)
- (atom out-alists)))
- acc)
-
- ((when (or (atom extract-alists)
- (atom out-alists)))
- (er hard? 'stv-extract-relevant-signals
- "Should have as many extract alists as out-alists."))
-
- (extr1 (car extract-alists))
- (outs1 (car out-alists))
- ((when (not extr1))
- ;; Optimization. There is nothing to extract during this phase,
- ;; so just go on. This is very common and lets us avoid making
- ;; a fast-alist for the out-alist at this step.
- (stv-extract-relevant-signals (cdr extract-alists)
- (cdr out-alists)
- acc))
-
- (user-bits (alist-vals extr1))
- (want-names (alist-keys extr1))
- (outs1 (make-fast-alist outs1))
- (want-exprs (vl::look-up-each-fast want-names outs1))
- (- (fast-alist-free outs1))
- (acc (safe-pairlis-onto-acc user-bits want-exprs acc)))
- (stv-extract-relevant-signals (cdr extract-alists)
- (cdr out-alists)
- acc))))
+ (stv stvdata-p
+ "The bundled up, original symbolic test vector description that the
+ user wrote. This isn't actually used for anything, except that we
+ stuff it into the resulting processed-stv, perhaps mainly for
+ documentation?")
+
+ (cstv compiled-stv-p
+ "An already-compiled version of @('stv'). We take this as an argument,
+ rather than compiling it ourselves, mainly to parallelize the STV
+ book building process.")
+
+ (mod good-esim-modulep
+ "The @(see esim) module that @('stv') is being written for."))
+
+ :returns (pstv (equal (processed-stv-p pstv)
+ (if pstv t nil))
+ :hyp (and (force (symbolp name))
+ (force (compiled-stv-p cstv)))
+ "The fully processed, ready-to-run STV.")
+ :long "An STV must be processed before it can be run with @(see stv-run).
+This processing can be expensive and involves several steps.
+
-(defsection stv-process
- :parents (symbolic-test-vectors)
- :short "Process a symbolic test vector and prepare it to be run."
+The @('mod') is symbolically simulated using a fully-general multi-phase
+@(see esim) simulation.
- :long "Signature: @(call stv-process) returns a processed STV.
+The relevant outputs are then extracted from this simulation and
+specialized as suggested by this particular @('stv').
-The @('stv') should be an @(see stvdata-p), i.e., the bundled up original
-symbolic test vector description that the user wrote; see @(see defstv).
+These restricted outputs and other information is then saved into a @(see
+processed-stv-p) object that can be given to @(see stv-run) or @(see
+stv-debug).
-The @('cstv') should be the already-compiled version of @('stv'). We take
-this as an argument, rather than compiling it ourselves, to split up the build
-process more nicely.
-
-The @('mod') is the @(see esim) module that the @('stv') is being written
-for.
-
-An STV must be processed before it can be run with @(see stv-run). This
-processing can be expensive and involves several steps. The @('mod') is
-symbolically simulated using a fully-general multi-phase @(see esim)
-simulation. The relevant outputs are then extracted from this simulation and
-specialized as suggested by this particular @('stv'). These restricted outputs
-and other information is then saved into a @(see processed-stv-p) object that
-can be given to @(see stv-run) or @(see stv-debug).
+
Note that there are many chances for memoization, e.g., if you have a lot of
different symbolic test vectors that all target the same module, they can reuse
the same @(see esim) simulation, so processing the first STV may be very
expensive but processing subsequent STVs can be much cheaper.
"
- (defund stv-process (stv cstv mod)
- (declare (xargs :guard (and (stvdata-p stv)
- (compiled-stv-p cstv)
- (good-esim-modulep mod))))
- (b* (((compiled-stv cstv) cstv)
-
- (need-internals
- ;; We can avoid computing the internal signals if we didn't ask for
- ;; any. This is kind of silly, but it can save a lot of time if you
- ;; don't care about the internals at all. This isn't ideal, better
- ;; would be to mark the CSTV with some flag that says whether it
- ;; needs any int-out bits.
- (consp cstv.expanded-ints))
-
- ((mv ?init-st-general
- ?in-alists-general
- ?nst-alists-general
- out-alists-general
- int-alists-general)
- ;; Do the fully general simulation for however many steps are needed.
- (if need-internals
- (time$ (stv-fully-general-simulation-debug cstv.nphases mod)
- :msg "; stv-process debug simulation: ~st sec, ~sa bytes.~%"
- :mintime 1/2)
- (time$ (stv-fully-general-simulation-run cstv.nphases mod)
- :msg "; stv-process simulation: ~st sec, ~sa bytes.~%"
- :mintime 1/2)))
-
- (relevant-signals-general
- ;; The out-alists-general and int-alists-general bind names to sexprs
- ;; based on the fully general inputs. We probably don't care about
- ;; the vast majority of these names---usually we only care about a
- ;; few outputs at certain stages! So now we pull out only the
- ;; signals we actually care about. This seems like a good place to
- ;; stop distinguishing between internal and output signals, so that
- ;; the user just sees uniform output simulation variables.
- (time$ (let* ((acc nil)
- (acc (stv-extract-relevant-signals cstv.out-extract-alists
- out-alists-general
- acc))
- (acc
- (if need-internals
- (stv-extract-relevant-signals cstv.int-extract-alists
- int-alists-general
- acc)
- acc)))
- acc)
- :msg "; stv-process extraction: ~st sec, ~sa bytes.~%"
- :mintime 1/2))
-
- (relevant-signals-specialized
- ;; The general alists are still in terms of the fully general input
- ;; variables. So, we now rewrite them using the restrict-alist,
- ;; which will basically (1) "assume" the concrete STV bindings, and
- ;; (2) replaces certain general input variables with the names of the
- ;; bits of the input simulation variables.
- (time$ (4v-sexpr-restrict-with-rw-alist relevant-signals-general
- cstv.restrict-alist)
- :msg "; stv-process specialization: ~st sec, ~sa bytes.~%"
+ (b* (((compiled-stv cstv) cstv)
+
+ (need-internals
+ ;; We can avoid computing the internal signals if we didn't ask for
+ ;; any. This is kind of silly, but it can save a lot of time if you
+ ;; don't care about the internals at all.
+ (not (subsetp cstv.int-extract-alists '(nil))))
+
+ ((mv ?init-st-general
+ ?in-alists-general
+ nst-alists-general
+ out-alists-general
+ int-alists-general)
+ ;; Do the fully general simulation for however many steps are needed.
+ (if need-internals
+ (time$ (stv-fully-general-simulation-debug cstv.nphases mod cstv.override-bits)
+ :msg "; stv-process debug simulation: ~st sec, ~sa bytes.~%"
+ :mintime 1/2)
+ (time$ (stv-fully-general-simulation-run cstv.nphases mod cstv.override-bits)
+ :msg "; stv-process simulation: ~st sec, ~sa bytes.~%"
:mintime 1/2)))
- (make-processed-stv :mod mod
- :user-stv stv
- :compiled-stv cstv
- :relevant-signals relevant-signals-specialized)))
-
- (local (in-theory (enable stv-process)))
-
- (defthm processed-stv-p-of-stv-process
- (implies (force (compiled-stv-p cstv))
- (equal (processed-stv-p (stv-process stv cstv mod))
- (if (stv-process stv cstv mod)
- t
- nil)))))
+ (relevant-signals-general
+ ;; The out-alists-general and int-alists-general bind names to sexprs
+ ;; based on the fully general inputs. We probably don't care about
+ ;; the vast majority of these names---usually we only care about a
+ ;; few outputs at certain stages! So now we pull out only the
+ ;; signals we actually care about. This seems like a good place to
+ ;; stop distinguishing between internal and output signals, so that
+ ;; the user just sees uniform output simulation variables.
+ (time$ (let* ((acc nil)
+ (acc (stv-extract-relevant-signals cstv.out-extract-alists
+ out-alists-general
+ acc))
+ (acc
+ (if need-internals
+ (stv-extract-relevant-signals cstv.int-extract-alists
+ int-alists-general
+ acc)
+ acc))
+ (acc
+ (stv-extract-relevant-signals cstv.nst-extract-alists
+ nst-alists-general
+ acc)))
+ acc)
+ :msg "; stv-process extraction: ~st sec, ~sa bytes.~%"
+ :mintime 1/2))
+
+ (relevant-signals-specialized
+ ;; The general alists are still in terms of the fully general input
+ ;; variables. So, we now rewrite them using the restrict-alist,
+ ;; which will basically (1) "assume" the concrete STV bindings, and
+ ;; (2) replaces certain general input variables with the names of the
+ ;; bits of the input simulation variables.
+ (time$ (with-fast-alist cstv.restrict-alist
+ (4v-sexpr-restrict-with-rw-alist relevant-signals-general
+ cstv.restrict-alist))
+ :msg "; stv-process specialization: ~st sec, ~sa bytes.~%"
+ :mintime 1/2)))
+
+ (make-processed-stv :name name
+ :user-stv stv
+ :compiled-stv cstv
+ :relevant-signals relevant-signals-specialized)))
diff -Nru acl2-6.2/books/centaur/esim/stv/stv-top.lisp acl2-6.3/books/centaur/esim/stv/stv-top.lisp
--- acl2-6.2/books/centaur/esim/stv/stv-top.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/stv/stv-top.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -36,7 +36,6 @@
;; these can be omitted unless desired.
;; (include-book "stv-debug")
-
(defxdoc symbolic-test-vectors
:parents (esim)
:short "A concise way to describe, evaluate, and debug symbolic simulations
@@ -78,14 +77,11 @@
:long "Example Test Vector
@({
- ((:initial
- (\"foo.statemachine.busy\" 0)
- (\"foo.prevStutter\" stutter))
-
- ;; phases: 0 1 2 3 4 5 6 ...
+ (
+ ;; phases: 0 1 2 3 4 5 6 ...
;; ---------------------------------------------------------------------------
- (:inputs
+ (:inputs ;; for supplying values to input wires
(\"clock\" 0 ~)
(\"ibus[13:10]\" #b101 #b101 _)
(\"ibus[9:0]\" op op _)
@@ -95,26 +91,30 @@
(\"reset\" 0)
(\"fuse[0]\" X))
- (:outputs
+ (:outputs ;; for extracting values on output wires
(\"result_bus\" _ _ _ _ _ res1 res2)
(\"result_bus[63:32]\" _ _ _ _ _ res-hi1 res-hi2)
(\"result_bus[31:0]\" _ _ _ _ _ res-lo1 res-lo2)
)
- (:internals
+ (:internals ;; for extracting values on internal wires
(\"queue0.mgr.fail\" _ _ qf1 qf2 _))
+ ;; advanced features:
+
+ (:overrides ;; for forcibly overriding values on wires
+
+ ;; abstract away product wire, replacing it with variables
+ (\"foo.prod\" _ _ prod _ _ _ _ )
+
+ ;; force fast mode to true after phase 1, no matter what its real value is
+ (\"foo.fastmode\" _ _ 1 1 1 1 1 ))
+
)
- ;; ---------------------------------------------------------------------------
})
High-Level Overview
-The @(':initial') section controls the initial values of state bits. For
-the above vector, @('foo.statemachine.busy') will be initialized to zero and
-@('foo.prevStutter') will be some particular value, @('stutter'), that can be
-specified at @(see stv-run) time.
-
The @(':inputs') section controls how the module's inputs will be set over
the course of the simulation. For the above vector,
@@ -167,6 +167,11 @@
you to pull out the values of internal signals in the module.
+The @(':overrides') section is similar to the inputs section, but it allows
+you to forcibly install new values onto wires, regardless of how they are
+actually driven by the circuit.
+
+
Input Line Format
Each line in the @(':inputs') section explains how a certain input should be
@@ -281,33 +286,40 @@
use explicit lsb-first ordered lists of ESIM paths.
-Initial Line Format
-
-Each line in the @(':initial') section explains how to initialize some state
-bits. Unlike input lines, each initial line has only a single value, namely
-its value at the start of the simulation. This is because the value the
-register stores during the subsequent phases of the simulation is determined by
-the circuit. Each initial line has the following format:
+Override Line Format
-@({
- (name value)
-})
+Each line in the @(':override') section explains how to override some
+internal wire.
-The names in initial lines may be strings that are Verilog-style plain or
+
The names in override lines may be strings that are Verilog-style plain or
hierarchical identifiers using periods as separators, which may optionally
include a Verilog-style bit- or part-select at the end. It is also possible to
use explicit lsb-first ordered lists of ESIM paths.
-STVs are slightly clever in how they interpret these names. In short, you
-don't have to write down the whole path to a Verilog @('reg') or anything like
-that, because the STV compiler will automatically walk backwards from whatever
-paths you give it. As long as this walk takes it to a flop or latch, it will
-know which state bit to initialize. In practice, you can give paths that are
-separated from their Verilog @('reg')s through any number of assignments,
-inverters, and buffers.
+The @('value')s here are similar to those of input lines, except that:
-The @('value')s here are like those of input lines, except that you can't
-use @('~') since there isn't any previous value to invert.
")
+
+
+@('~') is not allowed, because it would be somewhat confusing.
+
+@('_') means \"don't override the wire during this phase\".
+
+
+
+Every variable used in an override line becomes both an input and an output
+variable of the STV. For instance, in the example above, we had the following
+override line:
+
+@({
+ (\"foo.prod\" _ _ prod _ _ _ _ )
+})
+
+Here, as an input to the STV, @('prod') allows us to forcibly set the value
+of the wire @('foo.prod'). As an output, @('prod') gives us the original,
+un-overridden expression for @('prod'). (Well, that's probably mostly
+true. If @('prod') depends on other overridden values, or is involved in some
+combinational loop so that it affects itself, then this may not be quite
+right.)
")
@@ -388,7 +400,7 @@
Once the STV has been processed, we can run it with concrete values for the
input simulation variables; see @(see stv-run). To do this, we basically need
to (1) translate the input numbers into bit-level bindings, (2) use @(see
-sexpr-eval) to reduce the sexprs that are found in the Processed STV with the
+4v-sexpr-eval) to reduce the sexprs that are found in the Processed STV with the
bindings for their inputs, and (3) translate back from the resulting output-bit
bindings into numbers (or Xes) for the output alist. This is about as cheap as
we know how to make it.
@@ -401,62 +413,252 @@
Well, basically we just do a new @(see esim) simulation that does include
the internal variables, and then run through the rest of the process again. We
-memoize things so that even though your first call of @(see stv-debug) is
-expensive, subsequent calls will not need to redo the simulation or
+@(see memoize) things so that even though your first call of @(see stv-debug)
+is expensive, subsequent calls will not need to redo the simulation or
specialization steps.
")
-(defsection stv-autohyps
+(define stv-autohyps-aux ((ins symbol-listp)
+ (stv processed-stv-p))
+ :parents (stv-autohyps)
+ :long "We could have used @(see unsigned-byte-p) instead, but that gets us
+into trouble with :expand hints when recursive definitions of unsigned-byte-p
+are installed, so just use explicit bounds instead.
"
+ (if (atom ins)
+ nil
+ (list* `(natp ,(car ins))
+ `(< ,(car ins) (expt 2 ,(stv-in->width (car ins) stv)))
+ (stv-autohyps-aux (cdr ins) stv))))
+
+(define stv-autohyps ((stv processed-stv-p))
+ :parents (defstv)
+ :short "Generate the body for an STV's autohyps macro."
+ (b* ((ins (stv->ins stv))
+ ((unless (symbol-listp ins))
+ (raise "Non-symbol inputs?")))
+ `(and . ,(stv-autohyps-aux ins stv))))
+
+(define stv-autobinds-aux ((ins symbol-listp)
+ (stv processed-stv-p))
+ :parents (stv-autobinds)
+ (if (atom ins)
+ nil
+ (cons `(:nat ,(car ins) ,(stv-in->width (car ins) stv))
+ (stv-autobinds-aux (cdr ins) stv))))
+
+(define stv-autobinds ((stv processed-stv-p))
+ :parents (defstv)
+ :short "Generate the body for an STV's autobinds macro."
+ (b* ((ins (stv->ins stv))
+ ((unless (symbol-listp ins))
+ (raise "Non-symbol inputs?")))
+ `(gl::auto-bindings . ,(stv-autobinds-aux ins stv))))
+
+(define stv-autoins-aux (ins)
+ :parents (stv-autoins)
+ (if (atom ins)
+ nil
+ (cons `(cons ',(car ins) ,(car ins))
+ (stv-autoins-aux (cdr ins)))))
+
+(define stv-autoins ((stv processed-stv-p))
+ :parents (defstv)
+ :short "Generate the body for an STV's autoins macro."
+ `(list . ,(stv-autoins-aux (stv->ins stv))))
+
+
+
+(local (in-theory (disable good-esim-modulep)))
+
+(define defstv-main
+ :parents (defstv)
+ :short "Main error checking and processing of an STV."
+
+ (&key (mod good-esim-modulep)
+ (name symbolp)
+ inputs outputs internals overrides)
+
+ :returns (pstv (equal (processed-stv-p pstv)
+ (if pstv t nil))
+ :hyp (force (symbolp name)))
+
+ :long "This is the main part of @(see defstv).
+
+We split this out into its own function for advanced users who need a
+non-event based way to introduce symbolic test vectors.
+
+This does only the STV processing. We don't deal here with generating
+documentation, creating autohyps macros, etc.
"
+
+ (b* ((mod (or mod
+ ;; Blah, silly, (good-esim-modulep nil) is true, so
+ ;; explicitly check for this.
+ (raise "No :mod was specified.")))
+ (inputs (if (true-list-listp inputs)
+ inputs
+ (raise ":inputs are not even a true-list-listp")))
+ (outputs (if (true-list-listp outputs)
+ outputs
+ (raise ":outputs are not even a true-list-listp")))
+ (internals (if (true-list-listp internals)
+ internals
+ (raise ":internals are not even a true-list-listp")))
+ (overrides (if (true-list-listp overrides)
+ overrides
+ (raise ":overrides are not even a true-list-listp")))
+
+ (stv (make-stvdata :overrides overrides
+ :inputs inputs
+ :outputs outputs
+ :internals internals))
+
+ (preprocessed-stv
+ (time$ (let* ((stv (stv-widen stv))
+ (stv (stv-expand stv mod)))
+ stv)
+ :msg "; stv preprocessing: ~st sec, ~sa bytes~%"
+ :mintime 1/2))
+
+ (compiled-stv
+ (time$ (stv-compile preprocessed-stv mod)
+ :msg "; stv compilation: ~st sec, ~sa bytes~%"
+ :mintime 1/2))
+
+ ((unless compiled-stv)
+ ;; this shouldn't happen... it should throw an error instead
+ (raise "stv-compile failed?"))
+
+ (mod (stv-cut-module
+ (compiled-stv->override-paths compiled-stv) mod))
+
+ (processed-stv
+ (time$ (stv-process name stv compiled-stv mod)
+ :msg "; stv processing: ~st sec, ~sa bytes~%"
+ :mintime 1/2))
+
+ ((unless processed-stv)
+ ;; this shouldn't happen... it should throw an error instead
+ (raise "stv-process failed?")))
+
+ processed-stv))
+
+
+(define defstv-fn
+ :parents (defstv)
+ :short "Implementation of @(see defstv)."
+
+ ((name symbolp "E.g., mmx-run")
+ (mod-const-name symbolp "E.g., the symbol *mmx*")
+ (mod good-esim-modulep "E.g., the actual E module for *mmx*")
+ ;; Arguments from the user...
+ inputs outputs internals overrides
+ labels parents short long)
+
+ (b* ((labels (if (symbol-listp labels)
+ labels
+ (raise ":labels need to be a symbol-listp.")))
+
+ (want-xdoc-p (or parents short long))
+ (short (cond ((stringp short) short)
+ ((not short) "")
+ (t (progn$ (raise ":short must be a string.")
+ ""))))
+ (long (cond ((stringp long) long)
+ ((not long) "")
+ (t (progn$ (raise ":long must be a string.")
+ ""))))
+
+ (processed-stv (defstv-main :mod mod
+ :name name
+ :overrides overrides
+ :inputs inputs
+ :outputs outputs
+ :internals internals))
+ ((unless processed-stv)
+ ;; In practice we should have already thrown an error, so we should
+ ;; never hit this.
+ (raise "Failed to process STV."))
+
+ (compiled-stv (processed-stv->compiled-stv processed-stv))
+ (stv (processed-stv->user-stv processed-stv))
+
+ ((unless (stvdata-p stv))
+ ;; Stupidity to satisfy guards of stv-to-xml call, below; this should
+ ;; be impossible to hit, I just don't want to prove it.
+ (raise "stv processing didn't produce good stvdata?"))
+
+ ;; Only now, after we've already compiled and processed the STV, do we
+ ;; bother to generate the documentation. We want to make sure it stays
+ ;; in this order, because stv-to-xml doesn't have good error reporting.
+ (long (if (not want-xdoc-p)
+ long
+ (str::cat "Simulation Diagram
- (defund stv-autohyps-aux (ins stv)
- (declare (xargs :guard (and (symbol-listp ins)
- (processed-stv-p stv))))
- (if (atom ins)
- nil
- ;; Could have used unsigned-byte-p instead, but that gets us into trouble
- ;; with :expand hints when recursive definitions of unsigned-byte-p are
- ;; installed, so just use explicit bounds instead.
- (list* `(natp ,(car ins))
- `(< ,(car ins) (expt 2 ,(stv-in->width (car ins) stv)))
- (stv-autohyps-aux (cdr ins) stv))))
-
- (defund stv-autohyps (stv)
- (declare (xargs :guard (processed-stv-p stv)))
- (b* ((ins (stv->ins stv))
- ((unless (symbol-listp ins))
- (er hard? 'stv-autohyps "Non-symbol inputs?")))
- `(and . ,(stv-autohyps-aux ins stv)))))
-
-
-(defsection stv-autobinds
-
- (defund stv-autobinds-aux (ins stv)
- (declare (xargs :guard (and (symbol-listp ins)
- (processed-stv-p stv))))
- (if (atom ins)
- nil
- (cons `(:nat ,(car ins) ,(stv-in->width (car ins) stv))
- (stv-autobinds-aux (cdr ins) stv))))
-
- (defund stv-autobinds (stv)
- (declare (xargs :guard (processed-stv-p stv)))
- (b* ((ins (stv->ins stv))
- ((unless (symbol-listp ins))
- (er hard? 'stv-autobinds "Non-symbol inputs?")))
- `(gl::auto-bindings . ,(stv-autobinds-aux ins stv)))))
-
-
-(defsection stv-autoins
-
- (defund stv-autoins-aux (ins)
- (declare (xargs :guard t))
- (if (atom ins)
- nil
- (cons `(cons ',(car ins) ,(car ins))
- (stv-autoins-aux (cdr ins)))))
-
- (defund stv-autoins (stv)
- (declare (xargs :guard (processed-stv-p stv)))
- `(list . ,(stv-autoins-aux (stv->ins stv)))))
+This is a symbolic test vector defined with @(see
+acl2::defstv).
"
+ (or (stv-to-xml stv compiled-stv labels)
+ "Error generating diagram")
+ long)))
+
+
+ ;; Stupid trick to avoid saving the module in the .cert file
+ (stvconst (intern-in-package-of-symbol
+ (str::cat "*" (symbol-name name) "*")
+ name))
+ (modconst (intern-in-package-of-symbol
+ (str::cat "*" (symbol-name name) "-MOD*")
+ name))
+ (name-mod (intern-in-package-of-symbol
+ (str::cat (symbol-name name) "-MOD")
+ name))
+ (name-autohyps (intern-in-package-of-symbol
+ (str::cat (symbol-name name) "-AUTOHYPS")
+ name))
+ (name-autoins (intern-in-package-of-symbol
+ (str::cat (symbol-name name) "-AUTOINS")
+ name))
+ (name-autobinds (intern-in-package-of-symbol
+ (str::cat (symbol-name name) "-AUTOBINDS")
+ name))
+
+ (cmds `((defconst ,stvconst ',processed-stv)
+
+ (defconst ,modconst
+ (stv-cut-module (compiled-stv->override-paths
+ (processed-stv->compiled-stv ,stvconst))
+ ,mod-const-name))
+
+ (defund ,name ()
+ ;; Using a 0-ary function instead of a constant is nice when
+ ;; we want to look at DEF-GL-THMs with :PR, etc.
+ (declare (xargs :guard t))
+ ,stvconst)
+
+ (defund ,name-mod ()
+ (declare (xargs :guard t))
+ ,modconst)
+
+ (defmacro ,name-autohyps ()
+ ',(stv-autohyps processed-stv))
+
+ (defmacro ,name-autoins ()
+ ',(stv-autoins processed-stv))
+
+ (defmacro ,name-autobinds ()
+ ',(stv-autobinds processed-stv))
+
+ ))
+
+ (cmds (if (not want-xdoc-p)
+ cmds
+ (cons `(defxdoc ,name
+ :parents ,parents
+ :short ,short
+ :long ,long)
+ cmds))))
+
+ `(with-output :off (event)
+ (progn . ,cmds))))
(defsection defstv
@@ -466,15 +668,15 @@
@({
(defstv my-run
- :mod *my-mod*
- :initial '((\"foo.bar.myreg\" mr) ...)
+ :mod *my-mod*
:inputs '((\"opcode\" _ _ op _) ...)
:outputs '((\"result\" _ _ _ _ res _) ...)
:internals '((\"foo.bar.mybus\" _ _ mb _) ...)
- :labels '(A nil B nil C nil)]
- :parents ...
- :short ...
- :long ...)
+ :overrides '((\"foo.bar.mywire\" _ mw _ _) ...)
+ :labels '(A nil B nil C nil)]
+ :parents ...
+ :short ...
+ :long ...)
})
The @('defstv') command is the main interface for defining symbolic test
@@ -492,9 +694,9 @@
requirement lets us avoid writing the module into the certificate, which can
significantly improve performance when including books with STVs.
-
The @(':initial'), @(':inputs'), @(':outputs'), and @(':internals') control
-how to simulate the module. For the syntax and meaning of these lines, see
-@(see symbolic-test-vector-format).
+The @(':inputs'), @(':outputs'), @(':internals'), and @(':overrides')
+control how to simulate the module. For the syntax and meaning of these lines,
+see @(see symbolic-test-vector-format).
@@ -525,7 +727,6 @@
not directly use the @('processed-stv-p') accessors (in case we change the
format).
-
@('(my-run-autohyps)')
This is a macro that expands to something like:
@@ -590,164 +791,76 @@
write your own binding macros. See @(see stv-easy-bindings) for a high-level
way to describe most kind of bindings.
- "
-
- (local (in-theory (disable good-esim-modulep)))
-
- (defund defstv-fn (name mod-const-name ;; e.g., *mmx*
- mod ;; e.g., the value of *mmx*
- initial inputs outputs internals
- labels parents short long)
- (declare (xargs :guard (and (symbolp name)
- (symbolp mod-const-name)
- (good-esim-modulep mod))))
- (b* ((mod (or mod (er hard? 'defstv "No :mod was specified.")))
-
- (initial (if (true-list-listp initial)
- initial
- (er hard? 'defstv ":initial is not even a true-list-listp?")))
- (inputs (if (true-list-listp inputs)
- inputs
- (er hard? 'defstv ":inputs are not even a true-list-listp?")))
- (outputs (if (true-list-listp outputs)
- outputs
- (er hard? 'defstv ":outputs are not even a true-list-listp?")))
- (internals (if (true-list-listp internals)
- internals
- (er hard? 'defstv ":internals are not even a true-list-listp?")))
- (labels (if (symbol-listp labels)
- labels
- (er hard? 'defstv ":labels need to be a symbol-listp.")))
-
- (stv (make-stvdata :initial initial
- :inputs inputs
- :outputs outputs
- :internals internals))
-
- (want-xdoc-p (or parents short long))
- (short (cond ((stringp short) short)
- ((not short) "")
- (t (progn$ (er hard? 'defstv ":short must be a string.")
- ""))))
- (long (cond ((stringp long) long)
- ((not long) "")
- (t (progn$ (er hard? 'defstv ":long must be a string.")
- ""))))
-
- (preprocessed-stv
- (time$ (let* ((stv (stv-widen stv))
- (stv (stv-expand stv mod)))
- stv)
- :msg "; stv preprocessing: ~st sec, ~sa bytes~%"
- :mintime 1/2))
-
- (compiled-stv
- (time$ (stv-compile preprocessed-stv mod)
- :msg "; stv compilation: ~st sec, ~sa bytes~%"
- :mintime 1/2))
-
- ((unless compiled-stv)
- ;; this shouldn't happen... it should throw an error instead
- (er hard? 'defstv-fn "stv-compile failed?"))
-
-
- (processed-stv
- (time$ (stv-process stv compiled-stv mod)
- :msg "; stv processing: ~st sec, ~sa bytes~%"
- :mintime 1/2))
-
- ((unless processed-stv)
- ;; this shouldn't happen... it should throw an error instead
- (er hard? 'defstv-fn "stv-process failed?"))
-
-
- ;; Only now, after we've already compiled and processed the STV, do we
- ;; bother to generate the documentation. We want to make sure it
- ;; stays in this order, because stv-to-xml doesn't have good error
- ;; reporting.
- (long (if (not want-xdoc-p)
- long
- (str::cat "Simulation Diagram
-
-This is a symbolic test vector defined with @(see
-acl2::defstv).
"
- (or (stv-to-xml stv compiled-stv labels)
- "Error generating diagram"))))
-
-
- ;; Stupid trick to avoid saving the module in the .cert file
- (stvconst-without-mod (intern-in-package-of-symbol
- (str::cat "*" (symbol-name name) "-WITHOUT-MOD*")
- name))
- (stvconst-with-mod (intern-in-package-of-symbol
- (str::cat "*" (symbol-name name) "*")
- name))
- (name-autohyps (intern-in-package-of-symbol
- (str::cat (symbol-name name) "-AUTOHYPS")
- name))
- (name-autoins (intern-in-package-of-symbol
- (str::cat (symbol-name name) "-AUTOINS")
- name))
- (name-autobinds (intern-in-package-of-symbol
- (str::cat (symbol-name name) "-AUTOBINDS")
- name))
-
- (cmds `((defconst ,stvconst-without-mod
- ;; Remove :mod from the quoted constant we save
- ',(change-processed-stv processed-stv :mod nil))
-
- (defconst ,stvconst-with-mod
- ;; Now restore it with a separate defconst, which gets evaluated
- ;; at include-book time
- (change-processed-stv ,stvconst-without-mod
- :mod ,mod-const-name))
-
- (defund ,name ()
- ;; Using a 0-ary function instead of a constant is nice when
- ;; we want to look at DEF-GL-THMs with :PR, etc.
- (declare (xargs :guard t))
- ,stvconst-with-mod)
-
- (defmacro ,name-autohyps ()
- ',(stv-autohyps processed-stv))
-
- (defmacro ,name-autoins ()
- ',(stv-autoins processed-stv))
-
- (defmacro ,name-autobinds ()
- ',(stv-autobinds processed-stv))
-
- ))
+@('(my-run-mod)')
- (cmds (if (not want-xdoc-p)
- cmds
- (cons `(defxdoc ,name
- :parents ,parents
- :short ,short
- :long ,long)
- cmds))))
+This is a disabled 0-ary function (i.e., a constant) that either returns
+@('*mod*') or, when @(':overrides') are used, some modified version of
+@('*mod*') where the overridden wires have been cut. There is ordinarily no
+reason to need this, but certain functions like @('stv-debug') make use of
+it.
- `(progn . ,cmds)))
+"
(defmacro defstv (name &key
mod
- initial inputs outputs internals
+ inputs outputs internals overrides
labels parents short long)
`(make-event
(let ((event (defstv-fn ',name
',mod ,mod
- ,initial ,inputs ,outputs ,internals
+ ,inputs ,outputs ,internals ,overrides
,labels ',parents ,short ,long)))
event))))
-(defsection stv-easy-bindings
+
+
+(define stv-easy-bindings-inside-mix ((x "Some arguments inside of a :mix")
+ (stv processed-stv-p))
+ :parents (stv-easy-bindings)
+ (cond ((atom x)
+ nil)
+ ((symbolp (car x))
+ ;; Should be an STV input.
+ (cons `(:nat ,(car x) ,(stv-in->width (car x) stv))
+ (stv-easy-bindings-inside-mix (cdr x) stv)))
+ (t
+ ;; Anything else is illegal inside mix.
+ (raise "Inside a :mix you can only have symbols (the names of stv ~
+ inputs), so ~x0 is illegal." (car x)))))
+
+(define stv-easy-bindings-main ((x "Some arguments to easy-bindings")
+ (stv processed-stv-p))
+ (cond ((atom x)
+ nil)
+ ((symbolp (car x))
+ ;; Should be an STV input.
+ (cons `(:nat ,(car x) ,(stv-in->width (car x) stv))
+ (stv-easy-bindings-main (cdr x) stv)))
+ ((and (consp (car x))
+ (equal (caar x) :mix))
+ (let ((things-to-mix (cdar x)))
+ (if (consp things-to-mix)
+ (cons `(:mix . ,(stv-easy-bindings-inside-mix things-to-mix stv))
+ (stv-easy-bindings-main (cdr x) stv))
+ (raise ":MIX with no arguments? ~x0" (car x)))))
+ (t
+ (raise "Arguments to stv-easy-bindings should be input names or ~
+ (:mix input-name-list), so ~x0 is illegal." (car x)))))
+
+(program)
+
+(define stv-easy-bindings
:parents (symbolic-test-vectors)
:short "Generating G-bindings from an STV in a particular way."
- :long "@(call stv-easy-bindings) returns a list of G-bindings. That is,
-you can write something like:
+ ((stv "The STV you are dealing with."
+ processed-stv-p)
+ (order "The variable order you want to use."))
+
+ :long "@(call stv-easy-bindings) is a macro for proving theorems about
+@(see symbolic-test-vectors) using @(see gl). It returns a list of G-bindings
+for use with @(see def-gl-thm). That is, you can write something like:
@({
(def-gl-thm foo
@@ -756,63 +869,39 @@
(stv-easy-bindings (my-stv) '(opcode size special (:mix a b) c)))
})
-The format of @('x') is simple: you can list out STV inputs and also use
-@('(:mix a b c ...)') where @('a'), @('b'), @('c'), ... are all STV inputs.
+This is probably only useful when:
+
+
+
+You are using GL in BDD mode, not some AIG or SAT based mode.
+
+You are running into performance problems when using the default
+@('-autobinds') from the @(see defstv).
-Bindings will be generated in the order specified, e.g., in the above
-example the @('opcode') will have the smallest indices, then @('size') next,
-etc.
+You want to see if a different variable order performs better.
+
+
-You do not have to mention all of the STV variables. All unmentioned
-variables will be assigned indices after mentioned variables.
+To use @('stv-easy-bindings'), you just list (a subset of) the STV inputs in
+priority order. For instance, in the above example, the @('opcode') will get
+the smallest indices, then @('size') next, etc. You do not have to list
+all of the STV variables. Any unmentioned variables will be assigned indices
+after mentioned variables.
+
+As in @(see gl::auto-bindings), you can also use @('(:mix a b c ...)') to
+interleave the bits of @('a'), @('b'), @('c'), ...; note that for this to work
+these variables must all share the same width. This is generally useful for
+data buses that are going to be combined together.
An especially nice feature of easy-bindings is that they automatically
adjust when inputs to the STV are resized, when new inputs are added, and when
irrelevant inputs are removed.
"
- (defund stv-easy-bindings-inside-mix (x stv)
- (declare (xargs :guard (processed-stv-p stv)))
- (cond ((atom x)
- nil)
- ((symbolp (car x))
- ;; Should be an STV input.
- (cons `(:nat ,(car x) ,(stv-in->width (car x) stv))
- (stv-easy-bindings-inside-mix (cdr x) stv)))
- (t
- ;; Anything else is illegal inside mix.
- (er hard? 'stv-easy-bindings-inside-mix
- "Inside a :mix you can only have symbols (the names of stv
- inputs), ~ so ~x0 is illegal." (car x)))))
-
- (defund stv-easy-bindings-main (x stv)
- (declare (xargs :guard (processed-stv-p stv)))
- (cond ((atom x)
- nil)
- ((symbolp (car x))
- ;; Should be an STV input.
- (cons `(:nat ,(car x) ,(stv-in->width (car x) stv))
- (stv-easy-bindings-main (cdr x) stv)))
- ((and (consp (car x))
- (equal (caar x) :mix))
- (let ((things-to-mix (cdar x)))
- (if (consp things-to-mix)
- (cons `(:mix . ,(stv-easy-bindings-inside-mix things-to-mix stv))
- (stv-easy-bindings-main (cdr x) stv))
- (er hard? 'stv-easy-bindings-main
- ":MIX with no arguments? ~x0" (car x)))))
- (t
- (er hard? 'stv-easy-bindings-main
- "Arguments to stv-easy-bindings should be input names or ~
- (:mix input-name-list), so ~x0 is illegal." (car x)))))
-
- (defun stv-easy-bindings (stv x)
- (declare (xargs :guard (processed-stv-p stv)
- :mode :program))
- (b* ((binds (stv-easy-bindings-main x stv))
- (unbound (set-difference-equal (stv->ins stv)
- (pat-flatten1 binds))))
- (gl::auto-bindings-fn
- (append binds
- ;; bozo ugly, but workable enough...
- (stv-easy-bindings-inside-mix unbound stv))))))
+ (b* ((binds (stv-easy-bindings-main order stv))
+ (unbound (set-difference-equal (stv->ins stv)
+ (pat-flatten1 binds))))
+ (gl::auto-bindings-fn
+ (append binds
+ ;; bozo ugly, but workable enough...
+ (stv-easy-bindings-inside-mix unbound stv)))))
diff -Nru acl2-6.2/books/centaur/esim/stv/stv-util.lisp acl2-6.3/books/centaur/esim/stv/stv-util.lisp
--- acl2-6.2/books/centaur/esim/stv/stv-util.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/stv/stv-util.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -24,75 +24,82 @@
(in-package "ACL2")
(include-book "../esim-sexpr-support")
(include-book "cutil/defaggregate" :dir :system)
+(include-book "cutil/define" :dir :system)
(cutil::defaggregate stvdata
- (initial inputs outputs internals)
- :tag :stvdata
- :require ((true-list-listp-of-stvdata->initial (true-list-listp initial))
- (true-list-listp-of-stvdata->inputs (true-list-listp inputs))
- (true-list-listp-of-stvdata->outputs (true-list-listp outputs))
- (true-list-listp-of-stvdata->internals (true-list-listp internals)))
:parents (symbolic-test-vectors)
- :short "Temporary internal representation of STV lines during compilation.")
+ :short "Temporary internal representation of STV lines during compilation."
+ :tag :stvdata
+ ((inputs true-list-listp)
+ (outputs true-list-listp)
+ (internals true-list-listp)
+ (overrides true-list-listp)))
(cutil::defaggregate compiled-stv
- (nphases ;; number of phases for this simulation
- out-extract-alists ;; what to extract at times 0...{N-1} from outputs
- int-extract-alists ;; what to extract at times 0...{N-1} from internals
- restrict-alist ;; (init-state -> sexpr) + (input-bit@phase -> sexpr) alist
- in-usersyms ;; (simulation var -> bit list) alist for INITIAL+INS
- out-usersyms ;; (simulation var -> bit list) alist for OUTS+INTS
- expanded-ins ;; not useful for much
- expanded-outs ;; not useful for much
- expanded-ints ;; not useful for much
- )
- :tag :compiled-stv
- :require ((posp-of-compiled-stv->nphases
- (posp nphases)
- :rule-classes :type-prescription))
:parents (symbolic-test-vectors)
- :short "Compiled form of @(see symbolic-test-vectors).")
+ :short "Compiled form of @(see symbolic-test-vectors)."
+ :tag :compiled-stv
+ ((nphases posp
+ "number of phases for this simulation"
+ :rule-classes :type-prescription)
+
+ (nst-extract-alists "what to extract at times 0...{N-1} from next-states"
+ true-listp :rule-classes :type-prescription)
+
+ (out-extract-alists "what to extract at times 0...{N-1} from outputs"
+ true-listp :rule-classes :type-prescription)
+
+ (int-extract-alists "what to extract at times 0...{N-1} from internals"
+ true-listp :rule-classes :type-prescription)
+
+ (override-bits "flat list of state bits involved in overrides, i.e.,
+ just the override_value and override_decision vars"
+ symbol-listp)
+
+ (restrict-alist "combined alist binding
+ (input-bit@phase → sexpr) and
+ (override-bit@phase → sexpr)")
+
+ (in-usersyms "(simulation var → bit list) alist for Inputs +
+ Overrides (replacement value insertion)")
+ (out-usersyms "(simulation var → bit list) alist for Outputs +
+ Internals + Overrides (original value extraction)")
+
+ (expanded-ins "Input lines with s-expression values, used only so
+ that we can resolve ~s in stv-doc.")
+
+ (override-paths "Paths being overridden, so we can recreate the cut
+ module as needed."
+ true-listp)
+
+ ))
(cutil::defaggregate processed-stv
- (mod ;; module
- user-stv ;; pre-compilation stv
- compiled-stv ;; post-compilation stv
- relevant-signals ;; (out/int sim var bit -> sexpr) alist
- )
- :tag :processed-stv
:parents (stv-process)
:short "Representation of a processed STV."
+ :tag :processed-stv
+ ((name "A name for this STV."
+ symbolp)
+ (user-stv "The user-level, pre-compiled STV. This may be useful when
+ generating documentation for STVs.")
+ (compiled-stv compiled-stv-p
+ "A @(see compiled-stv-p), should be the compiled version
+ of the user's STV; see @(see stv-compile).")
+ (relevant-signals "(out/int sim var bit → sexpr) alist"))
:long "You should probably read @(see stv-implementation-details) to
understand these fields.
-
-
-The @('mod') is the @(see esim) module for this STV. We save this in the
-processed STV so that we re-simulate it later, if necessary, for @(see
-stv-debug).
-
-The @('user-stv') is the user-level, pre-compiled STV. This may be useful
-when generating documentation for STVs.
-
-The @('compiled-stv') is a @(see compiled-stv-p) and should be the compiled
-version of the user's STV; see @(see stv-compile).
-
-The @('relevant-signals') is an alist computed by @(see stv-process) that
+The @('relevant-signals') is an alist computed by @(see stv-process) that
maps each the bits for each internal/output simulation variable to
already-restricted @(see 4v-sexprs). That is, these s-expressions are
generally in terms of the input simulation variable bits, and ready to be
-evaluated by @(see stv-run).
-
-
+evaluated by @(see stv-run).
Historically we had another field that could also optionally store
pre-computed snapshots for debugging. We took this out because it could make
@(see stv-run) a lot slower during GL proofs. The snapshots were huge, and
-this really slowed down GL's gl-concrete-lite check.
"
-
- :require ((compiled-stv-p-of-processed-stv->compiled-stv
- (compiled-stv-p compiled-stv))))
+this really slowed down GL's gl-concrete-lite check.")
(defund ordered-subsetp (x y)
@@ -105,90 +112,69 @@
(ordered-subsetp x (cdr y))))
t))
-(defund intern-list-in-package-of-symbol (x y)
- ;; BOZO find me a home
- (declare (xargs :guard (and (string-listp x)
- (symbolp y))))
- (if (atom x)
- nil
- (cons (intern-in-package-of-symbol (car x) y)
- (intern-list-in-package-of-symbol (cdr x) y))))
-
-
-
-(defsection stv-number-of-phases
- :parents (symbolic-test-vectors)
- :short "@(call stv-number-of-phases) determines the maximum number of phases
-that are used in any line of a symbolic test vector."
-
- (defund stv-max-phases-in-lines (lines)
- (declare (xargs :guard (true-list-listp lines)))
- (if (atom lines)
- 0
- (max (length (cdr (car lines)))
- (stv-max-phases-in-lines (cdr lines)))))
-
- (defund stv-number-of-phases (stv)
- (declare (xargs :guard (stvdata-p stv)))
- (b* (((stvdata stv) stv))
- (max (stv-max-phases-in-lines stv.inputs)
- (max (stv-max-phases-in-lines stv.outputs)
- (stv-max-phases-in-lines stv.internals))))))
-
-(defsection stv-suffix-signals
+(define stv-max-phases-in-lines ((lines true-list-listp))
+ :returns (max-phases natp :rule-classes :type-prescription)
+ :parents (stv-number-of-phases)
+ (if (atom lines)
+ 0
+ (max (length (cdr (car lines)))
+ (stv-max-phases-in-lines (cdr lines)))))
+
+(define stv-number-of-phases ((stv stvdata-p))
+ :returns (num-phases natp :rule-classes :type-prescription)
+ :parents (symbolic-test-vectors)
+ :short "Maximum length of any line of an STV (i.e., how many phases we are
+going to simulate."
+
+ (b* (((stvdata stv) stv))
+ (max (stv-max-phases-in-lines stv.inputs)
+ (max (stv-max-phases-in-lines stv.outputs)
+ (max (stv-max-phases-in-lines stv.internals)
+ (stv-max-phases-in-lines stv.overrides))))))
+
+
+(define stv-suffix-signals ((x atom-listp)
+ (suffix stringp))
+ :returns (symbols symbol-listp)
:parents (symbolic-test-vectors)
- :short "@(call stv-suffix-signals) converts @('x'), a list of atoms, into a
-list of symbols with the given @('suffix')."
-
- (defund stv-suffix-signals (x suffix)
- (declare (xargs :guard (and (atom-listp x)
- (stringp suffix))))
- (if (atom x)
- nil
- (cons (intern$ (str::cat (stringify (car x)) suffix) "ACL2")
- (stv-suffix-signals (cdr x) suffix))))
-
- (local (in-theory (enable stv-suffix-signals)))
-
- (defthm symbol-listp-of-stv-suffix-signals
- (symbol-listp (stv-suffix-signals x suffix))))
-
+ :short "Convert a list of atoms into a list of symbols with some suffix."
+ ;; BOZO do we really need to support atom-listps?
+ (if (atom x)
+ nil
+ (cons (intern$ (str::cat (stringify (car x)) suffix) "ACL2")
+ (stv-suffix-signals (cdr x) suffix))))
-(defsection safe-pairlis-onto-acc
+(define safe-pairlis-onto-acc (x y acc)
:parents (stv-compile)
- :short "@(call safe-pairlis-onto-acc) pairs up @('x') and @('y'), and
-accumulates them onto @('acc'). It is \"safe\" in that it causes an error if
-@('x') and @('y') aren't the same length."
-
- (defun safe-pairlis-onto-acc (x y acc)
- (declare (xargs :guard t))
- (mbe :logic
- (revappend (pairlis$ x y) acc)
- :exec
- (b* (((when (and (atom x)
- (atom y)))
- acc)
- ((when (atom x))
- (er hard? 'safe-pairlis-onto-acc "Too many values!")
- acc)
- ((when (atom y))
- (er hard? 'safe-pairlis-onto-acc "Not enough values!")
- (safe-pairlis-onto-acc (cdr x) nil
- (cons (cons (car x) nil) acc))))
- (safe-pairlis-onto-acc (cdr x) (cdr y)
- (cons (cons (car x) (car y)) acc))))))
-
+ :short "Just @(see pairlis$) onto an accumulator, but for safety cause an
+error if the lists to pair up aren't the same length."
+ :enabled t
+ (mbe :logic
+ (revappend (pairlis$ x y) acc)
+ :exec
+ (b* (((when (and (atom x)
+ (atom y)))
+ acc)
+ ((when (atom x))
+ (raise "Too many values!")
+ acc)
+ ((when (atom y))
+ (raise "Not enough values!")
+ (safe-pairlis-onto-acc (cdr x) nil
+ (cons (cons (car x) nil) acc))))
+ (safe-pairlis-onto-acc (cdr x) (cdr y)
+ (cons (cons (car x) (car y)) acc)))))
-(defsection stv->ins
+(define stv->ins ((x processed-stv-p))
+ :returns (inputs "Should be a symbol-listp in practice.") ;; BOZO strengthen
:parents (symbolic-test-vectors)
:short "Get a list of an STV's input simulation variables."
- :long "@(call stv->ins) returns the user-level symbolic variables from the
-input and initial lines of a symbolic test vector. For instance, if you have
-an input line like:
+ :long "We collect simulation variables from all input and initial lines.
+For instance, if you have an input line like:
@({
(\"a_bus\" _ _ _ a1 _ a2 _ _)
@@ -196,20 +182,18 @@
Then the returned list will include @('a1') and @('a2').
"
- (defund stv->ins (x)
- (declare (xargs :guard (processed-stv-p x)))
- (b* (((processed-stv x) x)
- ((compiled-stv cstv) x.compiled-stv))
- (alist-keys cstv.in-usersyms))))
+ (b* (((processed-stv x) x)
+ ((compiled-stv cstv) x.compiled-stv))
+ (alist-keys cstv.in-usersyms)))
-(defsection stv->outs
+(define stv->outs ((x processed-stv-p))
+ :returns (outputs "Should be a symbol-listp in practice.") ;; BOZO strengthen
:parents (symbolic-test-vectors)
:short "Get a list of an STV's output simulation variables."
- :long "@(call stv->outs) returns the user-level symbolic variables from
-the output and internals lines of a symbolic test vector. For instance, if you
-have an output line like:
+ :long "We collect simulation variables from all output and internals
+lines. For instance, if you have an output line like:
@({
(\"main_result\" _ _ _ res1 _ res2 _ _)
@@ -217,77 +201,75 @@
Then the returned list will include @('res1') and @('res2').
"
- (defund stv->outs (x)
- (declare (xargs :guard (processed-stv-p x)))
- (b* (((processed-stv x) x)
- ((compiled-stv cstv) x.compiled-stv))
- (alist-keys cstv.out-usersyms))))
+ (b* (((processed-stv x) x)
+ ((compiled-stv cstv) x.compiled-stv))
+ (alist-keys cstv.out-usersyms)))
-(defsection stv->vars
+(define stv->vars ((x processed-stv-p))
+ :returns (vars "Should be a symbol-listp in practice.") ;; BOZO strengthen
:parents (symbolic-test-vectors)
:short "Get a list of an STV's simulation variables (both inputs and
outputs)."
- :long "See @(see stv->ins) and @(see stv->outs).
"
- (defund stv->vars (x)
- (declare (xargs :guard (processed-stv-p x)))
- (append (stv->ins x)
- (stv->outs x))))
+ (append (stv->ins x)
+ (stv->outs x)))
-(defsection stv-out->width
+(define stv-out->width ((x symbolp)
+ (stv processed-stv-p))
+ ;; BOZO fix this up to guarantee posp?
+ :returns (width natp :rule-classes :type-prescription)
:parents (symbolic-test-vectors)
:short "Get the bit-length for a particular output simulation variable."
- :long "@(call stv-out->width) returns the bit-length of an output
-simulation variable. For instance, if you have an STV output line like:
+ :long "For instance, if you have an STV output line like:
@({
(\"main_result\" _ _ _ res1 _ res2 _ _)
})
Then @('(stv-out->width 'res1 stv)') will return the width of
-@('main_result'), say 64. If @('x') isn't one of the STV's outputs, we cause a
-runtime error and logically return 0.
"
+@('main_result'), say 64.
- (defun stv-out->width (x stv)
- (declare (xargs :guard (and (symbolp x)
- (processed-stv-p stv))))
- (b* (((processed-stv stv) stv)
- ((compiled-stv cstv) stv.compiled-stv)
- (look (hons-assoc-equal x cstv.out-usersyms))
- ((unless look)
- (er hard? 'stv-out->width "Unknown output: ~x0~%" x)
- ;; returning 0 gets us at least a natp type prescription
- 0))
- (len (cdr look)))))
+If @('x') isn't one of the STV's outputs, we cause a runtime error and
+logically return 0.
"
+ (b* (((processed-stv stv) stv)
+ ((compiled-stv cstv) stv.compiled-stv)
+ (look (hons-assoc-equal x cstv.out-usersyms))
+ ((unless look)
+ (raise "Unknown output: ~x0~%" x)
+ ;; returning 0 gets us at least a natp type prescription
+ 0))
+ (len (cdr look))))
-(defsection stv-in->width
+
+(define stv-in->width ((x symbolp)
+ (stv processed-stv-p))
+ ;; BOZO fix this up to guarantee posp?
+ :returns (width natp :rule-classes :type-prescription)
:parents (symbolic-test-vectors)
:short "Get the bit-length for a particular input simulation variable."
- :long "@(call stv-in->width) returns the bit-length of an input simulation
-variable. For instance, if you have an STV input line like:
+ :long "For instance, if you have an STV input line like:
@({
(\"a_bus\" _ _ _ a1 _ a2 _ _)
})
Then @('(stv-in->width 'a1 stv)') will return the width of @('a_bus'), say
-128. If @('x') isn't one of the STV's inputs, we cause a runtime error and
+128.
+
+If @('x') isn't one of the STV's inputs, we cause a runtime error and
logically return 0.
"
- (defun stv-in->width (x stv)
- (declare (xargs :guard (and (symbolp x)
- (processed-stv-p stv))))
- (b* (((processed-stv stv) stv)
- ((compiled-stv cstv) stv.compiled-stv)
- (look (hons-assoc-equal x cstv.in-usersyms))
- ((unless look)
- (er hard? 'stv-in->width "Unknown input: ~x0~%" x)
- ;; returning 0 gets us at least a natp type prescription
- 0))
- (len (cdr look)))))
+ (b* (((processed-stv stv) stv)
+ ((compiled-stv cstv) stv.compiled-stv)
+ (look (hons-assoc-equal x cstv.in-usersyms))
+ ((unless look)
+ (raise "Unknown input: ~x0~%" x)
+ ;; returning 0 gets us at least a natp type prescription
+ 0))
+ (len (cdr look))))
diff -Nru acl2-6.2/books/centaur/esim/stv/stv-widen.lisp acl2-6.3/books/centaur/esim/stv/stv-widen.lisp
--- acl2-6.2/books/centaur/esim/stv/stv-widen.lisp 2013-06-06 17:11:46.000000000 +0000
+++ acl2-6.3/books/centaur/esim/stv/stv-widen.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -26,82 +26,68 @@
(include-book "std/lists/repeat" :dir :system)
(local (include-book "std/lists/take" :dir :system))
-(defsection stv-widen-lines
+(define stv-widen-lines ((lines true-list-listp)
+ (number-of-phases natp)
+ (warn-non-blank booleanp))
+ :returns (widened-lines true-list-listp :hyp :guard)
:parents (stv-widen)
- :short "@(call stv-widen-lines) rewrites lines of an STV, repeating the last
-entry in each line until the desired number of phases is reached."
+ :short "Rewrite lines of an STV, repeating the last entry in each line to
+extend it to the desired number of phases."
:long "The @('warn-non-blank') is intended to be set for :output lines
and :internals lines. When it is set, we cause an error if an attempt is made
to replicate any element other than @('_'), since it doesn't make sense to
replicate simulation variables.
"
- (defund stv-widen-lines (lines number-of-phases warn-non-blank)
- (declare (xargs :guard (and (true-list-listp lines)
- (natp number-of-phases))))
- (b* (((when (atom lines))
- nil)
- (line1 (car lines))
- (line1-name (car line1))
- (line1-phases (cdr line1))
- (- (or (consp line1-phases)
- (er hard? 'stv-widen-lines
- "No phases were provided for ~x0.~%" line1-name)))
- (line1-nphases (len line1-phases))
- (line1-widened-phases
- (cond ((= line1-nphases number-of-phases)
- line1-phases)
- ((< line1-nphases number-of-phases)
- (b* ((repeat-me (car (last line1-phases))))
- (or (not warn-non-blank)
- (eq repeat-me '_)
- (er hard? 'stv-widen-lines
- "The line for ~x0 needs to be extended, but it ends ~
+ (b* (((when (atom lines))
+ nil)
+ (line1 (car lines))
+ (line1-name (car line1))
+ (line1-phases (cdr line1))
+ (- (or (consp line1-phases)
+ (er hard? 'stv-widen-lines
+ "No phases were provided for ~x0.~%" line1-name)))
+ (line1-nphases (len line1-phases))
+ (line1-widened-phases
+ (cond ((= line1-nphases number-of-phases)
+ line1-phases)
+ ((< line1-nphases number-of-phases)
+ (b* ((repeat-me (car (last line1-phases))))
+ (or (not warn-non-blank)
+ (eq repeat-me '_)
+ (er hard? 'stv-widen-lines
+ "The line for ~x0 needs to be extended, but it ends ~
with ~x1. We only allow output and internal lines ~
to be extended when they end with an underscore."
- line1-name repeat-me))
- (append line1-phases
- (repeat repeat-me (- number-of-phases line1-nphases)))))
- (t
- (prog2$
- (er hard? 'stv-widen-lines
- "Entry for ~x0 is longer than the max number of phases?" line1-name)
- (take number-of-phases line1-phases))))))
- (cons (cons line1-name line1-widened-phases)
- (stv-widen-lines (cdr lines) number-of-phases warn-non-blank))))
-
- (local (in-theory (enable stv-widen-lines)))
-
- (defthm true-list-listp-of-stv-widen-lines
- (implies (true-list-listp lines)
- (true-list-listp (stv-widen-lines lines number-of-phases warn-non-blank)))))
-
+ line1-name repeat-me))
+ (append line1-phases
+ (repeat repeat-me (- number-of-phases line1-nphases)))))
+ (t
+ (prog2$
+ (er hard? 'stv-widen-lines
+ "Entry for ~x0 is longer than the max number of phases?" line1-name)
+ (take number-of-phases line1-phases))))))
+ (cons (cons line1-name line1-widened-phases)
+ (stv-widen-lines (cdr lines) number-of-phases warn-non-blank))))
-(defsection stv-widen
+(define stv-widen ((stv stvdata-p))
+ :returns (widened-stv stvdata-p :hyp :guard)
:parents (symbolic-test-vectors)
:short "Widen the input/output/internals lines so that they all agree on how
many phases there are."
- :long "Signature: @(call stv-widen) returns a new @(see stvdata-p).
-
-This is an STV preprocessing step which can be run before or after @(see
-stv-expand). We generally expect that all the lines have been widened before
-any compilation is performed.
-
-Note that we don't widen @(':initial') lines; they have only one value, not
-a series of values over time.
"
-
- (defund stv-widen (stv)
- (declare (xargs :guard (stvdata-p stv)))
- (b* (((stvdata stv) stv)
- (number-of-phases (stv-number-of-phases stv)))
- (change-stvdata stv
- :inputs (stv-widen-lines stv.inputs number-of-phases nil)
- :outputs (stv-widen-lines stv.outputs number-of-phases t)
- :internals (stv-widen-lines stv.internals number-of-phases t))))
-
- (local (in-theory (enable stv-widen)))
-
- (defthm stvdata-p-of-stv-widen
- (implies (stvdata-p stv)
- (stvdata-p (stv-widen stv)))))
+ :long "This is an STV preprocessing step which can be run before or after
+@(see stv-expand). We generally expect that all the lines have been widened
+before any compilation is performed.
"
+
+ (b* (((stvdata stv) stv)
+ (number-of-phases (stv-number-of-phases stv))
+ (new-inputs (stv-widen-lines stv.inputs number-of-phases nil))
+ (new-outputs (stv-widen-lines stv.outputs number-of-phases t))
+ (new-internals (stv-widen-lines stv.internals number-of-phases t))
+ (new-overrides (stv-widen-lines stv.overrides number-of-phases t)))
+ (change-stvdata stv
+ :inputs new-inputs
+ :outputs new-outputs
+ :internals new-internals
+ :overrides new-overrides)))
diff -Nru acl2-6.2/books/centaur/getopt/acl2-customization.lsp acl2-6.3/books/centaur/getopt/acl2-customization.lsp
--- acl2-6.2/books/centaur/getopt/acl2-customization.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/getopt/acl2-customization.lsp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,27 @@
+; ACL2 Getopt Library
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+#!ACL2
+(in-package "ACL2")
+
+(ld "~/acl2-customization.lsp" :ld-missing-input-ok t)
+(include-book "portcullis")
+(in-package "GETOPT")
+
diff -Nru acl2-6.2/books/centaur/getopt/cert.acl2 acl2-6.3/books/centaur/getopt/cert.acl2
--- acl2-6.2/books/centaur/getopt/cert.acl2 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/getopt/cert.acl2 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,22 @@
+; ACL2 Getopt Library
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(include-book "portcullis")
+; cert-flags: ? t :ttags :all
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/getopt/demo.lisp acl2-6.3/books/centaur/getopt/demo.lisp
--- acl2-6.2/books/centaur/getopt/demo.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/getopt/demo.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,318 @@
+; ACL2 Getopt Library
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "GETOPT-DEMO")
+(include-book "top")
+(include-book "str/top" :dir :system)
+(local (include-book "std/typed-lists/string-listp" :dir :system))
+
+(defoptions demo
+ :parents (getopt)
+ :short "A basic demo of using @(see getopt) to parse command-line options."
+
+ :long "This is a basic demo of how to use getopt, and a collection of unit
+tests to make sure getopt is working correctly.
+
+Note: our focus in this demo is just on the command-line parsing piece. We
+illustrate illustrates a lot of the things you can do with getopt, e.g., short
+aliases, long names, default values, validating inputs, and accumulating
+arguments. But we don't turn it into a working program. If you want to
+understand how @(see getopt) and @(see argv) and @(see save-exec) fit together,
+see @(see demo2).
+
+This @('defoptions') call does two things:
+
+
+
+It introduces @('demo-p'), an ordinary @(see cutil::defaggregate) with
+various fields and well-formedness conditions. These @('demo-p') structures
+can be passed around throughout your program just like any ordinary ACL2
+object.
+
+It introduces @(see parse-demo), a function that can parse a command-line
+into a @('demo-p'). The command-line is represented as a list of strings; see
+for instance @(see oslib::argv) to understand how to get the command-line
+arguments given to ACL2.
+
+ "
+
+ ;; GETOPT::DEFOPTIONS is a strict superset of defaggregate. So, everything
+ ;; here should look very familiar if you have created aggregates:
+
+ :tag :demo
+
+ ((help "Print a help message and exit with status 0."
+ booleanp
+ :rule-classes :type-prescription
+
+ ;; Because this field is a Boolean, defoptions automatically
+ ;; "knows" to treat it as a plain option, i.e., it knows that
+ ;; --help takes no extra argument.
+
+ ;; You don't have to tell it to use --help, either, because it
+ ;; just figures that out from the field name.
+
+ ;; However, if we want to also support -h, we need to tell it
+ ;; to treat the letter #\h as an alias for help:
+ :alias #\h)
+
+ (verbose "Turn on excessive debugging information."
+ booleanp
+ :rule-classes :type-prescription
+
+ ;; As with --help, there's little "extra" work to do here. We
+ ;; won't create an alias, because we'll use -v for --version.
+ )
+
+ (version "Print version information and exit with status 0."
+ booleanp
+ :rule-classes :type-prescription
+ :alias #\v)
+
+ (username "Change the username to something else."
+ stringp
+ :rule-classes :type-prescription
+ :default ""
+ :alias #\u
+ :argname "NAME"
+ ;; This option is more interesting. By default, a stringp option
+ ;; takes an argument. The ARGNAME affects how its printed in the
+ ;; usage message.
+ )
+
+ (port "Port to connect to."
+ natp
+ :rule-classes :type-prescription
+ :default 55432
+ :alias #\p
+ :argname "PORT"
+ ;; Support for numeric arguments is built into defoptions, so it
+ ;; can automatically parse the option into a number for you. We
+ ;; don't need to put in a :parser option here because parse-nat is
+ ;; the default for natp fields, but just to make this demo more
+ ;; complete I include it.
+ :parser getopt::parse-nat)
+
+ (dirs "Directory list"
+ string-listp
+
+ ;; This option is more interesting in several ways. The idea here
+ ;; is that the user can say, e.g.,
+ ;;
+ ;; --dir /usr --dir /home --dir /bin
+ ;;
+ ;; And these options should all get bundled up together into a
+ ;; single list.
+
+ ;; Well, internally in our program, we want to think of this as a
+ ;; list of dirs. So, we want to call the field "dirs". But the
+ ;; user enters one dir at a time, so we want the user-visible
+ ;; option name to be different. We can do that by overriding the
+ ;; longname that defoptions generates by default:
+ :longname "dir"
+
+ ;; Now, defoptions has no default way to parse in a string-listp.
+ ;; But it does have a built-in string parser, which we can reuse.
+ ;; So, first, tell it to use the string parser:
+ :parser getopt::parse-string
+
+ ;; But that wouldn't be enough on its own, because if we just set
+ ;; it to use parse-string, then that produces a stringp instead of
+ ;; a string-listp, and our proofs would fail. Instead, we need to
+ ;; tell defoptions how to merge the results of the parser with the
+ ;; previous value. Using CONS would actually reverse the order of
+ ;; the dirs, because the options are processed in order. So we
+ ;; avoid that by using rcons, to push the strings on the end.
+ :merge rcons)
+
+ (extra-stuff "Hidden option that the user never sees, but that is part of
+ our aggregate."
+ :hide t)
+
+ (extra-stuff2 stringp
+ "Hidden option that the user never sees, but that is part of
+ our aggregate."
+ :hide t
+ :default "")))
+
+
+#||
+
+;; Some good things to try:
+
+(xdoc::xdoc 'parse-demo)
+
+(princ$ *demo-usage* *standard-co* state)
+
+||#
+
+
+;; Here are some basic tests to make sure it's working.
+
+(defun run-parse-demo (input)
+ (let ((tokens (str::strtok input '(#\Space))))
+ (mv-let (err result extra)
+ (parse-demo tokens)
+ (if err
+ (prog2$ (cw "~@0~%" err)
+ (list :err err))
+ (let ((res (list :result result
+ :extra extra)))
+ (prog2$ (cw "Success: ~x0~%" res)
+ res))))))
+
+(defmacro check (input result extra)
+ `(acl2::assert! (equal (run-parse-demo ,input)
+ (list :result ,result :extra ,extra))))
+
+(defmacro fail (input)
+ `(acl2::assert! (equal (car (run-parse-demo ,input))
+ :err)))
+
+(check "" (make-demo) nil)
+
+(check "--help --version"
+ (make-demo :help t :version t)
+ nil)
+
+(check "--version --help"
+ (make-demo :help t :version t)
+ nil)
+
+(fail "--help=123")
+(fail "--help --help")
+(fail "--hlep")
+
+
+(fail "--port")
+(fail "--port abc")
+
+(check "--port 123"
+ (make-demo :port 123)
+ nil)
+
+(check "--port=123"
+ (make-demo :port 123)
+ nil)
+
+(check "--dir= --dir=abc --dir= --dir=xyz"
+ (make-demo :dirs '("" "abc" "" "xyz"))
+ nil)
+
+(check "-h -v"
+ (make-demo :help t :version t)
+ nil)
+
+(check "-h --version"
+ (make-demo :help t :version t)
+ nil)
+
+(check "-hv"
+ (make-demo :help t :version t)
+ nil)
+
+(fail "-huv")
+(fail "-hxv")
+(fail "-u")
+
+(check "-hv"
+ (make-demo :help t :version t)
+ nil)
+
+(fail "-p")
+(fail "-p abc")
+
+(check "-p 123"
+ (make-demo :port 123)
+ nil)
+
+(check "-p=123"
+ (make-demo :port 123)
+ nil)
+
+(check "a b c d"
+ (make-demo)
+ '("a" "b" "c" "d"))
+
+(check "a -u b c d"
+ (make-demo :username "b")
+ '("a" "c" "d"))
+
+(check "a -u=b c d"
+ (make-demo :username "b")
+ '("a" "c" "d"))
+
+(check "a -u b c -p=12 d"
+ (make-demo :username "b"
+ :port 12)
+ '("a" "c" "d"))
+
+(check "a b c --dir dir1 d e f"
+ (make-demo :dirs '("dir1"))
+ '("a" "b" "c" "d" "e" "f"))
+
+(check "a b c --dir dir1 --dir dir2 d e f"
+ (make-demo :dirs '("dir1" "dir2"))
+ '("a" "b" "c" "d" "e" "f"))
+
+(check "a b c --dir=dir1 --dir dir2 d e f"
+ (make-demo :dirs '("dir1" "dir2"))
+ '("a" "b" "c" "d" "e" "f"))
+
+(check "a b c --dir=dir1 --dir=dir2 d e f"
+ (make-demo :dirs '("dir1" "dir2"))
+ '("a" "b" "c" "d" "e" "f"))
+
+(check "a b c --dir dir1 --help --dir dir2 d e f"
+ (make-demo :help t
+ :dirs '("dir1" "dir2"))
+ '("a" "b" "c" "d" "e" "f"))
+
+(check "a b c --dir dir1 --help x y z --dir dir2 d e f"
+ (make-demo :help t
+ :dirs '("dir1" "dir2"))
+ '("a" "b" "c" "x" "y" "z" "d" "e" "f"))
+
+(check "a b c --dir dir1 --help x y z --dir=dir2 d e f --dir dir3"
+ (make-demo :help t
+ :dirs '("dir1" "dir2" "dir3"))
+ '("a" "b" "c" "x" "y" "z" "d" "e" "f"))
+
+(fail "a b c --dir")
+
+(fail "a b c --dir dir1 --dir")
+
+
+(check "--"
+ (make-demo)
+ '("--"))
+
+
+(check "-- --help"
+ (make-demo)
+ '("--" "--help"))
+
+(check "-- -x -y -z"
+ (make-demo)
+ '("--" "-x" "-y" "-z"))
+
+(check "--verbose -- --help"
+ (make-demo :verbose t)
+ '("--" "--help"))
diff -Nru acl2-6.2/books/centaur/getopt/demo2-save.lsp acl2-6.3/books/centaur/getopt/demo2-save.lsp
--- acl2-6.2/books/centaur/getopt/demo2-save.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/getopt/demo2-save.lsp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,81 @@
+; ACL2 Getopt Library
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+
+; You can give this script to ACL2 using something like:
+;
+; ACL2_CUSTOMIZATION=NONE acl2 < demo2-save.lsp
+;
+; This should create a demo2 script and Lisp image that:
+;
+; - Doesn't print any startup stuff
+; - Doesn't read any customization files
+; - Reads and processes the command-line arguments
+;
+; E.g.,
+;
+; $ ./demo2
+; colorless green ideas sleep furiously
+; $ echo $?
+; 0
+;
+; $ ./demo2 --help
+; demo2: how to write a command line program in ACL2
+; -h,--help Print a help message and exit with status 0.
+; -v,--version Print out a version message and exit with
+; status 0.
+; $ echo $?
+; 0
+;
+; $ ./demo2 --version
+; demo2: version 1.234
+; $ echo $?
+; 0
+;
+; $ ./demo2 --foo
+; Unrecognized option --foo
+; $ echo $?
+; 1
+;
+; $ ./demo2 --help=17
+; Option --help can't take an argument
+; $ echo $?
+; 1
+
+(include-book "demo2")
+
+:q
+
+;; Set up our program to not print a bunch of ACL2 banners.
+(setq *print-startup-banner* nil)
+
+;; Set up our program NOT try to read the any customization files.
+(defun initial-customization-filename () :none)
+
+(save-exec "demo2" "getopt demo 2 program"
+
+ ;; Inert-args MUST be given, or ACL2 won't put the "--" into the
+ ;; startup script, and ARGV won't know which arguments belong to the
+ ;; Lisp, and which belong to our program.
+ :inert-args ""
+ :return-from-lp '(getopt-demo::demo2-main acl2::state))
+
+
+
diff -Nru acl2-6.2/books/centaur/getopt/demo2.lisp acl2-6.3/books/centaur/getopt/demo2.lisp
--- acl2-6.2/books/centaur/getopt/demo2.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/getopt/demo2.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,102 @@
+; ACL2 Getopt Library
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "GETOPT-DEMO")
+(include-book "top")
+(include-book "oslib/argv" :dir :system)
+(set-state-ok t)
+
+(defsection demo2
+ :parents (getopt)
+ :short "Demonstration of how to use @(see getopt) and @(see argv) to create a
+working command-line program from ACL2."
+
+ :long "This is an example of how to write an extremely basic command-line
+program in ACL2 that parses some options from the command-line.
+
+Note: our focus in this demo is to show how @(see getopt) and @(see argv)
+and @(see save-exec) work together. Our program takes just a few basic
+options. If you want to see a demo of how to parse fancier command-line
+options, see @(see demo) instead.
+
+Depending on its input, our program will print out:
+
+
+A help message (--help or -h)
+A version message (--version or -v)
+The nonsense sentence @('colorless green ideas sleep furiously').
+
+
+Our top-level program is @(see demo2-main).
+
+
+ It uses @(see argv) to get the command-line options.
+ It uses @(see getopt) to parse them into a @(see demo2-opts-p) structure.
+ It then prints a message, as described above.
+
+
+To see how to turn @('demo2-main') into an executable, see the file
+@('centaur/getopt/demo2-save.lsp').
")
+
+(defoptions demo2-opts
+ :parents (demo2)
+ :tag :demo2
+
+ ((help "Print a help message and exit with status 0."
+ booleanp
+ :rule-classes :type-prescription
+ :alias #\h)
+
+ (version "Print out a version message and exit with status 0."
+ booleanp
+ :rule-classes :type-prescription
+ :alias #\v)))
+
+(defsection demo2-main
+ :parents (demo2)
+ :short "Run the demo2 program."
+
+ (defund demo2-main (state)
+ (b* (((mv argv state) (oslib::argv))
+ ((mv errmsg opts ?extra-args) (parse-demo2-opts argv))
+
+ ((when errmsg)
+ (cw "~@0~%" errmsg)
+ (exit 1)
+ state)
+
+ ((demo2-opts opts) opts)
+
+ ((when opts.help)
+ (b* ((- (cw "demo2: how to write a command line program in ACL2~%"))
+ (state (princ$ *demo2-opts-usage* *standard-co* state))
+ (- (cw "~%")))
+ (exit 0)
+ state))
+
+ ((when opts.version)
+ (cw "demo2: version 1.234~%")
+ (exit 0)
+ state))
+
+ (cw "colorless green ideas sleep furiously~%")
+ (exit 0)
+ state)))
+
diff -Nru acl2-6.2/books/centaur/getopt/package.lsp acl2-6.3/books/centaur/getopt/package.lsp
--- acl2-6.2/books/centaur/getopt/package.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/getopt/package.lsp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,89 @@
+; ACL2 Getopt Library
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "ACL2")
+
+(include-book "cutil/portcullis" :dir :system)
+(include-book "oslib/portcullis" :dir :system)
+
+(defpkg "GETOPT"
+ (union-eq (set-difference-eq
+ (union-eq *acl2-exports*
+ *common-lisp-symbols-from-main-lisp-package*)
+ '(union delete))
+ sets::*sets-exports*
+ cutil::*cutil-exports*
+ '(;; Things we want to "export", for nicer use from other
+ ;; packages.
+ getopt
+ defoptions
+ ;; Things we want to "import"
+ quit
+ exit
+ b*
+ getopt
+ assert!
+ list-fix
+ rcons
+ prefixp
+ lnfix
+ lifix
+ lbfix
+ xdoc
+ defxdoc
+ defsection
+ definline
+ definlined
+ unsigned-byte-p
+ signed-byte-p
+ str::explode
+ str::implode
+ str::cat
+ str::natstr
+ str::join
+ uniquep
+ duplicated-members
+ msg
+ value
+ def-ruleset
+ enable*
+ disable*
+ e/d*
+ cutil::formal
+ cutil::formal-p
+ cutil::formal->opts
+ cutil::formal->name
+ cutil::formallist-p
+ cutil::formallist->names
+ cutil::look-up-formals
+ cutil::look-up-return-vals
+ cutil::tuplep)))
+
+#!GETOPT
+(defconst *getopt-exports*
+ '(getopt defoptions))
+
+(defpkg "GETOPT-DEMO"
+ (union-eq *acl2-exports*
+ *common-lisp-symbols-from-main-lisp-package*
+ getopt::*getopt-exports*
+ '(acl2::rcons xdoc::defsection xdoc::defxdoc
+ b* oslib::argv)))
+
diff -Nru acl2-6.2/books/centaur/getopt/parsers.lisp acl2-6.3/books/centaur/getopt/parsers.lisp
--- acl2-6.2/books/centaur/getopt/parsers.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/getopt/parsers.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,315 @@
+; ACL2 Getopt Library
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "GETOPT")
+(include-book "cutil/top" :dir :system)
+(include-book "str/strval" :dir :system)
+
+
+(defsection parsers
+ :parents (getopt)
+ :short "Parsers for various kinds of command-line options."
+
+ :long "Different programs will need to take all sorts of different kinds
+of options. For instance:
+
+
+ssh takes a port number between 0 and 65535,
+svn takes a revision number that can be a natural or a
+ special word like HEAD, BASE, or PREV,
+wget takes a URL,
+mail takes an email address, and so on.
+
+
+There's no way for @(see getopt) to anticipate and support everything that
+every program might want, so instead we use a table-driven approach that you
+can extend with custom parsers for your types.
+
+Now, out of the box we do at least provide parsers for basic options like
+@('--verbose'), @('--username jared'), @('--level=100000'), and so forth.
+
+But when these aren't good enough, e.g., because you want to have stronger
+type requirements on your arguments structure, you can add your own @(see
+custom-parser) functions and plug them in.
")
+
+
+(defsection custom-parser
+ :parents (parsers)
+ :short "How to write custom argument-parsing functions."
+
+ :long "You can extend getopt with new functions for parsing the arguments
+you care about.
+
+Note that once you have introduced such a new parsing function, you
+can (optionally) register it as the default parser for a predicate using @(see
+set-default-parser).
+
+Every argument-parsing function must have the following form:
+
+
+ (parse-foo name explicit-value args)
+ →
+ (mv errmsg? value rest-args)
+
+
+Inputs:
+
+
+
+@('name') is a string that is the name of the option the user typed in,
+e.g., it might be @('--verbose'). This is included so that the parser can
+provide a nice error message.
+
+@('explicit-value') is NIL unless the use types something like
+@('--foo=bar'), in which case it is the value being assigned, e.g.,
+@('\"bar\").
+
+@('args') is a @(see string-listp) with the full command line arguments
+that the user typed in after the @('name') and, if applicable, the
+@('explicit-value'). It may be the empty list if @('name') was the last
+argument to the program.
+
+
+
+Outputs
+
+
+
+@('errmsg?') should be @('nil') if everything is okay, or an error message
+produced by @(see msg). Typically it might be something like:
+
+@({
+ (msg \"Option ~s0 needs a valid port number, but got ~x1\"
+ name (car args))
+})
+
+@('value') is irrelevant if there was an error, but otherwise must be a
+valid @('foop'), for whatever kind of data this parser is supposed to
+generate.
+
+@('rest-args') should be the remainder of @('args') after the arguments to
+@('name') have been removed. For termination, its length must be no greater
+than the length of @('args').
+
+
+
+All of the built-in parsers fit into the above scheme, so you can see
+several examples of argument-parsing functions by just looking at the built-in
+@(see parsers) like @(see parse-nat).
+
+You might wonder why we have the @('explicit-value') separate from
+@('args'). The basic reason is that we want to support any mixture of the
+following syntaxes:
+
+
+ @('--color red ...')
+ @('--color=red ...')
+
+
+Making the explicit-value explicit lets us very easily support this without
+requiring, e.g., that every argument has exactly one value.
")
+
+(table getopt 'parsers
+ ;; Maps predicates to the names of their default parsing functions.
+ nil)
+
+(defun getopt-parsers (world)
+ (declare (xargs :mode :program))
+ (cdr (assoc-eq 'parsers (table-alist 'getopt world))))
+
+(defun default-getopt-parser (predicate world)
+ (declare (xargs :mode :program))
+ (cdr (assoc predicate (getopt-parsers world))))
+
+(defun check-plausibly-a-parser-p (ctx fn world)
+ (declare (xargs :mode :program))
+ (b* ((look (getprop fn 'acl2::formals :bad 'acl2::current-acl2-world world))
+ ((when (eq look :bad))
+ (er hard? ctx "~x0 is not the name of a defined function." fn))
+ (nformals (len (look-up-formals fn world)))
+ (nreturns (len (look-up-return-vals fn world)))
+ ((unless (and (eql nformals 3)
+ (eql nreturns 3)))
+ (er hard? ctx
+ "The function ~x0 does not have the right signature for a getopt ~
+ parser. Expected 2 formals and 3 return vals, but found ~x1 and ~
+ ~x2, respectively. See :xdoc ~x3." fn nformals nreturns
+ 'custom-parser)))
+ t))
+
+
+(defsection defparser
+ :parents (parsers)
+ :short "Register a new argument-parsing function with @(see getopt)."
+
+ :long "@(call defparser) is a macro for registering parsing functions with
+@(see getopt).
+
+It first checks to make sure that @('fn') has the valid format for a @(see
+custom-parser), and tries to prove the necessary progress property.
+
+If @('predicate') is non-nil, it installs @('fn') as the default parsing
+function to use for options of type @('predicate'). The general idea here is
+that if you write a new custom parser for ports, you can then set it up to be
+the default parser for any @('port-p') field.
"
+
+ (defmacro defparser (fn &key predicate)
+ (declare (xargs :guard (symbolp fn)))
+ `(make-event
+ (b* ((world (w state))
+ (predicate ',predicate)
+ (fn ',fn)
+ (- (check-plausibly-a-parser-p 'defparser fn world))
+ ((unless (or (not predicate)
+ (and (eql (len (look-up-formals predicate world)) 1)
+ (eql (len (look-up-return-vals predicate world)) 1))))
+ (er soft 'defparser
+ "The function ~x0 does not seem like a valid unary predicate."
+ predicate))
+ (look (assoc predicate (getopt-parsers world)))
+ ((unless (or (not predicate)
+ (not look)
+ (eq (cdr look) fn)))
+ (er soft 'defparser
+ "The predicate ~x0 already has a different getopt parser ~
+ as its default: ~x1" predicate (cdr look))))
+ (value
+ '(progn
+ (local (in-theory (enable ,fn)))
+
+ (defthm ,(intern-in-package-of-symbol
+ (cat (symbol-name fn) "-MAKES-PROGRESS")
+ fn)
+ (<= (len (mv-nth 2 (,fn name explicit-value args)))
+ (len args))
+ :rule-classes ((:rewrite) (:linear)))
+
+ ,@(if (not predicate)
+ nil
+ `((table getopt 'parsers
+ (cons (cons ',predicate ',fn)
+ (getopt-parsers world)))))))))))
+
+
+(define parse-plain
+ :parents (parsers)
+ :short "Parser for plain, argument-free options that are off by default and
+must be explicitly enabled, e.g., @('--verbose') or @('--force')."
+
+ :long "We just return true, because by typing the name of the option the
+user is saying they want to turn it on. This is useful for options that the
+user has to explicitly ask for because they are unsafe or just unusual.
"
+ ((name stringp)
+ (explicit-value (or (not explicit-value)
+ (stringp explicit-value)))
+ (args string-listp))
+ :returns (mv err
+ (value booleanp :rule-classes :type-prescription)
+ (rest-args string-listp :hyp (force (string-listp args))))
+ (if explicit-value
+ (mv (msg "Option ~s0 can't take an argument" name) nil args)
+ (mv nil t args))
+ ///
+ (defparser parse-plain :predicate booleanp))
+
+
+(define parse-string
+ :parents (parsers)
+ :short "Parser for options that require an argument, but where any arbitrary
+string will do, e.g., @('--username') or @('--eval')."
+ :long "The only way this can fail is if there aren't any more arguments,
+e.g., someone types something like @('myprogram --username') and doesn't say
+what username to use.
"
+ ((name stringp)
+ (explicit-value (or (not explicit-value)
+ (stringp explicit-value)))
+ (args string-listp))
+ :returns (mv err
+ (value stringp :rule-classes :type-prescription)
+ (rest-args string-listp :hyp (force (string-listp args))))
+ (b* (((mv val args)
+ (if explicit-value
+ (mv explicit-value args)
+ (mv (car args) (cdr args))))
+ ((unless val)
+ (mv (msg "Option ~s0 needs an argument" name) "" args)))
+ (mv nil (str::str-fix val) args))
+ ///
+ (defparser parse-string :predicate stringp))
+
+
+(define parse-nat
+ :parents (parsers)
+ :short "Parser for options that require a @(see natp) argument, e.g.,
+@('--tabsize') or @('-O'), etc."
+ :long "We just read the next string out of the argument list and try to
+interpret it as a decimal number. This fails if it there is no argument, or if
+there are any non-numeric characters.
"
+ ((name stringp)
+ (explicit-value (or (not explicit-value)
+ (stringp explicit-value)))
+ (args string-listp))
+ :returns (mv err
+ (value natp :rule-classes :type-prescription)
+ (rest-args string-listp :hyp (force (string-listp args))))
+ (b* (((mv val args)
+ (if explicit-value
+ (mv explicit-value args)
+ (mv (car args) (cdr args))))
+ ((unless val)
+ (mv (msg "Option ~s0 needs an argument" name) 0 args))
+ (ret (str::strval val))
+ ((unless ret)
+ (mv (msg "Option ~s0 needs a number, but got ~x1" name val)
+ 0 args)))
+ (mv nil ret args))
+ ///
+ (defparser parse-nat :predicate natp))
+
+
+(define parse-pos
+ :parents (parsers)
+ :short "Parser for options that require a @(see posp) argument, e.g.,
+@('--block-size') or @('--line-number')."
+ :long "This is just like @(see parse-nat) except that we also cause
+an error if the argument is zero.
"
+ ((name stringp)
+ (explicit-value (or (not explicit-value)
+ (stringp explicit-value)))
+ (args string-listp))
+ :returns (mv err
+ (value posp :rule-classes :type-prescription)
+ (rest-args string-listp :hyp (force (string-listp args))))
+ (b* (((mv val args)
+ (if explicit-value
+ (mv explicit-value args)
+ (mv (car args) (cdr args))))
+ ((unless val)
+ (mv (msg "Option ~s0 needs an argument" name) 1 args))
+ (ret (str::strval val))
+ ((unless ret)
+ (mv (msg "Option ~s0 needs a number, but got ~x1" name val)
+ 1 args))
+ ((when (eql ret 0))
+ (mv (msg "Option ~s0 can't be zero" name) 1 args)))
+ (mv nil ret args))
+ ///
+ (defparser parse-pos :predicate posp))
+
diff -Nru acl2-6.2/books/centaur/getopt/portcullis.acl2 acl2-6.3/books/centaur/getopt/portcullis.acl2
--- acl2-6.2/books/centaur/getopt/portcullis.acl2 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/getopt/portcullis.acl2 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,22 @@
+; ACL2 Getopt Library
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(ld "package.lsp")
+; cert-flags: ? t :ttags :all
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/getopt/portcullis.lisp acl2-6.3/books/centaur/getopt/portcullis.lisp
--- acl2-6.2/books/centaur/getopt/portcullis.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/getopt/portcullis.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,21 @@
+; ACL2 Getopt Library
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "GETOPT")
diff -Nru acl2-6.2/books/centaur/getopt/top.lisp acl2-6.3/books/centaur/getopt/top.lisp
--- acl2-6.2/books/centaur/getopt/top.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/getopt/top.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,1100 @@
+; ACL2 Getopt Library
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "GETOPT")
+(include-book "cutil/top" :dir :system)
+(include-book "str/case-conversion" :dir :system)
+(include-book "str/strprefixp" :dir :system)
+(include-book "str/subseq" :dir :system)
+(include-book "str/strpos" :dir :system)
+(include-book "parsers")
+(include-book "xdoc/word-wrap" :dir :system)
+(include-book "std/misc/two-nats-measure" :dir :system)
+
+
+(defxdoc getopt
+ :parents (acl2::interfacing-tools)
+ :short "A library for processing command-line option."
+
+ :long "Introduction
+
+Getopt is a tool for writing command-line programs in ACL2. It is
+similar in spirit to Getopt::Long for Perl, Trollop for Ruby, and so on.
+
+We basically extend @(see defaggregate) with a command-line parsing layer.
+This has some nice consequences:
+
+
+
+Argument parsing gives you an ordinary aggregate that can have nice, strong
+type guarantees on its fields.
+
+It's very easy to add new options, pass the arguments throughout your
+program, etc.
+
+You get excellent integration with @(see xdoc), i.e., documentation is
+mostly automated.
+
+We can automatically generate usage messages that stay up to date as you
+add new arguments.
+
+
+
+To make Getopt more automatic, we insist on some typical Unix conventions.
+We support options like these:
+
+@({
+ --help Long names use two dashes.
+ --color red Values can use spaces or = signs.
+ --shape=square
+
+ -c red Short aliases use one dash. Plain
+ -s=square aliases (with no arguments) can be
+ -xfvz bundled. E.g., -xfvz instead of
+ -x -f -v -z.
+})
+
+We insist on two dashes for long options, and one dash for short options.
+This lets us support mixing options in with other arguments like file names.
+For instance, after parsing something like:
+
+@({ myprogram --depth 3 --verbose foo.java bar.java -o report.txt })
+
+You get two things out:
+
+
+
+A proper options structure with depth @('3'), verbose @('t'),
+and output @('report.txt').
+
+The \"extra\" arguments, i.e., @('(\"foo.java\" \"bar.java\")').
+
+
+
+For rare cases where you need to process a file that starts with @('-'), the
+special syntax @('--') is a marker that means \"stop looking for options
+here.\"
+
+Using Getopts
+
+Getopts is an ordinary library with no ttags. To load it, just include the
+top book:
+
+@({ (include-book \"centaur/getopt/top\" :dir :system) })
+
+After that, the main command is @(see defoptions).
+
+There is also a demo of how to use Getopt: @(see getopt-demo::demo-p).
+
+
+Copyright Information
+
+ACL2 Getopt Library
+Copyright (C) 2013
+Centaur Technology .
+
+Contact:
+@({
+Centaur Technology Formal Verification Group
+7600-C N. Capital of Texas Highway, Suite 300
+Austin, TX 78731, USA.
+})
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
+Street, Suite 500, Boston, MA 02110-1335, USA.
+
+Original author: Jared Davis
+<jared@centtech.com >
")
+
+
+(defsection defoptions
+ :parents (getopt)
+ :short "Define a structure for representing command line options, and a
+command-line parser that creates this structure."
+
+ :long "@('defoptions') is the main command provided by @(see getopt)
+library. It is really a thin wrapper around @(see defaggregate), where each
+field can have some additional keywords that have certain effects.
+
+
+A Basic Example
+
+@({
+ (defoptions myopts
+ :parents (myprogram)
+ :short \"Command line options for my program.\"
+ :tag :myopts
+ ((help booleanp
+ \"Print a help message and exit with status 0.\")
+ (outfile stringp
+ \"Where to write the output.\"
+ :default \"a.out\")))
+})
+
+So far, this is identical to @('defaggregate') except that we use
+@('defoptions') instead. Indeed, the first thing the above @('defoptions')
+form expands into is an ordinary @('defaggregate') call. The @('defaggregate')
+introduces a @('myopts-p') structure as usual, complete with the usual
+accessors like @('myopts->help'), a @('make-myopts') macro, etc.
+
+But in addition to introducing an aggregate, @('defoptions') introduces a
+usage message and a command-line parsing function.
+
+For @('myopts') above, the usage message, @('*myopts-usage*'), will just
+be:
+
+@({
+ --help Print a help message and exit with status 0.
+ --outfile=ARG Where to write the output.
+})
+
+So that's handy, and below we'll see how to customize this message a bit.
+You can probably easily imagine incorporating this into your program's
+@('--help') message.
+
+Meanwhile, the parsing function, @('parse-myopts'), allows you to parse a
+@(see string-listp) into a @('myopts-p') structure. The signature of
+@('parse-myopts') is:
+
+@({
+ (parse-myopts args &key (init '*default-myopts*))
+ -->
+ (mv errmsg result extra)
+})
+
+The @('args') here are just a string list. Normally, if you were writing a
+real command-line program with ACL2, you would normally get the @('args') to
+process by calling @(see oslib::argv). But for testing and development, we can
+just use any old string list we want.
+
+Usually you won't care about the optional @(':init') argument: it just lets
+you use a custom @('myopts') structure as the starting point, instead of
+starting from the default structure (which has the @(':default') value for each
+field.)
+
+Command-line parsing can fail because the user might type in something
+crazy. For instance, they might try to run @('myprogram --hlep') instead of
+@('myprogram --help'). The @('errmsg') will be NIL if everything is okay, or
+else will be an error message produced by @(see msg), which is suitable for
+printing with the @(see fmt) directive @('~@'). For example:
+
+@({
+ (b* (((mv errmsg result extra)
+ (parse-myopts '(\"--hlep\")))
+ ((when errmsg)
+ (cw \"Error processing options!~%\")
+ (cw \"~@0~%\" errmsg)
+ nil))
+ result)
+})
+
+Will print out:
+
+@({
+ Error processing options!
+ Unrecognized option --hlep
+})
+
+When command-line processing is successful, the main return value,
+@('result'), is a valid @('myopts-p') structure that contains the various
+settings, and the @('extra') return value is a list of any command-line options
+that we skipped because they didn't look like options. For example:
+
+@({
+ (b* (((mv ?errmsg result extra)
+ (parse-myopts
+ '(\"foo.java\" \"--outfile\" \"report.txt\" \"bar.java\"))))
+ (list :result result
+ :extra extra))
+})
+
+Will return:
+
+@({
+ (:RESULT (:MYOPTS (HELP)
+ (OUTFILE . \"report.txt\"))
+ :EXTRA (\"foo.java\" \"bar.java\"))
+})
+
+
+Adding Short Aliases (-h, -o, ...)
+
+Ordinarily a program that takes options like @('--help') and @('--outfile')
+will also have shorter ways to give these options, e.g., @('-h') and @('-o').
+You can set up these short names by just adding an @(':alias') to your fields,
+like this:
+
+@({
+ (defoptions myopts
+ :parents (myprogram)
+ :short \"Command line options for my program.\"
+ :tag :myopts
+ ((help booleanp
+ \"Print a help message and exit with status 0.\"
+ :alias #\\h)
+ (outfile stringp
+ \"Where to write the output.\"
+ :default \"a.out\"
+ :alias #\\o)))
+})
+
+Note that the usage message gets automatically extended to take these
+into account. @('*myopts-usage*') becomes:
+
+@({
+ -h,--help Print a help message and exit with status 0.
+ -o,--outfile=ARG Where to write the output.
+})
+
+
+Custom Option Types
+
+The @('myopts-p') structure is especially simple in that it only contains
+@(see booleanp) and @(see stringp) fields. Getopt has built-in @(see parsers)
+for these types, as well as for @(see natp) and @(see posp). But in some cases
+these may not be sufficient.
+
+If you need something fancier, you can write your own parser. See @(see
+custom-parser) for details. After writing your own @('parse-foo') function, you can
+either register it as the default for all @('foo-p') fields, or you can install
+it just as the parser for a particular field using the @(':parser') option.
+For instance:
+
+@({
+ (outfile stringp
+ \"Where to write the output.\"
+ :default \"a.out\"
+ :alias #\\o
+ ;; redundant, but acceptable, to explicitly say to use the
+ ;; default stringp parser
+ :parser getopt::parse-string)
+})
+
+
+Changing Option Names
+
+By default the option name is just automatically inferred from the field
+name. In rare cases you might want to change this, e.g., perhaps you prefer to
+use field-names like @('verbosep') instead of @('verbose'). You can accomplish
+this with a custom @(':longname') for the field, e.g.,
+
+@({
+ (defoptions myopts
+ :parents (myprogram)
+ :short \"Command line options for my program.\"
+ :tag :myopts
+ ((verbosep booleanp
+ :longname \"verbose\"
+ \"Print excessive debugging information.\")
+ (help booleanp
+ \"Print a help message and exit with status 0.\"
+ :alias #\\h)
+ (outfile stringp
+ \"Where to write the output.\"
+ :default \"a.out\"
+ :alias #\\o)))
+})
+
+
+List Types
+
+By default options are unmergeable , meaning that it is an error to
+try to specify them more than once. This is generally sensible behavior, e.g.,
+you probably don't want to support things like:
+
+@({ myprog --username jared --username sol ... })
+
+But occasionally you want to have an option that \"stacks\" with other
+options. For instance, in our Verilog parsing stuff we often want a \"search
+path\" that is a list of directories.
+
+To facilitate this, the @(':merge') option can be used to specify a custom
+\"merging function\" (typically @(see cons)) that can extend a field with a new
+value. For instance, here's basically the canonical way to have an option that
+lets the user write:
+
+@({ myprog --dir /dir1 --dir /dir2 ... })
+
+And turns them into a @('dirs') field:
+
+@({
+ (dirs string-listp
+ :longname \"dir\"
+ :parser getopt::parse-string
+ :merge cons)
+})
+
+Note that this will actually accumulate the options in the reverse
+order (because @(see cons) extends the front of a list). This is easily
+corrected for by using some kind of @('push') function instead of @('cons'), or
+by reversing the list at the end. See @(see getopt-demo::demo-p) for an
+example.
+
+
+Customizing Usage Messages
+
+By default we reuse the @(see xdoc) documentation for a field as its usage
+message. If you want to have a separate usage message instead, you can just
+add one, e.g., via @(':usage \"blah blah\"').
+
+For options that take arguments, you may occasionally want to name the
+argument. That is, by default, we will produce usage messages like:
+
+@({
+ --port ARG The port to connect to.
+ --out ARG Where to write the output.
+})
+
+But maybe you'd rather have this print as:
+
+@({
+ --port PORT The port to connect to.
+ --out FILE Where to write the output.
+})
+
+You can do this by adding, e.g., @(':argname \"PORT\"') and @(':argname
+\"FILE\"') to the port/out fields.
")
+
+
+(define split-equals ((x stringp))
+ :returns (mv (pre stringp
+ :rule-classes :type-prescription)
+ (post (or (not post)
+ (stringp post))
+ :rule-classes :type-prescription))
+ (b* ((x (str::str-fix x))
+ (pos (str::strpos "=" x))
+ ((when pos)
+ (mv (subseq x 0 pos)
+ (subseq x (+ 1 pos) nil))))
+ (mv x nil)))
+
+
+#||
+(split-equals "foo=bar") --> (mv "foo" "bar")
+||#
+
+(program)
+
+(defconst *extra-fields-for-defoptions*
+ '(:longname ;; Full name for this option, like "verbose". Overrides
+ ;; the field name, if supplied.
+
+ :alias ;; Short alias for this option, like #\v, if desired.
+
+ :parser ;; What function will parse the arguments. Automatically
+ ;; inferred from the field type, if not specified.
+
+ :merge ;; How to merge the new values with the old, if applicable,
+ ;; e.g., for list-type values.
+
+ :usage ;; A custom usage message, if one is needed instead of just
+ ;; using the formal's documentation
+
+ :argname ;; Name for this argument in the usage message, e.g., you
+ ;; might want the message to look like
+ ;;
+ ;; --port PORT The port to connect to on the server.
+ ;;
+ ;; --out FILE Where to write the output
+ ;;
+ ;; And so on, so you'd use :argnames like "PORT" and "FILE"
+ ;; The default is "ARG" unless it's a plain option.
+
+ :hide ;; A hidden option. This requires that there is no alias,
+ ;; usage message, argname, or any of that. This is generally
+ ;; useful for options you're going to fill in yourself, like
+ ;; file names.
+ ))
+
+(define formal->longname ((x formal-p))
+ :parents (getopt)
+ :returns (longname stringp)
+ (b* (((formal x) x)
+ (longname (cdr (assoc :longname x.opts)))
+ ((when (and (stringp longname)
+ (not (equal longname ""))))
+ longname)
+ ((when longname)
+ (raise "In ~x0, :longname must be ~s1, but found: ~x2"
+ x.name
+ (if (stringp longname) "nonempty" "a string")
+ longname)
+ ""))
+ ;; Else, no longname at all, by default use the name of the formal.
+ (str::downcase-string (symbol-name x.name))))
+
+(defprojection formallist->longnames (x)
+ (formal->longname x)
+ :guard (formallist-p x)
+ :result-type string-listp
+ :optimize nil)
+
+
+(define formal->alias ((x formal-p))
+ :parents (getopt)
+ :returns (alias (or (not alias)
+ (characterp alias)))
+ (b* (((formal x) x)
+ (alias (cdr (assoc :alias x.opts)))
+ ((when (characterp alias))
+ alias)
+ ((when alias)
+ (raise "In ~x0, :alias must be a character, but found ~x1."
+ x.name alias)
+ nil))
+ ;; No automatic inference of an alias
+ nil))
+
+(defprojection formallist->aliases (x)
+ (formal->alias x)
+ :guard (formallist-p x)
+ ;; :result-type maybe-character-listp
+ :optimize nil)
+
+
+
+(define formal->parser ((x formal-p) (world plist-worldp))
+ :parents (getopt)
+ :returns (parser-fn symbolp)
+ (b* (((formal x) x)
+ (parser (cdr (assoc :parser x.opts)))
+ ((when parser)
+ (check-plausibly-a-parser-p x.name parser world)
+ parser)
+ ;; Else, see if there is a default parser for this type
+ ((unless (and (tuplep 2 x.guard)
+ (equal (second x.guard) x.name)))
+ (raise "In ~x0, there's no :parser and the type isn't simple enough ~
+ to infer a default." x.name))
+ (predicate (first x.guard))
+ (parser (default-getopt-parser predicate world))
+ ((when parser)
+ (check-plausibly-a-parser-p x.name parser world)
+ parser))
+ (raise "In ~x0, there's no :parser and there's no default parser for type ~
+ ~x1." x.name predicate)))
+
+(defprojection formallist->parsers (x world)
+ (formal->parser x world)
+ :guard (and (formallist-p x)
+ (plist-worldp world))
+ :result-type symbol-listp
+ :optimize nil)
+
+
+(define formal->merge ((x formal-p))
+ :parents (getopt)
+ :returns (merge-fn symbolp)
+ (b* (((formal x) x)
+ (merge (cdr (assoc :merge x.opts)))
+ ((unless (symbolp merge))
+ (raise "In ~x0, :merge is not even a symbol: ~x1." x.name merge)))
+ merge))
+
+(defprojection formallist->merges (x)
+ (formal->merge x)
+ :guard (formallist-p x)
+ :result-type symbol-listp
+ :optimize nil)
+
+
+(define formal->usage ((x formal-p))
+ :parents (getopt)
+ :returns (usage stringp)
+ (b* (((formal x) x))
+ (or (cdr (assoc :usage x.opts))
+ x.doc)))
+
+(define formal->argname ((x formal-p) (world plist-worldp))
+ :parents (getopt)
+ :returns (argname stringp)
+ (b* (((formal x) x)
+ (custom (assoc :argname x.opts))
+ ((when (stringp (cdr custom)))
+ (cdr custom))
+ ((when custom)
+ (raise "In ~x0, :argname is not even a stringp: ~x1."
+ x.name (cdr custom)))
+ (parser (formal->parser x world))
+ ((when (equal parser 'parse-plain))
+ ""))
+ "ARG"))
+
+(define formal->hiddenp ((x formal-p))
+ :parents (getopt)
+ :returns (longname stringp)
+ (b* (((formal x) x)
+ (hide (cdr (assoc :hide x.opts)))
+ ((when hide)
+ t))
+ nil))
+
+(define drop-hidden-options ((x formallist-p))
+ :returns (subset formallist-p)
+ (cond ((atom x)
+ nil)
+ ((formal->hiddenp (car x))
+ (drop-hidden-options (cdr x)))
+ (t
+ (cons (car x) (drop-hidden-options (cdr x))))))
+
+(define sanity-check-formals ((basename symbolp)
+ (x formallist-p)
+ (world plist-worldp))
+ :parents (getopt)
+ :short "Make sure longnames and aliases are unique, every field has a parser,
+and so forth. This only applies to visible options."
+
+ (b* ((longnames (formallist->longnames x))
+ ((unless (uniquep longnames))
+ (raise "In ~x0, multiple fields have :longname ~&1."
+ basename (duplicated-members longnames)))
+
+ (aliases (remove nil (formallist->aliases x)))
+ ((unless (uniquep aliases))
+ (raise "In ~x0, multiple fields have :alias ~&1."
+ basename (duplicated-members aliases)))
+
+ ;; These are just doing the basic checks...
+ (?parsers (formallist->parsers x world))
+ (?merges (formallist->merges x)))
+ t))
+
+(defun parser-name (basename)
+ (intern-in-package-of-symbol
+ (str::cat "PARSE-" (symbol-name basename))
+ basename))
+
+(defun parser-name-aux (basename)
+ (intern-in-package-of-symbol
+ (str::cat "PARSE-" (symbol-name basename) "-AUX")
+ basename))
+
+(defun parser-name-long (basename)
+ (intern-in-package-of-symbol
+ (str::cat "PARSE-" (symbol-name basename) "-LONG")
+ basename))
+
+(defun parser-name-bundle (basename)
+ (intern-in-package-of-symbol
+ (str::cat "PARSE-" (symbol-name basename) "-BUNDLE")
+ basename))
+
+(defun parser-name-short->long (basename)
+ (intern-in-package-of-symbol
+ (str::cat "PARSE-" (symbol-name basename) "-SHORT->LONG")
+ basename))
+
+(defun parser-name-short->long-list (basename)
+ (intern-in-package-of-symbol
+ (str::cat "PARSE-" (symbol-name basename) "-SHORT->LONG-LIST")
+ basename))
+
+(defun default-name (basename)
+ (intern-in-package-of-symbol
+ (str::cat "*DEFAULT-" (symbol-name basename) "*")
+ basename))
+
+
+
+(define make-parse-short->long ((basename symbolp)
+ (formals formallist-p))
+ (b* ((parse-foo (parser-name basename))
+ (parse-short->long (parser-name-short->long basename))
+ (parse-short->long-list (parser-name-short->long-list basename))
+ (alist (pairlis$ (formallist->aliases formals)
+ (formallist->longnames formals))))
+ `(progn
+ (define ,parse-short->long ((alias characterp))
+ :parents (,parse-foo)
+ :returns (mv errmsg?
+ (longname stringp :rule-classes :type-prescription))
+ (b* ((look (assoc alias ',alist))
+ ((when look)
+ (mv nil (cdr look))))
+ (mv (msg "Unrecognized option -~s0." (implode (list alias)))
+ "")))
+
+ (define ,parse-short->long-list ((aliases character-listp))
+ :parents (,parse-foo)
+ :returns (mv (errmsg)
+ (longnames string-listp))
+ (b* (((when (atom aliases))
+ (mv nil nil))
+ ((mv err longname) (,parse-short->long (car aliases)))
+ ((when err)
+ (mv err nil))
+ ((mv err rest) (,parse-short->long-list (cdr aliases))))
+ (mv err (cons longname rest)))
+ ///
+ (defthm ,(intern-in-package-of-symbol
+ (cat "TRUE-LISTP-OF-" (symbol-name parse-short->long-list))
+ parse-short->long-list)
+ (true-listp (mv-nth 1 (,parse-short->long-list aliases)))
+ :rule-classes :type-prescription)))))
+
+(define collect-plain-options ((x formallist-p) (world plist-worldp))
+ :returns (subset formallist-p)
+ (cond ((atom x)
+ nil)
+ ((equal (formal->parser (car x) world) 'parse-plain)
+ (cons (car x) (collect-plain-options (cdr x) world)))
+ (t
+ (collect-plain-options (cdr x) world))))
+
+(define make-parse-long-cases ((basename symbolp)
+ (formals formallist-p)
+ (world plist-worldp))
+ (b* (((when (atom formals))
+ nil)
+ (field (formal->name (car formals)))
+ (longname (formal->longname (car formals)))
+ (parser (formal->parser (car formals) world))
+ (merge (formal->merge (car formals)))
+ (accessor (cutil::da-accessor-name basename field))
+ (changer (cutil::da-changer-name basename))
+ (kwd (intern$ (symbol-name field) "KEYWORD"))
+ (case1
+ `((equal longname ,longname)
+ (b* (;; If an option isn't mergeable, we don't allow it to be given
+ ;; multiple times.
+ ,@(and (not merge)
+ '(((when (member-equal longname seen))
+ (mv (msg "Option --~s0 given multiple times" longname)
+ acc args))))
+
+ ((mv err value rest) (,parser (cat "--" longname) explicit-val args))
+ ((when err)
+ (mv err acc args))
+ ;; If an option is mergeable, we need to merge this new value
+ ;; into the old one.
+ ,@(and merge
+ `((old-value (,accessor acc))
+ (value (,merge value old-value))))
+ ;; At this point everything should be good.
+ (acc (,changer acc ,kwd value)))
+ (mv nil acc rest)))))
+ (cons case1
+ (make-parse-long-cases basename (cdr formals) world))))
+
+(define make-parse-long ((basename symbolp)
+ (formals formallist-p)
+ (world plist-worldp))
+ (b* ((parse-foo (parser-name basename))
+ (parse-long (parser-name-long basename))
+ (foop (cutil::da-recognizer-name basename)))
+ `(define ,parse-long
+ :parents (,parse-foo)
+ ((longname stringp
+ "Longname we've just found, e.g., \"foo\" if we've just
+ seen @('--foo=bar').")
+ (explicit-val (or (not explicit-val)
+ (stringp explicit-val))
+ "Any explicit value passed to this option, e.g.,
+ \"bar\" if we've just seen @('--foo=bar'), or NIL
+ if we've just seen @('--foo').")
+ (args string-listp
+ "Remaining arguments past longname .")
+ (acc ,foop
+ "Structure we're updating")
+ (seen string-listp
+ "List of longnames that we've seen so far."))
+ :returns
+ (mv (errmsg "NIL on success or an error message.")
+ (acc ,foop
+ :hyp (force (,foop acc))
+ "Updated structure.")
+ (rest string-listp :hyp (force (string-listp args))
+ "Rest after this one."))
+ (cond ,@(make-parse-long-cases basename formals world)
+ (t
+ ;; No matching case for these formals
+ (mv (msg "Unrecognized option --~s0" longname)
+ acc
+ args)))
+ ///
+ (defthm ,(intern-in-package-of-symbol
+ (cat (symbol-name parse-long) "-MAKES-PROGRESS")
+ basename)
+ (<= (len (mv-nth 2 (,parse-long longname explicit-val args acc seen)))
+ (len args))
+ :rule-classes ((:rewrite) (:linear))))))
+
+(define make-parse-bundle ((basename symbolp))
+ (b* ((parse-foo (parser-name basename))
+ (parse-long (parser-name-long basename))
+ (parse-bundle (parser-name-bundle basename))
+ (foop (cutil::da-recognizer-name basename)))
+ `(define ,parse-bundle
+ :parents (,parse-foo)
+ ((longnames string-listp "The already-expanded out names of the bundled
+ options, with no dashes.")
+ (args string-listp "Remaining arguments past longname .")
+ (acc ,foop "Structure we're updating")
+ (seen string-listp "List of longnames that we've seen so far."))
+ :returns
+ (mv (errmsg "NIL on success or an error message.")
+ (acc ,foop :hyp (force (,foop acc)))
+ (seen string-listp :hyp (and (force (string-listp longnames))
+ (force (string-listp seen))))
+ (rest string-listp :hyp (force (string-listp args))))
+ (b* (((when (atom longnames))
+ (mv nil acc seen args))
+ ((mv err acc rest)
+ (,parse-long (car longnames) nil args acc seen))
+ ((when err)
+ (mv err acc seen rest))
+ (seen (cons (car longnames) seen)))
+ (,parse-bundle (cdr longnames) rest acc seen))
+ ///
+ (defthm ,(intern-in-package-of-symbol
+ (cat (symbol-name parse-bundle) "-MAKES-PROGRESS")
+ basename)
+ (<= (len (mv-nth 3 (,parse-bundle longnames args acc seen)))
+ (len args))
+ :rule-classes ((:rewrite) (:linear))))))
+
+(define make-parse-aux ((basename symbolp)
+ (formals formallist-p)
+ (world plist-worldp))
+ (b* ((parse-foo (parser-name basename))
+ (parse-aux (parser-name-aux basename))
+ (parse-long (parser-name-long basename))
+ (parse-short->long (parser-name-short->long basename))
+ (parse-short->long-list (parser-name-short->long-list basename))
+ (parse-bundle (parser-name-bundle basename))
+ (foop (cutil::da-recognizer-name basename))
+ (plain (collect-plain-options formals world))
+ (plain-longnames (formallist->longnames plain)))
+ `(define ,parse-aux
+ :parents (,parse-foo)
+ ((args string-listp "Arguments we're processing")
+ (acc ,foop "Structure we're building.")
+ (seen string-listp "List of longnames that we've seen so far.")
+ (skipped string-listp "Arguments we've skipped since they don't go with
+ options, in reverse order."))
+ :returns (mv errmsg
+ (result ,foop :hyp (force (,foop acc)))
+ (skipped string-listp
+ :hyp (and (force (string-listp skipped))
+ (force (string-listp args)))))
+ :measure (len args)
+ (b* (((when (or (atom args)
+ (equal (car args) "--")))
+ ;; Successfully processed all the arguments that belong to us. We
+ ;; leave the -- in, so the programmer can choose to process it, if
+ ;; they want.
+ (mv nil acc (revappend skipped args)))
+
+ ((unless (str::strprefixp "-" (car args)))
+ ;; Not an option. Skip it.
+ (,parse-aux (cdr args) acc seen (cons (car args) skipped)))
+
+ ((when (str::strprefixp "--" (car args)))
+ (b* (((mv longname explicit-value)
+ (split-equals (subseq (car args) 2 nil)))
+ ((mv err acc rest)
+ (,parse-long longname explicit-value (cdr args) acc seen))
+ ((when err)
+ (mv err acc rest))
+ (seen (cons longname seen)))
+ (,parse-aux rest acc seen skipped)))
+
+ ;; Else, just one leading dash.
+ ((mv shortnames explicit-value)
+ (split-equals (subseq (car args) 1 nil)))
+
+ (aliases (explode shortnames))
+ ((when (atom aliases))
+ ;; Very weird, either a stray dash or something like -= or -=blah.
+ ;; I guess we'll tolerate this but just treat it as a non-option
+ ;; by skipping it?
+ (,parse-aux (cdr args) acc seen (cons (car args) skipped)))
+
+ ((when (atom (cdr aliases)))
+ ;; A single alias. This is easy, just try to translate it into a
+ ;; long option and handle it normally.
+ (b* ((alias (car aliases))
+ ((mv err longname) (,parse-short->long alias))
+ ((when err)
+ (mv err acc args))
+ ((mv err acc rest)
+ (,parse-long longname explicit-value (cdr args) acc seen))
+ ((when err)
+ (mv err acc rest))
+ (seen (cons longname seen)))
+ (,parse-aux rest acc seen skipped)))
+
+ ;; Else, an option bundle. Try to translate them into longnames.
+ ((mv err longnames) (,parse-short->long-list aliases))
+ ((when err)
+ (mv err acc args))
+ ((when explicit-value)
+ (mv (msg "Option bundle ~s0 is not allowed (bundles can't have ~
+ arguments)." (car args))
+ acc args))
+
+ ;; We can only bundle options if they are plain, so check for that
+ ;; now. The HIDE here is just to prevent case splits.
+ (illegal-to-bundle (set-difference-equal longnames ',plain-longnames))
+ ((when illegal-to-bundle)
+ (mv (msg "Option bundle ~s0 is not allowed (--~s1 needs an argument)"
+ (car args)
+ (car illegal-to-bundle))
+ acc args))
+ ((mv err acc seen rest)
+ (,parse-bundle longnames (cdr args) acc seen))
+ ((when err)
+ (mv err acc rest)))
+ (,parse-aux rest acc seen skipped)))))
+
+(define make-parse ((basename symbolp))
+ (b* ((parse-foo (parser-name basename))
+ (parse-aux (parser-name-aux basename))
+ (default-foo (default-name basename))
+ (foop (cutil::da-recognizer-name basename))
+ (foop-link (b* ((acc (str::revappend-chars "" acc))
+ (acc (xdoc::sym-mangle foop foop acc))
+ (acc (str::revappend-chars " " acc)))
+ (str::rchars-to-string acc))))
+ `(define ,parse-foo
+ :parents (,foop)
+ :short ,(str::cat "Parse arguments from the command line into a "
+ foop-link " aggregate.")
+ ((args string-listp "The command line arguments to parse, which is
+ typically derived from @(see oslib::argv).")
+ &key
+ ((init ,foop ,(str::cat "An initial " foop-link " to start from, which
+ gives the default values for each field."))
+ ',default-foo))
+ :returns
+ (mv (errmsg "NIL on success, or an error message produced by @(see msg),
+ suitable for printing the @(see fmt) directive @('~@').")
+ (result ,foop
+ :hyp (force (,foop init))
+ "An updated version of @('init') where the command-line
+ arguments have been applied. On any error, this may be
+ only partially updated.")
+ (extra string-listp
+ :hyp (force (string-listp args))
+ "Any other arguments in @('args') that were not recognized
+ as options. Typically this might include the \"main\"
+ arguments to a program, e.g., file names, etc., that aren't
+ associated with --options."))
+ :long "This is an ordinary command line parser, automatically
+ produced by @(see getopt).
"
+ (,parse-aux args init nil nil))))
+
+(defsection defoption-lemmas
+ (logic)
+
+ (defthm defoptions-lemma-1
+ (equal (string-listp (append x y))
+ (and (string-listp (list-fix x))
+ (string-listp y))))
+
+ (defthm defoptions-lemma-2
+ (equal (string-listp (acl2::rev x))
+ (string-listp (list-fix x)))
+ :hints(("Goal" :induct (len x))))
+
+ (defthm defoptions-lemma-3
+ (implies (string-listp x)
+ (string-listp (list-fix x))))
+
+ (defthm defoptions-lemma-4
+ (implies (str::strprefixp "--" x)
+ (<= 2 (len (explode x))))
+ :rule-classes ((:rewrite) (:linear)))
+
+ (defthm defoptions-lemma-5
+ (implies (character-listp x)
+ (equal (characterp (car x))
+ (consp x))))
+
+ (defthm defoptions-lemma-6
+ (implies (character-listp x)
+ (equal (characterp (second x))
+ (consp (cdr x)))))
+
+ (defthm defoptions-lemma-7
+ (implies (character-listp x)
+ (character-listp (cdr x))))
+
+ (defthm defoptions-lemma-8
+ (implies (str::strprefixp "-" x)
+ (<= 1 (len (explode x))))
+ :rule-classes ((:rewrite) (:linear)))
+
+ (def-ruleset defoptions-lemmas
+ '(defoptions-lemma-1
+ defoptions-lemma-2
+ defoptions-lemma-3
+ defoptions-lemma-4
+ defoptions-lemma-5
+ defoptions-lemma-6
+ defoptions-lemma-7
+ acl2::revappend-removal
+ acl2::append-to-nil
+ acl2::list-fix-when-true-listp
+ str::stringp-of-subseq))
+
+ (in-theory (disable* defoptions-lemmas)))
+
+
+
+(defconst *ind-col* 26)
+(defconst *wrap-col* 72)
+
+(define usage-message-part ((title stringp)
+ (detail stringp)
+ (acc character-listp))
+ :returns (new-acc character-listp)
+ (b* ((title (cat " " title))
+ (acc (str::revappend-chars title acc))
+ (acc
+ (if (> (length title) (- *ind-col* 3))
+ ;; Title is really long. Give it its own line.
+ (b* ((acc (cons #\Newline acc)))
+ (make-list-ac *ind-col* #\Space acc))
+ ;; Title fits nicely, space out to *ind-col*.
+ (make-list-ac (- *ind-col* (length title))
+ #\Space acc)))
+ (x (xdoc::normalize-whitespace detail))
+ (acc (xdoc::word-wrap-paragraph-aux x 0 (length x)
+ *ind-col*
+ *wrap-col*
+ *ind-col*
+ acc))
+ (acc (xdoc::remove-spaces-from-front acc))
+ (acc (cons #\Newline acc)))
+ acc))
+
+#||
+(str::rchars-to-string
+ (usage-message-part "-o,--output=FILE"
+ "Lorem ipsum blah blah. This message has random newlines
+ in it, like something you might write in the middle of an
+ aggregate's documentation, etc." nil))
+
+(str::rchars-to-string
+ (usage-message-part "--a-really-long-option=FILE"
+ "Lorem ipsum blah blah. This message has random newlines
+ in it, like something you might write in the middle of an
+ aggregate's documentation, etc."
+ nil))
+||#
+
+(define make-usage-aux ((x formal-p)
+ (world plist-worldp)
+ (acc character-listp))
+ (b* ((longname (formal->longname x)) ; e.g., "outfile"
+ (alias (formal->alias x)) ; e.g., #\o
+ (argname (formal->argname x world)) ; e.g., "FILE"
+ (usage (formal->usage x)) ; e.g., "where to write ..."
+
+ (title (str::cat
+ (if alias (implode (list #\- alias #\,)) "")
+ "--"
+ longname
+ (if (equal argname "") "" "=")
+ argname)))
+ (usage-message-part title usage acc)))
+
+(define make-usage-loop ((x formallist-p)
+ (world plist-worldp)
+ (acc character-listp))
+ (if (atom x)
+ acc
+ (let ((acc (make-usage-aux (car x) world acc)))
+ (make-usage-loop (cdr x) world acc))))
+
+(define make-usage ((x formallist-p)
+ (world plist-worldp))
+ (str::rchars-to-string (make-usage-loop x world nil)))
+
+
+
+(define defoptions-fn ((info cutil::agginfo-p)
+ (world plist-worldp))
+ (b* (((cutil::agginfo info) info)
+ (visible (drop-hidden-options info.efields))
+ (- (sanity-check-formals info.name visible world))
+ (foop (cutil::da-recognizer-name info.name))
+ (usage-const (intern-in-package-of-symbol
+ (cat "*" (symbol-name info.name) "-USAGE*")
+ info.name))
+ (usage-msg (make-usage visible world))
+ (usage-html (b* ((acc (str::revappend-chars "" nil))
+ (acc (xdoc::simple-html-encode-chars
+ (explode usage-msg) acc))
+ (acc (str::revappend-chars "
" acc)))
+ (str::rchars-to-string acc)))
+ (events
+ `(progn
+ (local (in-theory (e/d* (defoptions-lemmas)
+ (str::strprefixp
+ set-difference-equal))))
+
+ ,(make-parse-long info.name visible world)
+ ,(make-parse-short->long info.name visible)
+ ,(make-parse-bundle info.name)
+ ,(make-parse-aux info.name visible world)
+ ,(make-parse info.name)
+ (defsection ,usage-const
+ :parents (,foop)
+ :short "Automatically generated usage message."
+ :long ,usage-html
+ (defconst ,usage-const ',usage-msg))
+ (value-triple '(defoptions ,info.name)))))
+ events))
+
+(defmacro defoptions (name &rest args)
+ (let ((default-foo (default-name name)))
+ `(progn
+ (defaggregate ,name
+ :extra-field-keywords ,*extra-fields-for-defoptions*
+ . ,args)
+ (defconst ,default-foo (,(cutil::da-maker-name name)))
+ (make-event
+ (b* ((world (w state))
+ (agginfo (cutil::get-aggregate ',name world)))
+ (value
+ (defoptions-fn agginfo world)))))))
+
+
+
+
diff -Nru acl2-6.2/books/centaur/gl/acl2-customization.lsp acl2-6.3/books/centaur/gl/acl2-customization.lsp
--- acl2-6.2/books/centaur/gl/acl2-customization.lsp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/acl2-customization.lsp 2013-09-30 17:53:14.000000000 +0000
@@ -1,5 +1,25 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(ld "package.lsp")
(set-gag-mode :goals)
(set-inhibit-warnings "theory")
+(ld "~/acl2-customization.lsp" :ld-missing-input-ok t)
(in-package "GL")
diff -Nru acl2-6.2/books/centaur/gl/always-equal-prep.lisp acl2-6.3/books/centaur/gl/always-equal-prep.lisp
--- acl2-6.2/books/centaur/gl/always-equal-prep.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/always-equal-prep.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,15 +1,32 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-
(include-book "symbolic-arithmetic-fns")
-(local (include-book "hyp-fix-logic"))
(include-book "g-if")
-(local (include-book "eval-g-base-help"))
(include-book "eval-g-base")
-
-
+(local (include-book "hyp-fix-logic"))
+(local (include-book "eval-g-base-help"))
+(local (include-book "clause-processors/find-subterms" :dir :system))
+(local (include-book "clause-processors/just-expand" :dir :system))
+(local (include-book "centaur/bitops/ihsext-basics" :dir :system))
;; This introduces a symbolic counterpart function for EQUAL (more
;; specifically, for ALWAYS-EQUAL, which is defined as EQUAL) that takes a
@@ -33,484 +50,458 @@
(declare (Xargs :guard t))
(equal x y))
-;; X and Y should be unequal BDDs. This produces a BDD with one path to a T,
-;; with the guarantee that X and Y are unequal on that path.
+;; X and Y should be unequal BDDs. This produces an environment under which x
+;; and y evaluate to opposite values.
(defun ctrex-for-always-equal (x y)
(declare (xargs :guard t :measure (+ (acl2-count x) (acl2-count y))))
(if (and (atom x) (atom y))
- t
+ nil
(b* (((mv xa xd) (if (consp x) (mv (car x) (cdr x)) (mv x x)))
((mv ya yd) (if (consp y) (mv (car y) (cdr y)) (mv y y))))
(if (hqual xa ya)
(cons nil (ctrex-for-always-equal xd yd))
- (cons (ctrex-for-always-equal xa ya) nil)))))
+ (cons t (ctrex-for-always-equal xa ya))))))
-(local
- (progn
- (defun ctrex-for-always-equal-ind (x y env)
- (declare (xargs :measure (+ (acl2-count x) (acl2-count y))))
- (if (and (atom x) (atom y))
- env
- (b* (((mv xa xd) (if (consp x) (mv (car x) (cdr x)) (mv x x)))
- ((mv ya yd) (if (consp y) (mv (car y) (cdr y)) (mv y y))))
- (if (hqual xa ya)
- (cons nil (ctrex-for-always-equal-ind xd yd (cdr env)))
- (cons (ctrex-for-always-equal-ind xa ya (cdr env)) nil)))))
-
- (defthmd ctrex-for-always-equal-correct
- (implies (and (acl2::ubddp x) (acl2::ubddp y) (not (equal x y))
- (acl2::eval-bdd (ctrex-for-always-equal x y) env))
- (not (equal (acl2::eval-bdd x env) (acl2::eval-bdd y env))))
- :hints (("goal" :induct (ctrex-for-always-equal-ind x y env)
- :in-theory (enable acl2::eval-bdd acl2::ubddp))))
-
- (defthm ctrex-for-always-equal-correct2
- (implies (and (acl2::ubddp x) (acl2::ubddp y) (not (equal x y))
- (equal (acl2::eval-bdd x env) (acl2::eval-bdd y env)))
- (not (acl2::eval-bdd (ctrex-for-always-equal x y) env)))
- :hints(("Goal" :in-theory (enable ctrex-for-always-equal-correct))))
-
- (defthm acl2::ubddp-ctrex-for-always-equal
- (acl2::ubddp (ctrex-for-always-equal a b))
- :hints(("Goal" :in-theory (enable acl2::ubddp))))))
+(defthmd ctrex-for-always-equal-correct
+ (implies (and (acl2::ubddp x) (acl2::ubddp y) (not (equal x y)))
+ (equal (acl2::eval-bdd x (ctrex-for-always-equal x y))
+ (not (acl2::eval-bdd y (ctrex-for-always-equal x y)))))
+ :hints (("goal" :induct (ctrex-for-always-equal x y)
+ :in-theory (enable acl2::ubddp acl2::eval-bdd))))
-
-;; This produces either: a BDD with one path to a T, with the guarantee that X
-;; and Y are unequal on that path and that the hyp holds on that path; or NIL,
-;; meaning X and Y are equal everywhere the hyp holds.
+;; This produces an environment under which x and y differ and hyp is true, if
+;; one exists. The first return value is a flag saying whether we succeeded or not.
;; This is used as a helper function for the top-level
;; ctrex-for-always-equal-under-hyp, but it is actually complete; the top-level
;; function just tries to find an easier answer first.
(defun ctrex-for-always-equal-under-hyp1 (x y hyp)
(declare (xargs :guard t))
- (cond ((hqual x y) nil)
- ((eq hyp nil) nil)
- ((atom hyp) (ctrex-for-always-equal x y))
+ (cond ((hqual x y) (mv nil nil))
+ ((eq hyp nil) (mv nil nil))
+ ((atom hyp) (mv (not (hqual x y))
+ (ctrex-for-always-equal x y)))
((and (atom x) (atom y))
- (ctrex-for-always-equal hyp nil))
+ (mv (not (eq hyp nil))
+ (ctrex-for-always-equal hyp nil)))
((eq (cdr hyp) nil)
- (let ((res
- (ctrex-for-always-equal-under-hyp1
- (if (consp x) (car x) x)
- (if (consp y) (car y) y)
- (car hyp))))
- (and res (cons res nil))))
+ (mv-let (ok env)
+ (ctrex-for-always-equal-under-hyp1
+ (if (consp x) (car x) x)
+ (if (consp y) (car y) y)
+ (car hyp))
+ (mv ok (cons t env))))
((eq (car hyp) nil)
- (let ((res (ctrex-for-always-equal-under-hyp1
- (if (consp x) (cdr x) x)
- (if (consp y) (cdr y) y)
- (cdr hyp))))
- (and res (cons nil res))))
+ (mv-let (ok env)
+ (ctrex-for-always-equal-under-hyp1
+ (if (consp x) (cdr x) x)
+ (if (consp y) (cdr y) y)
+ (cdr hyp))
+ (mv ok (cons nil env))))
(t (let ((x1 (acl2::q-and hyp x))
(y1 (acl2::q-and hyp y)))
- (if (hqual x1 y1)
- nil
- (ctrex-for-always-equal x1 y1))))))
-
-(local
- (defthm ctrex-for-always-equal-under-hyp1-ubddp
- (implies (and (acl2::ubddp x) (acl2::ubddp y) (acl2::ubddp hyp))
- (acl2::ubddp (ctrex-for-always-equal-under-hyp1 x y hyp)))
- :hints(("Goal" :in-theory (enable acl2::ubddp)
- :induct (ctrex-for-always-equal-under-hyp1 x y hyp)))))
-
-
-
-
-
-
+ (mv (not (hqual x1 y1))
+ (ctrex-for-always-equal x1 y1))))))
-(local
- (progn
-
-
- (defun ctrex-for-always-equal-under-hyp-ind (x y hyp env)
- (cond ((hqual x y) env)
- ((eq hyp nil) env)
- ((atom hyp) env)
- (t (if (car env)
- (ctrex-for-always-equal-under-hyp-ind
- (if (consp x) (car x) x)
- (if (consp y) (car y) y)
- (car hyp) (cdr env))
- (ctrex-for-always-equal-under-hyp-ind
- (if (consp x) (cdr x) x)
- (if (consp y) (cdr y) y)
- (cdr hyp) (cdr env))))))
-
- (defthm ctrex-for-always-equal-under-hyp1-correct1
- (implies (and (not (and (acl2::eval-bdd hyp env)
- (not (equal (acl2::eval-bdd x env) (acl2::eval-bdd y env)))))
- (acl2::ubddp x) (acl2::ubddp y) (acl2::ubddp hyp))
- (not (acl2::eval-bdd (ctrex-for-always-equal-under-hyp1 x y hyp) env)))
- :hints(("Goal" :in-theory (e/d* (acl2::ubddp)
- (ctrex-for-always-equal-under-hyp1
- acl2::eval-bdd-when-qs-subset
- ctrex-for-always-equal
- acl2::eval-bdd-when-not-consp
- acl2::eval-bdd-of-non-consp-cheap
- acl2::ubddp-compound-recognizer
- (:rules-of-class :type-prescription :here)
-; acl2::eval-bdd-booleanp
- equal-of-booleans-rewrite)
- ((:type-prescription acl2::eval-bdd)))
- :induct (ctrex-for-always-equal-under-hyp-ind x y hyp env)
- :expand
- ((:free (x y) (ctrex-for-always-equal-under-hyp1 x y hyp))
- (:free (x y) (ctrex-for-always-equal-under-hyp1 x y t))
- (:free (x y) (ctrex-for-always-equal-under-hyp1 x y nil))
- (:free (x y env) (acl2::eval-bdd (cons x y) env))
- (:free (env) (acl2::eval-bdd x env))
- (:free (env) (acl2::eval-bdd y env))))))
-
- (defthm hyp-eval-lemma
- (implies (and (syntaxp (eq hyp 'hyp)) (consp hyp))
- (and (implies (and (not (car env))
- (not (acl2::eval-bdd (cdr hyp) (cdr env))))
- (not (acl2::eval-bdd hyp env)))
- (implies (and (car env)
- (not (acl2::eval-bdd (car hyp) (cdr env))))
- (not (acl2::eval-bdd hyp env)))))
- :hints(("Goal" :in-theory (enable acl2::eval-bdd))))
-
-
- (defthm ctrex-for-always-equal-under-hyp1-correct2
- (implies (and (bind-free '((env . (cdr env))) (env))
- (not (equal (acl2::eval-bdd x env) (acl2::eval-bdd y env)))
- (acl2::eval-bdd hyp env)
- (acl2::ubddp x) (acl2::ubddp y) (acl2::ubddp hyp))
- (ctrex-for-always-equal-under-hyp1 x y hyp))
- :hints(("Goal" :in-theory (e/d* (acl2::ubddp)
- (ctrex-for-always-equal-under-hyp1
- acl2::eval-bdd-when-qs-subset
- ctrex-for-always-equal
- acl2::eval-bdd-when-not-consp
- ; acl2::eval-bdd-of-non-consp-cheap
- equal-of-booleans-rewrite
- (:rules-of-class :type-prescription :here))
- ((:type-prescription acl2::eval-bdd)
- (:type-prescription ctrex-for-always-equal)))
- :induct (ctrex-for-always-equal-under-hyp-ind x y hyp env)
- :do-not-induct t
- :expand
- ((:free (x y) (ctrex-for-always-equal-under-hyp1 x y hyp))
- (:free (x y) (ctrex-for-always-equal-under-hyp1 x y t))
- (:free (x y) (ctrex-for-always-equal-under-hyp1 x y nil))))
+(defun ctrex-for-always-equal-under-hyp1-ind (x y hyp env)
+ (cond ((hqual x y) env)
+ ((eq hyp nil) env)
+ ((atom hyp) env)
+ ((and (atom x) (atom y))
+ env)
+ ((eq (cdr hyp) nil)
+ (ctrex-for-always-equal-under-hyp1-ind
+ (if (consp x) (car x) x)
+ (if (consp y) (car y) y)
+ (car hyp)
+ (cdr env)))
+ ((eq (car hyp) nil)
+ (ctrex-for-always-equal-under-hyp1-ind
+ (if (consp x) (cdr x) x)
+ (if (consp y) (cdr y) y)
+ (cdr hyp)
+ (cdr env)))
+ (t env)))
+
+(local (in-theory (disable ctrex-for-always-equal-under-hyp1
+ ctrex-for-always-equal
+ acl2::qs-subset-when-booleans
+ acl2::eval-bdd-when-qs-subset
+ equal-of-booleans-rewrite)))
+
+(defthm ctrex-for-always-equal-under-hyp1-correct
+ (implies (and (acl2::ubddp x) (acl2::ubddp y) (acl2::ubddp hyp)
+ (not (equal (acl2::eval-bdd x env)
+ (acl2::eval-bdd y env)))
+ (acl2::eval-bdd hyp env))
+ (let ((env (mv-nth 1 (ctrex-for-always-equal-under-hyp1 x y hyp))))
+ (and (not (equal (acl2::eval-bdd x env)
+ (acl2::eval-bdd y env)))
+ (acl2::eval-bdd hyp env))))
+ :hints ((acl2::just-induct-and-expand
+ (ctrex-for-always-equal-under-hyp1-ind x y hyp env)
+ :expand-others ((ctrex-for-always-equal-under-hyp1 x y hyp)))
(and stable-under-simplificationp
- '(:clause-processor
- (acl2::eval-bdd-cp
- clause (list '(x y hyp)
- (let ((world (w state))) (acl2::bdd-patterns))
- ;; '(env)
- t))))
+ (let ((call (acl2::find-call-lst 'ctrex-for-always-equal
+ clause)))
+ (and call
+ `(:use ((:instance ctrex-for-always-equal-correct
+ (x ,(second call)) (y ,(third call))))
+ :in-theory (disable
+ ctrex-for-always-equal-correct)))))
+ (and (equal (car clause)
+ '(not (equal (acl2::q-binary-and hyp x)
+ (acl2::q-binary-and hyp y))))
+ (acl2::bdd-reasoning))
(and stable-under-simplificationp
- '(:expand ((acl2::eval-bdd x env)
- (acl2::eval-bdd y env))))))))
-
-
-
-
-
-(in-theory (Disable ctrex-for-always-equal-under-hyp1))
-
+ '(;; :in-theory (e/d (acl2::eval-bdd acl2::ubddp)
+ ;; (ctrex-for-always-equal-correct))
+ :expand ((:free (x a b)
+ (acl2::eval-bdd x (cons a b)))
+ (acl2::eval-bdd x env)
+ (acl2::eval-bdd x nil)
+ (acl2::eval-bdd y env)
+ (acl2::eval-bdd y nil)
+ (acl2::eval-bdd hyp env)
+ (acl2::eval-bdd hyp nil))))))
+
+(defthm ctrex-for-always-equal-under-hyp1-flag-correct
+ (implies (and (acl2::ubddp x) (acl2::ubddp y) (acl2::ubddp hyp))
+ (iff (mv-nth 0 (ctrex-for-always-equal-under-hyp1 x y hyp))
+ (let ((env (mv-nth 1 (ctrex-for-always-equal-under-hyp1 x y hyp))))
+ (and (not (equal (acl2::eval-bdd x env)
+ (acl2::eval-bdd y env)))
+ (acl2::eval-bdd hyp env)))))
+ :hints ((acl2::just-induct-and-expand
+ (ctrex-for-always-equal-under-hyp1-ind x y hyp env)
+ :expand-others ((ctrex-for-always-equal-under-hyp1 x y hyp)))
+ (and stable-under-simplificationp
+ (let ((call (acl2::find-call-lst 'ctrex-for-always-equal
+ clause)))
+ (and call
+ `(:use ((:instance ctrex-for-always-equal-correct
+ (x ,(second call)) (y ,(third call))))
+ :in-theory (disable
+ ctrex-for-always-equal-correct)))))
+ (and stable-under-simplificationp
+ (member-equal '(not (equal (acl2::q-binary-and hyp x)
+ (acl2::q-binary-and hyp y)))
+ clause)
+ (acl2::bdd-reasoning))
+ (and stable-under-simplificationp
+ '(;; :in-theory (e/d (acl2::eval-bdd acl2::ubddp)
+ ;; (ctrex-for-always-equal-correct))
+ :expand ((:free (x a b)
+ (acl2::eval-bdd x (cons a b))))))))
(defun ctrex-for-always-equal-under-hyp (x y hyp)
(declare (xargs :guard t :measure (acl2-count hyp)))
- (cond ((hqual x y) nil)
- ((eq hyp nil) nil)
- ((atom hyp) (ctrex-for-always-equal x y))
+ (cond ((hqual x y) (mv nil nil))
+ ((eq hyp nil) (mv nil nil))
+ ((atom hyp) (mv (not (hqual x y))
+ (ctrex-for-always-equal x y)))
((eq (cdr hyp) nil)
- (let ((res (ctrex-for-always-equal-under-hyp
- (if (consp x) (car x) x)
- (if (consp y) (car y) y)
- (car hyp))))
- (and res (cons res nil))))
+ (mv-let (ok env)
+ (ctrex-for-always-equal-under-hyp
+ (if (consp x) (car x) x)
+ (if (consp y) (car y) y)
+ (car hyp))
+ (mv ok (cons t env))))
((eq (car hyp) nil)
- (let ((res (ctrex-for-always-equal-under-hyp
- (if (consp x) (cdr x) x)
- (if (consp y) (cdr y) y)
- (cdr hyp))))
- (and res (cons nil res))))
+ (mv-let (ok env)
+ (ctrex-for-always-equal-under-hyp
+ (if (consp x) (cdr x) x)
+ (if (consp y) (cdr y) y)
+ (cdr hyp))
+ (mv ok (cons nil env))))
;; The bad case here is when x and y are equal wherever the hyp holds
- ;; and unequal everywhere else.
+ ;; and unequal everywhere else.
;; Possible ways to deal with this: Q-AND the hyp with each arg and
- ;; compare equality, or else recur on the car and then the cdr.
+ ;; compare equality, or else recur on the car and then the cdr.
;; We take a hybrid approch: recur down the car in hopes of finding an
;; easy counterexample, then at each level, use the Q-AND approch on
;; the cdr.
- (t (let ((car-result (ctrex-for-always-equal-under-hyp
- (if (consp x) (car x) x)
- (if (consp y) (car y) y)
- (car hyp))))
- (if car-result
- (cons car-result nil)
- (let ((cdr-result (ctrex-for-always-equal-under-hyp1
- (if (consp x) (cdr x) x)
- (if (consp y) (cdr y) y)
- (cdr hyp))))
- (and cdr-result
- (cons nil cdr-result))))))))
-
-(local (defthm ctrex-for-always-equal-under-hyp-ubddp
- (implies (and (acl2::ubddp x) (acl2::ubddp y) (acl2::ubddp hyp))
- (acl2::ubddp (ctrex-for-always-equal-under-hyp x y hyp)))
- :hints(("Goal" :in-theory (enable acl2::ubddp)))))
-
-;; (local (defthm ctrex-for-always-equal-under-hyp-bfr-p
-;; (implies (and (not (bfr-mode))
-;; (bfr-p x) (bfr-p y) (bfr-p hyp))
-;; (bfr-p (ctrex-for-always-equal-under-hyp x y hyp)))
-;; :hints(("Goal" :use ctrex-for-always-equal-under-hyp-ubddp
-;; :in-theory (e/d (bfr-p booleanp)
-;; (ctrex-for-always-equal-under-hyp-ubddp))))))
-
-
-(local
- (defthm ctrex-for-always-equal-under-hyp-correct1
- (implies (and (acl2::eval-bdd (ctrex-for-always-equal-under-hyp x y hyp) env)
- (acl2::ubddp x) (acl2::ubddp y) (acl2::ubddp hyp))
- (and (acl2::eval-bdd hyp env)
- (equal (acl2::eval-bdd x env)
- (not (acl2::eval-bdd y env)))))
- :hints(("Goal" :in-theory (e/d* (acl2::ubddp)
- (ctrex-for-always-equal-under-hyp
- acl2::eval-bdd-when-qs-subset
- equal-of-booleans-rewrite
- ctrex-for-always-equal
- acl2::eval-bdd-when-not-consp
- (:rules-of-class :type-prescription :here))
- ((:type-prescription acl2::eval-bdd)))
- :induct (ctrex-for-always-equal-under-hyp-ind x y hyp env)
- :expand
- ((:free (x y) (ctrex-for-always-equal-under-hyp x y hyp))
- (:free (x y) (ctrex-for-always-equal-under-hyp x y t))
- (:free (x y) (ctrex-for-always-equal-under-hyp x y nil))
- (:free (x y env) (acl2::eval-bdd (cons x y) env))
- (:free (env) (acl2::eval-bdd x env))
- (:free (env) (acl2::eval-bdd y env))
- (:free (env) (acl2::eval-bdd hyp env)))))))
-
-(local
- (defthm ctrex-for-always-equal-under-hyp-correct2
- (implies (and (not (equal (acl2::eval-bdd x env) (acl2::eval-bdd y env)))
- (acl2::eval-bdd hyp env)
- (acl2::ubddp x) (acl2::ubddp y) (acl2::ubddp hyp))
- (ctrex-for-always-equal-under-hyp x y hyp))
- :hints(("Goal" :in-theory (e/d* (acl2::ubddp)
- (ctrex-for-always-equal-under-hyp
- ;ctrex-for-always-equal-under-hyp1-correct2
- ctrex-for-always-equal-under-hyp-correct1
- acl2::eval-bdd-when-qs-subset
- ctrex-for-always-equal
- acl2::eval-bdd-when-not-consp
- ; acl2::eval-bdd-of-non-consp-cheap
- equal-of-booleans-rewrite
- (:rules-of-class :type-prescription :here))
- ((:type-prescription acl2::eval-bdd)
- (:type-prescription ctrex-for-always-equal)))
- :induct (ctrex-for-always-equal-under-hyp-ind x y hyp env)
- :do-not-induct t
- :expand
- ((:free (x y) (ctrex-for-always-equal-under-hyp x y hyp))
- (:free (x y) (ctrex-for-always-equal-under-hyp x y t))
- (:free (x y) (ctrex-for-always-equal-under-hyp x y nil))))
+ (t (b* (((mv ok env)
+ (ctrex-for-always-equal-under-hyp
+ (if (consp x) (car x) x)
+ (if (consp y) (car y) y)
+ (car hyp)))
+ ((when ok) (mv t (cons t env)))
+ ((mv ok env)
+ (ctrex-for-always-equal-under-hyp1
+ (if (consp x) (cdr x) x)
+ (if (consp y) (cdr y) y)
+ (cdr hyp))))
+ (mv ok (cons nil env))))))
+
+(defun ctrex-for-always-equal-under-hyp-ind (x y hyp env)
+ (declare (xargs :measure (acl2-count hyp)))
+ (cond ((hqual x y) env)
+ ((eq hyp nil) env)
+ ((atom hyp) env)
+ ((eq (cdr hyp) nil)
+ (ctrex-for-always-equal-under-hyp-ind
+ (if (consp x) (car x) x)
+ (if (consp y) (car y) y)
+ (car hyp)
+ (cdr env)))
+ ((eq (car hyp) nil)
+ (ctrex-for-always-equal-under-hyp-ind
+ (if (consp x) (cdr x) x)
+ (if (consp y) (cdr y) y)
+ (cdr hyp)
+ (cdr env)))
+ ;; The bad case here is when x and y are equal wherever the hyp holds
+ ;; and unequal everywhere else.
+ ;; Possible ways to deal with this: Q-AND the hyp with each arg and
+ ;; compare equality, or else recur on the car and then the cdr.
+ ;; We take a hybrid approch: recur down the car in hopes of finding an
+ ;; easy counterexample, then at each level, use the Q-AND approch on
+ ;; the cdr.
+ (t (ctrex-for-always-equal-under-hyp-ind
+ (if (consp x) (car x) x)
+ (if (consp y) (car y) y)
+ (car hyp) (cdr env)))))
+
+
+(local (in-theory (disable ctrex-for-always-equal-under-hyp
+ sets::double-containment)))
+
+(defthm ctrex-for-always-equal-under-hyp-flag-correct
+ (implies (and (acl2::ubddp x) (acl2::ubddp y) (acl2::ubddp hyp))
+ (iff (mv-nth 0 (ctrex-for-always-equal-under-hyp x y hyp))
+ (let ((env (mv-nth 1 (ctrex-for-always-equal-under-hyp x y hyp))))
+ (and (not (equal (acl2::eval-bdd x env)
+ (acl2::eval-bdd y env)))
+ (acl2::eval-bdd hyp env)))))
+ :hints ((acl2::just-induct-and-expand
+ (ctrex-for-always-equal-under-hyp-ind x y hyp env)
+ :expand-others ((ctrex-for-always-equal-under-hyp x y hyp)))
(and stable-under-simplificationp
- '(:clause-processor
- (acl2::eval-bdd-cp
- clause (list '(x y hyp)
- (let ((world (w state))) (acl2::bdd-patterns))
- ;; '(env)
- t))))
+ (b* ((call (acl2::find-call-lst 'ctrex-for-always-equal
+ clause))
+ ((when call)
+ `(:use ((:instance ctrex-for-always-equal-correct
+ (x ,(second call)) (y ,(third call))))
+ :in-theory (disable
+ ctrex-for-always-equal-correct))))
+ nil))
+ ;; (and (equal (car clause)
+ ;; '(not (equal (acl2::q-binary-and hyp x)
+ ;; (acl2::q-binary-and hyp y))))
+ ;; (acl2::bdd-reasoning))
(and stable-under-simplificationp
- '(:expand ((acl2::eval-bdd x env)
+ '(;; :in-theory (e/d (acl2::eval-bdd acl2::ubddp)
+ ;; (ctrex-for-always-equal-correct))
+ :expand ((:free (x a b)
+ (acl2::eval-bdd x (cons a b)))
+ (acl2::eval-bdd x env)
+ (acl2::eval-bdd x nil)
(acl2::eval-bdd y env)
+ (acl2::eval-bdd y nil)
(acl2::eval-bdd hyp env)
- (acl2::eval-bdd hyp nil)))))))
-
+ (acl2::eval-bdd hyp nil))))))
-
-;; (local
-;; (defthm ctrex-for-always-equal-under-hyp-correct1-bfr
-;; (implies (and (not (bfr-mode))
-;; (bfr-eval (ctrex-for-always-equal-under-hyp x y hyp) env)
-;; (bfr-p x) (bfr-p y) (bfr-p hyp))
-;; (and (bfr-eval hyp env)
-;; (equal (bfr-eval x env)
-;; (not (bfr-eval y env)))))
-;; :hints(("goal" :in-theory
-;; (e/d* (bfr-p bfr-eval booleanp)
-;; (ctrex-for-always-equal-under-hyp-correct1))
-;; :use ctrex-for-always-equal-under-hyp-correct1))))
-
-;; (local
-;; (defthm ctrex-for-always-equal-under-hyp-correct2-bfr
-;; (implies (and (not (bfr-mode))
-;; (not (equal (bfr-eval x env) (bfr-eval y env)))
-;; (bfr-eval hyp env)
-;; (bfr-p x) (bfr-p y) (bfr-p hyp))
-;; (ctrex-for-always-equal-under-hyp x y hyp))
-;; :hints(("goal" :in-theory
-;; (e/d* (bfr-p bfr-eval booleanp)
-;; (ctrex-for-always-equal-under-hyp-correct2))
-;; :use ctrex-for-always-equal-under-hyp-correct2))))
+(defthm ctrex-for-always-equal-under-hyp-correct
+ (implies (and (acl2::ubddp x) (acl2::ubddp y) (acl2::ubddp hyp)
+ (not (equal (acl2::eval-bdd x env)
+ (acl2::eval-bdd y env)))
+ (acl2::eval-bdd hyp env))
+ (let ((env (mv-nth 1 (ctrex-for-always-equal-under-hyp x y hyp))))
+ (and (not (equal (acl2::eval-bdd x env)
+ (acl2::eval-bdd y env)))
+ (acl2::eval-bdd hyp env))))
+ :hints ((acl2::just-induct-and-expand
+ (ctrex-for-always-equal-under-hyp-ind x y hyp env)
+ :expand-others ((ctrex-for-always-equal-under-hyp x y hyp)))
+ (and stable-under-simplificationp
+ (b* ((call (acl2::find-call-lst 'ctrex-for-always-equal
+ clause))
+ ((when call)
+ `(:use ((:instance ctrex-for-always-equal-correct
+ (x ,(second call)) (y ,(third call))))
+ :in-theory (disable
+ ctrex-for-always-equal-correct)))
+ (call (acl2::find-call-lst 'ctrex-for-always-equal-under-hyp1
+ clause))
+ ((when call)
+ `(:use ((:instance ctrex-for-always-equal-under-hyp1-correct
+ (x ,(second call)) (y ,(third call))
+ (hyp ,(fourth call)) (env (cdr env))))
+ :in-theory (disable
+ ctrex-for-always-equal-under-hyp1-correct))))
+ nil))
+ ;; (and (equal (car clause)
+ ;; '(not (equal (acl2::q-binary-and hyp x)
+ ;; (acl2::q-binary-and hyp y))))
+ ;; (acl2::bdd-reasoning))
+ (and stable-under-simplificationp
+ '(;; :in-theory (e/d (acl2::eval-bdd acl2::ubddp)
+ ;; (ctrex-for-always-equal-correct))
+ :expand ((:free (x a b)
+ (acl2::eval-bdd x (cons a b)))
+ (acl2::eval-bdd x env)
+ (acl2::eval-bdd x nil)
+ (acl2::eval-bdd y env)
+ (acl2::eval-bdd y nil)
+ (acl2::eval-bdd hyp env)
+ (acl2::eval-bdd hyp nil))
+ :do-not-induct t))))
-(defun always-equal-uu (x y)
- (declare (xargs :guard t :measure (+ (acl2-count x) (acl2-count y))))
- (if (and (atom x) (atom y))
- (mv t t)
- (b* (((mv xa xd) (if (consp x) (mv (car x) (cdr x)) (mv nil nil)))
- ((mv ya yd) (if (consp y) (mv (car y) (cdr y)) (mv nil nil)))
- ((when (hqual xa ya)) (always-equal-uu xd yd))
- (xa (acl2::ubdd-fix xa))
- (ya (acl2::ubdd-fix ya))
- ((when (hqual xa ya)) (always-equal-uu xd yd)))
- (mv nil (ctrex-for-always-equal xa ya)))))
+;; (defun always-equal-uu (x y)
+;; (declare (xargs :guard t :measure (+ (acl2-count x) (acl2-count y))))
+;; (if (and (atom x) (atom y))
+;; (mv t nil)
+;; (b* (((mv xa xd) (if (consp x) (mv (car x) (cdr x)) (mv nil nil)))
+;; ((mv ya yd) (if (consp y) (mv (car y) (cdr y)) (mv nil nil)))
+;; ((when (hqual xa ya)) (always-equal-uu xd yd))
+;; (xa (acl2::ubdd-fix xa))
+;; (ya (acl2::ubdd-fix ya))
+;; ((when (hqual xa ya)) (always-equal-uu xd yd)))
+;; (mv nil (ctrex-for-always-equal xa ya)))))
(defun always-equal-ss-under-hyp (x y hyp)
(declare (xargs :guard t :measure (+ (acl2-count x) (acl2-count y))))
- (b* (((mv xa xd xend) (if (consp x)
- (if (consp (cdr x))
- (mv (car x) (cdr x) nil)
- (mv (car x) x t))
- (mv nil nil t)))
- ((mv ya yd yend) (if (consp y)
- (if (consp (cdr y))
- (mv (car y) (cdr y) nil)
- (mv (car y) y t))
- (mv nil nil t)))
+ (b* (((mv xa xd xend) (first/rest/end x))
+ ((mv ya yd yend) (first/rest/end y))
((when (hqual xa ya))
(if (and xend yend)
- (mv t t)
+ (mv t nil)
(always-equal-ss-under-hyp xd yd hyp)))
(xa (acl2::ubdd-fix xa))
(ya (acl2::ubdd-fix ya))
- (res (ctrex-for-always-equal-under-hyp xa ya hyp)))
- (if (eq res nil)
- (if (and xend yend)
- (mv t t)
- (always-equal-ss-under-hyp xd yd hyp))
- (mv nil res))))
+ ((mv diffp res) (ctrex-for-always-equal-under-hyp xa ya hyp)))
+ (if diffp
+ (mv nil res)
+ (if (and xend yend)
+ (mv t nil)
+ (always-equal-ss-under-hyp xd yd hyp)))))
(local
(encapsulate nil
-
+
(local
(progn
- (include-book "arithmetic/top-with-meta" :dir :system)
- (defthm even-not-equal-odd
- (implies (and (evenp x) (evenp y))
- (not (equal x (+ 1 y)))))
-
- (defthm evenp-ash-1
- (implies (integerp x)
- (evenp (ash x 1)))
- :hints(("Goal" :in-theory (enable ash))))
-
- (defthm natp-ash-1
- (implies (natp x)
- (natp (ash x 1)))
- :hints(("Goal" :in-theory (enable ash)))
- :rule-classes :type-prescription)
-
- (defthm equal-ash-n
- (implies (and (integerp x) (integerp n))
- (equal (equal (ash x 1) n)
- (equal x (* 1/2 n))))
- :hints(("Goal" :in-theory (enable ash))))
-
- (defthm half-of-ash
- (implies (integerp x)
- (equal (* 1/2 (ash x 1)) x))
- :hints(("Goal" :in-theory (enable ash))))))
+ (defthm equal-of-bool->bit
+ (equal (equal (acl2::bool->bit x) (acl2::bool->bit y))
+ (iff x y)))
+
+ ;; (defthm even-not-equal-odd
+ ;; (implies (and (evenp x) (evenp y))
+ ;; (not (equal x (+ 1 y)))))
+
+ ;; (defthm *-2-not-minus-1
+ ;; (implies (integerp n)
+ ;; (not (equal (* 2 n) -1)))
+ ;; :hints (("goal" :use ((:instance even-not-equal-odd
+ ;; (x (* 2 n)) (y -2))))))
+
+ ;; (defthm evenp-ash-1
+ ;; (implies (integerp x)
+ ;; (evenp (ash x 1)))
+ ;; :hints(("Goal" :in-theory (enable ash))))
+
+ ;; (defthm natp-ash-1
+ ;; (implies (natp x)
+ ;; (natp (ash x 1)))
+ ;; :hints(("Goal" :in-theory (enable ash)))
+ ;; :rule-classes :type-prescription)
+
+ ;; (defthm equal-ash-n
+ ;; (implies (and (integerp x) (integerp n))
+ ;; (equal (equal (ash x 1) n)
+ ;; (equal x (* 1/2 n))))
+ ;; :hints(("Goal" :in-theory (enable ash))))
+
+ ;; (defthm half-of-ash
+ ;; (implies (integerp x)
+ ;; (equal (* 1/2 (ash x 1)) x))
+ ;; :hints(("Goal" :in-theory (enable ash))))
+ ))
- (defthm always-equal-uu-correct
- (mv-let (always-equal ctrex-bdd)
- (always-equal-uu x y)
- (implies (and (not (bfr-mode)))
- (and (implies always-equal
- (equal (v2n (bfr-eval-list x env))
- (v2n (bfr-eval-list y env))))
- (implies (and (not always-equal)
- (bfr-eval ctrex-bdd env))
- (not (equal (v2n (bfr-eval-list x env))
- (v2n (bfr-eval-list y env))))))))
- :hints(("Goal"
- :induct (always-equal-uu x y))
- '(:use ((:instance ctrex-for-always-equal-correct
- (x (and (consp x) (acl2::ubdd-fix (car x))))
- (y (and (consp y) (acl2::ubdd-fix (car y)))))
- (:instance acl2::eval-bdd-ubdd-fix
- (x (car x)))
- (:instance acl2::eval-bdd-ubdd-fix
- (x (car y))))
- :in-theory (e/d (bfr-eval bfr-eval-list v2n)
- (acl2::eval-bdd-ubdd-fix)))))
+ ;; (defthm always-equal-uu-correct
+ ;; (mv-let (always-equal ctrex-bdd)
+ ;; (always-equal-uu x y)
+ ;; (implies (and (not (bfr-mode)))
+ ;; (and (implies always-equal
+ ;; (equal (bfr-list->u x env)
+ ;; (bfr-list->u y env)))
+ ;; (implies (and (not always-equal)
+ ;; (bfr-eval ctrex-bdd env))
+ ;; (not (equal (bfr-list->u x env)
+ ;; (bfr-list->u y env)))))))
+ ;; :hints(("Goal"
+ ;; :induct (always-equal-uu x y))
+ ;; '(:use ((:instance ctrex-for-always-equal-correct
+ ;; (x (and (consp x) (acl2::ubdd-fix (car x))))
+ ;; (y (and (consp y) (acl2::ubdd-fix (car y)))))
+ ;; (:instance acl2::eval-bdd-ubdd-fix
+ ;; (x (car x)))
+ ;; (:instance acl2::eval-bdd-ubdd-fix
+ ;; (x (car y))))
+ ;; :in-theory (e/d (bfr-eval bfr-eval-list)
+ ;; (acl2::eval-bdd-ubdd-fix)))))
(defthm always-equal-ss-under-hyp-correct
- (mv-let (always-equal ctrex-bdd)
+ (mv-let (always-equal ctrex)
(always-equal-ss-under-hyp x y hyp)
(and (implies (and always-equal
(not (bfr-mode))
(acl2::ubddp hyp)
(bfr-eval hyp env))
- (equal (v2i (bfr-eval-list x env))
- (v2i (bfr-eval-list y env))))
+ (equal (bfr-list->s x env)
+ (bfr-list->s y env)))
(implies (and (not (bfr-mode))
(bfr-eval ctrex-bdd env)
(acl2::ubddp hyp)
(not always-equal))
- (and (bfr-eval hyp env)
- (not (equal (v2i (bfr-eval-list x env))
- (v2i (bfr-eval-list y env))))))))
- :hints(("Goal" :in-theory (e/d* (bfr-eval-list bfr-eval v2i)
- (ctrex-for-always-equal-under-hyp-correct1
- ctrex-for-always-equal-under-hyp-correct2
- ctrex-for-always-equal-under-hyp
-; bfr-eval-when-qs-subset
+ (and (bfr-eval hyp ctrex)
+ (not (equal (bfr-list->s x ctrex)
+ (bfr-list->s y ctrex)))))))
+ :hints(("Goal" :in-theory (e/d* (ACL2::EQUAL-LOGCONS-STRONG
+ bfr-list->s bfr-eval scdr s-endp)
+ (ctrex-for-always-equal-under-hyp
+ logcons
+ ctrex-for-always-equal-under-hyp-correct
+ ctrex-for-always-equal-under-hyp-flag-correct
default-cdr default-car
- natp-ash-1 default-+-1 default-+-2
- hyp-eval-lemma
- acl2::eval-bdd-ubdd-fix
-;; bfr-eval-when-not-consp
-;; bfr-eval-of-non-consp-cheap
-;; bfr-eval-when-non-consp-values
+ default-+-1 default-+-2
(:definition always-equal-ss-under-hyp)
(:rules-of-class :type-prescription
:here))
((:type-prescription bfr-eval)
(:type-prescription ash)
- (:type-prescription v2i)))
+ (:type-prescription bfr-list->s)
+ (:type-prescription acl2::eval-bdd)))
:induct (always-equal-ss-under-hyp x y hyp)
:expand ((always-equal-ss-under-hyp x y hyp)
(always-equal-ss-under-hyp x nil hyp)
(always-equal-ss-under-hyp nil y hyp)
(always-equal-ss-under-hyp nil nil hyp)))
- '(:use ((:instance ctrex-for-always-equal-under-hyp-correct1
- (x (and (consp x) (acl2::ubdd-fix (car x))))
- (y (and (consp y) (acl2::ubdd-fix (car y)))))
- (:instance ctrex-for-always-equal-under-hyp-correct2
- (x (and (consp x) (acl2::ubdd-fix (car x))))
- (y (and (consp y) (acl2::ubdd-fix (car y)))))
- (:instance acl2::eval-bdd-ubdd-fix
- (x (car x)))
- (:instance acl2::eval-bdd-ubdd-fix
- (x (car y))))))
+ (and stable-under-simplificationp
+ (b* ((call (acl2::find-call-lst 'ctrex-for-always-equal-under-hyp
+ clause))
+ ((when call)
+ `(:use ((:instance ctrex-for-always-equal-under-hyp-correct
+ (x ,(second call)) (y ,(third call)) (hyp ,(fourth call)))
+ (:instance ctrex-for-always-equal-under-hyp-flag-correct
+ (x ,(second call)) (y ,(third call)) (hyp ,(fourth call)))))))
+ nil)))
:rule-classes ((:rewrite :match-free :all)))))
-
+
;; (local
@@ -534,12 +525,14 @@
+(include-book "ctrex-utils")
-
-(defun always-equal-of-numbers (a b hyp)
+(defun always-equal-of-numbers (a b hyp config bvar-db state)
(declare (xargs :guard (and (not (bfr-mode))
+ (glcp-config-p config)
(general-numberp a)
- (general-numberp b))))
+ (general-numberp b))
+ :stobjs (bvar-db state)))
(b* (((mv arn ard ain aid)
(general-number-components a))
((mv brn brd bin bid)
@@ -558,19 +551,32 @@
((mv requal rctrex)
(always-equal-ss-under-hyp arn brn uhyp))
((unless requal)
- (prog2$ (cw "reals, ctrex: ~x0~%" rctrex)
- (g-if (mk-g-boolean rctrex)
- nil
- (g-apply 'equal (gl-list a b)))))
+ (ec-call
+ (glcp-print-single-ctrex rctrex
+ "Error:"
+ "ALWAYS-EQUAL violation"
+ config bvar-db state))
+ (g-apply 'equal (gl-list a b)))
((mv iequal ictrex)
(always-equal-ss-under-hyp ain bin uhyp))
((unless iequal)
- (prog2$ (cw "imags, ctrex: ~x0~%" rctrex)
- (g-if (mk-g-boolean ictrex)
- nil
- (g-apply 'equal (gl-list a b))))))
+ (ec-call
+ (glcp-print-single-ctrex ictrex
+ "Error:"
+ "ALWAYS-EQUAL violation"
+ config bvar-db state))
+ (g-apply 'equal (gl-list a b))))
t))
+(defthm deps-of-always-equal-of-numbers
+ (implies (and (not (gobj-depends-on k p a))
+ (not (gobj-depends-on k p b))
+ (general-numberp a)
+ (general-numberp b))
+ (not (gobj-depends-on
+ k p (always-equal-of-numbers a b hyp config bvar-db state))))
+ :hints(("Goal" :in-theory (enable always-equal-of-numbers))))
+
;; (local (defthm always-equal-of-numbers-gobjectp
;; (implies (and (not (bfr-mode))
;; (gobjectp a)
@@ -616,32 +622,48 @@
(general-numberp a)
(general-numberp b)
(bfr-eval hyp (car env)))
- (equal (eval-g-base (always-equal-of-numbers a b hyp) env)
+ (equal (eval-g-base (always-equal-of-numbers
+ a b hyp config bvar-db state) env)
(equal (eval-g-base a env)
(eval-g-base b env))))
- :hints(("Goal" :in-theory (enable* (:ruleset general-object-possibilities)
- ctrex-for-always-equal-correct
- boolean-list-bfr-eval-list)))))
+ :hints(("Goal" :in-theory (e/d* ((:ruleset general-object-possibilities)
+ ctrex-for-always-equal-correct
+ boolean-list-bfr-eval-list)
+ (bfr-sat-bdd-unsat bfr-list->s))))))
(in-theory (disable always-equal-of-numbers))
-(defun always-equal-of-booleans (a b hyp)
+(defun always-equal-of-booleans (a b hyp config bvar-db state)
(declare (xargs :guard (and (not (bfr-mode))
+ (glcp-config-p config)
(general-booleanp a)
- (general-booleanp b))))
- (let ((av (general-boolean-value a))
- (bv (general-boolean-value b)))
- (or (hqual av bv)
- (let* ((av (acl2::ubdd-fix av))
- (bv (acl2::ubdd-fix bv)))
- (or (hqual av bv)
- (g-if
- (mk-g-boolean
- (ctrex-for-always-equal-under-hyp
- av bv (acl2::ubdd-fix hyp)))
- nil
- (g-apply 'equal (gl-list a b))))))))
+ (general-booleanp b))
+ :stobjs (bvar-db state)))
+ (b* ((av (general-boolean-value a))
+ (bv (general-boolean-value b))
+ ((when (hqual av bv)) t)
+ (av (acl2::ubdd-fix av))
+ (bv (acl2::ubdd-fix bv))
+ ((when (hqual av bv)) t)
+ ((mv unequal ctrex) (ctrex-for-always-equal-under-hyp
+ av bv (acl2::ubdd-fix hyp)))
+ ((unless unequal) t))
+ (ec-call
+ (glcp-print-single-ctrex ctrex
+ "Error:"
+ "ALWAYS-EQUAL violation"
+ config bvar-db state))
+ (g-apply 'equal (gl-list a b))))
+
+(defthm deps-of-always-equal-of-booleans
+ (implies (and (not (gobj-depends-on k p a))
+ (not (gobj-depends-on k p b))
+ (general-booleanp a)
+ (general-booleanp b))
+ (not (gobj-depends-on
+ k p (always-equal-of-booleans a b hyp config bvar-db state))))
+ :hints(("Goal" :in-theory (enable always-equal-of-booleans))))
;; (local (defthm always-equal-of-booleans-gobjectp
;; (implies (and (not (bfr-mode))
@@ -652,39 +674,50 @@
;; (bfr-p hyp))
;; (gobjectp (always-equal-of-booleans a b hyp)))))
+(local (defthm ubdd-fixes-unequal
+ (implies (not (equal (acl2::eval-bdd a env) (acl2::eval-bdd b env)))
+ (not (equal (acl2::ubdd-fix a) (acl2::ubdd-fix b))))
+ :hints (("goal" :in-theory (disable ACL2::EVAL-BDD-UBDD-FIX)
+ :use ((:instance ACL2::EVAL-BDD-UBDD-FIX (x a)
+ (acl2::env gl::env))
+ (:instance ACL2::EVAL-BDD-UBDD-FIX (x b)
+ (acl2::env gl::env)))))))
+
(local (defthm always-equal-of-booleans-correct
(implies (and (not (bfr-mode))
(general-booleanp a)
(general-booleanp b)
(bfr-eval hyp (car env)))
- (equal (eval-g-base (always-equal-of-booleans a b hyp) env)
+ (equal (eval-g-base (always-equal-of-booleans a b hyp config bvar-db state) env)
(equal (eval-g-base a env)
(eval-g-base b env))))
:hints(("Goal" :in-theory (e/d (bfr-eval)
- (ctrex-for-always-equal-under-hyp-correct1
- acl2::eval-bdd-ubdd-fix))
- :use ((:instance ctrex-for-always-equal-under-hyp-correct1
- (x (acl2::ubdd-fix (general-boolean-value a)))
- (y (acl2::ubdd-fix (general-boolean-value b)))
- (hyp (acl2::ubdd-fix hyp))
- (env (car env)))
- (:instance acl2::eval-bdd-ubdd-fix
- (x (general-boolean-value a))
- (env (car env)))
- (:instance acl2::eval-bdd-ubdd-fix
- (x (general-boolean-value b))
- (env (car env))))))))
+ (ctrex-for-always-equal-under-hyp-correct
+ ctrex-for-always-equal-under-hyp-flag-correct)))
+ (and stable-under-simplificationp
+ (b* ((call (acl2::find-call-lst 'ctrex-for-always-equal-under-hyp
+ clause))
+ ((when call)
+ `(:use ((:instance ctrex-for-always-equal-under-hyp-correct
+ (x ,(second call)) (y ,(third call))
+ (hyp ,(fourth call)) (env (car env)))
+ (:instance ctrex-for-always-equal-under-hyp-flag-correct
+ (x ,(second call)) (y ,(third call))
+ (hyp ,(fourth call)))))))
+ nil)))))
(in-theory (disable always-equal-of-booleans))
-(defun g-always-equal-core (a b hyp clk)
+(defun g-always-equal-core (a b hyp clk config bvar-db state)
(declare (xargs :measure (+ (acl2-count a) (Acl2-count b))
:guard (and (not (bfr-mode))
- (natp clk))
- :verify-guards nil))
+ (natp clk)
+ (glcp-config-p config))
+ :verify-guards nil
+ :stobjs (bvar-db state)))
(cond ((hqual a b) t)
((and (general-concretep a) (general-concretep b))
(hons-equal (general-concrete-obj a) (general-concrete-obj b)))
@@ -697,12 +730,12 @@
(cond
((general-booleanp a)
(and (general-booleanp b)
- (always-equal-of-booleans a b hyp)))
+ (always-equal-of-booleans a b hyp config bvar-db state)))
((general-booleanp b) nil)
((general-numberp a)
(and
(general-numberp b)
- (always-equal-of-numbers a b hyp)))
+ (always-equal-of-numbers a b hyp config bvar-db state)))
((general-numberp b) nil)
((general-consp a)
(and
@@ -711,12 +744,12 @@
(g-always-equal-core
(general-consp-car a)
(general-consp-car b)
- hyp clk)))
+ hyp clk config bvar-db state)))
(if (eq car-equal t)
(g-always-equal-core
(general-consp-cdr a)
(general-consp-cdr b)
- hyp clk)
+ hyp clk config bvar-db state)
(g-if car-equal
(g-apply 'equal (gl-list a b))
nil)))))
@@ -728,8 +761,8 @@
(then (g-ite->then b))
(else (g-ite->else b)))
(g-if test
- (g-always-equal-core a then hyp clk)
- (g-always-equal-core a else hyp clk)))))
+ (g-always-equal-core a then hyp clk config bvar-db state)
+ (g-always-equal-core a else hyp clk config bvar-db state)))))
(t (g-apply 'equal (gl-list a b)))))
((eq (tag a) :g-ite)
(if (zp clk)
@@ -738,8 +771,8 @@
(then (g-ite->then a))
(else (g-ite->else a)))
(g-if test
- (g-always-equal-core then b hyp clk)
- (g-always-equal-core else b hyp clk)))))
+ (g-always-equal-core then b hyp clk config bvar-db state)
+ (g-always-equal-core else b hyp clk config bvar-db state)))))
(t (g-apply 'equal (gl-list a b)))))
@@ -750,20 +783,20 @@
;; (t (pattern-match a
;; ((g-ite test then else)
;; (g-if test
-;; (g-always-equal-core then b hyp clk)
-;; (g-always-equal-core else b hyp clk)))
+;; (g-always-equal-core then b hyp clk config bvar-db state)
+;; (g-always-equal-core else b hyp clk config bvar-db state)))
;; (& (pattern-match b
;; ((g-ite test then else)
;; (g-if test
-;; (g-always-equal-core a then hyp clk)
-;; (g-always-equal-core a else hyp clk)))
+;; (g-always-equal-core a then hyp clk config bvar-db state)
+;; (g-always-equal-core a else hyp clk config bvar-db state)))
;; ((g-var &)
;; (or (equal a b)
;; (g-apply 'equal (list a b))))
;; ((g-apply fn args)
;; (pattern-match a
;; ((g-apply !fn aargs)
-;; (g-if (g-always-equal-core aargs args hyp clk)
+;; (g-if (g-always-equal-core aargs args hyp clk config bvar-db state)
;; t
;; (g-apply 'equal (list a b))))
;; (& (g-apply 'equal (list a b)))))
@@ -788,12 +821,12 @@
;; (g-always-equal-core
;; (general-consp-car a)
;; (general-consp-car b)
-;; hyp clk)))
+;; hyp clk config bvar-db state)))
;; (if (eq car-equal t)
;; (g-always-equal-core
;; (general-consp-cdr a)
;; (general-consp-cdr b)
-;; hyp clk)
+;; hyp clk config bvar-db state)
;; (g-if car-equal
;; (g-apply 'equal (list a b))
;; nil)))))
@@ -802,7 +835,7 @@
;; (defthm g-always-equal-core-gobjectp
;; (implies (and (not (bfr-mode))
;; (bfr-p hyp))
-;; (gobjectp (g-always-equal-core x y hyp clk)))
+;; (gobjectp (g-always-equal-core x y hyp clk config bvar-db state)))
;; :hints (("Goal" :in-theory (e/d* (booleanp-gobjectp)
;; ((:definition g-always-equal-core)
;; general-boolean-value
@@ -819,9 +852,9 @@
;; (:rules-of-class :type-prescription :here)
;; equal-of-booleans-rewrite
;; (force)))
-;; :induct (g-always-equal-core x y hyp clk)
-;; :expand ((g-always-equal-core x y hyp clk)
-;; (g-always-equal-core x x hyp clk))
+;; :induct (g-always-equal-core x y hyp clk config bvar-db state)
+;; :expand ((g-always-equal-core x y hyp clk config bvar-db state)
+;; (g-always-equal-core x x hyp clk config bvar-db state))
;; :do-not-induct t)))
@@ -836,7 +869,7 @@
(:type-prescription general-numberp)
(:type-prescription acl2::ubddp)
(:type-prescription general-concretep)
- (:type-prescription =-uu)
+ (:type-prescription bfr-=-uu)
;; (:type-prescription assume-true-under-hyp2)
;; (:type-prescription assume-false-under-hyp2)
;(:type-prescription assume-true-under-hyp)
@@ -855,6 +888,17 @@
(verify-guards g-always-equal-core))
+(defthm deps-of-g-always-equal-core
+ (implies (and (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y)))
+ (not (gobj-depends-on
+ k p (g-always-equal-core x y hyp clk config bvar-db state))))
+ :hints('(:in-theory (e/d ((:i g-always-equal-core))
+ (gobj-depends-on
+ general-concrete-obj-when-consp-for-eval-g-base)))
+ (acl2::just-induct-and-expand
+ (g-always-equal-core x y hyp clk config bvar-db state))))
+
(encapsulate nil
(local (include-book "clause-processors/just-expand" :dir :system))
@@ -879,7 +923,7 @@
mk-g-boolean-correct-for-eval-g-base
geval-g-if-marker-eval-g-base
geval-g-or-marker-eval-g-base
-
+
general-concretep-not-general-consp
general-concretep-not-general-booleanp
general-concretep-not-general-numberp
@@ -897,45 +941,47 @@
booleanp-compound-recognizer
gtests-g-test-marker
-
+
bfr-eval-bfr-binary-and
bfr-eval-bfr-not
bfr-eval-bfr-binary-or
gtests-nonnil-correct-for-eval-g-base
- hyp-fix-correct
+ hyp-fix-correct
always-equal-of-numbers-correct
always-equal-of-booleans-correct
- (:type-prescription v2i)
-
+
bfr-eval-g-hyp-marker
cons-equal
eval-g-base-apply-of-equal-kwote-lst
-
+ eval-g-base-list-of-gl-cons
+
general-concrete-obj-of-atomic-constants
general-concretep-of-atomic-constants
hons-equal acl2::always-equal
(:induction g-always-equal-core))
((general-concrete-obj)
- (general-concretep)))))
+ (general-concretep)
+ (kwote-lst)))))
(defthm g-always-equal-core-correct
(implies (and (not (bfr-mode))
(bfr-eval hyp (car env)))
- (equal (eval-g-base (g-always-equal-core x y hyp clk) env)
+ (equal (eval-g-base (g-always-equal-core x y hyp clk config bvar-db state) env)
(acl2::always-equal (eval-g-base x env)
(eval-g-base y env))))
:hints ((acl2::just-induct-and-expand
- (g-always-equal-core x y hyp clk))
+ (g-always-equal-core x y hyp clk config bvar-db state))
(and stable-under-simplificationp
- '(:expand ((g-always-equal-core x y hyp clk)
- (g-always-equal-core x x hyp clk)
- (g-always-equal-core x y hyp clk)
- (g-always-equal-core x x hyp clk)
+ '(:expand ((g-always-equal-core x y hyp clk config bvar-db state)
+ (g-always-equal-core x x hyp clk config bvar-db state)
+ (g-always-equal-core x y hyp clk config bvar-db state)
+ (g-always-equal-core x x hyp clk config bvar-db state)
(eval-g-base x env)
(eval-g-base y env)
(eval-g-base nil env)
- (eval-g-base t env))
+ (eval-g-base t env)
+ (eval-g-base-list nil env))
:do-not-induct t)))))
(in-theory (disable g-always-equal-core))
diff -Nru acl2-6.2/books/centaur/gl/auto-bindings.lisp acl2-6.3/books/centaur/gl/auto-bindings.lisp
--- acl2-6.2/books/centaur/gl/auto-bindings.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/auto-bindings.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,21 +1,38 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
; auto-bindings.lisp
-; Original author: Jared Davis
+;
+; Original author: Jared Davis
(in-package "GL")
-(include-book "gl-doc-string")
(include-book "gobject-types")
(include-book "../misc/numlist")
(include-book "tools/bstar" :dir :system)
(program)
-(defdoc auto-bindings
- ":Doc-Section ACL2::GL
-Simplified shape specifiers for ~c[:g-bindings].~/
+(defxdoc auto-bindings
+ :parents (reference shape-specs)
+ :short "Simplified shape specifiers for @(':g-bindings')."
+ :long "The @('auto-bindings') function lets you create simple @(see
+shape-specs) in an easy way. Here is an example:
-The ~c[auto-bindings] function lets you create simple ~il[shape-specs] in an
-easy way. Here is an example:
-
-~bv[]
+@({
(def-gl-thm foo
...
:g-bindings (auto-bindings ; expands to:
@@ -27,25 +44,32 @@
(:nat c-bus 128)) ; }
(:nat fixup-bits 4) ; g-number with indices 415-420
))
-~ev[]
+})
+
+This is good because
+
+
+
+you don't have to think about sign bits and do a bunch of stupid arithmetic
+to figure out the next free index, and
+
+you can painlessly etend the bindings when you want to add a new variable
+without having to update a bunch of indices.
-This is good because (1) you don't have to think about sign bits and do a bunch
-of stupid arithmetic to figure out the next free index, and (2) you can
-painlessly etend the bindings when you want to add a new variable without
-having to update a bunch of indices.~/
+
-Auto-bindings are more limited than shape-specs. Except for the special
-~c[:mix] command, you can only write:
+Auto-bindings are more limited than shape-specs. Except for the special
+@(':mix') command, you can only write:
-~bv[]
+@({
(:bool var) -- expands to a g-boolean shape-specifier
(:int var n) -- expands to a g-integer with n bits (signed 2's complement)
(:nat var n) -- equivalent to (:int var (+ 1 n))
-~ev[]
+})
-The ~c[:mix] command cannot be nested and all of its elements must be numbers
-with the same size. That is, think of a ~c[:nat] as just an abbreviation for
-an ~c[:int] with one more variable.~/")
+The @(':mix') command cannot be nested and all of its elements must be
+numbers with the same size. That is, think of a @(':nat') as just an
+abbreviation for an @(':int') with one more variable.
")
(defun auto-bind-xlate (x inside-mix-p)
;; Syntax check that X is (:nat ...), (:int ...), or (:bool ...)
diff -Nru acl2-6.2/books/centaur/gl/bfr-aig-bddify.acl2 acl2-6.3/books/centaur/gl/bfr-aig-bddify.acl2
--- acl2-6.2/books/centaur/gl/bfr-aig-bddify.acl2 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/bfr-aig-bddify.acl2 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,22 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(set-waterfall-parallelism nil)
diff -Nru acl2-6.2/books/centaur/gl/bfr-aig-bddify.lisp acl2-6.3/books/centaur/gl/bfr-aig-bddify.lisp
--- acl2-6.2/books/centaur/gl/bfr-aig-bddify.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/bfr-aig-bddify.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,9 +1,28 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
(include-book "bfr-sat")
-(include-book "gl-doc-string")
-(include-book "../aig/bddify-correct")
+(include-book "../aig/bddify")
+(local (include-book "../aig/bddify-correct"))
(local (include-book "../aig/eval-restrict"))
@@ -21,7 +40,7 @@
(declare (xargs :guard t))
(bfr-case
:bdd (mv nil nil nil) ;; fail
- :aig
+ :aig
(b* ((vars (acl2::aig-vars prop))
(bindings (vars-to-bdd-bindings vars 0))
((mv bdd & exact)
@@ -33,8 +52,8 @@
-(defthm ubddp-val-alistp-vars-to-bdd-bindings
- (acl2::ubddp-val-alistp (vars-to-bdd-bindings x n)))
+(local (defthm ubddp-val-alistp-vars-to-bdd-bindings
+ (acl2::ubddp-val-alistp (vars-to-bdd-bindings x n))))
(local (include-book "arithmetic/top-with-meta" :dir :system))
@@ -58,7 +77,8 @@
(equal (nth n (vars-to-bdd-env vars aig-env))
(if (hons-assoc-equal (nth n vars) aig-env)
(cdr (hons-assoc-equal (nth n vars) aig-env))
- t))))
+ t)))
+ :hints(("Goal" :in-theory (enable nth))))
(defthm len-member-equal
(implies (member-equal x vars)
@@ -118,18 +138,19 @@
(acl2::vars (vars-to-bdd-env (acl2::aig-vars prop) env)))))))
-(defmacro gl-aig-bddify-mode ()
- ":Doc-section ACL2::GL
-Use experimental AIG-based symbolic simulation in GL.~/
-This macro produces an event which sets the GL reasoning mode to use AIGs.
-This is a new, experimental feature under development.~/~/"
- '(progn (acl2::defattach bfr-mode bfr-aig)
- (acl2::defattach bfr-counterex-mode bfr-counterex-bdd)
- (acl2::defattach
- (bfr-sat bfr-sat-bddify)
- :hints (("goal" :in-theory '(bfr-sat-bddify-unsat))
- (and stable-under-simplificationp
- '(:in-theory (enable bfr-sat-bddify)))))))
+(defsection gl-aig-bddify-mode
+ :parents (modes reference)
+ :short "GL: use AIGs as the Boolean function representation and solve queries
+by transforming them to BDDs."
+
+ (defmacro gl-aig-bddify-mode ()
+ '(progn (acl2::defattach bfr-mode bfr-aig)
+ (acl2::defattach bfr-counterex-mode bfr-counterex-bdd)
+ (acl2::defattach
+ (bfr-sat bfr-sat-bddify)
+ :hints (("goal" :in-theory '(bfr-sat-bddify-unsat))
+ (and stable-under-simplificationp
+ '(:in-theory (enable bfr-sat-bddify))))))))
(local (gl-aig-bddify-mode))
diff -Nru acl2-6.2/books/centaur/gl/bfr-param.lisp acl2-6.3/books/centaur/gl/bfr-param.lisp
--- acl2-6.2/books/centaur/gl/bfr-param.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/bfr-param.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,127 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "GL")
+(include-book "bvecs")
+(include-book "centaur/ubdds/param" :dir :system)
+(include-book "centaur/aig/misc" :dir :system)
+(local (include-book "centaur/aig/eval-restrict" :dir :system))
+
+(local (in-theory (disable acl2::append-of-nil)))
+
+
+(defun bfr-list-to-param-space (p x)
+ (declare (xargs :guard t
+ :guard-hints ('(:in-theory (enable bfr-to-param-space
+ bfr-list-to-param-space))))
+ (ignorable p))
+ (mbe :logic (if (atom x)
+ nil
+ (cons (bfr-to-param-space p (car x))
+ (bfr-list-to-param-space p (cdr x))))
+ :exec (if (atom x)
+ nil
+ (bfr-case :bdd (acl2::to-param-space-list p x)
+ :aig (acl2::aig-restrict-list
+ x (acl2::aig-extract-iterated-assigns-alist p 10))))))
+
+
+(defthm bfr-eval-list-to-param-space-list
+ (implies (bfr-eval p env)
+ (equal (bfr-eval-list (bfr-list-to-param-space p x)
+ (bfr-param-env p env))
+ (bfr-eval-list x env)))
+ :hints(("Goal" :in-theory (e/d (bfr-eval-list
+ bfr-list-to-param-space)
+ (bfr-param-env)))))
+
+(defthm bfr-eval-list-to-param-space-list-with-unparam-env
+ (implies (syntaxp (not (and (consp env)
+ (eq (car env) 'bfr-param-env))))
+ (equal (bfr-eval-list (bfr-list-to-param-space p x)
+ env)
+ (bfr-eval-list x (bfr-unparam-env p env))))
+ :hints(("Goal" :in-theory (e/d (bfr-eval-list
+ bfr-list-to-param-space)
+ (bfr-param-env)))))
+
+(defthm bfr-list->s-to-param-space-list
+ (implies (bfr-eval p env)
+ (equal (bfr-list->s (bfr-list-to-param-space p x)
+ (bfr-param-env p env))
+ (bfr-list->s x env)))
+ :hints(("Goal" :in-theory (e/d (bfr-list->s
+ scdr s-endp
+ default-car
+ bfr-list-to-param-space)
+ (bfr-to-param-space
+ bfr-param-env))
+ :induct (bfr-list-to-param-space p x)
+ :expand ((bfr-list->s x env)))))
+
+(defthm bfr-list->s-to-param-space-list-with-unparam-env
+ (implies (syntaxp (not (and (consp env)
+ (eq (car env) 'bfr-param-env))))
+ (equal (bfr-list->s (bfr-list-to-param-space p x)
+ env)
+ (bfr-list->s x (bfr-unparam-env p env))))
+ :hints(("Goal" :in-theory (e/d (bfr-list->s
+ scdr s-endp
+ default-car
+ bfr-list-to-param-space)
+ (bfr-to-param-space
+ bfr-param-env))
+ :induct (bfr-list-to-param-space p x)
+ :expand ((:free (env) (bfr-list->s x env))))))
+
+(defthm bfr-list->u-to-param-space-list
+ (implies (bfr-eval p env)
+ (equal (bfr-list->u (bfr-list-to-param-space p x)
+ (bfr-param-env p env))
+ (bfr-list->u x env)))
+ :hints(("Goal" :in-theory (e/d (bfr-list->u scdr s-endp
+ ;; bfr-eval
+ bfr-list-to-param-space)
+ (bfr-to-param-space
+ bfr-param-env)))))
+
+(defthm bfr-list->u-to-param-space-list-with-unparam-env
+ (implies (syntaxp (not (and (consp env)
+ (eq (car env) 'bfr-param-env))))
+ (equal (bfr-list->u (bfr-list-to-param-space p x)
+ env)
+ (bfr-list->u x (bfr-unparam-env p env))))
+ :hints(("Goal" :in-theory (e/d (bfr-list->u scdr s-endp
+ ;; bfr-eval
+ bfr-list-to-param-space)
+ (bfr-to-param-space
+ bfr-param-env)))))
+
+(defund genv-param (p env)
+ (declare (xargs :guard (consp env))
+ (ignorable p))
+ (cons (bfr-param-env p (car env))
+ (cdr env)))
+
+(defund genv-unparam (p env)
+ (declare (xargs :guard (consp env))
+ (ignorable p))
+ (cons (bfr-unparam-env p (car env))
+ (cdr env)))
diff -Nru acl2-6.2/books/centaur/gl/bfr-sat.lisp acl2-6.3/books/centaur/gl/bfr-sat.lisp
--- acl2-6.2/books/centaur/gl/bfr-sat.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/bfr-sat.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,78 +1,25 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "bfr")
-(include-book "gl-doc-string")
-
-(defdoc experimental-aig-reasoning
- ":Doc-section ACL2::GL
- Note about GL's experimental AIG reasoning mode.~/
-
- By default, GL operates on BDD-based data structures and resolves Boolean
-reasoning questions using BDD operations. However, it also has some support
-for a different mode that uses And-Inverter graphs instead.
-Using AIG mode requires a way to solve Boolean satisfiability problems on AIGs.
-We provide one method, of dubious utility, which is to transform the AIG into a
-BDD. This mode may be used by including the book \"bfr-aig-bddify\" and then
-running (GL-AIG-BDDIFY-MODE), which is an ACL2 event. (To return to the
-default BDD-only mode, simply run (GL-BDD-MODE).) We describe below the
-mechanisms provided for putting GL into different reasoning modes. These
-mechanisms may be used, by an adventurous user, to attach an external SAT
-solver and use that to solve AIG satisfiability queries, avoiding the necessity
-of the AIG to BDD transformation. ~/
-
-GL can be put into different modes using ~il[defattach]. There are several
-functions that need to have proper attachments in order for GL to function;
-when the GL library is loaded, they are set up to a default configuration in
-which GL will use BDD-based reasoning.
-
-The functions that need attachments follow. Here, BFR stands for Boolean
-function representation.
-
- * BFR-MODE: 0-ary with no constraints. This detemines whether the Boolean
-function components in the symbolic object representation are BDDs or AIGs, and
-thus the functions used to combine them. E.g., the definition of BFR-NOT
-is (basically):
-
-~bv[]
- (if (bfr-mode) (aig-not x) (q-not x)).
-~ev[]
-
-Similarly, BFR-EVAL either applies EVAL-BDD or AIG-EVAL, depending on BFR-MODE.
-
-By default the function BFR-BDD (which returns NIL) is attached to BFR-MODE,
-and thus BFR-NOT uses the BDD operation Q-NOT. To use AIGs instead, attach
-BFR-AIG, which returns T.
-
- * BFR-SAT: Unary, returning three values: SAT, SUCCEEDED, CTREX. The main
-constraint of BFR-SAT is that if it returns SAT=NIL and SUCCEEDED=T, then
-BFR-EVAL of the input on any environment must be NIL, i.e., the input must be
-an unsatisfiable BDD or AIG (depending on the BFR-MODE.) The CTREX value
-should be a counterexample in the case of a SAT result, represented either as a
-BDD or an alist mapping variables to Boolean values; see below under
-BFR-COUNTEREX-MODE.
-
-To satisfy the constraint in the BDD case, it suffices to simply check whether
-the input BDD is NIL; if so, it is satisfiable, and otherwise, it isn't. This
-method is implemented as BFR-SAT-BDD, which is the default attachment of
-BFR-SAT. For AIG mode, we provide an attachment BFR-SAT-BDDIFY which solves an
-AIG satisfiability query by transforming the input AIG into a BDD. However,
-one might instead hook up a SAT solver into ACL2 so that it can take an AIG as
-input. Given a way of calling such an external tool, it would not be difficult
-to produce a function that conforms to the constraint described above. :-)
-
- * BFR-COUNTEREX-MODE: 0-ary, no constraints. This says whether the
-counterexample value sometimes returned by BFR-SAT is in the form of a BDD or
-an association list. If it is set up wrong, then output in case of a
-counterexample will be garbled. In both the default BDD mode and in the AIG
-BDDIFY mode provided, the counterexample is in the form of a BDD, and so we
-attach BFR-COUNTEREX-BDD by default. However, if an external SAT solver is
-used, then there will likely be a single assignment returned, which might more
-conveniently be provided as an alist. Then one would instead attach
-BFR-COUNTEREX-ALIST.
-~/
-")
(encapsulate
(((bfr-sat *) => (mv * * *)))
@@ -112,10 +59,13 @@
:use ((:instance acl2::eval-bdd-ubdd-fix
(x prop))))))
+
(acl2::defattach
(bfr-sat bfr-sat-bdd
:hints (("goal" :in-theory '(bfr-sat-bdd-unsat)))))
+(in-theory (disable bfr-sat-bdd-unsat bfr-sat-unsat))
+
;; In the AIG case, the counterexample returned is either an alist giving a
@@ -153,3 +103,124 @@
(if (eq (bfr-counterex-mode) t) ;; alist
ctrex
(to-satisfying-assign assign ctrex)))
+
+
+
+
+
+(defund bfr-known-value (x)
+ (declare (xargs :guard t))
+ (bfr-case :bdd (and x t)
+ :aig (acl2::aig-eval x nil)))
+
+
+(defsection bfr-constcheck
+ ;; Bfr-constcheck: use SAT (or examine the BDD) to determine whether x is
+ ;; constant, and if so return that constant.
+ (defund bfr-constcheck (x)
+ (declare (xargs :guard t))
+ (if (bfr-known-value x)
+ (b* (((mv sat ok &) (bfr-sat (bfr-not x))))
+ (if (or sat (not ok))
+ x
+ t))
+ (b* (((mv sat ok &) (bfr-sat x)))
+ (if (or sat (not ok))
+ x
+ nil))))
+
+ (local (in-theory (enable bfr-constcheck)))
+
+ (defthm bfr-eval-of-bfr-constcheck
+ (equal (bfr-eval (bfr-constcheck x) env)
+ (bfr-eval x env))
+ :hints (("goal" :use ((:instance bfr-sat-unsat
+ (prop x))
+ (:instance bfr-sat-unsat
+ (prop (bfr-not x)))))))
+
+ (defthm pbfr-depends-on-of-bfr-constcheck
+ (implies (not (pbfr-depends-on k p x))
+ (not (pbfr-depends-on k p (bfr-constcheck x))))))
+
+(defsection bfr-constcheck-pathcond
+ ;; Bfr-constcheck: use SAT (or examine the BDD) to determine whether x is
+ ;; constant, and if so return that constant.
+ (defund bfr-constcheck-pathcond (x pathcond)
+ (declare (xargs :guard t))
+ (b* (((mv sat ok &) (bfr-sat (bfr-and pathcond x)))
+ ((unless (or sat (not ok)))
+ nil)
+ ((mv sat ok &) (bfr-sat (bfr-and pathcond (bfr-not x))))
+ ((unless (or sat (not ok)))
+ t))
+ x))
+
+ (local (in-theory (enable bfr-constcheck-pathcond)))
+
+ (defthm bfr-eval-of-bfr-constcheck-pathcond
+ (implies (bfr-eval pathcond env)
+ (equal (bfr-eval (bfr-constcheck-pathcond x pathcond) env)
+ (bfr-eval x env)))
+ :hints (("goal" :use ((:instance bfr-sat-unsat
+ (prop (bfr-and pathcond x)))
+ (:instance bfr-sat-unsat
+ (prop (bfr-and pathcond (bfr-not x))))))))
+
+ (defthm pbfr-depends-on-of-bfr-constcheck-pathcond
+ (implies (not (pbfr-depends-on k p x))
+ (not (pbfr-depends-on k p (bfr-constcheck-pathcond x pathcond))))))
+
+
+(defsection bfr-check-true
+ ;; Bfr-constcheck: use SAT (or examine the BDD) to determine whether x is
+ ;; constant, and if so return that constant.
+ (defund bfr-check-true (x)
+ (declare (xargs :guard t))
+ (if (bfr-known-value x)
+ (b* (((mv sat ok &) (bfr-sat (bfr-not x))))
+ (if (or sat (not ok))
+ x
+ t))
+ x))
+
+ (local (in-theory (enable bfr-check-true)))
+
+ (defthm bfr-eval-of-bfr-check-true
+ (equal (bfr-eval (bfr-check-true x) env)
+ (bfr-eval x env))
+ :hints (("goal" :use ((:instance bfr-sat-unsat
+ (prop x))
+ (:instance bfr-sat-unsat
+ (prop (bfr-not x)))))))
+
+ (defthm pbfr-depends-on-of-bfr-check-true
+ (implies (not (pbfr-depends-on k p x))
+ (not (pbfr-depends-on k p (bfr-check-true x))))))
+
+(defsection bfr-check-false
+ ;; Bfr-constcheck: use SAT (or examine the BDD) to determine whether x is
+ ;; constant, and if so return that constant.
+ (defund bfr-check-false (x)
+ (declare (xargs :guard t))
+ (if (bfr-known-value x)
+ x
+ (b* (((mv sat ok &) (bfr-sat x)))
+ (if (or sat (not ok))
+ x
+ nil))))
+
+ (local (in-theory (enable bfr-check-false)))
+
+ (defthm bfr-eval-of-bfr-check-false
+ (equal (bfr-eval (bfr-check-false x) env)
+ (bfr-eval x env))
+ :hints (("goal" :use ((:instance bfr-sat-unsat
+ (prop x))
+ (:instance bfr-sat-unsat
+ (prop (bfr-not x)))))))
+
+ (defthm pbfr-depends-on-of-bfr-check-false
+ (implies (not (pbfr-depends-on k p x))
+ (not (pbfr-depends-on k p (bfr-check-false x))))))
+
diff -Nru acl2-6.2/books/centaur/gl/bfr-satlink.acl2 acl2-6.3/books/centaur/gl/bfr-satlink.acl2
--- acl2-6.2/books/centaur/gl/bfr-satlink.acl2 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/bfr-satlink.acl2 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,22 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(set-waterfall-parallelism nil)
diff -Nru acl2-6.2/books/centaur/gl/bfr-satlink.lisp acl2-6.3/books/centaur/gl/bfr-satlink.lisp
--- acl2-6.2/books/centaur/gl/bfr-satlink.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/bfr-satlink.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,8 +1,30 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; bfr-satlink.lisp
+;
+; Original authors: Sol Swords
+; Jared Davis
(in-package "GL")
(include-book "bfr-sat")
-(include-book "../aignet/aig-sat")
+(include-book "../aig/aig-sat")
(encapsulate
(((gl-satlink-config) => *))
@@ -24,22 +46,22 @@
:bdd (mv nil nil nil) ;; fail
:aig
(b* (((mv status env)
- (aignet::aig-sat prop :config (gl-satlink-config))))
+ (acl2::aig-sat prop :config (gl-satlink-config))))
(case status
(:sat (mv t t env))
(:unsat (mv nil t nil))
(t ;; failed
(mv nil nil nil))))))
-(defmacro gl-satlink-mode ()
- ":Doc-section ACL2::GL
-Use satlink to check AIGs in GL AIG mode~/
-Produces defattach events necessary to set the GL reasoning mode to use AIGs
-with Satlink.~/~/"
- '(progn
- (defattach bfr-mode bfr-aig)
- (defattach bfr-counterex-mode bfr-counterex-alist)
- (defattach (bfr-sat bfr-satlink)
- :hints(("Goal" :in-theory (enable bfr-eval))))))
-
+(defsection gl-satlink-mode
+ :parents (modes reference)
+ :short "GL: Use AIGs as the Boolean function representation and @(see
+satlink) to solve queries."
+
+ (defmacro gl-satlink-mode ()
+ '(progn
+ (defattach bfr-mode bfr-aig)
+ (defattach bfr-counterex-mode bfr-counterex-alist)
+ (defattach (bfr-sat bfr-satlink)
+ :hints(("Goal" :in-theory (enable bfr-eval)))))))
diff -Nru acl2-6.2/books/centaur/gl/bfr.lisp acl2-6.3/books/centaur/gl/bfr.lisp
--- acl2-6.2/books/centaur/gl/bfr.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/bfr.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,13 +1,36 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
(include-book "centaur/misc/universal-equiv" :dir :system)
+(include-book "centaur/misc/arith-equiv-defs" :dir :system)
+(include-book "centaur/ubdds/lite" :dir :system)
+(include-book "centaur/ubdds/param" :dir :system)
+(include-book "centaur/aig/misc" :dir :system)
+(local (include-book "centaur/aig/aig-vars" :dir :system))
+(local (include-book "centaur/misc/arith-equivs" :dir :system))
(defstub bfr-mode () t)
(defun bfr-aig () (declare (xargs :guard t)) t)
(defun bfr-bdd () (declare (xargs :guard t)) nil)
-
(defmacro bfr-case (&key aig bdd)
`(if (bfr-mode)
,aig ,bdd))
@@ -17,15 +40,13 @@
;; (if *experimental-aig-mode*
;; ',aig ',bdd)))
-(include-book "centaur/ubdds/lite" :dir :system)
-(include-book "../aig/witness")
(local (in-theory (enable booleanp)))
;; (defun bfr-p (x)
;; (declare (xargs :guard t)
;; (ignorable x))
-;; (mbe :logic
+;; (mbe :logic
;; (bfr-case :bdd (acl2::ubddp x) :aig t)
;; :exec (or (booleanp x)
;; (bfr-case :bdd (acl2::ubddp x) :aig t))))
@@ -77,7 +98,7 @@
;; `(let ,(bfr-fix-bindings vars)
;; (declare (ignorable . ,vars))
;; ,body))
-
+
(defun bfr-eval (x env)
(declare (xargs :guard t))
@@ -130,7 +151,7 @@
(defun bfr-binary-and (x y)
(declare (xargs :guard t))
- (mbe :logic
+ (mbe :logic
(bfr-case :bdd (acl2::q-binary-and x y)
:aig (acl2::aig-and x y))
:exec
@@ -166,9 +187,9 @@
(defun bfr-and-macro-logic-part (args)
;; Generates the :logic part for a bfr-and MBE call.
(declare (xargs :mode :program))
- (cond ((atom args)
+ (cond ((atom args)
t)
- ((atom (cdr args))
+ ((atom (cdr args))
(car args))
(t
`(bfr-binary-and ,(car args) ,(bfr-and-macro-logic-part (cdr args))))))
@@ -176,11 +197,11 @@
(defun bfr-and-macro-exec-part (args)
;; Generates the :exec part for a bfr-and MBE call.
(declare (xargs :mode :program))
- (cond ((atom args)
+ (cond ((atom args)
t)
- ((atom (cdr args))
+ ((atom (cdr args))
(car args))
- (t
+ (t
`(let ((bfr-and-x-do-not-use-elsewhere ,(car args)))
(and bfr-and-x-do-not-use-elsewhere
(bfr-binary-and
@@ -238,7 +259,7 @@
(cond ((and (or (quotep y) (atom y))
(or (quotep z) (atom z)))
`(bfr-ite-fn ,x ,y ,z))
- (t
+ (t
`(mbe :logic (bfr-ite-fn ,x ,y ,z)
:exec (let ((bfr-ite-x-do-not-use-elsewhere ,x))
(cond
@@ -285,20 +306,20 @@
(defun bfr-or-macro-logic-part (args)
(declare (xargs :mode :program))
- (cond ((atom args)
+ (cond ((atom args)
nil)
- ((atom (cdr args))
+ ((atom (cdr args))
(car args))
(t
`(bfr-binary-or ,(car args) ,(bfr-or-macro-logic-part (cdr args))))))
(defun bfr-or-macro-exec-part (args)
(declare (xargs :mode :program))
- (cond ((atom args)
+ (cond ((atom args)
nil)
- ((atom (cdr args))
+ ((atom (cdr args))
(car args))
- (t
+ (t
`(let ((bfr-or-x-do-not-use-elsewhere ,(car args)))
;; We could be slightly more permissive and just check
;; for any non-nil atom here. But it's probably faster
@@ -437,6 +458,17 @@
(in-theory (disable bfr-set-var (bfr-set-var) bfr-eval))
+(defcong acl2::nat-equiv equal (bfr-var n) 1
+ :hints(("Goal" :in-theory (enable bfr-var))))
+
+(defcong acl2::nat-equiv equal (bfr-lookup n env) 1
+ :hints(("Goal" :in-theory (enable bfr-lookup))))
+
+(defcong acl2::nat-equiv equal (bfr-set-var n val env) 1
+ :hints(("Goal" :in-theory (enable bfr-set-var))))
+
+
+
;;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
;; BFR reasoning clause processor
@@ -518,7 +550,7 @@
nil
(union-equal (collect-bfr-eval-vals (car clause) patterns)
(collect-bfr-eval-vals-list (cdr clause) patterns)))))
-
+
(include-book "tools/flag" :dir :system)
(flag::make-flag collect-bfr-eval-vals-flag collect-bfr-eval-vals
@@ -649,7 +681,7 @@
(defmacro bfr-reasoning (&key or-hint)
`(if stable-under-simplificationp
- (er-progn
+ (er-progn
;; This just lets us collect the clauses on which this hint is used.
,'(assign bfr-eval-cp-clauses
(cons clause
@@ -668,7 +700,7 @@
(:no-thanks t)))
cphint)))))
(value nil)))
-
+
(defmacro bfr-reasoning-mode (flg)
(if flg
@@ -735,6 +767,619 @@
+(defun bfr-to-param-space (p x)
+ (declare (xargs :guard t)
+ (ignorable p))
+ (bfr-case :bdd (acl2::to-param-space p x)
+ :aig (acl2::aig-restrict
+ x (acl2::aig-extract-iterated-assigns-alist p 10))))
+
+(defun bfr-to-param-space-weak (p x)
+ (declare (xargs :guard t)
+ (ignorable p))
+ (bfr-case :bdd (acl2::to-param-space p x)
+ :aig x))
+
+(defun bfr-from-param-space (p x)
+ (declare (xargs :guard t)
+ (ignorable p))
+ (bfr-case :bdd (acl2::from-param-space p x)
+ :aig x))
+
+
+(defun bfr-param-env (p env)
+ (declare (xargs :guard t)
+ (ignorable p))
+ (bfr-case :bdd (acl2::param-env p env)
+ :aig env))
+
+(defthmd bfr-eval-to-param-space
+ (implies (bfr-eval p env)
+ (equal (bfr-eval (bfr-to-param-space p x)
+ (bfr-param-env p env))
+ (bfr-eval x env)))
+ :hints(("Goal" :in-theory (e/d* (bfr-eval
+ bfr-to-param-space
+ acl2::param-env-to-param-space)))))
+
+(defthm bfr-eval-to-param-space-weak
+ (implies (bfr-eval p env)
+ (equal (bfr-eval (bfr-to-param-space-weak p x)
+ (bfr-param-env p env))
+ (bfr-eval x env)))
+ :hints(("Goal" :in-theory (e/d* (bfr-eval
+ bfr-to-param-space-weak
+ acl2::param-env-to-param-space)))))
+
+
+(defthm bfr-eval-from-param-space
+ (implies (bfr-eval p env)
+ (equal (bfr-eval (bfr-from-param-space p x)
+ env)
+ (bfr-eval x (bfr-param-env p env))))
+ :hints(("Goal" :in-theory (e/d* (bfr-eval bfr-param-env
+ bfr-from-param-space
+ acl2::param-env-to-param-space)))))
+
+
+
+(defun bfr-unparam-env (p env)
+ (declare (xargs :guard t))
+ (bfr-case :bdd (acl2::unparam-env p env)
+ :aig (append (acl2::aig-extract-iterated-assigns-alist p 10)
+ env)))
+
+(defthm bfr-eval-to-param-space-with-unparam-env
+ (equal (bfr-eval (bfr-to-param-space p x) env)
+ (bfr-eval x (bfr-unparam-env p env)))
+ :hints (("goal" :do-not-induct t
+ :in-theory (enable bfr-eval
+ acl2::unparam-env-to-param-space)))
+ :otf-flg t)
+
+(local (defthm aig-eval-of-extract-iterated-assigns-self
+ (implies (acl2::aig-eval x env)
+ (equal (acl2::aig-eval x
+ (append
+ (acl2::aig-extract-iterated-assigns-alist
+ x n)
+ env))
+ t))))
+
+(defthm bfr-eval-to-param-space-weak-with-unparam-env
+ (implies (not (bfr-eval x (bfr-unparam-env x env)))
+ (not (bfr-eval (bfr-to-param-space-weak x x) env)))
+ :hints(("Goal" :in-theory (e/d (bfr-eval bfr-to-param-space-weak
+ acl2::unparam-env-to-param-space
+ bfr-unparam-env)
+ (acl2::eval-bdd acl2::aig-eval)))))
+
+
+
+(defthm bfr-unparam-env-of-param-env
+ (implies (bfr-eval p env)
+ (equal (bfr-eval x (bfr-unparam-env p (bfr-param-env p env)))
+ (bfr-eval x env)))
+ :hints(("Goal" :in-theory (enable bfr-eval))))
+
+(defthm bfr-param-env-of-unparam-env-of-param-env
+ (implies (bfr-eval p env)
+ (equal (bfr-eval x (bfr-param-env
+ p
+ (bfr-unparam-env
+ p
+ (bfr-param-env p env))))
+ (bfr-eval x (bfr-param-env p env))))
+ :hints(("Goal" :in-theory (disable bfr-param-env bfr-unparam-env
+ bfr-from-param-space)
+ :use ((:instance bfr-eval-from-param-space
+ (env (bfr-unparam-env p (bfr-param-env p env))))))))
+
+(defthm bfr-lookup-of-unparam-env-of-param-env
+ (implies (bfr-eval p env)
+ (equal (bfr-lookup x (bfr-unparam-env p (bfr-param-env p env)))
+ (bfr-lookup x env)))
+ :hints(("Goal" :use ((:instance bfr-unparam-env-of-param-env
+ (x (bfr-var x))))
+ :in-theory (disable bfr-unparam-env-of-param-env))))
+
+(in-theory (disable bfr-to-param-space
+ bfr-to-param-space-weak
+ bfr-from-param-space
+ bfr-unparam-env
+ bfr-param-env))
+
+
+(defun-sk bfr-semantic-depends-on (k x)
+ (exists (env v)
+ (not (equal (bfr-eval x (bfr-set-var k v env))
+ (bfr-eval x env)))))
+
+(defthm bfr-semantic-depends-on-of-set-var
+ (implies (not (bfr-semantic-depends-on k x))
+ (equal (bfr-eval x (bfr-set-var k v env))
+ (bfr-eval x env))))
+
+(in-theory (disable bfr-semantic-depends-on
+ bfr-semantic-depends-on-suff))
+
+(defund bfr-depends-on (k x)
+ (bfr-case :bdd (bfr-semantic-depends-on k x)
+ :aig (sets::in (nfix k) (acl2::aig-vars x))))
+
+(local (defthm aig-eval-under-env-with-non-aig-var-member
+ (implies (not (sets::in k (acl2::aig-vars x)))
+ (equal (acl2::aig-eval x (cons (cons k v) env))
+ (acl2::aig-eval x env)))
+ :hints(("Goal" :in-theory (enable acl2::aig-eval acl2::aig-vars)))))
+
+(defthm bfr-eval-of-set-non-dep
+ (implies (not (bfr-depends-on k x))
+ (equal (bfr-eval x (bfr-set-var k v env))
+ (bfr-eval x env)))
+ :hints(("Goal" :in-theory (enable bfr-depends-on
+ bfr-semantic-depends-on-suff))
+ (and stable-under-simplificationp
+ '(:in-theory (enable bfr-eval bfr-set-var)))))
+
+;; (defthm bfr-eval-of-set-non-dep
+;; (implies (not (bfr-depends-on k x))
+;; (equal (bfr-eval x (bfr-set-var k v env))
+;; (bfr-eval x env)))
+;; :hints(("Goal" :use bfr-depends-on-suff)))
+
+(defthm bfr-depends-on-of-bfr-var
+ (equal (bfr-depends-on m (bfr-var n))
+ (equal (nfix m) (nfix n)))
+ :hints(("goal" :in-theory (e/d (bfr-depends-on) (nfix)))
+ (cond ((member-equal '(bfr-mode) clause)
+ (and stable-under-simplificationp
+ (if (eq (caar clause) 'not)
+ '(:use ((:instance bfr-semantic-depends-on-suff
+ (k m) (x (bfr-var n))
+ (v (not (bfr-lookup n env)))))
+ :in-theory (disable nfix))
+ '(:expand ((bfr-semantic-depends-on m (bfr-var n)))))))
+ ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (e/d (bfr-depends-on bfr-var) (nfix))))))
+ :otf-flg t)
+
+(defthm no-new-deps-of-bfr-not
+ (implies (not (bfr-depends-on k x))
+ (not (bfr-depends-on k (bfr-not x))))
+ :hints(("goal" :in-theory (e/d (bfr-depends-on)))
+ (cond ((member-equal '(bfr-mode) clause)
+ '(:expand ((bfr-semantic-depends-on k (bfr-not x)))
+ :use ((:instance bfr-semantic-depends-on-suff))))
+ ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (e/d (bfr-depends-on bfr-not)))))))
+
+(defthm no-new-deps-of-bfr-and
+ (implies (and (not (bfr-depends-on k x))
+ (not (bfr-depends-on k y)))
+ (not (bfr-depends-on k (bfr-binary-and x y))))
+ :hints(("goal" :in-theory (e/d (bfr-depends-on)))
+ (cond ((member-equal '(bfr-mode) clause)
+ '(:expand ((bfr-semantic-depends-on k (bfr-binary-and x y)))
+ :use ((:instance bfr-semantic-depends-on-suff)
+ (:instance bfr-semantic-depends-on-suff (x y)))))
+ ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (e/d (bfr-depends-on bfr-binary-and)))))))
+
+(defthm no-new-deps-of-bfr-or
+ (implies (and (not (bfr-depends-on k x))
+ (not (bfr-depends-on k y)))
+ (not (bfr-depends-on k (bfr-binary-or x y))))
+ :hints(("goal" :in-theory (e/d (bfr-depends-on)))
+ (cond ((member-equal '(bfr-mode) clause)
+ '(:expand ((bfr-semantic-depends-on k (bfr-binary-or x y)))
+ :use ((:instance bfr-semantic-depends-on-suff)
+ (:instance bfr-semantic-depends-on-suff (x y)))))
+ ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (e/d (bfr-depends-on bfr-binary-or acl2::aig-or)))))))
+
+(defthm no-new-deps-of-bfr-xor
+ (implies (and (not (bfr-depends-on k x))
+ (not (bfr-depends-on k y)))
+ (not (bfr-depends-on k (bfr-xor x y))))
+ :hints(("goal" :in-theory (e/d (bfr-depends-on)))
+ (cond ((member-equal '(bfr-mode) clause)
+ '(:expand ((bfr-semantic-depends-on k (bfr-xor x y)))
+ :use ((:instance bfr-semantic-depends-on-suff)
+ (:instance bfr-semantic-depends-on-suff (x y)))))
+ ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (e/d (bfr-depends-on bfr-xor acl2::aig-xor
+ acl2::aig-or)))))))
+
+(defthm no-new-deps-of-bfr-iff
+ (implies (and (not (bfr-depends-on k x))
+ (not (bfr-depends-on k y)))
+ (not (bfr-depends-on k (bfr-iff x y))))
+ :hints(("goal" :in-theory (e/d (bfr-depends-on)))
+ (cond ((member-equal '(bfr-mode) clause)
+ '(:expand ((bfr-semantic-depends-on k (bfr-iff x y)))
+ :use ((:instance bfr-semantic-depends-on-suff)
+ (:instance bfr-semantic-depends-on-suff (x y)))))
+ ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (e/d (bfr-depends-on bfr-iff acl2::aig-iff
+ acl2::aig-or)))))))
+
+(defthm no-new-deps-of-bfr-ite
+ (implies (and (not (bfr-depends-on k x))
+ (not (bfr-depends-on k y))
+ (not (bfr-depends-on k z)))
+ (not (bfr-depends-on k (bfr-ite-fn x y z))))
+ :hints(("goal" :in-theory (e/d (bfr-depends-on)))
+ (cond ((member-equal '(bfr-mode) clause)
+ '(:expand ((bfr-semantic-depends-on k (bfr-ite-fn x y z)))
+ :use ((:instance bfr-semantic-depends-on-suff)
+ (:instance bfr-semantic-depends-on-suff (x y))
+ (:instance bfr-semantic-depends-on-suff (x z)))))
+ ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (e/d (bfr-depends-on bfr-ite-fn acl2::aig-ite
+ acl2::aig-or)))))))
+
+(defthm no-deps-of-bfr-constants
+ (and (not (bfr-depends-on k t))
+ (not (bfr-depends-on k nil)))
+ :hints (("goal" :expand ((bfr-depends-on k nil)
+ (bfr-depends-on k t)
+ (bfr-semantic-depends-on k t)
+ (bfr-semantic-depends-on k nil)))))
+
+
+
+(defun-sk pbfr-semantic-depends-on (k p x)
+ (exists (env v)
+ (and (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k v env))
+ (not (equal (bfr-eval x (bfr-param-env p (bfr-set-var k v env)))
+ (bfr-eval x (bfr-param-env p env)))))))
+
+
+(defthm pbfr-semantic-depends-on-of-set-var
+ (implies (and (not (pbfr-semantic-depends-on k p x))
+ (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k v env)))
+ (equal (bfr-eval x (bfr-param-env p (bfr-set-var k v env)))
+ (bfr-eval x (bfr-param-env p env)))))
+
+
+(in-theory (disable pbfr-semantic-depends-on
+ pbfr-semantic-depends-on-suff))
+
+(defun pbfr-depends-on (k p x)
+ (bfr-case :bdd (pbfr-semantic-depends-on k p x)
+ :aig (bfr-depends-on k (bfr-from-param-space p x))))
+
+(in-theory (disable pbfr-depends-on))
+
+(defthm pbfr-eval-of-set-non-dep
+ (implies (and (not (pbfr-depends-on k p x))
+ (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k v env)))
+ (equal (bfr-eval x (bfr-param-env p (bfr-set-var k v env)))
+ (bfr-eval x (bfr-param-env p env))))
+ :hints (("goal" :in-theory (e/d (pbfr-depends-on)
+ (bfr-eval-of-set-non-dep))
+ :use ((:instance bfr-eval-of-set-non-dep
+ (x (bfr-from-param-space p x)))))))
+
+(local (defthm non-var-implies-not-member-extract-assigns
+ (implies (not (sets::in v (acl2::aig-vars x)))
+ (and (not (member v (mv-nth 0 (acl2::aig-extract-assigns x))))
+ (not (member v (mv-nth 1 (acl2::aig-extract-assigns x))))))))
+
+(local (defthm non-var-implies-not-in-aig-extract-assigns-alist
+ (implies (not (sets::in v (acl2::aig-vars x)))
+ (not (hons-assoc-equal v (acl2::aig-extract-assigns-alist x))))
+ :hints(("Goal" :in-theory (enable acl2::aig-extract-assigns-alist)))))
+
+(local (defthm non-var-implies-non-var-in-restrict-with-assigns-alist
+ (implies (not (sets::in v (acl2::aig-vars x)))
+ (not (sets::in v (acl2::aig-vars
+ (acl2::aig-restrict
+ x (acl2::aig-extract-assigns-alist y))))))
+ :hints(("Goal" :in-theory (enable acl2::aig-restrict
+ acl2::aig-extract-assigns-alist-lookup-boolean)))))
+
+(local (defthm non-var-implies-not-in-aig-extract-iterated-assigns-alist
+ (implies (not (sets::in v (acl2::aig-vars x)))
+ (not (hons-assoc-equal v (acl2::aig-extract-iterated-assigns-alist x clk))))
+ :hints(("Goal" :in-theory (enable
+ acl2::aig-extract-iterated-assigns-alist)))))
+
+(defthm non-var-implies-non-var-in-restrict-with-iterated-assigns-alist
+ (implies (not (sets::in v (acl2::aig-vars x)))
+ (not (sets::in v (acl2::aig-vars
+ (acl2::aig-restrict
+ x
+ (acl2::aig-extract-iterated-assigns-alist
+ y clk))))))
+ :hints(("Goal" :in-theory (e/d (acl2::aig-restrict
+ acl2::aig-extract-iterated-assigns-alist-lookup-boolean)
+ (acl2::aig-extract-iterated-assigns-alist)))))
+
+
+;; (encapsulate nil
+;; (local (defun ind (x k env)
+;; (if (or (atom x) (zp k))
+;; env
+;; (ind (if (car env) (car x) (cdr x)) (1- k) (cdr env)))))
+;; (local (defthm eval-bdd-of-update-true
+;; (implies (and (syntaxp (not (quotep v)))
+;; v)
+;; (equal (acl2::eval-bdd x (update-nth k v env))
+;; (acl2::eval-bdd x (update-nth k t env))))
+;; :hints(("Goal" :in-theory (enable acl2::eval-bdd update-nth)
+;; :induct (ind x k env)))))
+
+;; (defthmd bfr-semantic-depends-on-of-set-var-bdd
+;; (implies (and (not (bfr-semantic-depends-on k x))
+;; (not (bfr-mode)))
+;; (equal (acl2::eval-bdd x (update-nth k v env))
+;; (acl2::eval-bdd x env)))
+;; :hints (("goal" :use bfr-semantic-depends-on-suff
+;; :in-theory (e/d (bfr-eval bfr-set-var)
+;; (bfr-depends-on))))))
+
+(defthm pbfr-depends-on-of-bfr-var
+ (implies (and (not (bfr-depends-on m p))
+ (bfr-eval p env))
+ (equal (pbfr-depends-on m p (bfr-to-param-space p (bfr-var n)))
+ (equal (nfix m) (nfix n))))
+ :hints(("Goal" :in-theory (e/d (pbfr-depends-on
+ bfr-depends-on)
+ (nfix))
+ :do-not-induct t)
+ (cond ((member-equal '(bfr-mode) clause)
+ (and stable-under-simplificationp
+ (if (eq (caar (last clause)) 'not)
+ `(:expand (,(cadar (last clause))))
+ '(:use ((:instance pbfr-semantic-depends-on-of-set-var
+ (k m) (x (bfr-to-param-space p (bfr-var n)))
+ (v (not (bfr-lookup n env)))))
+ :in-theory (disable pbfr-semantic-depends-on-of-set-var)))))
+ ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (enable bfr-to-param-space
+ bfr-from-param-space
+ bfr-var
+ acl2::aig-extract-iterated-assigns-alist-lookup-boolean)))))
+ :otf-flg t)
+
+
+(defthm pbfr-depends-on-of-constants
+ (and (not (pbfr-depends-on k p t))
+ (not (pbfr-depends-on k p nil)))
+ :hints (("goal" :in-theory (enable pbfr-depends-on
+ bfr-from-param-space
+ pbfr-semantic-depends-on))))
+
+(defthm no-new-deps-of-pbfr-not
+ (implies (not (pbfr-depends-on k p x))
+ (not (pbfr-depends-on k p (bfr-not x))))
+ :hints(("Goal" :in-theory (enable pbfr-depends-on
+ bfr-depends-on))
+ (cond ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (enable bfr-from-param-space bfr-not) ))
+ ((member-equal '(bfr-mode) clause)
+ '(:expand ((pbfr-semantic-depends-on k p (bfr-not x))))))))
+
+
+(defthm no-new-deps-of-pbfr-and
+ (implies (and (not (pbfr-depends-on k p x))
+ (not (pbfr-depends-on k p y)))
+ (not (pbfr-depends-on k p (bfr-binary-and x y))))
+ :hints(("Goal" :in-theory (enable pbfr-depends-on
+ bfr-depends-on))
+ (cond ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (enable bfr-from-param-space bfr-binary-and) ))
+ ((member-equal '(bfr-mode) clause)
+ '(:expand ((pbfr-semantic-depends-on k p (bfr-binary-and x y))))))))
+
+(defthm no-new-deps-of-pbfr-or
+ (implies (and (not (pbfr-depends-on k p x))
+ (not (pbfr-depends-on k p y)))
+ (not (pbfr-depends-on k p (bfr-binary-or x y))))
+ :hints(("Goal" :in-theory (enable pbfr-depends-on
+ bfr-depends-on))
+ (cond ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (enable bfr-from-param-space bfr-binary-or acl2::aig-or)))
+ ((member-equal '(bfr-mode) clause)
+ '(:expand ((pbfr-semantic-depends-on k p (bfr-binary-or x y))))))))
+
+(defthm no-new-deps-of-pbfr-xor
+ (implies (and (not (pbfr-depends-on k p x))
+ (not (pbfr-depends-on k p y)))
+ (not (pbfr-depends-on k p (bfr-xor x y))))
+ :hints(("Goal" :in-theory (enable pbfr-depends-on
+ bfr-depends-on))
+ (cond ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (enable bfr-from-param-space bfr-xor acl2::aig-xor
+ acl2::aig-or)))
+ ((member-equal '(bfr-mode) clause)
+ '(:expand ((pbfr-semantic-depends-on k p (bfr-xor x y))))))))
+
+(defthm no-new-deps-of-pbfr-iff
+ (implies (and (not (pbfr-depends-on k p x))
+ (not (pbfr-depends-on k p y)))
+ (not (pbfr-depends-on k p (bfr-iff x y))))
+ :hints(("Goal" :in-theory (enable pbfr-depends-on
+ bfr-depends-on))
+ (cond ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (enable bfr-from-param-space bfr-iff acl2::aig-iff
+ acl2::aig-or)))
+ ((member-equal '(bfr-mode) clause)
+ '(:expand ((pbfr-semantic-depends-on k p (bfr-iff x y))))))))
+
+(defthm no-new-deps-of-pbfr-ite
+ (implies (and (not (pbfr-depends-on k p x))
+ (not (pbfr-depends-on k p y))
+ (not (pbfr-depends-on k p z)))
+ (not (pbfr-depends-on k p (bfr-ite-fn x y z))))
+ :hints(("Goal" :in-theory (enable pbfr-depends-on
+ bfr-depends-on))
+ (cond ((member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (enable bfr-from-param-space bfr-ite-fn acl2::aig-ite
+ acl2::aig-or)))
+ ((member-equal '(bfr-mode) clause)
+ '(:expand ((pbfr-semantic-depends-on k p (bfr-ite-fn x y z))))))))
+
+(defthm pbfr-depends-on-when-booleanp
+ (implies (booleanp y)
+ (not (pbfr-depends-on k p y)))
+ :hints(("Goal" :in-theory (enable booleanp)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+
+
+
+
+
+
+
+
+;; (defund ubdd-deps-to-nat-list (n deps)
+;; (declare (xargs :guard (natp n)))
+;; (if (atom deps)
+;; nil
+;; (if (car deps)
+;; (cons n (ubdd-deps-to-nat-list (+ 1 n) (cdr deps)))
+;; (ubdd-deps-to-nat-list (+ 1 n) (cdr deps)))))
+
+
+;; (encapsulate nil
+;; (local (include-book "arithmetic/top-with-meta" :dir :system))
+;; (defthm member-of-ubdd-deps-to-nat-list
+;; (implies (integerp n)
+;; (iff (member m (ubdd-deps-to-nat-list n deps))
+;; (and (integerp m)
+;; (<= n m)
+;; (nth (- m n) deps))))
+;; :hints (("goal" :induct (ubdd-deps-to-nat-list n deps)
+;; :in-theory (enable ubdd-deps-to-nat-list natp posp)))))
+
+
+;; (defun bfr-deps (x)
+;; (declare (xargs :guard t))
+;; (bfr-case :bdd (ubdd-deps-to-nat-list 0 (acl2::ubdd-deps x))
+;; :aig (acl2::aig-vars x)))
+
+;; (local (defthm aig-eval-acons-when-not-in-vars
+;; (implies (not (member k (acl2::aig-vars x)))
+;; (equal (acl2::aig-eval x (cons (cons k v) env))
+;; (acl2::aig-eval x env)))))
+
+;; (defund bfr-depends-on (k x)
+;; (declare (xargs :guard (natp k)))
+;; (consp (member (lnfix k) (bfr-deps x))))
+
+;; (local (defthm consp-member
+;; (iff (consp (member k x))
+;; (member k x))))
+
+;; (defthm bfr-eval-of-set-non-dep
+;; (implies (not (bfr-depends-on k x))
+;; (equal (bfr-eval x (bfr-set-var k v env))
+;; (bfr-eval x env)))
+;; :hints(("Goal" :in-theory (e/d (bfr-eval
+;; bfr-set-var
+;; bfr-depends-on)
+;; (update-nth)))))
+
+;; (defthm bfr-depends-on-of-bfr-var
+;; (equal (bfr-depends-on m (bfr-var n))
+;; (equal (nfix m) (nfix n)))
+;; :hints(("Goal" :in-theory (e/d (bfr-depends-on bfr-var)
+;; ((bfr-deps))))))
+
+;; (local
+;; #!acl2
+;; (progn
+;; (defthm aig-vars-of-aig-not
+;; (equal (aig-vars (aig-not x))
+;; (aig-vars x))
+;; :hints(("Goal" :in-theory (enable aig-not))))
+
+;; (defthm aig-vars-of-aig-and
+;; (implies (and (not (member v (aig-vars x)))
+;; (not (member v (aig-vars y))))
+;; (not (member v (aig-vars (aig-and x y)))))
+;; :hints(("Goal" :in-theory (enable aig-and))))
+
+;; (defthm aig-vars-of-aig-or
+;; (implies (and (not (member v (aig-vars x)))
+;; (not (member v (aig-vars y))))
+;; (not (member v (aig-vars (aig-or x y)))))
+;; :hints(("Goal" :in-theory (enable aig-or))))
+
+;; (defthm aig-vars-of-aig-xor
+;; (implies (and (not (member v (aig-vars x)))
+;; (not (member v (aig-vars y))))
+;; (not (member v (aig-vars (aig-xor x y)))))
+;; :hints(("Goal" :in-theory (enable aig-xor))))
+
+;; (defthm aig-vars-of-aig-iff
+;; (implies (and (not (member v (aig-vars x)))
+;; (not (member v (aig-vars y))))
+;; (not (member v (aig-vars (aig-iff x y)))))
+;; :hints(("Goal" :in-theory (enable aig-iff))))
+
+;; (defthm aig-vars-of-aig-ite
+;; (implies (and (not (member v (aig-vars x)))
+;; (not (member v (aig-vars y)))
+;; (not (member v (aig-vars z))))
+;; (not (member v (aig-vars (aig-ite x y z)))))
+;; :hints(("Goal" :in-theory (enable aig-ite))))))
+
+;; (defthm no-new-deps-of-bfr-not
+;; (implies (not (bfr-depends-on k x))
+;; (not (bfr-depends-on k (bfr-not x))))
+;; :hints(("Goal" :in-theory (e/d (bfr-depends-on bfr-not)
+;; (nth)))))
+
+;; (defthm no-new-deps-of-bfr-and
+;; (implies (and (not (bfr-depends-on k x))
+;; (not (bfr-depends-on k y)))
+;; (not (bfr-depends-on k (bfr-binary-and x y))))
+;; :hints(("Goal" :in-theory (e/d (bfr-depends-on bfr-binary-and)
+;; (nth)))))
+
+;; (defthm no-new-deps-of-bfr-or
+;; (implies (and (not (bfr-depends-on k x))
+;; (not (bfr-depends-on k y)))
+;; (not (bfr-depends-on k (bfr-binary-or x y))))
+;; :hints(("Goal" :in-theory (e/d (bfr-depends-on bfr-binary-or)
+;; (nth)))))
+
+;; (defthm no-new-deps-of-bfr-xor
+;; (implies (and (not (bfr-depends-on k x))
+;; (not (bfr-depends-on k y)))
+;; (not (bfr-depends-on k (bfr-xor x y))))
+;; :hints(("Goal" :in-theory (e/d (bfr-depends-on bfr-xor)
+;; (nth)))))
+
+;; (defthm no-new-deps-of-bfr-iff
+;; (implies (and (not (bfr-depends-on k x))
+;; (not (bfr-depends-on k y)))
+;; (not (bfr-depends-on k (bfr-iff x y))))
+;; :hints(("Goal" :in-theory (e/d (bfr-depends-on bfr-iff)
+;; (nth)))))
+
+;; (defthm no-new-deps-of-bfr-ite
+;; (implies (and (not (bfr-depends-on k x))
+;; (not (bfr-depends-on k y))
+;; (not (bfr-depends-on k z)))
+;; (not (bfr-depends-on k (bfr-ite-fn x y z))))
+;; :hints(("Goal" :in-theory (e/d (bfr-depends-on bfr-ite-fn)
+;; (nth)))))
+
+;; (defthm no-deps-of-bfr-constants
+;; (and (not (bfr-depends-on k t))
+;; (not (bfr-depends-on k nil)))
+;; :hints(("Goal" :in-theory (e/d (bfr-depends-on) ((bfr-deps))))))
+
+
@@ -793,3 +1438,432 @@
;; (w state)))))
+
+
+
+
+;; Could just be done on trees but this makes the proofs easier (?)
+;; This returns one plus the maximum natural number present -- this way it's
+;; similar to the BDD lib's MAX-DEPTH.
+;; (defund aig-max-nat (x)
+;; (declare (xargs :guard t))
+;; (cond ((natp x) (+ 1 x))
+;; ((atom x) 0)
+;; ((not (cdr x)) (aig-max-nat (car x)))
+;; (t (max (aig-max-nat (car x))
+;; (aig-max-nat (cdr x))))))
+
+;; (local
+;; (progn
+;; (defthm aig-eval-of-acons-max-nat
+;; (implies (and (<= (aig-max-nat x) var)
+;; (natp var))
+;; (equal (acl2::aig-eval x (cons (cons var val) env))
+;; (acl2::aig-eval x env)))
+;; :hints(("Goal" :in-theory (enable acl2::aig-eval aig-max-nat))))
+
+;; (defthm aig-max-nat-of-aig-not
+;; (equal (aig-max-nat (acl2::aig-not x))
+;; (aig-max-nat x))
+;; :hints(("Goal" :in-theory (enable acl2::aig-not aig-max-nat))))
+
+;; ;; (defthm aig-max-nat-of-aig-and
+;; ;; (<= (aig-max-nat (acl2::aig-and x y)) (max (aig-max-nat x)
+;; ;; (aig-max-nat y)))
+;; ;; :hints(("Goal" :in-theory (enable acl2::aig-and aig-max-nat)))
+;; ;; :rule-classes (:rewrite :linear))
+
+;; (defthm gte-aig-max-nat-of-and
+;; (implies (and (<= (aig-max-nat x) n)
+;; (<= (aig-max-nat y) n))
+;; (<= (aig-max-nat (acl2::aig-and x y)) n))
+;; :hints(("Goal" :in-theory (enable acl2::aig-and aig-max-nat)))
+;; :rule-classes (:rewrite
+;; (:linear :match-free :all)))
+
+;; ;; (defthm aig-max-nat-of-aig-or
+;; ;; (<= (aig-max-nat (acl2::aig-or x y)) (max (aig-max-nat x)
+;; ;; (aig-max-nat y)))
+;; ;; :hints(("Goal" :in-theory (e/d (acl2::aig-or aig-max-nat))))
+;; ;; :rule-classes (:rewrite :linear))
+
+;; (defthm gte-aig-max-nat-of-or
+;; (implies (and (<= (aig-max-nat x) n)
+;; (<= (aig-max-nat y) n))
+;; (<= (aig-max-nat (acl2::aig-or x y)) n))
+;; :hints(("Goal" :in-theory (enable acl2::aig-or aig-max-nat)))
+;; :rule-classes (:rewrite
+;; (:linear :match-free :all)))
+
+
+;; ;; (defthm aig-max-nat-of-aig-xor
+;; ;; (<= (aig-max-nat (acl2::aig-xor x y)) (max (aig-max-nat x)
+;; ;; (aig-max-nat y)))
+;; ;; :hints(("Goal" :in-theory (enable acl2::aig-xor aig-max-nat)
+;; ;; :do-not-induct t))
+;; ;; :rule-classes (:rewrite :linear))
+
+;; (defthm gte-aig-max-nat-of-xor
+;; (implies (and (<= (aig-max-nat x) n)
+;; (<= (aig-max-nat y) n))
+;; (<= (aig-max-nat (acl2::aig-xor x y)) n))
+;; :hints(("Goal" :in-theory (enable acl2::aig-xor aig-max-nat)))
+;; :rule-classes (:rewrite
+;; (:linear :match-free :all)))
+
+;; (defthm gte-aig-max-nat-of-iff
+;; (implies (and (<= (aig-max-nat x) n)
+;; (<= (aig-max-nat y) n))
+;; (<= (aig-max-nat (acl2::aig-iff x y)) n))
+;; :hints(("Goal" :in-theory (enable acl2::aig-iff aig-max-nat)))
+;; :rule-classes (:rewrite
+;; (:linear :match-free :all)))
+
+;; (defthm gte-aig-max-nat-of-ite
+;; (implies (and (<= (aig-max-nat x) n)
+;; (<= (aig-max-nat y) n)
+;; (<= (aig-max-nat z) n))
+;; (<= (aig-max-nat (acl2::aig-ite x y z)) n))
+;; :hints(("Goal" :in-theory (enable acl2::aig-ite aig-max-nat)))
+;; :rule-classes (:rewrite
+;; (:linear :match-free :all)))))
+
+
+;; (memoize 'aig-max-nat :condition '(and (consp x) (cdr x)))
+
+;; (local
+;; (progn
+;; (defun ind (x n env)
+;; (if (zp n)
+;; x
+;; (if (car env)
+;; (ind (car x) (1- n) (cdr env))
+;; (ind (cdr x) (1- n) (cdr env)))))
+
+;; (defthm eval-bdd-of-update-past-max-depth
+;; (implies (<= (max-depth x) (nfix n))
+;; (equal (acl2::eval-bdd x (update-nth n v env))
+;; (acl2::eval-bdd x env)))
+;; :hints(("Goal" :expand ((:free (env) (acl2::eval-bdd x env))
+;; (max-depth x)
+;; (update-nth n v env))
+;; :induct (ind x n env))))))
+
+;; (defund bfr-max-nat-var (x)
+;; (declare (xargs :guard t))
+;; (bfr-case :bdd (max-depth x)
+;; :aig (aig-max-nat x)))
+
+;; (local (in-theory (enable bfr-max-nat-var)))
+
+
+;; (defthm bfr-eval-of-bfr-set-var-past-max-nat
+;; (implies (and (<= (bfr-max-nat-var x) var)
+;; (natp var))
+;; (equal (bfr-eval x (bfr-set-var var val env))
+;; (bfr-eval x env)))
+;; :hints(("Goal" :in-theory (enable bfr-set-var bfr-eval))))
+
+
+
+;; (local
+;; (progn
+;; (include-book "arithmetic/top-with-meta" :dir :system)
+
+;; (defthm max-plus
+;; (equal (max (+ n x) (+ n y))
+;; (+ n (max x y))))
+
+;; (defthm max-assoc
+;; (equal (max (max a b) c)
+;; (max a (max b c))))
+
+;; (defthm max-commute
+;; (implies (and (rationalp a) (rationalp b))
+;; (equal (max a b)
+;; (max b a)))
+;; :rule-classes ((:rewrite :loop-stopper ((a b max)))))
+
+;; (defthm max-commute-2
+;; (implies (and (rationalp a) (rationalp b))
+;; (equal (max a (max b c))
+;; (max b (max a c))))
+;; :rule-classes ((:rewrite :loop-stopper ((a b max)))))
+
+;; (defthm max-id
+;; (equal (max x x) x))
+
+;; (defthm max-id-2
+;; (equal (max x (max x y)) (max x y)))
+
+;; (defthm gt-max-implies
+;; (equal (< (max a b) c)
+;; (and (< a c)
+;; (< b c))))
+
+;; (defthm lt-max-implies
+;; (equal (< c (max a b))
+;; (or (< c a)
+;; (< c b))))
+
+;; (defthm gt-max-plus-1-implies
+;; (equal (< (+ 1 (max a b)) c)
+;; (and (< (+ 1 a) c)
+;; (< (+ 1 b) c))))
+
+;; (defthm lt-max-plus-1-implies
+;; (equal (< c (+ 1 (max a b)))
+;; (or (< c (+ 1 a))
+;; (< c (+ 1 b)))))
+
+;; (defun max-depth2-ind (x y n)
+;; (declare (xargs :measure (+ (acl2-count x) (acl2-count y))))
+;; (if (and (atom x) (atom y))
+;; n
+;; (list (max-depth2-ind (car x) (car y) (1- n))
+;; (max-depth2-ind (cdr x) (cdr y) (1- n)))))
+
+;; (defthm max-depth-of-q-not
+;; (equal (max-depth (acl2::q-not x))
+;; (max-depth x))
+;; :hints(("Goal" :in-theory (enable acl2::q-not max-depth))))
+
+;; (defthm max-depth-of-q-and
+;; (implies (and (<= (max-depth x) n)
+;; (<= (max-depth y) n))
+;; (<= (max-depth (acl2::q-and x y)) n))
+;; :hints(("Goal" :in-theory (e/d (max-depth)
+;; ((force) max))
+;; :induct (max-depth2-ind x y n)
+;; :expand ((acl2::q-and x y))))
+;; :rule-classes (:rewrite
+;; (:linear :match-free :all)))
+
+;; (defthm max-depth-of-q-or
+;; (implies (and (<= (max-depth x) n)
+;; (<= (max-depth y) n))
+;; (<= (max-depth (acl2::q-or x y)) n))
+;; :hints(("Goal" :in-theory (e/d (max-depth)
+;; ((force) max))
+;; :induct (max-depth2-ind x y n)
+;; :expand ((acl2::q-or x y))))
+;; :rule-classes (:rewrite
+;; (:linear :match-free :all)))
+
+;; (defthm max-depth-of-q-xor
+;; (implies (and (<= (max-depth x) n)
+;; (<= (max-depth y) n))
+;; (<= (max-depth (acl2::q-xor x y)) n))
+;; :hints(("Goal" :in-theory (e/d (max-depth)
+;; ((force) max))
+;; :induct (max-depth2-ind x y n)
+;; :expand ((acl2::q-binary-xor x y))))
+;; :rule-classes (:rewrite
+;; (:linear :match-free :all)))
+
+;; (defthm max-depth-of-q-iff
+;; (implies (and (<= (max-depth x) n)
+;; (<= (max-depth y) n))
+;; (<= (max-depth (acl2::q-iff x y)) n))
+;; :hints(("Goal" :in-theory (e/d (max-depth)
+;; ((force) max))
+;; :induct (max-depth2-ind x y n)
+;; :expand ((acl2::q-binary-iff x y))))
+;; :rule-classes (:rewrite
+;; (:linear :match-free :all)))))
+
+;; (local
+;; (progn
+
+;; (defun replace-if-equal (x y v)
+;; (if (equal x y) v y))
+
+;; (defthm q-ite-redef
+;; (equal (acl2::q-ite-fn x y z)
+;; (COND
+;; ((NULL X) Z)
+;; ((ATOM X) Y)
+;; (T
+;; (LET
+;; ((Y (replace-if-equal x y t))
+;; (Z (replace-if-equal x z nil)))
+;; (COND
+;; ((HONS-EQUAL Y Z) Y)
+;; ((AND (EQ Y T) (EQ Z NIL)) X)
+;; ((AND (EQ Y NIL) (EQ Z T))
+;; (ACL2::Q-NOT X))
+;; (T (ACL2::QCONS (ACL2::Q-ITE-FN (CAR X)
+;; (ACL2::QCAR Y)
+;; (ACL2::QCAR Z))
+;; (ACL2::Q-ITE-FN (CDR X)
+;; (ACL2::QCDR Y)
+;; (ACL2::QCDR Z)))))))))
+;; :hints(("Goal" :in-theory (e/d () ((force)))))
+;; :rule-classes ((:definition :clique (acl2::q-ite-fn)
+;; :controller-alist ((acl2::q-ite-fn t nil nil)))))
+
+;; (defun max-depth3-ind (x y z n)
+;; (if (atom x)
+;; (list y z n)
+;; (list (max-depth3-ind (car x)
+;; (acl2::qcar (replace-if-equal x y t))
+;; (acl2::qcar (replace-if-equal x z nil))
+;; (1- n))
+;; (max-depth3-ind (cdr x)
+;; (acl2::qcdr (replace-if-equal x y t))
+;; (acl2::qcdr (replace-if-equal x z nil))
+;; (1- n)))))
+
+;; (defthm max-depth-of-qcar-replace-strong
+;; (implies (and (consp y) (not (consp a)))
+;; (< (max-depth (acl2::qcar (replace-if-equal x y a))) (max-depth y)))
+;; :hints (("goal" :expand ((max-depth y)
+;; (max-depth a))))
+;; :rule-classes :linear)
+
+;; (defthm max-depth-of-qcdr-replace-strong
+;; (implies (and (consp y) (not (consp a)))
+;; (< (max-depth (acl2::qcdr (replace-if-equal x y a))) (max-depth y)))
+;; :hints (("goal" :expand ((max-depth y)
+;; (max-depth a))))
+;; :rule-classes :linear)
+
+;; (defthm max-depth-of-qcar-replace-weak
+;; (implies (not (consp a))
+;; (<= (max-depth (acl2::qcar (replace-if-equal x y a))) (max-depth y)))
+;; :hints (("goal" :expand ((max-depth y)
+;; (max-depth a))))
+;; :rule-classes :linear)
+
+;; (defthm max-depth-of-qcdr-replace-weak
+;; (implies (not (consp a))
+;; (<= (max-depth (acl2::qcdr (replace-if-equal x y a))) (max-depth y)))
+;; :hints (("goal" :expand ((max-depth y)
+;; (max-depth a))))
+;; :rule-classes :linear)
+
+;; (defthm max-depth-of-qcar-replace-atom
+;; (implies (and (not (consp y)) (not (consp a)))
+;; (equal (max-depth (acl2::qcar (replace-if-equal x y a))) 0))
+;; :hints (("goal" :expand ((max-depth y)
+;; (max-depth a)))))
+
+;; (defthm max-depth-of-qcdr-replace-atom
+;; (implies (and (not (consp y)) (not (consp a)))
+;; (equal (max-depth (acl2::qcdr (replace-if-equal x y a))) 0))
+;; :hints (("goal" :expand ((max-depth y)
+;; (max-depth a)))))
+
+;; ;; (defthm max-depth-of-qcdr-strong
+;; ;; (implies (consp x)
+;; ;; (< (max-depth (acl2::qcdr x)) (max-depth x)))
+;; ;; :hints (("goal" :expand ((max-depth x))))
+;; ;; :rule-classes :linear)
+
+;; ;; (defthm max-depth-of-qcdr-atom
+;; ;; (implies (not (consp x))
+;; ;; (equal (max-depth (acl2::qcdr x)) 0))
+;; ;; :hints (("goal" :expand ((max-depth x)))))
+
+;; (defthm max-depth-of-replace-if-equal
+;; (implies (not (consp a))
+;; (<= (max-depth (replace-if-equal x y a)) (max-depth y)))
+;; :hints (("goal" :expand ((max-depth a))))
+;; :rule-classes :linear)
+
+;; (local (in-theory (disable replace-if-equal acl2::qcar acl2::qcdr)))
+
+;; (defthm max-depth-of-qcons
+;; (implies (and (<= (max-depth x) (+ -1 n))
+;; (<= (max-depth y) (+ -1 n)))
+;; (<= (max-depth (acl2::qcons x y)) n))
+;; :hints(("Goal" :in-theory (enable acl2::qcons max-depth)))
+;; :rule-classes ((:linear :trigger-terms ((max-depth (acl2::qcons x y)))
+;; :match-free :all)))
+
+
+;; ;; (local (defthm qcar/cdr-when-consp
+;; ;; (implies (consp x)
+;; ;; (and (equal (acl2::qcar x) (car x))
+;; ;; (equal (acl2::qcdr x) (cdr x))))
+;; ;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+;; ;; (local (defthm qcar/cdr-when-atom
+;; ;; (implies (not (consp x))
+;; ;; (and (equal (acl2::qcar x) x)
+;; ;; (equal (acl2::qcdr x) x)))
+;; ;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+;; (defthm max-depth-of-q-ite
+;; (implies (and (<= (max-depth x) n)
+;; (<= (max-depth y) n)
+;; (<= (max-depth z) n))
+;; (<= (max-depth (acl2::q-ite-fn x y z)) n))
+;; :hints(("Goal" :in-theory (e/d (max-depth)
+;; ((force) max acl2::qcar acl2::qcdr acl2::qcons))
+;; :induct (max-depth3-ind x y z n)
+;; :expand ((acl2::q-ite-fn x y z)))
+;; (and stable-under-simplificationp
+;; '(:cases ((consp y))))
+;; (and stable-under-simplificationp
+;; '(:cases ((consp z)))))
+;; :rule-classes ((:rewrite)
+;; (:linear :match-free :all)))))
+
+;; (defthm bfr-max-nat-var-of-bfr-not
+;; (equal (bfr-max-nat-var (bfr-not x))
+;; (bfr-max-nat-var x))
+;; :hints(("Goal" :in-theory (enable bfr-max-nat-var bfr-not))))
+
+;; (defthm bfr-max-nat-var-of-bfr-and
+;; (implies (and (<= (bfr-max-nat-var x) n)
+;; (<= (bfr-max-nat-var y) n))
+;; (<= (bfr-max-nat-var (bfr-binary-and x y)) n))
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var bfr-binary-and)
+;; (max gt-max-implies gt-max-plus-1-implies))))
+;; :rule-classes ((:rewrite)
+;; (:linear :match-free :all)))
+
+;; (defthm bfr-max-nat-var-of-bfr-or
+;; (implies (and (<= (bfr-max-nat-var x) n)
+;; (<= (bfr-max-nat-var y) n))
+;; (<= (bfr-max-nat-var (bfr-binary-or x y)) n))
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var bfr-binary-or)
+;; (max gt-max-implies gt-max-plus-1-implies))))
+;; :rule-classes ((:rewrite)
+;; (:linear :match-free :all)))
+
+;; (defthm bfr-max-nat-var-of-bfr-xor
+;; (implies (and (<= (bfr-max-nat-var x) n)
+;; (<= (bfr-max-nat-var y) n))
+;; (<= (bfr-max-nat-var (bfr-xor x y)) n))
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var bfr-xor)
+;; (max gt-max-implies gt-max-plus-1-implies))))
+;; :rule-classes ((:rewrite)
+;; (:linear :match-free :all)))
+
+;; (defthm bfr-max-nat-var-of-bfr-iff
+;; (implies (and (<= (bfr-max-nat-var x) n)
+;; (<= (bfr-max-nat-var y) n))
+;; (<= (bfr-max-nat-var (bfr-iff x y)) n))
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var bfr-iff)
+;; (max gt-max-implies gt-max-plus-1-implies))))
+;; :rule-classes (:rewrite
+;; (:linear :match-free :all)))
+
+;; (defthm bfr-max-nat-var-of-bfr-ite
+;; (implies (and (<= (bfr-max-nat-var x) n)
+;; (<= (bfr-max-nat-var y) n)
+;; (<= (bfr-max-nat-var z) n))
+;; (<= (bfr-max-nat-var (bfr-ite-fn x y z)) n))
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var bfr-ite-fn)
+;; (max gt-max-implies gt-max-plus-1-implies))))
+;; :rule-classes ((:rewrite)
+;; (:linear :match-free :all)))
+
+;; (defthm bfr-max-nat-var-of-consts
+;; (and (equal (bfr-max-nat-var nil) 0)
+;; (equal (bfr-max-nat-var t) 0))
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var)
+;; ((bfr-max-nat-var))))))
+
+
diff -Nru acl2-6.2/books/centaur/gl/bvar-db.lisp acl2-6.3/books/centaur/gl/bvar-db.lisp
--- acl2-6.2/books/centaur/gl/bvar-db.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/bvar-db.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,933 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "GL")
+(include-book "centaur/misc/arith-equiv-defs" :dir :system)
+(include-book "centaur/misc/absstobjs" :dir :system)
+;; (include-book "std/lists/index-of" :dir :system)
+(local (include-book "centaur/misc/arith-equivs" :dir :system))
+(local (include-book "std/lists/final-cdr" :dir :system))
+(local (include-book "std/lists/resize-list" :dir :system))
+(local (include-book "arithmetic/top-with-meta" :dir :system))
+(local (include-book "std/lists/nth" :dir :system))
+
+(local (in-theory (enable* acl2::arith-equiv-forwarding)))
+
+(local (in-theory (disable nth update-nth acl2::nth-when-zp)))
+
+
+;; ----------- Implementation ----------------
+;; The "terms" stored in the bvar-db$c are really g-apply objects
+(defstobj bvar-db$c
+ (base-bvar$c :type (integer 0 *) :initially 0)
+ (next-bvar$c :type (integer 0 *) :initially 0)
+ (bvar-terms$c :type (array t (0)) :resizable t)
+ (term-bvars$c :type t)
+ (term-equivs$c :type t))
+
+(defun get-term->bvar$c (x bvar-db$c)
+ (declare (xargs :stobjs bvar-db$c))
+ (cdr (hons-get x (term-bvars$c bvar-db$c))))
+
+(defun bvar-db-wfp$c (bvar-db$c)
+ (declare (xargs :stobjs bvar-db$c))
+ (and (<= (lnfix (base-bvar$c bvar-db$c))
+ (lnfix (next-bvar$c bvar-db$c)))
+ (<= (- (lnfix (next-bvar$c bvar-db$c))
+ (lnfix (base-bvar$c bvar-db$c)))
+ (bvar-terms$c-length bvar-db$c))))
+
+(defun get-bvar->term$c (n bvar-db$c)
+ (declare (type (integer 0 *) n)
+ (xargs :stobjs bvar-db$c
+ :guard (and (<= (base-bvar$c bvar-db$c) n)
+ (< n (next-bvar$c bvar-db$c))
+ (bvar-db-wfp$c bvar-db$c))))
+ (bvar-terms$ci (- (lnfix n) (lnfix (base-bvar$c bvar-db$c))) bvar-db$c))
+
+(defcong acl2::nat-equiv equal (get-bvar->term$c n bvar-db$c) 1)
+
+(defun add-term-bvar$c (x bvar-db$c)
+ (declare (xargs :stobjs bvar-db$c
+ :guard (bvar-db-wfp$c bvar-db$c)))
+ (b* ((next (the (integer 0 *) (lnfix (next-bvar$c bvar-db$c))))
+ (idx (the (integer 0 *) (lnfix (- next (lnfix (base-bvar$c bvar-db$c))))))
+ (terms-len (the (integer 0 *) (bvar-terms$c-length bvar-db$c)))
+ (bvar-db$c (if (mbe :logic (<= terms-len idx)
+ :exec (int= terms-len idx))
+ (resize-bvar-terms$c
+ (max 16 (* 2 terms-len)) bvar-db$c)
+ bvar-db$c))
+ (bvar-db$c (update-bvar-terms$ci idx x bvar-db$c))
+ (bvar-db$c (update-next-bvar$c (+ 1 next) bvar-db$c)))
+ (update-term-bvars$c
+ (hons-acons (hons-copy x) next (term-bvars$c bvar-db$c))
+ bvar-db$c)))
+
+(defthm get-term->bvar$c-of-add-term-bvar$c
+ (equal (get-term->bvar$c x (add-term-bvar$c y bvar-db$c))
+ (if (equal x y)
+ (nfix (next-bvar$c bvar-db$c))
+ (get-term->bvar$c x bvar-db$c))))
+
+(defthm term-equivs$c-of-add-term-bvar$c
+ (equal (term-equivs$c (add-term-bvar$c y bvar-db$c))
+ (term-equivs$c bvar-db$c)))
+
+(defthm get-bvar->term$c-of-add-term-bvar$c
+ (implies (and (<= (nfix (base-bvar$c bvar-db$c)) (nfix n))
+ (<= (nfix (base-bvar$c bvar-db$c))
+ (nfix (next-bvar$c bvar-db$c))))
+ (equal (get-bvar->term$c n (add-term-bvar$c x bvar-db$c))
+ (if (equal (nfix n) (nfix (next-bvar$c bvar-db$c)))
+ x
+ (get-bvar->term$c n bvar-db$c)))))
+
+
+
+(defthm base-bvar$c-of-add-term-bvar$c
+ (equal (nth *base-bvar$c* (add-term-bvar$c x bvar-db$c))
+ (nth *base-bvar$c* bvar-db$c)))
+
+(defthm next-bvar$c-of-add-term-bvar$c
+ (equal (nth *next-bvar$c* (add-term-bvar$c x bvar-db$c))
+ (+ 1 (nfix (nth *next-bvar$c* bvar-db$c)))))
+
+(defthm bvar-db-wfp$c-of-add-term-bvar$c
+ (implies (bvar-db-wfp$c bvar-db$c)
+ (bvar-db-wfp$c (add-term-bvar$c x bvar-db$c))))
+
+;; (defun add-term-equiv$c (x n bvar-db$c)
+;; (declare (xargs :stobjs bvar-db$c
+;; :guard (and (integerp n)
+;; (<= (base-bvar$c bvar-db$c) n)
+;; (< n (next-bvar$c bvar-db$c))
+;; (bvar-db-wfp$c bvar-db$c))))
+;; (b* ((term-equivs (term-equivs$c bvar-db$c)))
+;; (update-term-equivs$c (hons-acons x (cons n (cdr (hons-get x term-equivs)))
+;; term-equivs)
+;; bvar-db$c)))
+
+(defthm get-term->bvar$c-of-update-term-equivs$c
+ (equal (get-term->bvar$c x (update-term-equivs$c q bvar-db$c))
+ (get-term->bvar$c x bvar-db$c)))
+
+(defthm term-equivs$c-of-update-term-equivs$c
+ (equal (term-equivs$c (update-term-equivs$c q bvar-db$c))
+ q))
+;; (defthm get-term->bvar$c-of-add-term-equiv$c
+;; (equal (get-term->bvar$c x (add-term-equiv$c y n bvar-db$c))
+;; (get-term->bvar$c x bvar-db$c)))
+
+;; (defthm get-term->equivs$c-of-add-term-equiv$c
+;; (equal (term-equivs$c (add-term-equiv$c y n bvar-db$c))
+;; (hons-acons x (cons n (get-term->equivs$c x bvar-db$c))
+;; (term-equivs$c bvar-db$c))))
+
+
+(defthm get-bvar->term$c-of-update-term-equivs$c
+ (equal (get-bvar->term$c x (update-term-equivs$c q bvar-db$c))
+ (get-bvar->term$c x bvar-db$c)))
+
+(defthm base-bvar$c-of-update-term-equivs$c
+ (equal (nth *base-bvar$c* (update-term-equivs$c q bvar-db$c))
+ (nth *base-bvar$c* bvar-db$c)))
+
+(defthm next-bvar$c-of-update-term-equivs$c
+ (equal (nth *next-bvar$c* (update-term-equivs$c q bvar-db$c))
+ (nth *next-bvar$c* bvar-db$c)))
+
+
+(defthm bvar-db-wfp$c-of-update-term-equivs$c
+ (implies (bvar-db-wfp$c bvar-db$c)
+ (bvar-db-wfp$c (update-term-equivs$c q bvar-db$c))))
+
+
+
+;; (defthm get-bvar->term$c-of-add-term-equiv$c
+;; (equal (get-bvar->term$c x (add-term-equiv$c y n bvar-db$c))
+;; (get-bvar->term$c x bvar-db$c)))
+
+;; (defthm base-bvar$c-of-add-term-equiv$c
+;; (equal (nth *base-bvar$c* (add-term-equiv$c x n bvar-db$c))
+;; (nth *base-bvar$c* bvar-db$c)))
+
+;; (defthm next-bvar$c-of-add-term-equiv$c
+;; (equal (nth *next-bvar$c* (add-term-equiv$c x n bvar-db$c))
+;; (nth *next-bvar$c* bvar-db$c)))
+
+
+;; (defthm bvar-db-wfp$c-of-add-term-equiv$c
+;; (implies (bvar-db-wfp$c bvar-db$c)
+;; (bvar-db-wfp$c (add-term-equiv$c x n bvar-db$c))))
+
+
+
+(defun init-bvar-db$c (base-bvar bvar-db$c)
+ (declare (type (integer 0 *) base-bvar)
+ (xargs :stobjs bvar-db$c))
+ (b* ((bvar-db$c (update-base-bvar$c (lnfix base-bvar) bvar-db$c))
+ (bvar-db$c (update-next-bvar$c (lnfix base-bvar) bvar-db$c))
+ (bvar-db$c (update-term-equivs$c nil bvar-db$c)))
+ (update-term-bvars$c nil bvar-db$c)))
+
+(defthm base-bvar$c-of-init-bvar-db$c
+ (equal (nth *base-bvar$c* (init-bvar-db$c base bvar-db$c))
+ (nfix base)))
+
+(defthm term-equivs$c-of-init-bvar-db$c
+ (equal (term-equivs$c (init-bvar-db$c base-bvar bvar-db$c))
+ nil))
+
+(defthm next-bvar$c-of-init-bvar-db$c
+ (equal (nth *next-bvar$c* (init-bvar-db$c base bvar-db$c))
+ (nfix base)))
+
+(defthm get-term->bvar-of-init-bvar-db$c
+ (equal (get-term->bvar$c x (init-bvar-db$c base bvar-db$c))
+ nil))
+
+(defthm bvar-db-wfp$c-of-init-bvar-db$c
+ (bvar-db-wfp$c (init-bvar-db$c base bvar-db$c)))
+
+
+(defthm create-bvar-db$c-rewrite
+ (equal (create-bvar-db$c)
+ (init-bvar-db$c 0 '(0 0 nil nil nil))))
+
+(local (in-theory (disable (create-bvar-db$c) create-bvar-db$c)))
+
+
+(defund bvar-listp$c (x bvar-db$c)
+ (declare (xargs :stobjs bvar-db$c))
+ (if (atom x)
+ (eq x nil)
+ (and (natp (car x))
+ (<= (base-bvar$c bvar-db$c) (car x))
+ (< (car x) (next-bvar$c bvar-db$c))
+ (bvar-listp$c (cdr x) bvar-db$c))))
+
+(defund term-equivsp$c (equivs bvar-db$c)
+ (declare (xargs :stobjs bvar-db$c))
+ (if (atom equivs)
+ (eq equivs nil)
+ (and (consp (car equivs))
+ (bvar-listp$c (cdar equivs) bvar-db$c)
+ (term-equivsp$c (cdr equivs) bvar-db$c))))
+
+;; ------------------ Logic ----------------
+
+;; (encapsulate
+;; ;; (((next-bvar$a *) => *
+;; ;; :formals (bvar-db$a)
+;; ;; :guard t)
+;; ;; ((base-bvar$a *) => *
+;; ;; :formals (bvar-db$a)
+;; ;; :guard t)
+;; ;; ((get-bvar->term$a * *) => *
+;; ;; :formals (n bvar-db$a)
+;; ;; :guard (and (natp n)
+;; ;; (<= (base-bvar$a bvar-db$a) n)
+;; ;; (< n (next-bvar$a bvar-db$a))))
+;; ;; ((get-term->bvar$a * *) => *
+;; ;; :formals (x bvar-db$a)
+;; ;; :guard t)
+;; ;; ((add-term-bvar$a * *) => *
+;; ;; :formals (x bvar-db$a)
+;; ;; :guard (not (get-term->bvar$a x bvar-db$a)))
+;; ;; ((init-bvar-db$a * *) => *
+;; ;; :formals (base bvar-db$a)
+;; ;; :guard (natp base)))
+
+;; (defund init-bvar-db$a (base bvar-db$a)
+;; (declare (ignore bvar-db$a))
+;; (cons (nfix base) nil))
+
+;; (defund base-bvar$a (bvar-db$a)
+;; (nfix (car bvar-db$a)))
+
+;; (defund next-bvar$a (bvar-db$a)
+;; (+ (base-bvar$a bvar-db$a)
+;; (len (cdr bvar-db$a))))
+
+;; (defund get-bvar->term$a (n bvar-db$a)
+;; (nth (- (nfix n) (base-bvar$a bvar-db$a))
+;; (cdr bvar-db$a)))
+
+;; (defund get-term->bvar$a (x bvar-db$a)
+;; (let ((idx (acl2::index-of x (cdr bvar-db$a))))
+;; (and idx (+ idx (base-bvar$a bvar-db$a)))))
+
+;; (defund add-term-bvar$a (x bvar-db$a)
+;; (cons (car bvar-db$a)
+;; (append (cdr bvar-db$a) (list x))))
+
+;; (local (in-theory (enable init-bvar-db$a
+;; base-bvar$a
+;; next-bvar$a
+;; get-bvar->term$a
+;; get-term->bvar$a
+;; add-term-bvar$a)))
+
+;; (defthm type-of-base-bvar$a
+;; (natp (base-bvar$a bvar-db$a))
+;; :rule-classes :type-prescription)
+
+;; (defthm type-of-next-bvar$a
+;; (natp (next-bvar$a bvar-db$a))
+;; :rule-classes :type-prescription)
+
+;; (defthm type-of-get-term->bvar$a
+;; (or (not (get-term->bvar$a x bvar-db$a))
+;; (natp (get-term->bvar$a x bvar-db$a)))
+;; :rule-classes :type-prescription)
+
+;; (defthm next-bvar-gte-base-bvar$a
+;; (<= (base-bvar$a bvar-db$a) (next-bvar$a bvar-db$a))
+;; :rule-classes (:rewrite :linear))
+
+;; (defthm term-bvar-gte-base-bvar$a
+;; (implies (get-term->bvar$a x bvar-db$a)
+;; (<= (base-bvar$a bvar-db$a)
+;; (get-term->bvar$a x bvar-db$a)))
+;; :rule-classes (:rewrite :linear))
+
+;; ;; this is probably derivable
+;; (defthm term-bvar-less-than-next-bvar$a
+;; (implies (get-term->bvar$a x bvar-db$a)
+;; (< (get-term->bvar$a x bvar-db$a)
+;; (next-bvar$a bvar-db$a)))
+;; :rule-classes (:rewrite :linear))
+
+;; (defthm init-bvar-db$a-normalize
+;; (implies (syntaxp (not (equal bvar-db$a ''nil)))
+;; (equal (init-bvar-db$a base bvar-db$a)
+;; (init-bvar-db$a base nil))))
+
+;; (defthm base-bvar-of-init-bvar-db$a
+;; (equal (base-bvar$a (init-bvar-db$a base bvar-db$a))
+;; (nfix base)))
+
+;; (defthm next-bvar-of-init-bvar-db$a
+;; (equal (next-bvar$a (init-bvar-db$a base bvar-db$a))
+;; (nfix base)))
+
+;; (defthm get-term->bvar-of-init-bvar-db$a
+;; (equal (get-term->bvar$a x (init-bvar-db$a base bvar-db$a))
+;; nil))
+
+;; (defthm base-bvar$a-of-add-term-bvar$a
+;; (equal (base-bvar$a (add-term-bvar$a x bvar-db$a))
+;; (base-bvar$a bvar-db$a)))
+
+;; (local (defthm len-append
+;; (equal (len (append a b))
+;; (+ (len a) (len b)))))
+
+;; (defthm next-bvar$a-of-add-term-bvar$a
+;; (equal (next-bvar$a (add-term-bvar$a x bvar-db$a))
+;; (+ 1 (next-bvar$a bvar-db$a))))
+
+;; (defthm get-bvar->term$a-of-add-term-bvar$a-existing
+;; (implies (and (<= (base-bvar$a bvar-db$a) (nfix n))
+;; (not (equal (nfix n) (next-bvar$a bvar-db$a))))
+;; (equal (get-bvar->term$a n (add-term-bvar$a x bvar-db$a))
+;; (get-bvar->term$a n bvar-db$a))))
+
+;; (defthm get-bvar->term$a-of-add-term-bvar$a-new
+;; (implies (and (<= (base-bvar$a bvar-db$a) (nfix n))
+;; (equal (nfix n) (next-bvar$a bvar-db$a)))
+;; (equal (get-bvar->term$a n (add-term-bvar$a x bvar-db$a))
+;; x)))
+
+;; (defthm get-term->bvar$a-of-add-term-bvar$a-other
+;; (implies (not (equal x y))
+;; (equal (get-term->bvar$a y (add-term-bvar$a x bvar-db$a))
+;; (get-term->bvar$a y bvar-db$a)))
+;; :hints(("Goal" :in-theory (enable acl2::index-of-append-split))))
+
+;; (defthm get-term->bvar$a-of-add-term-bvar$a-new
+;; (implies (not (get-term->bvar$a x bvar-db$a))
+;; (equal (get-term->bvar$a x (add-term-bvar$a x bvar-db$a))
+;; (next-bvar$a bvar-db$a)))))
+
+(encapsulate
+ (((next-bvar$a *) => *
+ :formals (bvar-db$a)
+ :guard t)
+ ((base-bvar$a *) => *
+ :formals (bvar-db$a)
+ :guard t)
+ ((get-bvar->term$a * *) => *
+ :formals (n bvar-db$a)
+ :guard (and (natp n)
+ (<= (base-bvar$a bvar-db$a) n)
+ (< n (next-bvar$a bvar-db$a))))
+ ((get-term->bvar$a * *) => *
+ :formals (x bvar-db$a)
+ :guard t)
+ ((add-term-bvar$a * *) => *
+ :formals (x bvar-db$a)
+ :guard t)
+ ((term-equivs$a *) => *
+ :formals (bvar-db$a)
+ :guard t)
+ ((bvar-listp$a * *) => *
+ :formals (x bvar-db$a)
+ :guard t)
+ ((term-equivsp$a * *) => *
+ :formals (equivs bvar-db$a)
+ :guard t)
+ ((update-term-equivs$a * *) => *
+ :formals (equivs bvar-db$a)
+ :guard (term-equivsp$a equivs bvar-db$a))
+ ((init-bvar-db$a * *) => *
+ :formals (base bvar-db$a)
+ :guard (natp base)))
+
+ (local
+ (progn
+
+
+ (defund init-bvar-db$a (base bvar-db$a)
+ (declare (ignore bvar-db$a)
+ (xargs :guard t))
+ (cons (nfix base) nil))
+
+ (defund base-bvar$a (bvar-db$a)
+ (declare (xargs :guard t))
+ (nfix (acl2::final-cdr (ec-call (car bvar-db$a)))))
+
+ (defund next-bvar$a (bvar-db$a)
+ (declare (xargs :guard t))
+ (+ (base-bvar$a bvar-db$a) (len (ec-call (car bvar-db$a)))))
+
+ (defund filter-bvars (x bvar-db$a)
+ (declare (xargs :guard t))
+ (if (atom x)
+ nil
+ (if (and (natp (car x))
+ (<= (base-bvar$a bvar-db$a) (car x))
+ (< (car x) (next-bvar$a bvar-db$a)))
+ (cons (car x) (filter-bvars (cdr x) bvar-db$a))
+ (filter-bvars (cdr x) bvar-db$a))))
+
+ (defund filter-equivs (x bvar-db$a)
+ (declare (xargs :guard t))
+ (if (atom x)
+ nil
+ (if (consp (car x))
+ (cons (cons (caar x) (filter-bvars (cdar x) bvar-db$a))
+ (filter-equivs (cdr x) bvar-db$a))
+ (filter-equivs (cdr x) bvar-db$a))))
+
+ (defund get-bvar->term$a (n bvar-db$a)
+ (declare (xargs :guard (and (natp n)
+ (<= (base-bvar$a bvar-db$a) n)
+ (< n (next-bvar$a bvar-db$a)))))
+ (and (< (nfix n) (next-bvar$a bvar-db$a))
+ (ec-call (nth (+ -1 (len (ec-call (car bvar-db$a))) (base-bvar$a bvar-db$a) (- (nfix n) ))
+ (ec-call (car bvar-db$a))))))
+
+ (defund term-equivs$a (bvar-db$a)
+ (declare (xargs :guard t))
+ (filter-equivs (ec-call (cdr bvar-db$a)) bvar-db$a))
+
+
+ (defund bvar-listp$a (x bvar-db$a)
+ (declare (xargs :guard t))
+ (if (atom x)
+ (eq x nil)
+ (and (natp (car x))
+ (<= (base-bvar$a bvar-db$a) (car x))
+ (< (car x) (next-bvar$a bvar-db$a))
+ (bvar-listp$a (cdr x) bvar-db$a))))
+
+ (defund term-equivsp$a (equivs bvar-db$a)
+ (declare (xargs :guard t))
+ (if (atom equivs)
+ (eq equivs nil)
+ (and (consp (car equivs))
+ (bvar-listp$a (cdar equivs) bvar-db$a)
+ (term-equivsp$a (cdr equivs) bvar-db$a))))
+
+ (defund update-term-equivs$a (equivs bvar-db$a)
+ (declare (xargs :guard (term-equivsp$a equivs bvar-db$a)))
+ (cons (ec-call (car bvar-db$a))
+ (filter-equivs equivs bvar-db$a)))
+
+ (defund get-term->bvar$a (x bvar-db$a)
+ (declare (xargs :guard t))
+ (let ((suff (ec-call (member-equal x (ec-call (car bvar-db$a))))))
+ (and suff (+ -1 (len suff) (base-bvar$a bvar-db$a)))))
+
+ (defund add-term-bvar$a (x bvar-db$a)
+ (declare (xargs :guard t))
+ (cons (cons x (ec-call (car bvar-db$a)))
+ (filter-equivs (ec-call (cdr bvar-db$a)) bvar-db$a)))))
+
+ (defthm bvar-listp$a-def
+ (equal (bvar-listp$a x bvar-db$a)
+ (if (atom x)
+ (eq x nil)
+ (and (natp (car x))
+ (<= (base-bvar$a bvar-db$a) (car x))
+ (< (car x) (next-bvar$a bvar-db$a))
+ (bvar-listp$a (cdr x) bvar-db$a))))
+ :hints(("Goal" :in-theory (enable bvar-listp$a)))
+ :rule-classes ((:definition :controller-alist ((bvar-listp$a t nil)))))
+
+ (defthm term-equivsp$a-def
+ (equal (term-equivsp$a equivs bvar-db$a)
+ (if (atom equivs)
+ (eq equivs nil)
+ (and (consp (car equivs))
+ (bvar-listp$a (cdar equivs) bvar-db$a)
+ (term-equivsp$a (cdr equivs) bvar-db$a))))
+ :hints(("Goal" :in-theory (enable term-equivsp$a)))
+ :rule-classes ((:definition :controller-alist ((term-equivsp$a t nil)))))
+
+
+ (local (in-theory (enable init-bvar-db$a
+ base-bvar$a
+ next-bvar$a
+ get-bvar->term$a
+ get-term->bvar$a
+ add-term-bvar$a
+ term-equivs$a
+ update-term-equivs$a)))
+
+ (defcong acl2::nat-equiv equal (get-bvar->term$a n bvar-db$a) 1)
+ (defcong acl2::nat-equiv equal (init-bvar-db$a n bvar-db$a) 1)
+
+ (defthm type-of-base-bvar$a
+ (natp (base-bvar$a bvar-db$a))
+ :rule-classes :type-prescription)
+
+ (defthm type-of-next-bvar$a
+ (natp (next-bvar$a bvar-db$a))
+ :rule-classes :type-prescription)
+
+ (local (defthm equal-len-0
+ (equal (equal (len x) 0)
+ (not (consp x)))))
+
+ (defthm type-of-get-term->bvar$a
+ (or (not (get-term->bvar$a x bvar-db$a))
+ (natp (get-term->bvar$a x bvar-db$a)))
+ :rule-classes :type-prescription)
+
+ (local (defthm bvar-listp$a-of-filter-bvars
+ (bvar-listp$a (filter-bvars x bvar-db$a) bvar-db$a)
+ :hints(("Goal" :in-theory (enable filter-bvars)))))
+
+ (local (defthm nat-listp-of-filter-bvars
+ (acl2::nat-listp (filter-bvars x bvar-db$a))
+ :hints(("Goal" :in-theory (enable filter-bvars)))))
+
+ (local (defthm term-equivsp$a-of-filter-equivs
+ (term-equivsp$a (filter-equivs x bvar-db$a) bvar-db$a)
+ :hints(("Goal" :in-theory (enable filter-equivs)))))
+
+ (local (defthm lookup-of-filter-equivs
+ (equal (cdr (hons-assoc-equal x (filter-equivs y bvar-db$a)))
+ (filter-bvars (cdr (hons-assoc-equal x y)) bvar-db$a))
+ :hints(("Goal" :in-theory (enable filter-equivs)
+ :induct t)
+ (and stable-under-simplificationp
+ '(:in-theory (enable filter-bvars))))))
+
+ (defthm next-bvar-gte-base-bvar$a
+ (<= (base-bvar$a bvar-db$a) (next-bvar$a bvar-db$a))
+ :rule-classes (:rewrite :linear))
+
+ (defthm term-bvar-gte-base-bvar$a
+ (implies (get-term->bvar$a x bvar-db$a)
+ (<= (base-bvar$a bvar-db$a)
+ (get-term->bvar$a x bvar-db$a)))
+ :rule-classes (:rewrite :linear))
+
+ (local (defthm len-member
+ (<= (len (member x y)) (len y))
+ :rule-classes :linear))
+
+ (defthm term-bvar-less-than-next-bvar$a
+ (implies (get-term->bvar$a x bvar-db$a)
+ (< (get-term->bvar$a x bvar-db$a)
+ (next-bvar$a bvar-db$a)))
+ :rule-classes (:rewrite :linear))
+
+ (defthm term-equivsp$a-of-term-equivs$a
+ (term-equivsp$a (term-equivs$a bvar-db) bvar-db))
+
+ (defthm bvar-listp$a-of-lookup
+ (implies (term-equivsp$a q bvar-db$a)
+ (bvar-listp$a (cdr (hons-assoc-equal x q)) bvar-db$a)))
+
+ ;; (local (defun nth-filter-ind (n x bvar-db$a)
+ ;; (if (atom x)
+ ;; n
+ ;; (nth-filter-ind (if (and (natp (car x))
+ ;; (<= (base-bvar$a bvar-db$a) (car x))
+ ;; (< (car x) (next-bvar$a bvar-db$a)))
+ ;; (1- n)
+ ;; n)
+ ;; (cdr x) bvar-db$a))))
+
+
+ ;; (local (defthm nth-filter-bvars-gte-base-bvar$a
+ ;; (implies (< (nfix n) (len (filter-bvars x bvar-db$a)))
+ ;; (<= (base-bvar$a bvar-db$a) (nth n (filter-bvars x bvar-db$a))))
+ ;; :hints(("Goal" :in-theory (enable filter-bvars nth)
+ ;; :induct (nth-filter-ind n x bvar-db$a)))
+ ;; :rule-classes :linear))
+
+ ;; (defthm term-equiv-gte-base-bvar$a
+ ;; (implies (< (nfix n) (len (get-term->equivs$a x bvar-db$a)))
+ ;; (<= (base-bvar$a bvar-db$a) (nth n (get-term->equivs$a x bvar-db$a))))
+ ;; :rule-classes :linear)
+
+ ;; (local (defthm nth-filter-bvars-less-than-next-bvar$a
+ ;; (implies (< (nfix n) (len (filter-bvars x bvar-db$a)))
+ ;; (< (nth n (filter-bvars x bvar-db$a)) (next-bvar$a bvar-db$a)))
+ ;; :hints(("Goal" :in-theory (enable filter-bvars nth)
+ ;; :induct (nth-filter-ind n x bvar-db$a)))
+ ;; :rule-classes :linear))
+
+ ;; (defthm term-equiv-less-than-next-bvar$a
+ ;; (implies (< (nfix n) (len (get-term->equivs$a x bvar-db$a)))
+ ;; (< (nth n (get-term->equivs$a x bvar-db$a)) (next-bvar$a bvar-db$a))))
+
+ (defthm init-bvar-db$a-normalize
+ (implies (syntaxp (not (equal bvar-db$a ''nil)))
+ (equal (init-bvar-db$a base bvar-db$a)
+ (init-bvar-db$a base nil))))
+
+ (defthm base-bvar-of-init-bvar-db$a
+ (equal (base-bvar$a (init-bvar-db$a base bvar-db$a))
+ (nfix base)))
+
+ (defthm next-bvar-of-init-bvar-db$a
+ (equal (next-bvar$a (init-bvar-db$a base bvar-db$a))
+ (nfix base)))
+
+ (defthm get-term->bvar-of-init-bvar-db$a
+ (equal (get-term->bvar$a x (init-bvar-db$a base bvar-db$a))
+ nil))
+
+ (defthm term->equivs-of-init-bvar-db$a
+ (equal (term-equivs$a (init-bvar-db$a base bvar-db$a))
+ nil)
+ :hints(("Goal" :in-theory (enable filter-bvars filter-equivs))))
+
+ (defthm base-bvar$a-of-add-term-bvar$a
+ (equal (base-bvar$a (add-term-bvar$a x bvar-db$a))
+ (base-bvar$a bvar-db$a)))
+
+ (local (defthm len-append
+ (equal (len (append a b))
+ (+ (len a) (len b)))))
+
+ (defthm base-bvar$a-of-update-term-equivs$a
+ (equal (base-bvar$a (update-term-equivs$a x bvar-db$a))
+ (base-bvar$a bvar-db$a)))
+
+ (defthm next-bvar$a-of-update-term-equivs$a
+ (equal (next-bvar$a (update-term-equivs$a x bvar-db$a))
+ (next-bvar$a bvar-db$a)))
+
+ (defthm get-term->bvar$a-of-update-term-equivs$a
+ (equal (get-term->bvar$a x (update-term-equivs$a q bvar-db$a))
+ (get-term->bvar$a x bvar-db$a)))
+
+ (defthm get-bvar->term$a-of-update-term-equivs$a
+ (equal (get-bvar->term$a x (update-term-equivs$a q bvar-db$a))
+ (get-bvar->term$a x bvar-db$a)))
+
+ (local (defthm filter-bvars-of-filter-bvars
+ (implies (equal (car db1) (car db2))
+ (equal (filter-bvars (filter-bvars x db1) db2)
+ (filter-bvars x db1)))
+ :hints(("Goal" :in-theory (enable base-bvar$a next-bvar$a
+ filter-bvars)))))
+
+ (local (defthm filter-bvars-when-bvar-listp$a
+ (implies (and (bvar-listp$a q bvar-db2)
+ (equal (car bvar-db2) (car bvar-db$a)))
+ (equal (filter-bvars q bvar-db$a)
+ q))
+ :hints(("Goal" :in-theory (enable filter-bvars)))))
+
+ (local (defthm filter-equivs-when-term-equivsp$a
+ (implies (and (term-equivsp$a q bvar-db2)
+ (equal (car bvar-db2) (car bvar-db$a)))
+ (equal (filter-equivs q bvar-db$a)
+ q))
+ :hints(("Goal" :in-theory (enable filter-equivs)))))
+
+ (defthm term-equivs-of-update-term-equiv1$a
+ (implies (term-equivsp$a q bvar-db$a)
+ (equal (term-equivs$a (update-term-equivs$a q bvar-db$a))
+ q)))
+
+
+ ;; (local (defthm member-remove-duplicates
+ ;; (iff (member k (remove-duplicates-equal x))
+ ;; (member k x))))
+
+ (defthm next-bvar$a-of-add-term-bvar$a-split
+ (equal (next-bvar$a (add-term-bvar$a x bvar-db$a))
+ (+ 1 (next-bvar$a bvar-db$a))))
+
+ (local (defthm nth-of-cons
+ (equal (nth n (cons a b))
+ (if (zp n) a
+ (nth (1- n) b)))
+ :hints(("Goal" :in-theory (enable nth)))))
+
+ (defthm get-bvar->term$a-of-add-term-bvar$a-split
+ (implies (<= (base-bvar$a bvar-db$a) (nfix n))
+ (equal (get-bvar->term$a n (add-term-bvar$a x bvar-db$a))
+ (if (equal (nfix n) (next-bvar$a bvar-db$a))
+ x
+ (get-bvar->term$a n bvar-db$a)))))
+
+ ;; (defthm get-bvar->term$a-of-add-term-bvar$a-existing
+ ;; (implies (and (<= (base-bvar$a bvar-db$a) (nfix n))
+ ;; (not (equal (nfix n) (next-bvar$a bvar-db$a))))
+ ;; (equal (get-bvar->term$a n (mv-nth 1 (add-term-bvar$a x bvar-db$a)))
+ ;; (get-bvar->term$a n bvar-db$a))))
+
+ ;; (defthm get-bvar->term$a-of-add-term-bvar$a-new
+ ;; (implies (and (<= (base-bvar$a bvar-db$a) (nfix n))
+ ;; (equal (nfix n) (next-bvar$a bvar-db$a)))
+ ;; (equal (get-bvar->term$a n (add-term-bvar$a x bvar-db$a))
+ ;; x)))
+
+ (defthm get-term->bvar$a-of-add-term-bvar$a-split
+ (equal (get-term->bvar$a y (add-term-bvar$a x bvar-db$a))
+ (if (equal x y)
+ (next-bvar$a bvar-db$a)
+ (get-term->bvar$a y bvar-db$a))))
+
+ (local (defthm filter-bvars-of-filter-bvars-cons
+ (equal (filter-bvars (filter-bvars x db1)
+ (cons (cons y (car db1)) z))
+ (filter-bvars x db1))
+ :hints(("Goal" :in-theory (enable base-bvar$a next-bvar$a
+ filter-bvars)))))
+
+ (local (defthm filter-equivs-of-filter-equivs-cons
+ (equal (filter-equivs (filter-equivs x db1)
+ (cons (cons y (car db1)) z))
+ (filter-equivs x db1))
+ :hints(("Goal" :in-theory (enable base-bvar$a next-bvar$a
+ filter-equivs)))))
+
+ (defthm term-equivs-of-add-term-bvar$a
+ (equal (term-equivs$a (add-term-bvar$a x bvar-db$a))
+ (term-equivs$a bvar-db$a)))
+
+ (local (defthm len-of-member-bound
+ (<= (len (member x y)) (len y))
+ :rule-classes :linear))
+
+ (local (defthm consp-member-equal
+ (iff (consp (member-equal x y))
+ (member-equal x y))))
+
+ (local (defthm len-member-when-member
+ (implies (member x y)
+ (< 0 (len (member x y))))
+ :rule-classes :linear))
+
+ (local (defthm nth-by-member
+ (implies (member x z)
+ (equal (nth (+ (len z)
+ (- (len (member x z))))
+ z)
+ x))
+ :hints(("Goal" :in-theory (enable nth member)))))
+
+
+ (defthm get-bvar->term$a-of-get-term->bvar
+ (let ((bvar (get-term->bvar$a x bvar-db$a)))
+ (implies bvar
+ (equal (get-bvar->term$a bvar bvar-db$a)
+ x))))
+
+ ;; (local (defthm no-duplicatesp-of-remove-duplicates
+ ;; (no-duplicatesp (remove-duplicates-equal x))))
+
+ ;; (local (defthm len-member-nth-when-no-duplicates
+ ;; (implies (and (< (nfix n) (len x))
+ ;; (no-duplicatesp x))
+ ;; (equal (len (member (nth n x) x))
+ ;; (- (len x) (nfix n))))
+ ;; :hints(("Goal" :in-theory (enable nth)))))
+
+ (defthm get-term->bvar$a-of-get-bvar->term
+ (let ((term (get-bvar->term$a n bvar-db$a)))
+ (implies (and (<= (base-bvar$a bvar-db$a) (nfix n))
+ (< (nfix n) (next-bvar$a bvar-db$a)))
+ (get-term->bvar$a term bvar-db$a)))))
+
+
+(defun create-bvar-db$a ()
+ (declare (xargs :guard t))
+ (init-bvar-db$a 0 nil))
+
+(defun bvar-db$ap (bvar-db$a)
+ (declare (ignore bvar-db$a)
+ (xargs :guard t))
+ t)
+
+
+(defun-sk bvar-dbs-terms-corr (bvar-db$c bvar-db$a)
+ (forall x
+ (and (equal (get-term->bvar$c x bvar-db$c)
+ (get-term->bvar$a x bvar-db$a))
+ (equal (term-equivs$c bvar-db$c)
+ (term-equivs$a bvar-db$a))))
+ :rewrite :direct)
+
+(defun-sk bvar-dbs-bvars-corr (bvar-db$c bvar-db$a)
+ (forall n
+ (implies (and (natp n)
+ (<= (base-bvar$a bvar-db$a) n)
+ (< n (next-bvar$a bvar-db$a)))
+ (equal (get-bvar->term$c n bvar-db$c)
+ (get-bvar->term$a n bvar-db$a))))
+ :rewrite :direct)
+
+(local (in-theory (disable bvar-dbs-terms-corr
+ bvar-dbs-bvars-corr)))
+
+(defun-nx bvar-dbs-corr (bvar-db$c bvar-db$a)
+ (and (equal (base-bvar$c bvar-db$c) (base-bvar$a bvar-db$a))
+ (equal (next-bvar$c bvar-db$c) (next-bvar$a bvar-db$a))
+ (bvar-dbs-bvars-corr bvar-db$c bvar-db$a)
+ (bvar-dbs-terms-corr bvar-db$c bvar-db$a)
+ (bvar-db-wfp$c bvar-db$c)))
+
+(defthm bvar-listp$c-is-$a
+ (implies (and (bind-free '((bvar-db . bvar-db)) (bvar-db))
+ (equal (base-bvar$c bvar-db$c)
+ (base-bvar$a bvar-db))
+ (equal (next-bvar$c bvar-db$c)
+ (next-bvar$a bvar-db)))
+ (equal (bvar-listp$c x bvar-db$c)
+ (bvar-listp$a x bvar-db)))
+ :hints (("goal" :induct (bvar-listp$c x bvar-db$c)
+ :in-theory (enable bvar-listp$c))))
+
+(defthm term-equivsp$c-is-$a
+ (implies (and (bind-free '((bvar-db . bvar-db)) (bvar-db))
+ (equal (base-bvar$c bvar-db$c)
+ (base-bvar$a bvar-db))
+ (equal (next-bvar$c bvar-db$c)
+ (next-bvar$a bvar-db)))
+ (equal (term-equivsp$c x bvar-db$c)
+ (term-equivsp$a x bvar-db)))
+ :hints (("goal" :induct (term-equivsp$c x bvar-db$c)
+ :in-theory (enable term-equivsp$c))))
+
+
+(encapsulate nil
+ (local (set-default-hints
+ '((and stable-under-simplificationp
+ (let ((lit (car (last clause))))
+ (and (not (eq (car lit) 'equal))
+ `(:expand (,lit))))))))
+
+ (local (in-theory (disable (init-bvar-db$c)
+ init-bvar-db$c
+ get-term->bvar$c
+ add-term-bvar$c
+ get-bvar->term$c
+ update-term-equivs$c
+ term-equivs$c)))
+
+ (acl2::defabsstobj-events bvar-db
+ :creator (create-bvar-db :logic create-bvar-db$a :exec create-bvar-db$c)
+ :recognizer (bvar-dbp :logic bvar-db$ap :exec bvar-db$cp)
+ :corr-fn bvar-dbs-corr
+ :exports ((base-bvar :logic base-bvar$a :exec base-bvar$c)
+ (next-bvar :logic next-bvar$a :exec next-bvar$c)
+ (get-term->bvar :logic get-term->bvar$a :exec get-term->bvar$c)
+ (get-bvar->term :logic get-bvar->term$a :exec get-bvar->term$c)
+ (term-equivs :logic term-equivs$a :exec term-equivs$c)
+ (bvar-listp :logic bvar-listp$a :exec bvar-listp$c)
+ (term-equivsp :logic term-equivsp$a :exec term-equivsp$c)
+ (add-term-bvar :logic add-term-bvar$a :exec add-term-bvar$c :protect t)
+ (update-term-equivs :logic update-term-equivs$a :exec update-term-equivs$c)
+ (init-bvar-db :logic init-bvar-db$a :exec init-bvar-db$c :protect t))))
+
+
+(defun add-term-bvar-unique (x bvar-db)
+ (declare (xargs :stobjs bvar-db))
+ (let ((look (get-term->bvar x bvar-db)))
+ (if look
+ (mv look bvar-db)
+ (b* ((next (next-bvar bvar-db))
+ (bvar-db (add-term-bvar x bvar-db)))
+ (mv next bvar-db)))))
+
+(defsection get-term->equivs
+
+ (defund get-term->equivs (x bvar-db)
+ (declare (xargs :stobjs bvar-db))
+ (cdr (hons-get x (term-equivs bvar-db))))
+
+ (local (in-theory (enable get-term->equivs)))
+
+ (defthm bvar-listp-get-term->equivs
+ (bvar-listp$a (get-term->equivs x bvar-db) bvar-db)
+ :hints(("Goal" :in-theory (enable get-term->equivs)))))
+
+
+(defsection add-term-equiv
+ (defund add-term-equiv (x n bvar-db)
+ (declare (xargs :guard (and (integerp n)
+ (<= (base-bvar bvar-db) n)
+ (< n (next-bvar bvar-db)))
+ :stobjs bvar-db))
+ (update-term-equivs (hons-acons x
+ (cons n (get-term->equivs x bvar-db))
+ (term-equivs bvar-db))
+ bvar-db))
+
+ (local (in-theory (enable add-term-equiv)))
+
+ (defthm base-bvar-of-add-term-equiv
+ (equal (base-bvar$a (add-term-equiv x n bvar-db))
+ (base-bvar$a bvar-db)))
+
+ (defthm next-bvar-of-add-term-equiv
+ (equal (next-bvar$a (add-term-equiv x n bvar-db))
+ (next-bvar$a bvar-db)))
+
+ (defthm get-term->bvar-of-add-term-equiv
+ (equal (get-term->bvar$a y (add-term-equiv x n bvar-db))
+ (get-term->bvar$a y bvar-db)))
+
+ (defthm get-bvar->term-of-add-term-equiv
+ (equal (get-bvar->term$a y (add-term-equiv x n bvar-db))
+ (get-bvar->term$a y bvar-db))))
diff -Nru acl2-6.2/books/centaur/gl/bvec-ite.lisp acl2-6.3/books/centaur/gl/bvec-ite.lisp
--- acl2-6.2/books/centaur/gl/bvec-ite.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/bvec-ite.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,11 +1,30 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-
(include-book "bvecs")
-
(include-book "tools/bstar" :dir :system)
+(include-book "ihs/logops-definitions" :dir :system)
+(include-book "centaur/misc/arith-equiv-defs" :dir :system)
+(local (include-book "centaur/bitops/ihsext-basics" :dir :system))
+(local (in-theory (disable floor)))
(defthm consp-bfr-eval-list
(equal (consp (bfr-eval-list x env))
@@ -20,20 +39,42 @@
(local (bfr-reasoning-mode t))
+
;; If/then/else where the branches are (unsigned) bit vectors
(defn bfr-ite-bvv-fn (c v1 v0)
(declare (xargs :measure (+ (acl2-count v1) (acl2-count v0))
:guard t))
(if (and (atom v1) (atom v0))
nil
- (let ((tail (bfr-ite-bvv-fn c (if (atom v1) nil (cdr v1))
- (if (atom v0) nil (cdr v0))))
- (head (bfr-ite-fn c (if (atom v1) nil (car v1))
- (if (atom v0) nil (car v0)))))
- (if (or head tail)
- (cons head tail)
- nil))))
+ (b* (((mv v11 v1r) (car/cdr v1))
+ ((mv v01 v0r) (car/cdr v0))
+ (tail (bfr-ite-bvv-fn c v1r v0r))
+ (head (bfr-ite-fn c v11 v01)))
+ (bfr-ucons head tail))))
+
+(defthm pbfr-list-depends-on-of-bfr-ite-bvv-fn
+ (implies (and (not (pbfr-depends-on n p c))
+ (not (pbfr-list-depends-on n p v1))
+ (not (pbfr-list-depends-on n p v0)))
+ (not (pbfr-list-depends-on n p (bfr-ite-bvv-fn c v1 v0))))
+ :hints(("Goal" :in-theory (e/d (pbfr-list-depends-on)
+ (pbfr-depends-on (pbfr-depends-on)
+ (pbfr-list-depends-on))))))
+
+(defthm eval-of-bfr-ite-bvv-fn
+ (equal (bfr-list->u (bfr-ite-bvv-fn c v1 v0) env)
+ (if (bfr-eval c env)
+ (bfr-list->u v1 env)
+ (bfr-list->u v0 env)))
+ :hints (("goal" :induct (bfr-ite-bvv-fn c v1 v0))))
+(defmacro bfr-ite-bvv (c v1 v0)
+ `(let ((bfr-ite-bvv-test ,c))
+ (if bfr-ite-bvv-test
+ (if (eq bfr-ite-bvv-test t)
+ ,v1
+ (bfr-ite-bvv-fn bfr-ite-bvv-test ,v1 ,v0))
+ ,v0)))
;; (defcong bfr-equiv bfr-list-equiv (cons a b) 1
;; :hints ((and stable-under-simplificationp
@@ -71,34 +112,37 @@
;; (defcong bfr-list-equiv equal (bfr-ite-bvv-fn c v1 v0) 2)
;; (defcong bfr-list-equiv equal (bfr-ite-bvv-fn c v1 v0) 3)
-(defmacro bfr-ite-bvv (c v1 v0)
- `(let ((bfr-ite-bvv-test ,c))
- (if bfr-ite-bvv-test
- (if (eq bfr-ite-bvv-test t)
- ,v1
- (bfr-ite-bvv-fn bfr-ite-bvv-test ,v1 ,v0))
- ,v0)))
+
(defn bfr-ite-bss-fn (c v1 v0)
(declare (xargs :measure (+ (acl2-count v1) (acl2-count v0))
:guard t))
- (b* (((mv head1 tail1 end1) (if (atom v1)
- (mv nil nil t)
- (if (atom (cdr v1))
- (mv (car v1) v1 t)
- (mv (car v1) (cdr v1) nil))))
- ((mv head0 tail0 end0) (if (atom v0)
- (mv nil nil t)
- (if (atom (cdr v0))
- (mv (car v0) v0 t)
- (mv (car v0) (cdr v0) nil)))))
+ (b* (((mv head1 tail1 end1) (first/rest/end v1))
+ ((mv head0 tail0 end0) (first/rest/end v0)))
(if (and end1 end0)
- (list (bfr-ite-fn c head1 head0))
+ (bfr-sterm (bfr-ite-fn c head1 head0))
(let ((rst (bfr-ite-bss-fn c tail1 tail0))
(head (bfr-ite c head1 head0)))
- (if (and (atom (cdr rst)) (hqual head (car rst)))
- rst
- (cons head rst))))))
+ (bfr-scons head rst)))))
+
+
+(defthm pbfr-list-depends-on-of-bfr-ite-bss-fn
+ (implies (and (not (pbfr-depends-on n p c))
+ (not (pbfr-list-depends-on n p v1))
+ (not (pbfr-list-depends-on n p v0)))
+ (not (pbfr-list-depends-on n p (bfr-ite-bss-fn c v1 v0))))
+ :hints(("Goal" :in-theory (e/d (pbfr-list-depends-on)
+ (pbfr-depends-on (pbfr-depends-on)
+ (pbfr-list-depends-on))))))
+
+
+
+(defthm eval-of-bfr-ite-bss-fn
+ (equal (bfr-list->s (bfr-ite-bss-fn c v1 v0) env)
+ (if (bfr-eval c env)
+ (bfr-list->s v1 env)
+ (bfr-list->s v0 env)))
+ :hints (("goal" :induct (bfr-ite-bss-fn c v1 v0))))
;; (defcong bfr-equiv equal (bfr-ite-bss-fn c v1 v0) 1)
;; (defcong bfr-list-equiv equal (bfr-ite-bss-fn c v1 v0) 2)
@@ -115,63 +159,68 @@
(add-macro-alias bfr-ite-bss bfr-ite-bss-fn)
-(defthmd v2n-bfr-eval-list-atom
- (implies (atom x)
- (equal (v2n (bfr-eval-list x env)) 0))
- :hints (("goal" :in-theory (enable v2n bfr-eval-list))))
-
-
-(defthmd bfr-ite-bvv-fn-nil
- (implies (not (bfr-ite-bvv-fn c v1 v0))
- (and (implies (bfr-eval c env)
- (equal (v2n (bfr-eval-list v1 env)) 0))
- (implies (not (bfr-eval c env))
- (equal (v2n (bfr-eval-list v0 env)) 0))))
- :hints (("Goal" :in-theory (enable v2n bfr-eval-list)))
- :otf-flg t)
-
-(defthmd v2n-bfr-ite-bvv-fn
- (equal (v2n (bfr-eval-list (bfr-ite-bvv-fn c v1 v0) env))
- (if (bfr-eval c env)
- (v2n (bfr-eval-list v1 env))
- (v2n (bfr-eval-list v0 env))))
- :hints (("Goal" :in-theory (enable v2n bfr-eval-list))))
-
-(defthm v2i-bfr-ite-bss-fn
- (equal (v2i (bfr-eval-list (bfr-ite-bss-fn c v1 v0) env))
- (if (bfr-eval c env)
- (v2i (bfr-eval-list v1 env))
- (v2i (bfr-eval-list v0 env))))
- :hints(("Goal" :in-theory (enable v2i bfr-eval-list))))
-
-
-(defthmd boolean-listp-bfr-ite-bvv-fn-v2n-bind-env-car-env
- (implies (and (bind-free '((env . (car env))) (env))
- (boolean-listp (bfr-ite-bvv-fn c v1 v0)))
- (equal (v2n (bfr-ite-bvv-fn c v1 v0))
- (if (bfr-eval c env)
- (v2n (bfr-eval-list v1 env))
- (v2n (bfr-eval-list v0 env)))))
- :hints (("goal" :use ((:instance bfr-eval-list-consts
- (x (bfr-ite-bvv-fn c v1 v0)))
- v2n-bfr-ite-bvv-fn)
- :in-theory (e/d ()
- (bfr-ite-bvv-fn v2n-bfr-ite-bvv-fn
- bfr-eval-list-consts)))))
-
-(defthmd boolean-listp-bfr-ite-bss-fn-v2i-bind-env-car-env
- (implies (and (bind-free '((env . (car env))) (env))
- (boolean-listp (bfr-ite-bss-fn c v1 v0)))
- (equal (v2i (bfr-ite-bss-fn c v1 v0))
- (if (bfr-eval c env)
- (v2i (bfr-eval-list v1 env))
- (v2i (bfr-eval-list v0 env)))))
- :hints (("goal" :use ((:instance bfr-eval-list-consts
- (x (bfr-ite-bss-fn c v1 v0)))
- v2i-bfr-ite-bss-fn)
- :in-theory (e/d ()
- (bfr-ite-bss-fn v2i-bfr-ite-bss-fn
- bfr-eval-list-consts)))))
+(defthm bfr-eval-list-of-atom
+ (implies (not (consp x))
+ (equal (bfr-eval-list x env) nil))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+;; (defthmd v2n-bfr-eval-list-atom
+;; (implies (atom x)
+;; (equal (v2n (bfr-eval-list x env)) 0))
+;; :hints (("goal" :in-theory (enable v2n bfr-eval-list))))
+
+
+;; (defthmd bfr-ite-bvv-fn-nil
+;; (implies (not (bfr-ite-bvv-fn c v1 v0))
+;; (and (implies (bfr-eval c env)
+;; (equal (v2n (bfr-eval-list v1 env)) 0))
+;; (implies (not (bfr-eval c env))
+;; (equal (v2n (bfr-eval-list v0 env)) 0))))
+;; :hints (("Goal" :in-theory (enable v2n bfr-eval-list)))
+;; :otf-flg t)
+
+;; (defthmd v2n-bfr-ite-bvv-fn
+;; (equal (v2n (bfr-eval-list (bfr-ite-bvv-fn c v1 v0) env))
+;; (if (bfr-eval c env)
+;; (v2n (bfr-eval-list v1 env))
+;; (v2n (bfr-eval-list v0 env))))
+;; :hints (("Goal" :in-theory (enable v2n bfr-eval-list))))
+
+;; (defthm v2i-bfr-ite-bss-fn
+;; (equal (v2i (bfr-eval-list (bfr-ite-bss-fn c v1 v0) env))
+;; (if (bfr-eval c env)
+;; (v2i (bfr-eval-list v1 env))
+;; (v2i (bfr-eval-list v0 env))))
+;; :hints(("Goal" :in-theory (enable v2i bfr-eval-list))))
+
+
+;; (defthmd boolean-listp-bfr-ite-bvv-fn-v2n-bind-env-car-env
+;; (implies (and (bind-free '((env . (car env))) (env))
+;; (boolean-listp (bfr-ite-bvv-fn c v1 v0)))
+;; (equal (v2n (bfr-ite-bvv-fn c v1 v0))
+;; (if (bfr-eval c env)
+;; (v2n (bfr-eval-list v1 env))
+;; (v2n (bfr-eval-list v0 env)))))
+;; :hints (("goal" :use ((:instance bfr-eval-list-consts
+;; (x (bfr-ite-bvv-fn c v1 v0)))
+;; v2n-bfr-ite-bvv-fn)
+;; :in-theory (e/d ()
+;; (bfr-ite-bvv-fn v2n-bfr-ite-bvv-fn
+;; bfr-eval-list-consts)))))
+
+;; (defthmd boolean-listp-bfr-ite-bss-fn-v2i-bind-env-car-env
+;; (implies (and (bind-free '((env . (car env))) (env))
+;; (boolean-listp (bfr-ite-bss-fn c v1 v0)))
+;; (equal (v2i (bfr-ite-bss-fn c v1 v0))
+;; (if (bfr-eval c env)
+;; (v2i (bfr-eval-list v1 env))
+;; (v2i (bfr-eval-list v0 env)))))
+;; :hints (("goal" :use ((:instance bfr-eval-list-consts
+;; (x (bfr-ite-bss-fn c v1 v0)))
+;; v2i-bfr-ite-bss-fn)
+;; :in-theory (e/d ()
+;; (bfr-ite-bss-fn v2i-bfr-ite-bss-fn
+;; bfr-eval-list-consts)))))
diff -Nru acl2-6.2/books/centaur/gl/bvecs.lisp acl2-6.3/books/centaur/gl/bvecs.lisp
--- acl2-6.2/books/centaur/gl/bvecs.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/bvecs.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,18 +1,36 @@
-
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "bfr")
+(include-book "ihs/logops-definitions" :dir :system)
+(include-book "centaur/misc/arith-equiv-defs" :dir :system)
+(local (include-book "centaur/bitops/ihsext-basics" :dir :system))
+(local (in-theory (disable floor)))
;; (include-book "tools/with-arith5-help" :dir :system)
;; (allow-arith5-help)
-(local (include-book "ihs/quotient-remainder-lemmas" :dir :system))
-(local (include-book "ihs/math-lemmas" :dir :system))
-(local (in-theory (disable floor)))
-
+;; (local (include-book "ihs/quotient-remainder-lemmas" :dir :system))
+;; (local (include-book "ihs/math-lemmas" :dir :system))
;; (defun bfr-listp1 (x)
@@ -71,9 +89,429 @@
(equal (bfr-eval-list (acl2::list-fix x) env)
(bfr-eval-list x env)))
+
+(defund pbfr-list-depends-on (k p x)
+ (if (atom x)
+ nil
+ (or (pbfr-depends-on k p (car x))
+ (pbfr-list-depends-on k p (cdr x)))))
+
+(defthm pbfr-list-depends-on-of-list-fix
+ (equal (pbfr-list-depends-on k p (acl2::list-fix x))
+ (pbfr-list-depends-on k p x))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on))))
+
+(defthm bfr-eval-list-of-set-non-dep
+ (implies (and (not (pbfr-list-depends-on k p x))
+ (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k v env)))
+ (equal (bfr-eval-list x (bfr-param-env p (bfr-set-var k v env)))
+ (bfr-eval-list x (bfr-param-env p env))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on))))
+
+
+(defthm bfr-depends-on-car
+ (implies (not (pbfr-list-depends-on k p x))
+ (not (pbfr-depends-on k p (car x))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on default-car))))
+
+(defthm bfr-depends-on-cdr
+ (implies (not (pbfr-list-depends-on k p x))
+ (not (pbfr-list-depends-on k p (cdr x))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on))))
+
+;; (defund bfr-max-nat-var-list (x)
+;; (declare (xargs :guard t))
+;; (if (atom x)
+;; 0
+;; (max (bfr-max-nat-var (car x))
+;; (bfr-max-nat-var-list (cdr x)))))
+
+;; (defthm bfr-eval-list-of-bfr-set-var-past-max-nat
+;; (implies (and (<= (bfr-max-nat-var-list x) var)
+;; (natp var))
+;; (equal (bfr-eval-list x (bfr-set-var var val env))
+;; (bfr-eval-list x env)))
+;; :hints(("Goal" :in-theory (enable bfr-max-nat-var-list))))
+
+
+;; (defthm bfr-max-nat-var-of-car
+;; (<= (bfr-max-nat-var (car x)) (bfr-max-nat-var-list x))
+;; :hints(("Goal" :in-theory (enable bfr-max-nat-var-list)))
+;; :rule-classes :linear)
+
+;; (defthm bfr-max-nat-var-list-of-car-rw
+;; (implies (<= (bfr-max-nat-var-list x) n)
+;; (<= (bfr-max-nat-var (car x)) n)))
+
+;; (defthm bfr-max-nat-var-of-cdr
+;; (<= (bfr-max-nat-var-list (cdr x)) (bfr-max-nat-var-list x))
+;; :hints(("Goal" :in-theory (enable bfr-max-nat-var-list)))
+;; :rule-classes :linear)
+
+;; (defthm bfr-max-nat-var-list-of-cdr-rw
+;; (implies (<= (bfr-max-nat-var-list x) n)
+;; (<= (bfr-max-nat-var-list (cdr x)) n)))
+
+
+
+
+
+
+
+(defund-inline scdr (v)
+ (declare (xargs :guard t))
+ (mbe :logic (if (atom (cdr v)) v (cdr v))
+ :exec (if (or (atom v) (atom (cdr v))) v (cdr v))))
+
+(defthm pbfr-list-depends-on-scdr
+ (implies (not (pbfr-list-depends-on k p x))
+ (not (pbfr-list-depends-on k p (scdr x))))
+ :hints(("Goal" :in-theory (enable scdr pbfr-list-depends-on))))
+
+;; (defthm bfr-max-nat-var-list-of-scdr
+;; (<= (bfr-max-nat-var-list (scdr x)) (bfr-max-nat-var-list x))
+;; :hints(("Goal" :in-theory (enable bfr-max-nat-var-list scdr)))
+;; :rule-classes :linear)
+
+;; (defthm bfr-max-nat-var-list-of-scdr-rw
+;; (implies (<= (bfr-max-nat-var-list x) n)
+;; (<= (bfr-max-nat-var-list (scdr x)) n)))
+
+(defthm scdr-of-list-fix
+ (equal (scdr (acl2::list-fix x))
+ (acl2::list-fix (scdr x)))
+ :hints(("Goal" :in-theory (enable scdr))))
+
+
+(defund-inline s-endp (v)
+ (declare (xargs :guard t))
+ (mbe :logic (atom (cdr v)) :exec (or (atom v) (atom (cdr v)))))
+
+(defun-inline first/rest/end (x)
+ (declare (xargs :guard t
+ :guard-hints ('(:in-theory (enable scdr s-endp)))))
+ (mbe :logic (mv (car x) (scdr x) (s-endp x))
+ :exec (cond ((atom x) (mv nil x t))
+ ((atom (cdr x)) (mv (car x) x t))
+ (t (mv (car x) (cdr x) nil)))))
+
+(defthm s-endp-of-list-fix
+ (equal (s-endp (acl2::list-fix x))
+ (s-endp x))
+ :hints(("Goal" :in-theory (enable s-endp))))
+
+(defthm scdr-count-strong
+ (implies (not (s-endp v))
+ (< (acl2-count (scdr v)) (acl2-count v)))
+ :hints(("Goal" :in-theory (enable s-endp scdr)))
+ :rule-classes :linear)
+
+(defthm scdr-count-weak
+ (<= (acl2-count (scdr v)) (acl2-count v))
+ :hints(("Goal" :in-theory (enable s-endp scdr)))
+ :rule-classes :linear)
+
+(defthm scdr-len-strong
+ (implies (not (s-endp v))
+ (< (len (scdr v)) (len v)))
+ :hints(("Goal" :in-theory (enable s-endp scdr)))
+ :rule-classes :linear)
+
+(defthm scdr-len-weak
+ (<= (len (scdr v)) (len v))
+ :hints(("Goal" :in-theory (enable s-endp scdr)))
+ :rule-classes :linear)
+
+
+
+(defthm s-endp-of-scdr
+ (implies (s-endp b)
+ (s-endp (scdr b)))
+ :hints(("Goal" :in-theory (enable s-endp scdr))))
+
+(defun bool->sign (x)
+ (declare (xargs :guard t))
+ (if x -1 0))
+
+
+(defun bfr-list->s (x env)
+ (declare (xargs :guard t))
+ (b* (((mv first rest end) (first/rest/end x)))
+ (if end
+ (bool->sign (bfr-eval first env))
+ (logcons (acl2::bool->bit (bfr-eval first env))
+ (bfr-list->s rest env)))))
+
+
+(defthm bfr-list->s-of-list-fix
+ (equal (bfr-list->s (acl2::list-fix x) env)
+ (bfr-list->s x env)))
+
+(defund bfr-snorm (v)
+ (declare (xargs :guard t))
+ (if (atom v) '(nil) v))
+
+(defthm s-endp-of-bfr-snorm
+ (equal (s-endp (bfr-snorm v))
+ (s-endp v))
+ :hints(("Goal" :in-theory (enable s-endp bfr-snorm))))
+
+(defthm scdr-of-bfr-snorm
+ (equal (scdr (bfr-snorm v))
+ (bfr-snorm (scdr v)))
+ :hints(("Goal" :in-theory (enable scdr bfr-snorm))))
+
+(defthm car-of-bfr-snorm
+ (equal (car (bfr-snorm v))
+ (car v))
+ :hints(("Goal" :in-theory (enable bfr-snorm))))
+
+(defthm bfr-list->s-of-bfr-snorm
+ (equal (bfr-list->s (bfr-snorm v) env)
+ (bfr-list->s v env)))
+
+(defund bfr-scons (b v)
+ (declare (xargs :guard t))
+ (if (atom v)
+ (if b (list b nil) '(nil))
+ (if (and (atom (cdr v))
+ (hons-equal (car v) b))
+ v
+ (cons b v))))
+
+(defthm scdr-of-bfr-scons
+ (equal (scdr (bfr-scons b v))
+ (bfr-snorm v))
+ :hints(("Goal" :in-theory (enable bfr-snorm bfr-scons scdr))))
+
+(defthm s-endp-of-bfr-scons
+ (equal (s-endp (bfr-scons b v))
+ (and (s-endp v)
+ (hqual b (car v))))
+ :hints(("Goal" :in-theory (enable s-endp bfr-scons))))
+
+(defthm car-of-bfr-scons
+ (equal (car (bfr-scons b v))
+ b)
+ :hints(("Goal" :in-theory (enable bfr-scons))))
+
+(defthm bfr-list->s-of-bfr-scons
+ (equal (bfr-list->s (bfr-scons b x) env)
+ (logcons (acl2::bool->bit (bfr-eval b env))
+ (bfr-list->s x env)))
+ :hints(("Goal" ;:in-theory (enable bfr-scons scdr s-endp)
+ :expand ((bfr-list->s (bfr-scons b x) env))
+ :do-not-induct t)))
+
+(defthm pbfr-list-depends-on-of-scons
+ (implies (and (not (pbfr-depends-on k p b))
+ (not (pbfr-list-depends-on k p x)))
+ (not (pbfr-list-depends-on k p (bfr-scons b x))))
+ :hints(("Goal" :in-theory (enable bfr-scons pbfr-list-depends-on))))
+
+;; (defthm bfr-max-nat-var-list-of-bfr-scons
+;; (implies (and (<= (bfr-max-nat-var b) n)
+;; (<= (bfr-max-nat-var-list x) n))
+;; (<= (bfr-max-nat-var-list (bfr-scons b x)) n))
+;; :hints(("Goal" :in-theory (e/d (bfr-scons bfr-max-nat-var-list)
+;; ((bfr-max-nat-var-list)))))
+;; :rule-classes (:rewrite (:linear :match-free :all)))
+
+(defund bfr-sterm (b)
+ (declare (xargs :guard t))
+ (list b))
+
+(defthm s-endp-of-bfr-sterm
+ (equal (s-endp (bfr-sterm b)) t)
+ :hints(("Goal" :in-theory (enable s-endp bfr-sterm))))
+
+(defthm scdr-of-bfr-sterm
+ (equal (scdr (bfr-sterm b))
+ (bfr-sterm b))
+ :hints(("Goal" :in-theory (enable scdr bfr-sterm))))
+
+(defthm car-of-bfr-sterm
+ (equal (car (bfr-sterm b))
+ b)
+ :hints(("Goal" :in-theory (enable bfr-sterm))))
+
+
+(defthm bfr-list->s-of-bfr-sterm
+ (equal (bfr-list->s (bfr-sterm b) env)
+ (bool->sign (bfr-eval b env))))
+
+(defthm pbfr-list-depends-on-of-bfr-sterm
+ (equal (pbfr-list-depends-on k p (bfr-sterm b))
+ (pbfr-depends-on k p b))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on bfr-sterm))))
+
+;; (defthm bfr-max-nat-var-list-of-bfr-sterm
+;; (equal (bfr-max-nat-var-list (bfr-sterm b))
+;; (bfr-max-nat-var b))
+;; :hints(("Goal" :in-theory (enable bfr-sterm bfr-max-nat-var-list))))
+
+(defthm scdr-when-s-endp
+ (implies (s-endp x)
+ (equal (scdr x) x))
+ :hints(("Goal" :in-theory (enable scdr s-endp)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+(defthmd bfr-list->s-of-scdr
+ (equal (bfr-list->s (scdr x) env)
+ (logcdr (bfr-list->s x env))))
+
+(defthm logcdr-of-bfr-list->s
+ (equal (logcdr (bfr-list->s x env))
+ (bfr-list->s (scdr x) env)))
+
+(defthm logcar-of-bfr-list->s
+ (equal (logcar (bfr-list->s x env))
+ (acl2::bool->bit (bfr-eval (car x) env))))
+
+(defthm bfr-list->s-when-s-endp
+ (implies (s-endp x)
+ (equal (bfr-list->s x env)
+ (bool->sign (bfr-eval (car x) env))))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+
+(defn i2v (n)
+ (declare (xargs :measure (integer-length n)
+ :hints(("Goal" :in-theory (enable acl2::integer-length**)))))
+ (cond ((eql 0 (ifix n)) '(nil))
+ ((eql n -1) '(t))
+ (t (bfr-scons (equal (logcar n) 1) (i2v (logcdr n))))))
+
+(defthm bfr-list->s-of-i2v
+ (equal (bfr-list->s (i2v n) env)
+ (ifix n)))
+
+(defthm pbfr-list-depends-on-of-i2v
+ (not (pbfr-list-depends-on k p (i2v n)))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on i2v))))
+
+;; (defthm bfr-max-nat-var-list-of-i2v
+;; (equal (bfr-max-nat-var-list (i2v n)) 0)
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var-list bfr-scons bfr-max-nat-var)
+;; ((bfr-max-nat-var-list))))))
+
+
+(defthm bfr-list->s-of-set-non-dep
+ (implies (and (not (pbfr-list-depends-on k p x))
+ (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k v env)))
+ (equal (bfr-list->s x (bfr-param-env p (bfr-set-var k v env)))
+ (bfr-list->s x (bfr-param-env p env))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on))))
+
+;; (defthm bfr-list->s-of-bfr-set-var-past-max-nat
+;; (implies (and (<= (bfr-max-nat-var-list x) var)
+;; (natp var))
+;; (equal (bfr-list->s x (bfr-set-var var val env))
+;; (bfr-list->s x env)))
+;; :hints(("Goal" :in-theory (enable bfr-max-nat-var-list))))
+
+
+
+
+
+
+
+
+
+
+
+
+(defmacro car/cdr (x)
+ `(let* ((a ,x))
+ (mbe :logic (mv (car a) (cdr a))
+ :exec (if (atom a) (mv nil nil) (mv (car a) (cdr a))))))
+
+(defun bfr-list->u (x env)
+ (declare (xargs :guard t))
+ (if (atom x)
+ 0
+ (logcons (acl2::bool->bit (bfr-eval (car x) env))
+ (bfr-list->u (cdr x) env))))
+
+(defthm bfr-list->u-of-list-fix
+ (equal (bfr-list->u (acl2::list-fix x) env)
+ (bfr-list->u x env)))
+
+(defthm bfr-list->u-type
+ (natp (bfr-list->u x env))
+ :rule-classes :type-prescription)
+
+(in-theory (disable (:t bfr-list->u)))
+
+(defthm bfr-list->u-of-set-non-dep
+ (implies (and (not (pbfr-list-depends-on k p x))
+ (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k v env)))
+ (equal (bfr-list->u x (bfr-param-env p (bfr-set-var k v env)))
+ (bfr-list->u x (bfr-param-env p env))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on))))
+
+;; (defthm bfr-list->u-of-bfr-set-var-past-max-nat
+;; (implies (and (<= (bfr-max-nat-var-list x) var)
+;; (natp var))
+;; (equal (bfr-list->u x (bfr-set-var var val env))
+;; (bfr-list->u x env)))
+;; :hints(("Goal" :in-theory (enable bfr-max-nat-var-list))))
+
;; (in-theory (disable (bfr-listp)))
(add-bfr-eval-pat (bfr-eval-list & env))
+(add-bfr-eval-pats (bfr-list->u & env))
+(add-bfr-eval-pats (bfr-list->s & env))
+
+(defund bfr-ucons (b x)
+ (declare (xargs :guard t))
+ (if (and (atom x) (not b))
+ nil
+ (cons b x)))
+
+(defthm bfr-list->u-of-bfr-ucons
+ (equal (bfr-list->u (bfr-ucons b x) env)
+ (logcons (acl2::bool->bit (bfr-eval b env))
+ (bfr-list->u x env)))
+ :hints(("Goal" :in-theory (enable bfr-ucons))))
+
+(defthm pbfr-list-depends-on-of-bfr-ucons
+ (implies (and (not (pbfr-depends-on k p b))
+ (not (pbfr-list-depends-on k p x)))
+ (not (pbfr-list-depends-on k p (bfr-ucons b x))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on bfr-ucons))))
+
+;; (defthm bfr-max-nat-var-list-of-bfr-ucons
+;; (implies (and (<= (bfr-max-nat-var b) n)
+;; (<= (bfr-max-nat-var-list x) n))
+;; (<= (bfr-max-nat-var-list (bfr-ucons b x)) n))
+;; :hints(("Goal" :in-theory (enable bfr-ucons bfr-max-nat-var-list)))
+;; :rule-classes (:rewrite (:linear :match-free :all)))
+
+
+(defn n2v (n)
+ (if (eql (nfix n) 0)
+ nil
+ (bfr-ucons (equal 1 (logcar n))
+ (n2v (logcdr n)))))
+
+(defthm bfr-list->u-of-n2v
+ (equal (bfr-list->u (n2v n) env)
+ (nfix n)))
+
+(defthm pbfr-list-depends-on-of-n2v
+ (not (pbfr-list-depends-on k p (n2v n)))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on n2v))))
+
+;; (defthm bfr-max-nat-var-list-of-n2v
+;; (equal (bfr-max-nat-var-list (n2v n)) 0)
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var-list bfr-ucons bfr-max-nat-var)
+;; ((bfr-max-nat-var-list))))))
+
+
;; (defun bfr-list-fix (x)
;; (declare (xargs :guard t))
@@ -120,7 +558,6 @@
;; :hints (("goal" :in-theory (enable bfr-list-equiv-necc))))
-
(defun bfr-eval-alist (al vals)
(declare (xargs :guard t))
(if (atom al)
@@ -133,65 +570,305 @@
+(defun boolfix (x)
+ (declare (xargs :guard t))
+ (if x t nil))
+
+(defcong iff equal (boolfix x) 1)
+
+(defthm boolfix-under-iff
+ (iff (boolfix x) x))
+
+
+
+
+
+;; useful for dealing with unsigned and signed bit vectors, resp.
+
+
+
+;; (defund scons (b v)
+;; (declare (xargs :guard t))
+;; (let* ((b (boolfix b)))
+;; (if (atom v)
+;; (if b '(t nil) '(nil))
+;; (if (and (atom (cdr v))
+;; (eq (boolfix (car v)) b))
+;; v
+;; (cons b v)))))
+
+;; (defthm car-of-scons
+;; (iff (car (scons b v))
+;; b)
+;; :hints(("Goal" :in-theory (enable scons))))
+
+;; (defcong iff equal (scons b v) 1
+;; :hints(("Goal" :in-theory (enable scons))))
+
+
+
+
+
+;; (defund sterm (x)
+;; (declare (xargs :guard t))
+;; (if x '(t) '(nil)))
+
+;; (defthm car-of-sterm
+;; (equal (car (sterm x))
+;; (boolfix x))
+;; :hints(("Goal" :in-theory (enable sterm))))
+
+;; (defcong iff equal (sterm x) 1
+;; :hints(("Goal" :in-theory (enable sterm))))
+
+
+;; (defn sfix (v)
+;; (declare (xargs :verify-guards nil))
+;; (mbe :logic (if (s-endp v)
+;; (sterm (car v))
+;; (scons (car v)
+;; (sfix (scdr v))))
+;; :exec (if (atom v)
+;; (list nil)
+;; (if (atom (cdr v))
+;; (list (if (car v) t nil))
+;; (let ((rst (sfix (cdr v)))
+;; (car (if (car v) t nil)))
+;; (if (and (atom (cdr rst)) (eq (car rst) car))
+;; rst
+;; (cons car rst)))))))
+
+;; (defthm consp-sfix
+;; (consp (sfix v))
+;; :hints(("Goal" :in-theory (enable scons s-endp)))
+;; :rule-classes :type-prescription)
+
+;; (defthmd boolean-listp-sfix
+;; (boolean-listp (sfix v))
+;; :hints(("Goal" :in-theory (enable scons sterm))))
+
+;; (local (defthm booleanp-car-sfix
+;; (booleanp (car (sfix v)))
+;; :hints (("goal" :use boolean-listp-sfix))
+;; :rule-classes :type-prescription))
+
+;; (verify-guards sfix :hints(("Goal" :in-theory (enable sterm scons scdr s-endp))))
+
+;; (defun sv-equiv (x y)
+;; (declare (xargs :guard t))
+;; (equal (sfix x) (sfix y)))
+
+;; (defequiv sv-equiv)
+
+;; (defthm sfix-of-scons
+;; (equal (sfix (scons b v))
+;; (scons b (sfix v)))
+;; :hints(("Goal" :in-theory (enable scons scdr s-endp sterm))))
+
+;; (defthm sfix-of-sterm
+;; (equal (sfix (sterm b))
+;; (sterm b))
+;; :hints(("Goal" :in-theory (enable sterm s-endp))))
+
+;; (defthm sfix-of-sfix
+;; (equal (sfix (sfix x)) (sfix x)))
+
+;; (defthm sfix-under-sv-equiv
+;; (sv-equiv (sfix x) x))
+
+;; (defthm car-of-sfix
+;; (equal (car (sfix x))
+;; (boolfix (car x)))
+;; :hints(("Goal" :in-theory (enable scons))))
+
+;; (defcong sv-equiv iff (car x) 1
+;; :hints(("Goal" :in-theory (enable car-of-sfix))))
+
+;; (defcong sv-equiv sv-equiv (scdr x) 1
+;; :hints(("Goal" :in-theory (enable scdr s-endp sterm scons))))
+
+
+;; (defthm sv-equiv-repeat-last
+;; (sv-equiv (append v (last v))
+;; v)
+;; :hints(("Goal" :in-theory (enable append s-endp scdr scons sterm)
+;; :induct (last v))))
+
+
+;; ;; (defthm sv-equiv-of-cdr-sfix
+;; ;; (implies (consp (cdr (sfix x)))
+;; ;; (sv-equiv (cdr (sfix x))
+;; ;; (cdr x)))
+;; ;; :hints(("Goal" :in-theory (enable scons scdr s-endp sterm))))
+
+
+;; (defthm sterm-when-s-endp
+;; (implies (s-endp x)
+;; (sv-equiv (sterm (car x)) x))
+;; :hints(("Goal" :in-theory (enable s-endp sterm)))
+;; :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+;; (defthm scons-car-cdr
+;; (sv-equiv (scons (car x) (scdr x))
+;; x)
+;; :hints(("Goal" :in-theory (enable scons scdr s-endp sterm))))
+
+;; (defcong sv-equiv sv-equiv (scons a b) 2)
+
+
+;; (defthm scdr-of-scons
+;; (sv-equiv (scdr (scons a b))
+;; b)
+;; :hints(("Goal" :in-theory (e/d (scdr scons s-endp)
+;; (boolfix sfix))
+;; :use ((:instance sfix (v b))))))
+
+
+
+;; (defthmd sv-equiv-of-scons
+;; (equal (sv-equiv (scons a b) c)
+;; (and (iff (car c) a)
+;; (sv-equiv (scdr c) b)))
+;; :hints(("Goal" :in-theory (disable sv-equiv scons-car-cdr)
+;; :use ((:instance scons-car-cdr
+;; (x (scons a b)))
+;; (:instance scons-car-cdr
+;; (x c))))))
+
+;; (defthmd scdr-when-equiv-to-endp
+;; (implies (and (sv-equiv a b)
+;; (s-endp b))
+;; (sv-equiv (scdr a) b))
+;; :hints(("Goal" :in-theory (disable sv-equiv)))
+;; :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+;; (defthm scons-sterm
+;; (equal (scons b (sterm b))
+;; (sterm b))
+;; :hints(("Goal" :in-theory (enable scons sterm))))
+
+;; (defthm scdr-sterm
+;; (equal (scdr (sterm b))
+;; (sterm b))
+;; :hints(("Goal" :in-theory (enable scdr sterm))))
+
+;; (defthm scons-equiv-sterm
+;; (and (equal (sv-equiv (scons a b) (sterm c))
+;; (and (iff a c)
+;; (sv-equiv b (sterm c))))
+;; (equal (sv-equiv (sterm c) (scons a b))
+;; (and (iff a c)
+;; (sv-equiv b (sterm c)))))
+;; :hints(("Goal" :in-theory (enable sterm scons s-endp sfix scdr))))
+
+;; (defthm sv-equiv-of-sconses
+;; (equal (sv-equiv (scons a b) (scons c d))
+;; (and (iff a c)
+;; (sv-equiv b d)))
+;; :hints(("Goal" :in-theory (enable sterm scons s-endp sfix scdr))))
+
+
(defn v2i (v)
- (if (atom v)
- 0
- (if (atom (cdr v))
- (if (car v) -1 0)
- (let ((rst (ash (v2i (cdr v)) 1)))
- (+ (if (car v) 1 0) rst)))))
+ (declare (xargs :guard-hints (("goal" :in-theory (enable logcons s-endp scdr
+ acl2::bool->bit)))))
+ (mbe :logic (if (s-endp v)
+ (bool->sign (car v))
+ (logcons (acl2::bool->bit (car v))
+ (v2i (scdr v))))
+ :exec
+ (if (atom v)
+ 0
+ (if (atom (cdr v))
+ (if (car v) -1 0)
+ (logcons (acl2::bool->bit (car v))
+ (v2i (cdr v)))))))
+
+(defthm consp-of-bfr-eval-list
+ (equal (consp (bfr-eval-list x env))
+ (consp x)))
+
+
+
+(defthm v2i-of-bfr-eval-list
+ (equal (v2i (bfr-eval-list x env))
+ (bfr-list->s x env))
+ :hints(("Goal" :induct (bfr-list->s x env)
+ :expand ((bfr-eval-list x env))
+ :in-theory (enable s-endp scdr default-car))))
+
+(defthm v2i-of-i2v
+ (equal (v2i (i2v x))
+ (ifix x))
+ :hints(("Goal" :in-theory (enable bfr-scons s-endp scdr))))
+
+
+
+;; ;; (defthmd v2i-of-scons
+;; ;; (equal (v2i (scons b v))
+;; ;; (v2i (cons b v)))
+;; ;; :hints(("Goal" :in-theory (enable scons))))
-(defn i2v (n)
- (if (eql (ifix n) 0)
- '(nil)
- (if (eql n -1)
- '(t)
- (cons (logbitp 0 n)
- (i2v (ash n -1))))))
-
-
-(defthm v2i-repeat-last
- (equal (v2i (append v (last v)))
- (v2i v))
- :hints(("Goal" :in-theory (enable append))))
-
-(defthm v2i-i2v
- (equal (v2i (i2v i)) (ifix i))
- :hints (("goal" :in-theory (e/d (logbitp) ((:definition i2v)))
- :induct (i2v i)
- :expand ((i2v i)))))
-(defn sfix (v)
- (if (atom v)
- (list nil)
- (if (atom (cdr v))
- (list (if (car v) t nil))
- (let ((rst (sfix (cdr v)))
- (car (if (car v) t nil)))
- (if (and (atom (cdr rst)) (eq (car rst) car))
- rst
- (cons car rst))))))
-
-(defthm v2i-sfix
- (equal (v2i (sfix n))
- (v2i n)))
-
-(defthm i2v-singleton
- (implies (and (atom (cdr (i2v x)))
- (integerp x))
- (equal x (if (car (i2v x)) -1 0)))
- :rule-classes nil)
-
-(defthm i2v-v2i
- (equal (i2v (v2i v)) (sfix v))
- :hints (("goal" :in-theory (e/d (logbitp) ((:definition v2i)))
- :induct (v2i v)
- :expand ((v2i v)))
- ("subgoal *1/4"
- :use ((:instance i2v-singleton
- (x (v2i (cdr v))))))))
+
+
+
+
+
+
+;; (local (defthmd cons-equals-scons-in-i2v
+;; (implies (and (not (zip (logcons b n)))
+;; (not (equal (logcons b n) -1)))
+;; (equal (cons (equal b 1) (i2v n))
+;; (scons (equal b 1) (i2v n))))
+;; :hints(("Goal" :in-theory (enable scons i2v)))))
+
+;; (verify-guards i2v
+;; :hints(("Goal" :in-theory (enable cons-equals-scons-in-i2v))))
+
+;; ;; (if (eql (ifix n) 0)
+;; ;; '(nil)
+;; ;; (if (eql n -1)
+;; ;; '(t)
+;; ;; (cons (logbitp 0 n)
+;; ;; (i2v (ash n -1))))))
+
+
+
+
+;; (defthm v2i-scons
+;; (equal (v2i (scons a b))
+;; (logcons (acl2::bool->bit a) (v2i b)))
+;; :hints(("Goal" :in-theory (enable scons s-endp scdr))))
+
+;; (defthm v2i-i2v
+;; (equal (v2i (i2v i)) (ifix i))
+;; :hints (("goal" :in-theory (e/d () ((:definition i2v)))
+;; :induct (i2v i)
+;; :expand ((i2v i)))))
+
+
+;; (defthm v2i-sterm
+;; (equal (v2i (sterm x))
+;; (bool->sign x))
+;; :hints(("Goal" :in-theory (enable sterm))))
+
+
+;; (defthm v2i-sfix
+;; (equal (v2i (sfix n))
+;; (v2i n)))
+
+;; (defcong sv-equiv equal (sfix x) 1)
+
+;; (defcong sv-equiv equal (v2i x) 1
+;; :hints (("goal" :use ((:instance v2i-sfix (n x))
+;; (:instance v2i-sfix (n x-equiv)))
+;; :in-theory (disable v2i-sfix))))
+
+
+;; (defthm i2v-v2i
+;; (equal (i2v (v2i v)) (sfix v)))
@@ -199,65 +876,210 @@
(defn v2n (v)
(if (atom v)
0
- (let ((rst (ash (v2n (cdr v)) 1)))
- (+ (if (car v) 1 0) rst))))
+ (logcons (acl2::bool->bit (car v))
+ (v2n (cdr v)))))
+
+(defthm v2n-of-bfr-eval-list
+ (equal (v2n (bfr-eval-list x env))
+ (bfr-list->u x env)))
+
+(defthm v2n-of-n2v
+ (equal (v2n (n2v x))
+ (nfix x))
+ :hints(("Goal" :in-theory (enable bfr-ucons))))
-(defn n2v (n)
- (if (eql (nfix n) 0)
- nil
- (cons (logbitp 0 n)
- (n2v (ash n -1)))))
+;; (defund ucons (b x)
+;; (declare (xargs :guard t))
+;; (if (and (atom x) (not b))
+;; nil
+;; (cons (boolfix b) x)))
-(defthm v2n-n2v
- (equal (v2n (n2v n)) (nfix n))
- :hints(("Goal" :in-theory (e/d (logbitp) ((:definition n2v)))
- :induct (n2v n)
- :expand ((n2v n)))))
+;; (defthm v2n-of-ucons
+;; (equal (v2n (ucons b v))
+;; (logcons (acl2::bool->bit b)
+;; (v2n v)))
+;; :hints(("Goal" :in-theory (enable ucons))))
+;; (defthm car-of-ucons
+;; (equal (car (ucons b v))
+;; (boolfix b))
+;; :hints(("Goal" :in-theory (enable ucons))))
-(defn ufix (v)
- (if (atom v)
- nil
- (let ((rst (ufix (cdr v)))
- (car (if (car v) t nil)))
- (if (and (eq rst nil) (eq car nil))
- nil
- (cons car rst)))))
-
-(defthm v2n-ufix
- (equal (v2n (ufix v))
- (v2n v)))
-
-(defthm v2n-nonneg
- (<= 0 (v2n v))
- :rule-classes (:rewrite :linear :type-prescription))
-
-(in-theory (disable (:rewrite v2n-nonneg)
- (:linear v2n-nonneg)))
-
-(defthm n2v-v2n
- (equal (n2v (v2n v)) (ufix v))
- :hints(("Goal" :in-theory (e/d (v2n-nonneg logbitp)
- ((:definition v2n)))
- :induct (v2n v)
- :expand ((v2n v)))))
-
-
-(in-theory (disable v2n n2v v2i i2v ash logbitp))
+;; (defcong iff equal (ucons b v) 1
+;; :hints(("Goal" :in-theory (enable ucons))))
+
+
+
+
+;; (local (defthm cons-is-ucons-in-n2v
+;; (implies (not (zp (logcons b n)))
+;; (equal (cons (equal 1 b) (n2v n))
+;; (ucons (equal 1 b) (n2v n))))
+;; :hints(("Goal" :in-theory (enable ucons)))))
+
+;; (verify-guards n2v)
+
+
+;; (defthm v2n-n2v
+;; (equal (v2n (n2v n)) (nfix n)))
+
+
+
+;; (defn ufix (v)
+;; (declare (xargs :verify-guards nil))
+;; (mbe :logic (if (atom v)
+;; nil
+;; (ucons (car v) (ufix (cdr v))))
+;; :exec
+;; (if (atom v)
+;; nil
+;; (let ((rst (ufix (cdr v)))
+;; (car (if (car v) t nil)))
+;; (if (and (eq rst nil) (eq car nil))
+;; nil
+;; (cons car rst))))))
+
+;; (verify-guards ufix :hints (("goal" :in-theory (enable ucons))))
+
+;; (defthm ufix-of-ucons
+;; (equal (ufix (ucons a b))
+;; (ucons a (ufix b)))
+;; :hints(("Goal" :in-theory (enable ucons))))
+
+;; (defthm v2n-ufix
+;; (equal (v2n (ufix v))
+;; (v2n v)))
+
+;; (defun uv-equiv (x y)
+;; (declare (xargs :guard t))
+;; (equal (ufix x) (ufix y)))
+
+;; (defequiv uv-equiv)
+
+;; (defcong uv-equiv equal (ufix x) 1)
+
+;; (defcong uv-equiv equal (v2n x) 1
+;; :hints (("goal" :use ((:instance v2n-ufix (v x))
+;; (:instance v2n-ufix (v x-equiv)))
+;; :in-theory (disable v2n-ufix))))
+
+;; (defthm ufix-of-ufix
+;; (equal (ufix (ufix x)) (ufix x)))
+
+
+;; (defcong uv-equiv uv-equiv (cdr x) 1
+;; :hints(("Goal" :in-theory (enable ucons))))
+
+;; (defcong uv-equiv iff (car a) 1
+;; :hints(("Goal" :in-theory (enable ucons))))
+;; (defthmd uv-equiv-implies-cars-equiv
+;; (implies (not (iff (car a) (car b)))
+;; (not (uv-equiv a b)))
+;; :hints(("Goal" :in-theory (enable ucons))))
+;; (defthmd equal-of-ucons
+;; (equal (uv-equiv (ucons x y) z)
+;; (and (iff (car z) x)
+;; (uv-equiv y (cdr z))))
+;; :hints(("Goal" :in-theory (enable ucons))))
-(defthm us-to-num
- (implies (natp n)
- (equal (v2n (bfr-eval-list (n2v n) env))
- n))
- :hints(("Goal" :in-theory (enable n2v v2n logbitp ash natp))))
-
-(defthm i2v-to-num
- (implies (integerp n)
- (equal (v2i (bfr-eval-list (i2v n) env)) n))
- :hints(("Goal" :in-theory (enable i2v v2i logbitp
- ash natp))))
+;; (defthm v2n-nonneg
+;; (<= 0 (v2n v))
+;; :rule-classes (:rewrite :linear :type-prescription))
+
+;; (in-theory (disable (:rewrite v2n-nonneg)
+;; (:linear v2n-nonneg)))
+
+;; (defthm n2v-v2n
+;; (equal (n2v (v2n v)) (ufix v)))
+
+
+;; (in-theory (disable v2n n2v v2i i2v ash logbitp))
+
+
+
+
+
+;; ;; (defthm us-to-num
+;; ;; (equal (v2n (bfr-eval-list (n2v n) env))
+;; ;; (nfix n))
+;; ;; :hints(("Goal" :in-theory (enable n2v v2n logbitp ash natp))))
+
+;; ;; (defthm i2v-to-num
+;; ;; (equal (v2i (bfr-eval-list (i2v n) env))
+;; ;; (ifix n))
+;; ;; :hints(("Goal" :in-theory (enable i2v v2i logbitp
+;; ;; ash natp))))
+
+;; (defthm bfr-max-nat-var-list-of-i2v
+;; (equal (bfr-max-nat-var-list (i2v n)) 0)
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var-list i2v scons)
+;; ((bfr-max-nat-var-list) (bfr-max-nat-var))))))
+
+;; (defthm bfr-max-nat-var-list-of-n2v
+;; (equal (bfr-max-nat-var-list (n2v n)) 0)
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var-list n2v ucons)
+;; ((bfr-max-nat-var-list) (bfr-max-nat-var))))))
+
+;; (defthm bfr-max-nat-var-list-of-ufix
+;; (equal (bfr-max-nat-var-list (ufix x)) 0)
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var-list ufix ucons)
+;; ((bfr-max-nat-var-list) (bfr-max-nat-var))))))
+
+;; (defthm bfr-max-nat-var-list-of-sfix
+;; (equal (bfr-max-nat-var-list (sfix x)) 0)
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var-list sfix scons sterm)
+;; ((bfr-max-nat-var-list) (bfr-max-nat-var))))))
+
+;; (defthm bfr-max-nat-var-of-car-when-s-endp
+;; (implies (s-endp x)
+;; (equal (bfr-max-nat-var (car x))
+;; (bfr-max-nat-var-list x)))
+;; :hints(("Goal" :in-theory (enable s-endp bfr-max-nat-var-list)))
+;; :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+;; (defthm bfr-max-nat-var-list-of-append
+;; (equal (bfr-max-nat-var-list (append x y))
+;; (max (bfr-max-nat-var-list x)
+;; (bfr-max-nat-var-list y)))
+;; :hints(("Goal" :in-theory (e/d (bfr-max-nat-var-list)))))
+
+;; (defthm bfr-max-nat-var-list-of-last
+;; (<= (bfr-max-nat-var-list (last x)) (bfr-max-nat-var-list x))
+;; :hints(("Goal" :in-theory (enable bfr-max-nat-var-list)))
+;; :rule-classes (:rewrite :linear))
+
+
+
+;; (acl2::def-universal-equiv
+;; bfr-sv-equiv
+;; :qvars (env)
+;; :equiv-terms ((sv-equiv (bfr-eval-list x env))))
+
+;; (acl2::def-universal-equiv
+;; bfr-uv-equiv
+;; :qvars (env)
+;; :equiv-terms ((uv-equiv (bfr-eval-list x env))))
+
+;; (defcong bfr-sv-equiv sv-equiv (bfr-eval-list x env) 1
+;; :hints(("Goal" :in-theory (disable sv-equiv)
+;; :use ((:instance bfr-sv-equiv-necc (y x-equiv))))))
+
+;; (defcong bfr-uv-equiv uv-equiv (bfr-eval-list x env) 1
+;; :hints(("Goal" :in-theory (disable uv-equiv)
+;; :use ((:instance bfr-uv-equiv-necc (y x-equiv))))))
+
+;; (defthm scdr-when-endp-under-bfr-sv-equiv
+;; (implies (s-endp x)
+;; (bfr-sv-equiv (scdr x) x))
+;; :hints(("Goal" :in-theory (e/d (bfr-sv-equiv bfr-eval-list)))))
+
+;; (defthm scdr-when-endp
+;; (implies (s-endp b)
+;; (sv-equiv (scdr b) b))
+;; :hints(("Goal" :in-theory (enable s-endp scdr)))
+;; :rule-classes ((:rewrite :backchain-limit-lst 0)))
diff -Nru acl2-6.2/books/centaur/gl/cert.acl2 acl2-6.3/books/centaur/gl/cert.acl2
--- acl2-6.2/books/centaur/gl/cert.acl2 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/cert.acl2 2013-09-30 17:53:14.000000000 +0000
@@ -1,16 +1,36 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
; We disabled waterfall parallelism for the gl books. Many of them
; use the bfr-reasoning hint, which can modify state. Here are at
; least some of the books that fail because of this:
-; centaur/gl/g-floor.lisp
-; centaur/gl/cert.acl2
-; centaur/gl/ite-merge.lisp
-; centaur/gl/hyp-fix-logic.lisp
-; centaur/gl/gl-generic-clause-proc.lisp
-; centaur/gl/symbolic-arithmetic.lisp
-; centaur/gl/gify-clause-proc.lisp
-; centaur/gl/gtests.lisp
-; centaur/gl/bvec-ite.lisp
+; centaur/gl/g-floor.lisp
+; centaur/gl/cert.acl2
+; centaur/gl/ite-merge.lisp
+; centaur/gl/hyp-fix-logic.lisp
+; centaur/gl/gl-generic-clause-proc.lisp
+; centaur/gl/symbolic-arithmetic.lisp
+; centaur/gl/gify-clause-proc.lisp
+; centaur/gl/gtests.lisp
+; centaur/gl/bvec-ite.lisp
; centaur/gl/bfr.lisp
(set-waterfall-parallelism nil)
diff -Nru acl2-6.2/books/centaur/gl/constraint-db-deps.lisp acl2-6.3/books/centaur/gl/constraint-db-deps.lisp
--- acl2-6.2/books/centaur/gl/constraint-db-deps.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/constraint-db-deps.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,522 @@
+
+(in-package "GL")
+
+(include-book "constraint-db")
+(include-book "glcp-unify-thms")
+
+(define gobj-alist-list-depends-on (k p x)
+ :verify-guards nil
+ (if (atom x)
+ nil
+ (or (gobj-alist-depends-on k p (car x))
+ (gobj-alist-list-depends-on k p (cdr x))))
+ ///
+ (defthm gobj-alist-list-depends-on-of-append
+ (equal (gobj-alist-list-depends-on k p (append a b))
+ (or (gobj-alist-list-depends-on k p a)
+ (gobj-alist-list-depends-on k p b)))
+ :hints(("Goal" :in-theory (enable gobj-alist-list-depends-on))))
+ (defthm gobj-alist-list-depends-on-nil
+ (not (gobj-alist-list-depends-on k p nil))
+ :hints(("Goal" :in-theory (enable gobj-alist-list-depends-on)))))
+
+(define gbc-sigtable-depends-on (k p sigtable)
+ :verify-guards nil
+ (if (atom sigtable)
+ nil
+ (if (atom (car sigtable))
+ (gbc-sigtable-depends-on k p (cdr sigtable))
+ (or (gobj-alist-list-depends-on k p (cdar sigtable))
+ (gbc-sigtable-depends-on k p (cdr sigtable))))))
+
+(define gbc-tuples-depends-on (k p tuples)
+ :verify-guards nil
+ (if (atom tuples)
+ nil
+ (or (gbc-sigtable-depends-on k p (constraint-tuple->sig-table (car tuples)))
+ (gbc-tuples-depends-on k p (cdr tuples)))))
+
+
+(define gbc-db-depends-on (k p ccat)
+ :verify-guards nil
+ (if (atom ccat)
+ nil
+ (if (atom (car ccat))
+ (gbc-db-depends-on k p (cdr ccat))
+ (or (gbc-tuples-depends-on k p (cdar ccat))
+ (gbc-db-depends-on k p (cdr ccat))))))
+
+
+(defsection gbc-db-emptyp
+
+ (define gbc-sigtable-emptyp (x)
+ :verify-guards nil
+ (if (atom x)
+ t
+ (and (or (atom (car x))
+ (subsetp (cdar x) '(nil)))
+ (gbc-sigtable-emptyp (cdr X))))
+ ///
+ (defthm gbc-sigtable-empty-implies-no-dependencies
+ (implies (gbc-sigtable-emptyp x)
+ (not (gbc-sigtable-depends-on k p x)))
+ :hints(("Goal" :in-theory (enable gbc-sigtable-depends-on
+ gobj-alist-list-depends-on)))))
+
+
+ (define gbc-tuples-emptyp (x)
+ :verify-guards nil
+ (if (atom x)
+ t
+ (and (gbc-sigtable-emptyp (constraint-tuple->sig-table (car x)))
+ (gbc-tuples-emptyp (cdr x))))
+ ///
+ (defthm gbc-tuples-empty-implies-no-dependencies
+ (implies (gbc-tuples-emptyp x)
+ (not (gbc-tuples-depends-on k p x)))
+ :hints(("Goal" :in-theory (enable gbc-tuples-depends-on)))))
+
+ (define gbc-db-emptyp (x)
+ :verify-guards nil
+ (if (atom x)
+ t
+ (and (or (atom (car x))
+ (gbc-tuples-emptyp (cdar x)))
+ (gbc-db-emptyp (cdr x))))
+ ///
+ (defthm gbc-db-emptyp-implies-no-dependencies
+ (implies (gbc-db-emptyp x)
+ (not (gbc-db-depends-on k p x)))
+ :hints(("Goal" :in-theory (enable gbc-db-depends-on))))))
+
+
+
+(defthm gbc-extend-substs-dependencies
+ (implies (and (not (gobj-alist-depends-on k p lit-subst))
+ (not (gobj-alist-list-depends-on k p partial-substs)))
+ (not (gobj-alist-list-depends-on k p (gbc-extend-substs lit-subst
+ partial-substs))))
+ :hints(("Goal" :in-theory (enable gobj-alist-list-depends-on))))
+
+(local (in-theory (enable alist-vals)))
+
+(defthm gbc-substs-check-syntaxp-dependencies
+ (implies (not (gobj-alist-list-depends-on k p substs))
+ (not (gobj-alist-list-depends-on
+ k p (alist-vals (gbc-substs-check-syntaxp substs thmname syntaxp
+ state)))))
+ :hints(("Goal" :in-theory (enable gbc-substs-check-syntaxp
+ gobj-alist-list-depends-on))))
+
+(defthm dependencies-of-sigtable-lookup
+ (implies (not (gbc-sigtable-depends-on k p sigtable))
+ (not (gobj-alist-list-depends-on k p (cdr (hons-assoc-equal sig
+ sigtable)))))
+ :hints(("Goal" :in-theory (enable gbc-sigtable-depends-on
+ gobj-alist-list-depends-on))))
+
+(defthm gbc-sort-substs-into-sigtable-dependencies
+ (implies (and (not (gobj-alist-list-depends-on k p substs))
+ (not (gbc-sigtable-depends-on k p sigtable)))
+ (not (gbc-sigtable-depends-on
+ k p (gbc-sort-substs-into-sigtable substs common-vars
+ sigtable))))
+ :hints(("Goal" :in-theory (enable gobj-alist-list-depends-on
+ gbc-sigtable-depends-on))))
+
+(defthm gbc-unbound-lits-add-to-existing-tuple-dependencies
+ (implies (and (not (gobj-alist-list-depends-on k p substs))
+ (not (gbc-tuples-depends-on k p tuples)))
+ (not (gbc-tuples-depends-on
+ k p (mv-nth 1 (gbc-unbound-lits-add-to-existing-tuple
+ rule existing-lits lit substs tuples)))))
+ :hints(("Goal" :in-theory (enable gbc-tuples-depends-on))))
+
+(defthm gbc-unbound-lits-add-tuples-dependencies
+ (implies (and (not (gobj-alist-list-depends-on k p substs))
+ (not (gbc-db-depends-on k p ccat)))
+ (not (gbc-db-depends-on k p (gbc-unbound-lits-add-tuples
+ litvars rule existing-lits
+ existing-vars substs ccat))))
+ :hints(("Goal" :in-theory (enable gbc-db-depends-on
+ gbc-tuples-depends-on))))
+
+
+;; (local (defthm gobj-alist-depends-on-nil
+;; (not (gobj-alist-depends-on k p nil))
+;; :hints(("Goal" :in-theory (enable gobj-alist-depends-on)))))
+
+(defthm dependencies-of-gbc-db-lookup
+ (implies (not (gbc-db-depends-on k p sigtable))
+ (not (gbc-tuples-depends-on k p (cdr (hons-assoc-equal sig sigtable)))))
+ :hints(("Goal" :in-theory (enable gbc-db-depends-on))))
+
+(defthm gbc-process-new-lit-tuple-dependencies
+ (implies (and (not (gobj-depends-on k p lit))
+ (not (gbc-sigtable-depends-on k p (constraint-tuple->sig-table
+ tuple)))
+ (not (gbc-db-depends-on k p ccat)))
+ (mv-let (substs ccat)
+ (gbc-process-new-lit-tuple lit tuple ccat state)
+ (and (not (gobj-alist-list-depends-on k p (alist-vals substs)))
+ (not (gbc-db-depends-on k p ccat)))))
+ :hints (("goal" :expand ((:free (a b) (gbc-db-depends-on k p (cons a b)))
+ (:free (a b) (gbc-tuples-depends-on k p (cons a
+ b)))))))
+
+(local (defthm alist-vals-of-append
+ (equal (alist-vals (append a b))
+ (append (alist-vals a) (alist-vals b)))))
+
+
+
+(defthm gbc-process-new-lit-tuples-dependencies
+ (implies (and (not (gobj-depends-on k p lit))
+ (not (gbc-tuples-depends-on k p tuples))
+ (not (gbc-db-depends-on k p ccat)))
+ (mv-let (substs ccat)
+ (gbc-process-new-lit-tuples lit tuples ccat state)
+ (and (not (gobj-alist-list-depends-on k p (alist-vals substs)))
+ (not (gbc-db-depends-on k p ccat)))))
+ :hints(("Goal" :in-theory (e/d (gbc-tuples-depends-on)
+ (gbc-process-new-lit-tuple)))))
+
+(defthm gbc-process-new-lit-dependencies
+ (implies (and (not (gobj-depends-on k p lit))
+ (not (gbc-db-depends-on k p ccat)))
+ (mv-let (substs ccat)
+ (gbc-process-new-lit lit ccat state)
+ (and (not (gobj-alist-list-depends-on k p (alist-vals substs)))
+ (not (gbc-db-depends-on k p ccat)))))
+ :hints(("Goal" :in-theory (enable gbc-process-new-lit))))
+
+
+
+(defund parametrize-gobj-alists (p alists)
+ (declare (xargs :guard t))
+ (if (atom alists)
+ nil
+ (cons (gobj-alist-to-param-space (car alists) p)
+ (parametrize-gobj-alists p (cdr alists)))))
+
+(defund parametrize-sig-table (p sig-table)
+ (declare (xargs :guard t))
+ (if (atom sig-table)
+ nil
+ (if (atom (car sig-table))
+ (parametrize-sig-table p (cdr sig-table))
+ (hons-acons (gobj-list-to-param-space (caar sig-table) p)
+ (parametrize-gobj-alists p (cdar sig-table))
+ (parametrize-sig-table p (cdr sig-table))))))
+
+
+(defund parametrize-constraint-db-tuples (p tuples)
+ (declare (xargs :guard t))
+ (b* (((when (atom tuples)) nil)
+ ((unless (constraint-tuple-p (car tuples)))
+ (parametrize-constraint-db-tuples p (cdr tuples)))
+ ((constraint-tuple x) (car tuples))
+ (sig-table (parametrize-sig-table p x.sig-table)))
+ (fast-alist-free x.sig-table)
+ (cons (constraint-tuple x.rule x.existing-lits x.matching-lit x.common-vars
+ x.existing-vars sig-table)
+ (parametrize-constraint-db-tuples p (cdr tuples)))))
+
+(defund parametrize-constraint-db (p ccat)
+ (declare (xargs :guard t))
+ (b* (((when (atom ccat)) nil)
+ ((when (atom (car ccat)))
+ (parametrize-constraint-db p (cdr ccat))))
+ (hons-acons (caar ccat)
+ (parametrize-constraint-db-tuples p (cdar ccat))
+ (parametrize-constraint-db p (cdr ccat)))))
+
+
+
+
+
+(defsection gobj-alist-list-vars-bounded
+ (defund gobj-alist-list-vars-bounded (k p x)
+ (if (atom x)
+ t
+ (and (gobj-alist-vars-bounded k p (car x))
+ (gobj-alist-list-vars-bounded k p (cdr x)))))
+
+ (defund gobj-alist-list-vars-bounded-witness (k p x)
+ (if (atom x)
+ nil
+ (or (gobj-alist-vars-bounded-witness k p (car x))
+ (gobj-alist-list-vars-bounded-witness k p (cdr x)))))
+
+ (local (in-theory (enable gobj-alist-list-vars-bounded
+ gobj-alist-list-vars-bounded-witness)))
+
+ (local (in-theory (disable nfix)))
+
+ (defthm gobj-alist-list-vars-bounded-implies-not-depends-on
+ (implies (and (gobj-alist-list-vars-bounded k p x)
+ (<= (nfix k) (nfix n)))
+ (not (gobj-alist-list-depends-on n p x)))
+ :hints(("Goal" :in-theory (e/d (gobj-alist-list-depends-on)))))
+
+ (defthm gobj-alist-list-vars-bounded-incr
+ (implies (and (gobj-alist-list-vars-bounded m p x)
+ (<= (nfix m) (nfix n)))
+ (gobj-alist-list-vars-bounded n p x)))
+
+ (defthm gobj-alist-list-vars-bounded-witness-under-iff
+ (iff (gobj-alist-list-vars-bounded-witness k p x)
+ (not (gobj-alist-list-vars-bounded k p x))))
+
+ (defthmd gobj-alist-list-vars-bounded-in-terms-of-witness
+ (implies (acl2::rewriting-positive-literal
+ `(gobj-alist-list-vars-bounded ,k ,p ,x))
+ (equal (gobj-alist-list-vars-bounded k p x)
+ (let ((n (gobj-alist-list-vars-bounded-witness k p x)))
+ (or (< (nfix n) (nfix k))
+ (not (gobj-alist-list-depends-on n p x))))))
+ :hints(("Goal" :in-theory (enable gobj-alist-list-depends-on
+ gobj-alist-vars-bounded-in-terms-of-witness))))
+
+ (defthm gobj-alist-list-vars-bounded-of-cons
+ (equal (gobj-alist-list-vars-bounded k p (cons a b))
+ (and (gobj-alist-vars-bounded k p a)
+ (gobj-alist-list-vars-bounded k p b))))
+
+ (defthm gobj-alist-list-vars-bounded-of-atom
+ (implies (not (consp x))
+ (equal (gobj-alist-list-vars-bounded k p x) t))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm gobj-alist-list-vars-bounded-of-parametrize-gobj-alists
+ (implies (gobj-alist-list-vars-bounded k t x)
+ (gobj-alist-list-vars-bounded
+ k p (parametrize-gobj-alists p x)))
+ :hints(("Goal" :in-theory (enable gobj-alist-list-vars-bounded
+ parametrize-gobj-alists)))))
+
+
+(defsection gbc-sigtable-vars-bounded
+ (defund gbc-sigtable-vars-bounded (k p x)
+ (if (atom x)
+ t
+ (and (or (atom (car x))
+ (gobj-alist-list-vars-bounded k p (cdar x)))
+ (gbc-sigtable-vars-bounded k p (cdr x)))))
+
+ (defund gbc-sigtable-vars-bounded-witness (k p x)
+ (if (atom x)
+ nil
+ (or (and (consp (car x))
+ (gobj-alist-list-vars-bounded-witness k p (cdar x)))
+ (gbc-sigtable-vars-bounded-witness k p (cdr x)))))
+
+ (local (in-theory (enable gbc-sigtable-vars-bounded
+ gbc-sigtable-vars-bounded-witness)))
+
+ (local (in-theory (disable nfix)))
+
+ (defthm gbc-sigtable-vars-bounded-implies-not-depends-on
+ (implies (and (gbc-sigtable-vars-bounded k p x)
+ (<= (nfix k) (nfix n)))
+ (not (gbc-sigtable-depends-on n p x)))
+ :hints(("Goal" :in-theory (e/d (gbc-sigtable-depends-on)))))
+
+ (defthm gbc-sigtable-vars-bounded-incr
+ (implies (and (gbc-sigtable-vars-bounded m p x)
+ (<= (nfix m) (nfix n)))
+ (gbc-sigtable-vars-bounded n p x)))
+
+ (defthm gbc-sigtable-vars-bounded-witness-under-iff
+ (iff (gbc-sigtable-vars-bounded-witness k p x)
+ (not (gbc-sigtable-vars-bounded k p x))))
+
+ (defthmd gbc-sigtable-vars-bounded-in-terms-of-witness
+ (implies (acl2::rewriting-positive-literal
+ `(gbc-sigtable-vars-bounded ,k ,p ,x))
+ (equal (gbc-sigtable-vars-bounded k p x)
+ (let ((n (gbc-sigtable-vars-bounded-witness k p x)))
+ (or (< (nfix n) (nfix k))
+ (not (gbc-sigtable-depends-on n p x))))))
+ :hints(("Goal" :in-theory (enable gbc-sigtable-depends-on
+ gobj-alist-list-vars-bounded-in-terms-of-witness))))
+
+ (defthm gbc-sigtable-vars-bounded-of-cons
+ (equal (gbc-sigtable-vars-bounded k p (cons a b))
+ (and (or (atom a)
+ (gobj-alist-list-vars-bounded k p (cdr a)))
+ (gbc-sigtable-vars-bounded k p b))))
+
+ (defthm gbc-sigtable-vars-bounded-of-atom
+ (implies (not (consp x))
+ (equal (gbc-sigtable-vars-bounded k p x) t))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+
+ (defthm gbc-sigtable-vars-bounded-of-parametrize-sig-table
+ (implies (gbc-sigtable-vars-bounded k t x)
+ (gbc-sigtable-vars-bounded
+ k p (parametrize-sig-table p x)))
+ :hints(("Goal" :in-theory (enable gbc-sigtable-vars-bounded
+ parametrize-sig-table)))))
+
+
+(defsection gbc-tuples-vars-bounded
+ (defund gbc-tuples-vars-bounded (k p x)
+ (if (atom x)
+ t
+ (and (gbc-sigtable-vars-bounded k p (constraint-tuple->sig-table (car x)))
+ (gbc-tuples-vars-bounded k p (cdr x)))))
+
+ (defund gbc-tuples-vars-bounded-witness (k p x)
+ (if (atom x)
+ nil
+ (or (gbc-sigtable-vars-bounded-witness k p (constraint-tuple->sig-table (car x)))
+ (gbc-tuples-vars-bounded-witness k p (cdr x)))))
+
+ (local (in-theory (enable gbc-tuples-vars-bounded
+ gbc-tuples-vars-bounded-witness)))
+
+ (local (in-theory (disable nfix)))
+
+ (defthm gbc-tuples-vars-bounded-implies-not-depends-on
+ (implies (and (gbc-tuples-vars-bounded k p x)
+ (<= (nfix k) (nfix n)))
+ (not (gbc-tuples-depends-on n p x)))
+ :hints(("Goal" :in-theory (e/d (gbc-tuples-depends-on)))))
+
+ (defthm gbc-tuples-vars-bounded-incr
+ (implies (and (gbc-tuples-vars-bounded m p x)
+ (<= (nfix m) (nfix n)))
+ (gbc-tuples-vars-bounded n p x)))
+
+ (defthm gbc-tuples-vars-bounded-witness-under-iff
+ (iff (gbc-tuples-vars-bounded-witness k p x)
+ (not (gbc-tuples-vars-bounded k p x))))
+
+ (defthmd gbc-tuples-vars-bounded-in-terms-of-witness
+ (implies (acl2::rewriting-positive-literal
+ `(gbc-tuples-vars-bounded ,k ,p ,x))
+ (equal (gbc-tuples-vars-bounded k p x)
+ (let ((n (gbc-tuples-vars-bounded-witness k p x)))
+ (or (< (nfix n) (nfix k))
+ (not (gbc-tuples-depends-on n p x))))))
+ :hints(("Goal" :in-theory (enable gbc-tuples-depends-on
+ gbc-sigtable-vars-bounded-in-terms-of-witness))))
+
+ (defthm gbc-tuples-vars-bounded-of-cons
+ (equal (gbc-tuples-vars-bounded k p (cons a b))
+ (and (gbc-sigtable-vars-bounded k p (constraint-tuple->sig-table a))
+ (gbc-tuples-vars-bounded k p b))))
+
+ (defthm gbc-tuples-vars-bounded-of-atom
+ (implies (not (consp x))
+ (equal (gbc-tuples-vars-bounded k p x) t))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm gbc-tuples-vars-bounded-of-parametrize-constraint-db-tuples
+ (implies (gbc-tuples-vars-bounded k t x)
+ (gbc-tuples-vars-bounded
+ k p (parametrize-constraint-db-tuples p x)))
+ :hints(("Goal" :in-theory (enable gbc-tuples-vars-bounded
+ parametrize-constraint-db-tuples)))))
+
+
+
+(defsection gbc-db-vars-bounded
+ (defund gbc-db-vars-bounded (k p x)
+ (if (atom x)
+ t
+ (and (or (atom (car x))
+ (gbc-tuples-vars-bounded k p (cdar x)))
+ (gbc-db-vars-bounded k p (cdr x)))))
+
+ (defund gbc-db-vars-bounded-witness (k p x)
+ (if (atom x)
+ nil
+ (or (and (consp (car x))
+ (gbc-tuples-vars-bounded-witness k p (cdar x)))
+ (gbc-db-vars-bounded-witness k p (cdr x)))))
+
+ (local (in-theory (enable gbc-db-vars-bounded
+ gbc-db-vars-bounded-witness)))
+
+ (local (in-theory (disable nfix)))
+
+ (defthm gbc-db-vars-bounded-implies-not-depends-on
+ (implies (and (gbc-db-vars-bounded k p x)
+ (<= (nfix k) (nfix n)))
+ (not (gbc-db-depends-on n p x)))
+ :hints(("Goal" :in-theory (e/d (gbc-db-depends-on)))))
+
+ (defthm gbc-db-vars-bounded-incr
+ (implies (and (gbc-db-vars-bounded m p x)
+ (<= (nfix m) (nfix n)))
+ (gbc-db-vars-bounded n p x)))
+
+ (defthm gbc-db-vars-bounded-witness-under-iff
+ (iff (gbc-db-vars-bounded-witness k p x)
+ (not (gbc-db-vars-bounded k p x))))
+
+ (defthmd gbc-db-vars-bounded-in-terms-of-witness
+ (implies (acl2::rewriting-positive-literal
+ `(gbc-db-vars-bounded ,k ,p ,x))
+ (equal (gbc-db-vars-bounded k p x)
+ (let ((n (gbc-db-vars-bounded-witness k p x)))
+ (or (< (nfix n) (nfix k))
+ (not (gbc-db-depends-on n p x))))))
+ :hints(("Goal" :in-theory (enable gbc-db-depends-on
+ gbc-tuples-vars-bounded-in-terms-of-witness))))
+
+ (defthm gbc-db-vars-bounded-of-cons
+ (equal (gbc-db-vars-bounded k p (cons a b))
+ (and (or (atom a)
+ (gbc-tuples-vars-bounded k p (cdr a)))
+ (gbc-db-vars-bounded k p b))))
+
+ (defthm gbc-db-vars-bounded-of-atom
+ (implies (not (consp x))
+ (equal (gbc-db-vars-bounded k p x) t))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+
+ (defthm gbc-db-vars-bounded-of-parametrize-constraint-db
+ (implies (gbc-db-vars-bounded k t x)
+ (gbc-db-vars-bounded
+ k p (parametrize-constraint-db p x)))
+ :hints(("Goal" :in-theory (enable gbc-db-vars-bounded
+ parametrize-constraint-db)))))
+
+
+
+
+
+(defthm gbc-process-new-lit-bounded
+ (implies (and (gobj-vars-bounded k p lit)
+ (gbc-db-vars-bounded k p ccat))
+ (mv-let (substs ccat)
+ (gbc-process-new-lit lit ccat state)
+ (and (gobj-alist-list-vars-bounded k p (alist-vals substs))
+ (gbc-db-vars-bounded k p ccat))))
+ :hints (("goal" :in-theory (enable
+ gobj-alist-list-vars-bounded-in-terms-of-witness
+ gbc-db-vars-bounded-in-terms-of-witness))))
+
+
+
+
+(defthm gbc-db-vars-bounded-of-incr
+ (implies (and (gbc-db-vars-bounded n p x)
+ (<= (nfix n) (nfix k)))
+ (gbc-db-vars-bounded k p x))
+ :hints (("goal" :in-theory (e/d (gbc-db-vars-bounded-in-terms-of-witness)
+ (nfix)))))
+
+
+
+(defthmd gbc-db-empty-implies-gbc-db-vars-bounded
+ (implies (gbc-db-emptyp x)
+ (gbc-db-vars-bounded k p x))
+ :hints(("Goal" :in-theory (enable gbc-db-vars-bounded-in-terms-of-witness))))
+
+
diff -Nru acl2-6.2/books/centaur/gl/constraint-db.lisp acl2-6.3/books/centaur/gl/constraint-db.lisp
--- acl2-6.2/books/centaur/gl/constraint-db.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/constraint-db.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,413 @@
+
+
+(in-package "GL")
+
+(include-book "clause-processors/unify-subst" :dir :system)
+(include-book "glcp-unify-defs")
+(include-book "clause-processors/magic-ev" :dir :system)
+
+
+(defun gl-bool-fix (x)
+ (and x t))
+
+;; A constraint rule is written as follows:
+
+;; (gl::def-gl-boolean-constraint thmname
+;; :bindings ((x (logbitp n a))
+;; (y (logbitp m a)))
+;; :syntaxp (and (<< n m)
+;; (not (and (atom n) (atom m))))
+;; :body (implies (equal n m)
+;; (equal x y))
+;; :hints ...)
+
+;; This generates an ACL2 theorem:
+;; (defthm thmname
+;; (let ((x (gl-bool-fix (logbitp n a)))
+;; (y (gl-bool-fix (logbitp m a))))
+;; (implies (equal n m)
+;; (equal x y)))
+;; :hints ...
+;; :rule-classes nil).
+
+;; The point of this rule is to add a constraint when we have two Boolean
+;; variables generated from (logbitp n a) terms. When we find two such
+;; variables, we call their corresponding terms the literals of the
+;; constraint. We generate the constraint by unifying the literals with the
+;; bindings from the constraint rule and then symbolically executing the body
+;; of the theorem under a Boolean context. Since it's a theorem, we can assume
+;; the symbolic-Boolean result to be true under our bvar-db.
+
+
+
+;; To find such literals, we maintain a constraint catalog, a data structure
+;; that lets us quickly match a new literal to existing ones. This uses a
+;; several-levels lookup system, as follows.
+;;
+;; Outermost structure is indexed by the first function symbol of the literal.
+;; Inside that is a list of tuples:
+;; (rule existing-lits matching-lit common-variables signature-table)
+;; rule is a constraint rule structure, matching-lit is the variable of the
+;; lit pattern we'll match against, existing-lits are variables of lit
+;; patterns for which literals have already been found.
+;; Common-vars are the intersection of the vars of the matching-lit pattern
+;; with the vars of the existing-lit patterns.
+;; Signature-table maps signatures to partial unifying substitution lists. A
+;; signature is the list of unifying bindings of common-vars.
+
+;; So to find new constraints given a new literal:
+;; - look up the tuples for that literal's leading function symbol
+;; - for each tuple,
+;; unify the literal with the matching-lit of the rule
+;; extract the bindings of common-vars to make the signature
+;; look up the signature in the signature-table to get the partial substs
+;; for each partial unifying subst, union the unifying subst for the
+;; literal.
+;; If the matching-lit + existing-lits are all the literals of the rule,
+;; then these substitutions are now complete and can be used to generate constraints.
+;; Otherwise, new entries should be added to the constraint-catalog for
+;; each other literal of the rule, as follows:
+;; under the function symbol of the addtl-literal,
+;; find the tuple matching (rule existing-lits+matching-lit addtl-lit ....)
+;; create it if not, computing the common-vars
+;; for each partial-subst:
+;; extract the common-vars to get the signature
+;; add the partial-subst to the list for that signature.
+
+;; As a GL proof progresses, new literals may be added to the bvar-db and the
+;; constraint-table may be extended. But we start with a base constraint-table
+;; at the beginning of any proof; this is stored in an ACL2 table. In this
+;; initial constraing table, each tuple has empty existing-lits, thus empty
+;; common-vars and thus the unique signature is NIL, and a single empty
+;; partial unifying subst is stored under that signature.
+
+;; Heuristic info about a constraint rule.
+;; We'll look up the theorem in the world, so it doesn't need to be stored
+;; here.
+;; Constrained-terms is an alist mapping variables to terms.
+(cutil::defaggregate constraint-rule
+ (thmname lit-alist syntaxp))
+
+;; this is the tuple referred to above
+(cutil::defaggregate constraint-tuple
+ (rule existing-lits matching-lit common-vars existing-vars sig-table))
+
+
+;; Code to add a rule to the initial catalog (with empty existing-lits etc).
+(defun gbc-rule-lit-add-catalog-entry (var pat rule ccat)
+ (b* ((fnsym (car pat))
+ (tuples (cdr (hons-assoc-equal fnsym ccat)))
+ ;; assume rule is new, so no matching tuple exists -- just cons on a new
+ ;; one.
+ ;; signature-table contains nil mapped to (list nil) -- list containing
+ ;; one empty unifying subst
+ (new-tuple (constraint-tuple rule nil var nil nil (hons-acons nil (list nil) nil))))
+ (cons (cons fnsym (cons new-tuple tuples)) ccat)))
+
+(defun gbc-rule-add-catalog-entries (lit-alist rule ccat)
+ (b* (((when (atom lit-alist)) ccat)
+ ((cons var pat) (car lit-alist))
+ (ccat (gbc-rule-lit-add-catalog-entry var pat rule ccat)))
+ (gbc-rule-add-catalog-entries (cdr lit-alist) rule ccat)))
+
+
+;; Optimization: if two constrained terms are isomorphic (they unify with the
+;; same terms), and there's no syntaxp, then there's no need to list the rule
+;; under both of them
+(defun gbc-alist-has-symmetric (term alist)
+ (b* (((when (atom alist)) nil)
+ (term2 (cdar alist))
+ ((mv ok1 &) (acl2::simple-one-way-unify term term2 nil))
+ ((mv ok2 &) (acl2::simple-one-way-unify term2 term nil)))
+ (or (and ok1 ok2)
+ (gbc-alist-has-symmetric term (cdr alist)))))
+
+(defun gbc-alist-remove-symmetric (alist)
+ (if (atom alist)
+ nil
+ (if (gbc-alist-has-symmetric (cdar alist) (cdr alist))
+ (gbc-alist-remove-symmetric (cdr alist))
+ (cons (car alist) (gbc-alist-remove-symmetric (cdr alist))))))
+
+
+
+
+(defun gbc-rule-add-to-catalog (rule ccat)
+ ;; Iterate over the constraint-alist.
+ (b* ((syntaxp (constraint-rule->syntaxp rule))
+ (alist (constraint-rule->lit-alist rule))
+ (reduced-alist (if (equal syntaxp ''t)
+ (gbc-alist-remove-symmetric alist)
+ alist)))
+ (hons-shrink-alist
+ (gbc-rule-add-catalog-entries reduced-alist rule ccat)
+ nil)))
+
+(defmacro gbc-add-rule (name lit-alist syntaxp)
+ `(table gl::gl-bool-constraints
+ nil
+ (gbc-rule-add-to-catalog
+ (constraint-rule ',name ',lit-alist ',syntaxp)
+ (table-alist 'gl::gl-bool-constraints world))
+ :clear))
+
+
+
+
+(defun gbc-translate-lit-alist (lit-patterns state)
+ (declare (xargs :mode :program :stobjs state))
+ (b* (((when (atom lit-patterns)) (value nil))
+ ((list var term) (car lit-patterns))
+ ((er trans) (acl2::translate term t t nil 'def-gl-boolean-constraint (w state)
+ state))
+ ((er rest) (gbc-translate-lit-alist (cdr lit-patterns) state)))
+ (value (cons (cons var trans) rest))))
+
+
+
+(defun def-gl-boolean-constraint-fn (name lit-patterns syntaxp body hints state)
+ (declare (xargs :mode :program :stobjs state))
+ (b* (((er syntaxp-trans) (acl2::translate syntaxp t t nil 'def-gl-boolean-constraint
+ (w state) state))
+ ((er alist) (gbc-translate-lit-alist lit-patterns state))
+ (body1 `(let ,(pairlis$ (strip-cars lit-patterns)
+ (pairlis$ (pairlis$
+ (make-list-ac (len lit-patterns) 'gl-bool-fix nil)
+ (strip-cdrs lit-patterns))
+ nil))
+ ,body)))
+ (value `(progn (defthm ,name
+ ,body1
+ :hints ,hints
+ :rule-classes nil)
+ (gbc-add-rule ,name ,alist ,syntaxp-trans)))))
+
+(defsection def-gl-boolean-constraint
+ :parents (reference g-call)
+ :short "Define a rule that recognizes constraints among GL generated Boolean variables"
+ :long "
+When using GL in a term-level style (see @(see term-level-reasoning)), GL
+may generate new Boolean variables from terms that appear as IF tests.
+
+Sometimes, the terms from which these variables are generated have
+interdependent meanings. For example, if Boolean variable @('a') represents
+@('(logbitp 5 x)') and Boolean variable @('b') represents @('(integerp x)'), it
+should be impossible for @('a') to be true when @('b') is false. However, by
+default, the Boolean variables generated this way are unconstrained. When
+this sort of interdependency among variables exists but is not accounted for,
+it can cause GL to find @(see false-counterexamples).
+
+@('Def-gl-boolean-constraint') provides a mechanism to make such constraints
+known to GL. While symbolically executing a form, GL maintains a constraint, a
+Boolean formula known to always be true (under the evolving assignment of
+Boolean variables to terms).
"
+
+
+ (defmacro def-gl-boolean-constraint (name &key bindings (syntaxp ''t) body
+ hints)
+ `(make-event
+ (def-gl-boolean-constraint-fn
+ ',name ',bindings ',syntaxp ',body ',hints state))))
+
+(defun gbc-signature (common-vars subst)
+ (if (atom common-vars)
+ nil
+ (hons (cdr (assoc (car common-vars) subst))
+ (gbc-signature (cdr common-vars) subst))))
+
+(defun gbc-extend-substs (lit-subst partial-substs)
+ (if (atom partial-substs)
+ nil
+ ;; is append good enough? I think so
+ (cons (append lit-subst (car partial-substs))
+ (gbc-extend-substs lit-subst (cdr partial-substs)))))
+
+(defun gbc-substs-check-syntaxp (substs thmname syntaxp state)
+ (declare (xargs :stobjs state :verify-guards nil))
+ (b* (((when (atom substs)) nil)
+ ((mv err ok) (acl2::magic-ev syntaxp (car substs) state t t))
+ ((when (or err (not ok)))
+ (gbc-substs-check-syntaxp (cdr substs) thmname syntaxp state)))
+ (cons (cons thmname (car substs))
+ (gbc-substs-check-syntaxp (cdr substs) thmname syntaxp state))))
+
+
+(defun gbc-sort-substs-into-sigtable (substs common-vars sigtable)
+ (b* (((when (atom substs)) sigtable)
+ (subst (car substs))
+ (sig (gbc-signature common-vars subst))
+ (sig-substs (cdr (hons-get sig sigtable)))
+ (sigtable (hons-acons sig (cons subst sig-substs) sigtable)))
+ (gbc-sort-substs-into-sigtable (cdr substs) common-vars sigtable)))
+
+(defun gbc-unbound-lits-add-to-existing-tuple (rule existing-lits lit substs tuples)
+ (b* (((when (atom tuples)) (mv nil tuples))
+ ((constraint-tuple x) (car tuples))
+ ((unless (and (equal rule x.rule)
+ (equal existing-lits x.existing-lits)
+ (equal lit x.matching-lit)))
+ (b* (((mv found rest)
+ (gbc-unbound-lits-add-to-existing-tuple
+ rule existing-lits lit substs (cdr tuples)))
+ ((when found)
+ (mv t (cons (car tuples) rest))))
+ (mv nil tuples)))
+ (sigtable (gbc-sort-substs-into-sigtable substs x.common-vars
+ x.sig-table)))
+ (mv t
+ (cons (constraint-tuple rule existing-lits lit
+ x.common-vars x.existing-vars sigtable)
+ (cdr tuples)))))
+
+
+(defun gbc-unbound-lits-add-tuples (litvars rule existing-lits existing-vars
+ substs ccat)
+ (b* (((when (atom litvars)) ccat)
+ (var (car litvars))
+ ((constraint-rule r) rule)
+ (lit (cdr (hons-assoc-equal var r.lit-alist)))
+ (fnsym (car lit))
+ (tuples (cdr (hons-get fnsym ccat)))
+ ((mv found tuples)
+ (gbc-unbound-lits-add-to-existing-tuple
+ rule existing-lits var substs tuples))
+ ((when found)
+ (hons-acons fnsym tuples ccat))
+ (lit-vars (sets::mergesort (acl2::simple-term-vars lit)))
+ (common-vars (sets::intersect existing-vars lit-vars))
+ (sigtable (gbc-sort-substs-into-sigtable substs common-vars nil))
+ (new-tuple (constraint-tuple rule existing-lits var common-vars
+ existing-vars sigtable)))
+ (hons-acons fnsym (cons new-tuple tuples) ccat)))
+
+(defun gbc-process-new-lit-tuple (lit tuple ccat state)
+ (declare (xargs :stobjs state :verify-guards nil))
+ (b* (((constraint-tuple x) tuple)
+ ;; (rule existing-lits matching-lit common-vars existing-vars sig-table)
+ ((constraint-rule r) x.rule)
+ ;; (thmname lit-alist syntaxp)
+ (pat (cdr (hons-assoc-equal x.matching-lit r.lit-alist)))
+ ((mv ok lit-subst) (glcp-unify-term/gobj pat lit nil))
+ ((unless ok) (mv nil ccat))
+ (sig (gbc-signature x.common-vars lit-subst))
+ (partial-substs (cdr (hons-get sig x.sig-table)))
+ (new-substs (gbc-extend-substs lit-subst partial-substs))
+ (rest-litvars (set-difference-eq (strip-cars r.lit-alist)
+ (cons x.matching-lit x.existing-lits)))
+ ;; (- (cw "rest-litvars: ~x0 matching: ~x1 existing: ~x2~%" rest-litvars
+ ;; x.matching-lit x.existing-lits))
+ ((unless rest-litvars)
+ (b* ((substs (gbc-substs-check-syntaxp new-substs r.thmname r.syntaxp state)))
+ (mv substs ccat)))
+ (new-existing-vars (sets::union (sets::mergesort (strip-cars lit-subst))
+ x.existing-vars))
+ ;; unbound lits remaining -- add to ccat
+ (ccat (gbc-unbound-lits-add-tuples
+ rest-litvars
+ x.rule
+ ;; need to keep these canonical
+ ;; so that we can find an existing
+ ;; tuple if it exists
+ (sets::insert x.matching-lit x.existing-lits)
+ new-existing-vars
+ new-substs
+ ccat)))
+ (mv nil ccat)))
+
+
+
+
+(defun gbc-process-new-lit-tuples (lit tuples ccat state)
+ (declare (xargs :stobjs state :verify-guards nil))
+ (b* (((when (atom tuples)) (mv nil ccat))
+ ((mv substs1 ccat)
+ (gbc-process-new-lit-tuple lit (car tuples) ccat state))
+ ((mv substs-rest ccat)
+ (gbc-process-new-lit-tuples lit (cdr tuples) ccat state)))
+ (mv (append substs1 substs-rest) ccat)))
+
+
+(defund gbc-process-new-lit (lit ccat state)
+ (declare (xargs :stobjs state :verify-guards nil))
+ (b* (((unless (and (consp lit)
+ (eq (tag lit) :g-apply)))
+ (mv nil ccat))
+ (tuples (cdr (hons-get (g-apply->fn lit) ccat))))
+ (gbc-process-new-lit-tuples lit tuples ccat state)))
+
+
+(defun gbc-tuples-make-fast (x)
+ (if (atom x)
+ nil
+ (cons (change-constraint-tuple (car x)
+ :sig-table
+ (make-fast-alist
+ (constraint-tuple->sig-table (car x))))
+ (gbc-tuples-make-fast (cdr x)))))
+
+(defun gbc-tuples-free (x)
+ (if (atom x)
+ nil
+ (prog2$ (fast-alist-free (constraint-tuple->sig-table (car x)))
+ (gbc-tuples-free (cdr x)))))
+
+(defun gbc-db-make-fast-rec (x acc)
+ (b* (((when (atom x)) acc)
+ (acc (if (and (consp (car x))
+ (not (hons-get (caar x) acc)))
+ (hons-acons (caar x)
+ (gbc-tuples-make-fast (cdar x))
+ acc)
+ acc)))
+ (gbc-db-make-fast-rec (cdr x) acc)))
+
+(defund gbc-db-make-fast (x)
+ (gbc-db-make-fast-rec x nil))
+
+(defun gbc-db-free-rec (x)
+ (if (atom x)
+ nil
+ (prog2$ (and (consp (car x))
+ (gbc-tuples-free (cdar x)))
+ (gbc-db-free-rec (cdr x)))))
+
+(defund gbc-db-free (x)
+ (gbc-db-free-rec (fast-alist-free x)))
+
+
+
+
+#||
+
+(gl::def-gl-boolean-constraint logbitp-n-m
+ :bindings ((x (logbitp n a))
+ (y (logbitp m a)))
+ :syntaxp (and (acl2::<< n m)
+ (not (and (atom n) (atom m))))
+ :body (implies (equal n m)
+ (equal x y)))
+
+(time$ (b* ((ccat (table-alist 'gl-bool-constraints (w state)))
+ ((mv substs ccat)
+ (gbc-process-new-lit '(:g-apply logbitp (fff) q) ccat state))
+ (- (cw "substs1: ~x0~%" substs))
+ (ccat (hons-shrink-alist ccat nil))
+ (state (f-put-global 'ccat1 ccat state))
+ ((mv substs ccat)
+ (gbc-process-new-lit '(:g-apply logbitp (qwr) b) ccat state))
+ (- (cw "substs2: ~x0~%" substs))
+ (ccat (hons-shrink-alist ccat nil))
+ (state (f-put-global 'ccat2 ccat state))
+ ((mv substs ccat)
+ (gbc-process-new-lit '(:g-apply logbitp (qwf) q) ccat state))
+ (- (cw "substs3: ~x0~%" substs))
+ (ccat (hons-shrink-alist ccat nil))
+ (state (f-put-global 'ccat3 ccat state))
+ ((mv substs ccat)
+ (gbc-process-new-lit '(:g-apply logbitp (fff) b) ccat state))
+ (- (cw "substs4: ~x0~%" substs))
+ (ccat (hons-shrink-alist ccat nil))
+ (state (f-put-global 'ccat3 ccat state)))
+ state))
+
+||#
diff -Nru acl2-6.2/books/centaur/gl/ctrex-utils.lisp acl2-6.3/books/centaur/gl/ctrex-utils.lisp
--- acl2-6.2/books/centaur/gl/ctrex-utils.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/ctrex-utils.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,1123 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "GL")
+(include-book "bvar-db")
+(include-book "cutil/defaggregate" :dir :system)
+(include-book "clause-processors/meta-extract-user" :dir :system)
+(include-book "bfr")
+(include-book "bfr-sat")
+(include-book "centaur/aig/misc" :dir :system)
+(include-book "param")
+(include-book "centaur/misc/vecs-ints" :dir :system)
+(include-book "std/misc/two-nats-measure" :dir :system)
+(include-book "generic-geval")
+(include-book "glcp-config")
+(include-book "centaur/misc/hons-extra" :dir :system)
+(local (include-book "centaur/misc/arith-equivs" :dir :system))
+(set-state-ok t)
+
+;; To-satisfying-assign-spec generates the same satisfying assignment as
+;; to-satisfying-assign given the same lst and bdd, except that when a
+;; variable's value is irrelevant (car and cdr are equal), we put X in the list
+;; instead of T or NIL.
+(defun to-satisfying-assign-spec (lst bdd)
+ (declare (xargs :hints (("goal" :in-theory (enable acl2-count)))))
+ (cond ((atom bdd) lst)
+ ((eq (cdr bdd) nil) (cons t (to-satisfying-assign-spec lst (car bdd))))
+ ((eq (car bdd) nil) (cons nil (to-satisfying-assign-spec lst (cdr bdd))))
+ ((hqual (car bdd) (cdr bdd))
+ (cons 'x (to-satisfying-assign-spec (cdr lst) (car bdd))))
+ (t (cons (car lst) (to-satisfying-assign-spec
+ (cdr lst)
+ (if (car lst) (car bdd) (cdr bdd)))))))
+
+
+(defun n-satisfying-assigns-and-specs (n hyp-bdd bdd bound state)
+ (declare (ignorable hyp-bdd))
+ (if (zp n)
+ (value nil)
+ (b* (((mv rand state) (acl2::random$ (ash 1 bound) state))
+ (lst (acl2::nat-to-v rand bound))
+ ;; From when we passed in the unparametrized counterexample BDD:
+;; (assign (to-satisfying-assign lst bdd))
+;; (assign-spec (to-satisfying-assign-spec lst bdd))
+ (assign (to-satisfying-assign lst bdd))
+ (assign-spec (to-satisfying-assign-spec lst (acl2::from-param-space hyp-bdd bdd)))
+ ((er rest) (n-satisfying-assigns-and-specs (1- n) hyp-bdd bdd bound state)))
+ (value (cons (list* "generated randomly:" assign assign-spec) rest)))))
+
+(defthm n-satisfying-assigns-does-not-fail
+ (not (mv-nth 0 (n-satisfying-assigns-and-specs n hyp-bdd bdd bound state))))
+
+
+(defun vars-onto-alist (vars val al)
+ (if (atom vars)
+ al
+ (if (hons-get (car vars) al)
+ (vars-onto-alist (cdr vars) val al)
+ (vars-onto-alist (cdr vars) val (hons-acons (car vars) val al)))))
+
+(defun nat-list-max (x)
+ (declare (xargs :guard (nat-listp x)
+ :guard-hints (("goal" :in-theory (enable nat-listp)))))
+ (if (atom x)
+ 0
+ (max (+ 1 (lnfix (car x)))
+ (nat-list-max (cdr x)))))
+
+
+
+(mutual-recursion
+ (defun shape-spec-max-bvar (x)
+ (declare (xargs :guard (shape-specp x)
+ :verify-guards nil))
+ (if (atom x)
+ 0
+ (case (tag x)
+ (:g-number (b* ((num (g-number->num x))
+ ((list rn rd in id) num))
+ (max (nat-list-max rn)
+ (max (nat-list-max rd)
+ (max (nat-list-max in)
+ (nat-list-max id))))))
+ (:g-integer (max (+ 1 (lnfix (g-integer->sign x)))
+ (nat-list-max (g-integer->bits x))))
+ (:g-integer? (max (+ 1 (lnfix (g-integer?->sign x)))
+ (max (+ 1 (lnfix (g-integer?->intp x)))
+ (nat-list-max (g-integer?->bits x)))))
+ (:g-boolean (+ 1 (lnfix (g-boolean->bool x))))
+ (:g-concrete 0)
+ (:g-var 0)
+ (:g-ite (max (shape-spec-max-bvar (g-ite->test x))
+ (max (shape-spec-max-bvar (g-ite->then x))
+ (shape-spec-max-bvar (g-ite->else x)))))
+ (:g-call (shape-spec-max-bvar-list (g-call->args x)))
+ (otherwise (max (shape-spec-max-bvar (car x))
+ (shape-spec-max-bvar (cdr x)))))))
+ (defun shape-spec-max-bvar-list (x)
+ (declare (xargs :guard (shape-spec-listp x)))
+ (if (atom x)
+ 0
+ (max (shape-spec-max-bvar (car x))
+ (shape-spec-max-bvar-list (cdr x))))))
+
+
+
+(defun glcp-gen-assignments (ctrex-info alist hyp-bdd n state)
+ (if (and (bfr-mode) ;; AIG mode
+ (bfr-counterex-mode)) ;; alist counterexample mode
+ (b* ((al (acl2::aig-extract-iterated-assigns-alist hyp-bdd 10))
+ ;; Careful: al is memoized so we can't steal it.
+ (cex-alist (hons-shrink-alist (append al ctrex-info) nil)))
+ (value (list (list "counterexample from SAT:"
+ (vars-onto-alist
+ ;; WRONG:
+ ;; Hmm, logically this isn't really well-typed,
+ ;; because alist consists of real g-objects whereas
+ ;; shape-spec-indices wants shape-specs. But in the
+ ;; AIG case, parametrization doesn't do anything, so
+ ;; this works. If we were to apply this in cases
+ ;; where alist was not generated by parametrizing a
+ ;; shape-spec-alist, this would need to be changed.
+
+ ;; Actually, parametrization gets rid of any AIG
+ ;; variables that are constrained to concrete values.
+ ;; So we need to reproduce the parametrized binding
+ ;; alist here.
+ (shape-spec-indices (strip-cdrs alist)) nil
+ cex-alist)))))
+ (b* ((bound (shape-spec-max-bvar-list (strip-cdrs alist)))
+ ((er assigns) (n-satisfying-assigns-and-specs
+ (max 0 (- n 2)) hyp-bdd ctrex-info bound state))
+ (nils (acl2::nat-to-v 0 bound))
+ (ts (acl2::nat-to-v -1 bound)))
+ (value (take n
+ (list* (list* "generated by assigning 0/NIL to all possible bits:"
+ (to-satisfying-assign nils ctrex-info)
+ (to-satisfying-assign-spec
+ nils (acl2::from-param-space hyp-bdd ctrex-info)))
+ (list* "generated by assigning 1/T to all possible bits:"
+ (to-satisfying-assign ts ctrex-info)
+ (to-satisfying-assign-spec
+ ts (acl2::from-param-space hyp-bdd ctrex-info)))
+ assigns))))))
+
+(defun glcp-ctrex-complete-single-assign (string bfr-env alist hyp-bdd)
+ (if (and (bfr-mode)
+ (bfr-counterex-mode))
+ (b* ((al (acl2::aig-extract-iterated-assigns-alist hyp-bdd 10))
+ ;; Careful: al is memoized so we can't steal it.
+ (cex-alist (hons-shrink-alist (append al bfr-env) nil)))
+ (list string
+ (vars-onto-alist
+ (shape-spec-indices (strip-cdrs alist)) nil
+ cex-alist)))
+ (list* string
+ (acl2::unparam-env hyp-bdd bfr-env)
+ nil)))
+
+
+
+(defthm glcp-gen-assignments-does-not-fail
+ (not (mv-nth 0 (glcp-gen-assignments n hyp-bdd bdd bound state))))
+
+
+(defun pos-fix (x)
+ (if (posp x) x 1))
+
+
+(defun gl-ctrex-def (fn state)
+ (declare (xargs :stobjs state
+ :guard (symbolp fn)))
+ (b* ((tab (table-alist 'gl-ctrex-defs (w state)))
+ (look (cdr (hons-assoc-equal fn tab)))
+ ((when (equal (len look) 2))
+ (b* (((list formals body) look))
+ (mv t formals body))))
+ (acl2::fn-get-def fn state)))
+
+
+
+(mutual-recursion
+ (defun magicer-ev (x alist clk state hard-errp aokp)
+ (declare (xargs :guard (and (natp clk)
+ (pseudo-termp x)
+ (symbol-alistp alist))
+ :well-founded-relation acl2::nat-list-<
+ :measure (list clk (acl2-count x))
+ :hints(("Goal" :in-theory (enable nfix)))
+ :verify-guards nil
+ :stobjs state))
+ (cond ((not x) (mv nil nil))
+ ((atom x)
+ (mv nil (cdr (assoc-eq x alist))))
+ ((eq (car x) 'quote) (mv nil (cadr x)))
+ ((zp clk) (mv "clock ran out" nil))
+ ((consp (car x))
+ (b* (((mv err args)
+ (magicer-ev-lst (cdr x) alist clk state hard-errp aokp))
+ ((when err)
+ (mv err nil))
+ (new-alist (pairlis$ (cadar x) args)))
+ (magicer-ev (caddar x) new-alist clk state hard-errp aokp)))
+ ((eq (car x) 'if)
+ (b* (((mv err test)
+ (magicer-ev (cadr x) alist clk state hard-errp aokp))
+ ((when err) (mv err nil)))
+ (if test
+ (magicer-ev (caddr x) alist clk state hard-errp aokp)
+ (magicer-ev (cadddr x) alist clk state hard-errp aokp))))
+ ((and (eq (car x) 'return-last)
+ (quotep (cadr x)))
+ (b* ((fnsym (cadr (cadr x))))
+ (case fnsym
+ (progn (b* (((mv err args)
+ (magicer-ev-lst (cddr x) alist clk state hard-errp
+ aokp))
+ ((when err) (mv err nil)))
+ (mv nil (cadr args))))
+ (otherwise
+ (magicer-ev (fourth x) alist clk state hard-errp aokp)))))
+ (t (b* (((mv err args)
+ (magicer-ev-lst (cdr x) alist clk state hard-errp aokp))
+ ((when err)
+ (mv err nil))
+ (fn (car x))
+ ((mv ev-err val)
+ (acl2::magic-ev-fncall fn args state hard-errp aokp))
+ ((unless ev-err) (mv nil val))
+ ((mv ok formals body) (gl-ctrex-def fn state))
+ ((unless ok) (mv (acl2::msg
+ "can't execute and no definition: ~x0 ~@1~%"
+ fn (if (eq ev-err t) "" ev-err))
+ nil)))
+ (magicer-ev body (pairlis$ formals args) (1- clk) state hard-errp
+ aokp)))))
+
+ (defun magicer-ev-lst (x alist clk state hard-errp aokp)
+ (declare (xargs :guard (and (posp clk)
+ (pseudo-term-listp x)
+ (symbol-alistp alist))
+ :measure (list (pos-fix clk) (acl2-count x))
+ :stobjs state))
+ (if (endp x)
+ (mv nil nil)
+ (b* (((mv err first) (magicer-ev (car x) alist clk state hard-errp aokp))
+ ((when err) (mv err nil))
+ ((mv err rest) (magicer-ev-lst (cdr x) alist clk state hard-errp aokp))
+ ((when err) (mv err nil)))
+ (mv nil (cons first rest))))))
+
+(defun set-gl-ctrex-def-fn (fn formals body state)
+ (declare (xargs :mode :program :stobjs state))
+ (b* (((er tr-body) (acl2::translate body t t t 'set-gl-ctrex-def (w state) state)))
+ (value `(table gl-ctrex-defs ',fn '(,formals ,tr-body)))))
+
+(defmacro set-gl-ctrex-def (fn formals body)
+ `(make-event (set-gl-ctrex-def-fn ',fn ',formals ',body state)))
+
+
+
+(mutual-recursion
+ (defun magic-geval (x env state)
+ (declare (xargs :guard (consp env)
+ :stobjs state
+ :measure (acl2-count x)
+ :hints (("goal" :in-theory '(measure-for-geval atom)))))
+ (if (atom x)
+ ;; Every atom represents itself.
+ (mv nil x)
+ (pattern-match x
+
+ ;; A Concrete is like an escape sequence; we take (cdr x) as a concrete
+ ;; object even if it looks symbolic.
+ ((g-concrete obj) (mv nil obj))
+
+ ;; Boolean
+ ((g-boolean bool) (mv nil (bfr-eval bool (car env))))
+
+ ;; Number. This is the hairy case. Can represent all ACL2-NUMBERPs,
+ ;; but naturals are more compact than integers, which are more compact
+ ;; than rationals, which are more compact than complexes. Denominators
+ ;; are coerced to 1 if they evaluate to 0 -- ugly.
+ ((g-number num)
+ (b* (((mv real-num
+ real-denom
+ imag-num
+ imag-denom)
+ (break-g-number num)))
+ (flet ((uval (n env)
+ (bfr-list->u n (car env)))
+ (sval (n env)
+ (bfr-list->s n (car env))))
+ (mv nil (components-to-number (sval real-num env)
+ (uval real-denom env)
+ (sval imag-num env)
+ (uval imag-denom env))))))
+
+ ;; If-then-else.
+ ((g-ite test then else)
+ (b* (((mv err test) (magic-geval test env state))
+ ((unless err)
+ (if test
+ (magic-geval then env state)
+ (magic-geval else env state))))
+ (mv err nil)))
+
+ ;; Apply: Unevaluated function call.
+ ((g-apply fn args)
+ (b* (((mv err args) (magic-geval args env state))
+ ((when err) (mv err nil))
+ (term (cons fn (ec-call (kwote-lst args)))))
+ (mv-let (err val)
+ (ec-call (magicer-ev term nil 10000 state t t))
+ (if err
+ (mv err nil)
+ (mv nil val)))))
+
+ ;; Var: untyped variable.
+ ((g-var name) (mv nil (cdr (het name (cdr env)))))
+
+ ;; Conses where the car is not a recognized flag represent conses.
+ (& (b* (((mv err car) (magic-geval (car x) env state))
+ ((when err) (mv err nil))
+ ((mv err cdr) (magic-geval (cdr x) env state))
+ ((when err) (mv err nil)))
+ (mv nil (cons car cdr)))))))
+ (defun magic-geval-list (x env state)
+ (declare (xargs :guard (consp env)
+ :stobjs state
+ :measure (acl2-count x)))
+ (if (atom x)
+ (mv nil nil)
+ (b* (((mv err val) (magic-geval (car x) env state))
+ ((when err) (mv err nil))
+ ((mv err rest) (magic-geval (car x) env state))
+ ((when err) (mv err nil)))
+ (mv nil (cons val rest))))))
+
+(defun gl-bit-abstract (bfr bfr-alist n)
+ (declare (xargs :guard (natp n)))
+ (b* ((n (lnfix n))
+ ((when (booleanp bfr))
+ (mv bfr bfr-alist n))
+ (res (hons-get bfr bfr-alist))
+ ((when res)
+ (mv (cdr res) bfr-alist n)))
+ (mv n (hons-acons bfr n bfr-alist) (1+ n))))
+
+(defthm gl-bit-abstract-new-n-type
+ (natp (mv-nth 2 (gl-bit-abstract bfr bfr-alist n)))
+ :rule-classes :type-prescription)
+
+(defun gl-bitlist-abstract (bfrs bfr-alist n)
+ (declare (xargs :guard (natp n)))
+ (b* (((when (atom bfrs))
+ (mv nil bfr-alist (lnfix n)))
+ ((mv first bfr-alist n) (gl-bit-abstract (car bfrs) bfr-alist n))
+ ((mv rest bfr-alist n) (gl-bitlist-abstract (cdr bfrs) bfr-alist n)))
+ (mv (cons first rest) bfr-alist n)))
+
+(defthm gl-bitlist-abstract-new-n-type
+ (natp (mv-nth 2 (gl-bitlist-abstract bfrs bfr-alist n)))
+ :rule-classes :type-prescription)
+
+(defun gl-bitlistlist-abstract (bfr-lists bfr-alist n)
+ (declare (xargs :guard (natp n)))
+ (b* (((when (atom bfr-lists))
+ (mv nil bfr-alist (lnfix n)))
+ ((mv first bfr-alist n) (gl-bitlist-abstract (car bfr-lists) bfr-alist n))
+ ((mv rest bfr-alist n) (gl-bitlistlist-abstract (cdr bfr-lists) bfr-alist n)))
+ (mv (cons first rest) bfr-alist n)))
+
+(defthm gl-bitlistlist-abstract-new-n-type
+ (natp (mv-nth 2 (gl-bitlistlist-abstract bfrs bfr-alist n)))
+ :rule-classes :type-prescription)
+
+(mutual-recursion
+ (defun gobj-abstract (x bfr-alist n)
+ (declare (xargs :guard (natp n)
+ :verify-guards nil))
+ (if (atom x)
+ (mv x bfr-alist (lnfix n))
+ (case (tag x)
+ (:g-boolean (b* (((mv bit bfr-alist n)
+ (gl-bit-abstract (g-boolean->bool x) bfr-alist n)))
+ (mv (g-boolean bit) bfr-alist n)))
+ (:g-number (b* (((mv bits bfr-alist n)
+ (gl-bitlistlist-abstract (g-number->num x) bfr-alist n)))
+ (mv (g-number bits) bfr-alist n)))
+ (:g-concrete (mv x bfr-alist (lnfix n)))
+ (:g-ite (b* (((mv test bfr-alist n)
+ (gobj-abstract (g-ite->test x) bfr-alist n))
+ ((mv then bfr-alist n)
+ (gobj-abstract (g-ite->then x) bfr-alist n))
+ ((mv else bfr-alist n)
+ (gobj-abstract (g-ite->else x) bfr-alist n)))
+ (mv (g-ite test then else) bfr-alist n)))
+ (:g-var (mv x bfr-alist (lnfix n)))
+ (:g-apply (b* (((mv args bfr-alist n)
+ (gobjlist-abstract (g-apply->args x) bfr-alist n)))
+ (mv (g-apply (g-apply->fn x) args) bfr-alist n)))
+ (otherwise (b* (((mv car bfr-alist n)
+ (gobj-abstract (car x) bfr-alist n))
+ ((mv cdr bfr-alist n)
+ (gobj-abstract (cdr x) bfr-alist n)))
+ (mv (cons car cdr) bfr-alist n))))))
+
+ (defun gobjlist-abstract (x bfr-alist n)
+ (declare (xargs :guard (natp n)))
+ (b* (((when (atom x)) (mv x bfr-alist (lnfix n)))
+ ((mv car bfr-alist n)
+ (gobj-abstract (car x) bfr-alist n))
+ ((mv cdr bfr-alist n)
+ (gobjlist-abstract (cdr x) bfr-alist n)))
+ (mv (cons car cdr) bfr-alist n))))
+
+
+(flag::make-flag gobj-abstract-flg gobj-abstract)
+
+(defthm-gobj-abstract-flg
+ (defthm gobj-abstract-new-n-type
+ (natp (mv-nth 2 (gobj-abstract x bfr-alist n)))
+ :hints ('(:expand ((gobj-abstract x bfr-alist n))))
+ :flag gobj-abstract)
+ (defthm gobjlist-abstract-new-n-type
+ (natp (mv-nth 2 (gobjlist-abstract x bfr-alist n)))
+ :hints ('(:expand ((gobjlist-abstract x bfr-alist n))))
+ :flag gobjlist-abstract))
+
+(verify-guards gobj-abstract)
+
+(defun gobj-abstract-top (x)
+ (declare (xargs :guard t))
+ (b* (((mv x al &) (gobj-abstract x nil 0)))
+ (fast-alist-free al)
+ x))
+
+(defun gobjlist-abstract-top (x)
+ (declare (xargs :guard t))
+ (b* (((mv x al &) (gobjlist-abstract x nil 0)))
+ (fast-alist-free al)
+ x))
+
+
+
+
+(defun bool-to-bit (x)
+ (cond ((eq x t) 1)
+ ((eq x nil) 0)
+ (t x)))
+
+
+(defun nth-list-bits (x lst)
+ (if (atom x)
+ nil
+ (cons (bool-to-bit (nth (car x) lst))
+ (nth-list-bits (cdr x) lst))))
+
+(defun nth-list-list-bits (x lst)
+ (if (atom x)
+ nil
+ (cons (nth-list-bits (car x) lst)
+ (nth-list-list-bits (cdr x) lst))))
+
+
+;; For each index N in an shape spec, this substitutes the Nth value found in
+;; lst. In the number case, it substitutes 1 and 0 for booleans.
+(defund inspec-show-assign-spec (x lst)
+ (if (atom x)
+ x
+ (pattern-match x
+ ((g-concrete &) x)
+ ((g-boolean b) (g-boolean (nth b lst)))
+ ((g-number n) (g-number (nth-list-list-bits n lst)))
+ ((g-ite if then else)
+ (g-ite (inspec-show-assign-spec if lst)
+ (inspec-show-assign-spec then lst)
+ (inspec-show-assign-spec else lst)))
+ ((g-apply fn args) (g-apply fn (inspec-show-assign-spec args lst)))
+ ((g-var &) x)
+ (& (cons (inspec-show-assign-spec (car x) lst)
+ (inspec-show-assign-spec (cdr x) lst))))))
+
+
+;; recursively match patterns, e.g.:
+;; set (equal (logcar (logcdr (logcdr x))) 1) to t
+;; --> set (logcar (logcdr (logcdr x))) to 1
+;; --> set (logbitp 0 (logcdr (logcdr x))) to t
+;; --> set (logbitp 1 (logcdr x)) to t
+;; --> set (logbitp 2 x) to t
+;; --> set x to (logior (ash 1 2) x)
+
+(defun translate-pair (pair ctx state)
+ (declare (xargs :stobjs state :mode :program))
+ (b* (((list a b) pair)
+ ((er aa) (acl2::translate a t t t ctx (w state) state))
+ ((er bb) (acl2::translate b t t t ctx (w state) state)))
+ (value (list aa bb))))
+
+(defun translate-pair-list (pairs ctx state)
+ (declare (xargs :stobjs state :mode :program))
+ (b* (((when (atom pairs)) (value nil))
+ ((er first) (translate-pair (car pairs) ctx state))
+ ((er rest) (translate-pair-list (cdr pairs) ctx state)))
+ (value (cons first rest))))
+
+(defun def-glcp-ctrex-rewrite-fn (from test tos state)
+ (declare (xargs :mode :program :stobjs state))
+ (b* (((er fromtrans) (translate-pair from 'def-gplcp-ctrex-rewrite state))
+ ((er tostrans) (translate-pair-list tos 'def-gplcp-ctrex-rewrite state))
+ ((er testtrans) (acl2::translate test t t t 'def-gplcp-ctrex-rewrite (w state) state))
+ (entry (list* fromtrans testtrans tostrans))
+ (fnsym (caar fromtrans)))
+ (value `(table glcp-ctrex-rewrite
+ ',fnsym
+ (cons ',entry
+ (cdr (assoc ',fnsym (table-alist
+ 'glcp-ctrex-rewrite world))))))))
+
+(defsection def-glcp-ctrex-rewrite
+ :parents (reference)
+ :short "Define a heuristic for GL to use when generating counterexamples"
+ :long
+ "Usage:
+
+@({
+ (gl::def-glcp-ctrex-rewrite
+ ;; from:
+ (lhs-lvalue lhs-rvalue)
+ ;; to:
+ (rhs-lvalue rhs-rvalue)
+ :test syntaxp-term)
+ })
+Example:
+@({
+ (gl::def-glcp-ctrex-rewrite
+ ((logbitp n x) t)
+ (x (logior (ash 1 n) x))
+ :test (quotep n))
+})
+
+If GL has generated Boolean variables corresponding to term-level objects,
+then an assignment to the Boolean variables does not directly induce an
+assignment of ACL2 objects to the ACL2 variables. Instead, we have terms that
+are assigned true or false by the Boolean assignment, and to generate a
+counterexample, we must find an assignment for the variables in those terms
+that cause the terms to take the required truth values. Ctrex-rewrite rules
+tell GL how to move from a valuation of a term to valuations of its
+components.
+
+The example rule above says that if we want @('(logbitp n x)') to be @('t'),
+and @('n') is (syntactically) a quoted constant, then assign @('x') a new value
+by effectively setting its @('n')th bit to T (that is, bitwise ORing X with the
+appropriate mask).
+
+Note that this rule does not always yield the desired result -- for example,
+in the case where N is a negative integer. Because these are just heuristics
+for generating counterexamples, there is no correctness requirement and no
+checking of these rules. Bad counterexample rules can't make anything unsound,
+but they can cause generated counterexamples to be nonsense. Be careful!
"
+
+ (defmacro def-glcp-ctrex-rewrite (from to &key (test 't))
+ `(make-event
+ (def-glcp-ctrex-rewrite-fn ',from ',test ',(list to) state))))
+
+(defmacro def-glcp-ctrex-split-rewrite (from tos &key (test 't))
+ `(make-event
+ (def-glcp-ctrex-rewrite-fn ',from ',test ',tos state)))
+
+(def-glcp-ctrex-rewrite ((equal x y) t) (x y)
+ :test (symbolp x))
+(def-glcp-ctrex-rewrite ((equal x y) t) (x y)
+ :test (quotep y))
+(def-glcp-ctrex-rewrite ((equal x y) t) (y x)
+ :test (symbolp y))
+(def-glcp-ctrex-rewrite ((equal x y) t) (y x)
+ :test (quotep x))
+(def-glcp-ctrex-rewrite
+ ((logcar x) 1)
+ ((logbitp 0 x) t))
+(def-glcp-ctrex-rewrite
+ ((logcar x) 0)
+ ((logbitp 0 x) nil))
+(def-glcp-ctrex-rewrite
+ ((logbitp n x) t)
+ (x (logior (ash 1 n) x))
+ :test (and (quotep n) (symbolp x)))
+(def-glcp-ctrex-rewrite
+ ((logbitp n x) t)
+ (x (logior (ash 1 n) x))
+ :test (quotep n))
+(def-glcp-ctrex-rewrite
+ ((logbitp n x) nil)
+ (x (logand (lognot (ash 1 n)) x))
+ :test (quotep n))
+(def-glcp-ctrex-rewrite
+ ((logbitp n (logcdr x)) v)
+ ((logbitp (+ 1 (nfix n)) x) v))
+(def-glcp-ctrex-rewrite
+ ((logbitp n (logtail m x)) v)
+ ((logbitp (+ (nfix m) (nfix n)) x) v))
+(def-glcp-ctrex-rewrite
+ ((integerp x) t)
+ (x (ifix x)))
+(def-glcp-ctrex-rewrite
+ ((integerp x) nil)
+ (x (if (integerp x) nil x)))
+
+
+;; (glcp-ctrex-rewrite 10
+;; '((equal (logcar (logcdr (logcdr x))) '1) 't)
+;; (table-alist 'glcp-ctrex-rewrites (w state))
+;; state)
+
+
+(mutual-recursion
+ (defun gobj->term-partial (x bfr-env)
+ (declare (xargs :guard t
+ :measure (acl2-count x)
+ :hints (("goal" :in-theory '(measure-for-geval atom)))))
+ (if (atom x)
+ (kwote x)
+ (pattern-match x
+ ((g-concrete obj) (kwote obj))
+
+ ((g-boolean bool) (kwote (bfr-eval bool bfr-env)))
+
+ ((g-number num)
+ (b* (((mv real-num
+ real-denom
+ imag-num
+ imag-denom)
+ (break-g-number num)))
+ (flet ((uval (n env)
+ (bfr-list->u n env))
+ (sval (n env)
+ (bfr-list->s n env)))
+ (kwote
+ (components-to-number (sval real-num bfr-env)
+ (uval real-denom bfr-env)
+ (sval imag-num bfr-env)
+ (uval imag-denom bfr-env))))))
+
+ ((g-ite test then else)
+ (list 'if
+ (gobj->term-partial test bfr-env)
+ (gobj->term-partial then bfr-env)
+ (gobj->term-partial else bfr-env)))
+
+ ((g-var name) name)
+
+ ((g-apply fn args)
+ (and (not (eq fn 'quote))
+ (cons fn (gobj-list->terms-partial args bfr-env))))
+
+ (& ;; cons
+ (list 'cons
+ (gobj->term-partial (car x) bfr-env)
+ (gobj->term-partial (cdr x) bfr-env))))))
+
+ (defun gobj-list->terms-partial (x bfr-env)
+ (declare (xargs :guard t
+ :measure (acl2-count x)))
+ (if (atom x)
+ nil
+ (cons (gobj->term-partial (car x) bfr-env)
+ (gobj-list->terms-partial (cdr x) bfr-env)))))
+
+
+(defun unquote-lst (x)
+ (declare (xargs :guard (and (pseudo-term-listp x)
+ (acl2::quote-listp x))))
+ (if (atom x)
+ nil
+ (cons (acl2::unquote (car x))
+ (unquote-lst (cdr x)))))
+
+(mutual-recursion
+ ;; Like magic-ev but constructs a partially-evaluated term by evaluating
+ ;; ground calls.
+ ;; A little bit wrong with respect to a regular pseudo-term evaluator because
+ ;; if the alist doesn't bind a variable, it's effectively bound to itself.
+ (defun magic-ev-partial (x alist state hard-errp aokp)
+ (declare (xargs :guard (and (pseudo-termp x)
+ (symbol-alistp alist)
+ (pseudo-term-listp (strip-cdrs alist)))
+ :measure (acl2-count x)
+ :hints(("Goal" :in-theory (enable nfix)))
+ :verify-guards nil
+ :stobjs state))
+ (cond ((not x) nil)
+ ((atom x) (let ((look (assoc x alist)))
+ (if look (cdr look) x)))
+ ((eq (car x) 'quote) x)
+ ((consp (car x))
+ (b* ((args
+ (magic-ev-partial-lst (cdr x) alist state hard-errp aokp))
+ (new-alist (pairlis$ (cadar x) args)))
+ (magic-ev-partial (caddar x) new-alist state hard-errp aokp)))
+ ((eq (car x) 'if)
+ (b* ((test
+ (magic-ev-partial (cadr x) alist state hard-errp aokp)))
+ (if (quotep test)
+ (if (cadr test)
+ (magic-ev-partial (caddr x) alist state hard-errp aokp)
+ (magic-ev-partial (cadddr x) alist state hard-errp
+ aokp))
+ (b* ((then
+ (magic-ev-partial (caddr x) alist state hard-errp aokp))
+ (else
+ (magic-ev-partial (cadddr x) alist state hard-errp aokp)))
+ (if (equal then else)
+ then
+ `(if ,test ,then ,else))))))
+ (t (b* ((args
+ (magic-ev-partial-lst (cdr x) alist state hard-errp aokp))
+ (fn (car x))
+ ((unless (acl2::quote-listp args)) (cons fn args))
+ ((mv ev-err val)
+ (acl2::magic-ev-fncall fn (unquote-lst args) state hard-errp aokp))
+ ((unless ev-err) (kwote val)))
+ (cons fn args)))))
+
+ (defun magic-ev-partial-lst (x alist state hard-errp aokp)
+ (declare (xargs :guard (and (pseudo-term-listp x)
+ (symbol-alistp alist)
+ (pseudo-term-listp (strip-cdrs alist)))
+ :measure (acl2-count x)
+ :stobjs state))
+ (if (endp x)
+ nil
+ (cons (magic-ev-partial (car x) alist state hard-errp aokp)
+ (magic-ev-partial-lst (cdr x) alist state hard-errp aokp)))))
+
+
+(flag::make-flag magic-ev-partial-flg magic-ev-partial)
+
+(defthm pseudo-term-listp-strip-cdrs-pairlis
+ (implies (pseudo-term-listp vals)
+ (pseudo-term-listp (strip-cdrs (pairlis$ keys vals)))))
+
+(defthm-magic-ev-partial-flg
+ (defthm pseudo-termp-of-magic-ev-partial
+ (implies (and (pseudo-termp x)
+ (pseudo-term-listp (strip-cdrs alist)))
+ (pseudo-termp (magic-ev-partial x alist state hard-errp aokp)))
+ :flag magic-ev-partial)
+ (defthm pseudo-term-listp-of-magic-ev-partial-lst
+ (implies (and (pseudo-term-listp x)
+ (pseudo-term-listp (strip-cdrs alist)))
+ (pseudo-term-listp (magic-ev-partial-lst x alist state hard-errp aokp)))
+ :flag magic-ev-partial-lst))
+
+(defun glcp-ctrex-subst-pairs (subst pairs)
+ (if (atom pairs)
+ nil
+ (cons (acl2::substitute-into-list (car pairs) subst)
+ (glcp-ctrex-subst-pairs subst (cdr pairs)))))
+
+
+(defun glcp-ctrex-apply-rule (pair rule state)
+ (declare (xargs :stobjs state :verify-guards nil))
+ (b* (((list* pat-pair cond subst-pairs)
+ rule)
+ ((mv ok alist) (acl2::simple-one-way-unify-lst pat-pair pair nil))
+ ((unless ok) (mv nil nil))
+ ((mv ev-err ok) (acl2::magic-ev cond alist state t t))
+ ((when (and (not ev-err) ok))
+ (mv t (glcp-ctrex-subst-pairs alist subst-pairs))))
+ (mv nil nil)))
+
+(defun glcp-ctrex-apply-rules (pair rules state)
+ (declare (xargs :stobjs state :verify-guards nil))
+ (b* (((when (atom rules)) (mv nil nil))
+ ((mv ok new-pairs) (glcp-ctrex-apply-rule pair (car rules) state))
+ ((when ok) (mv ok new-pairs)))
+ (glcp-ctrex-apply-rules pair (cdr rules) state)))
+
+
+(mutual-recursion
+ (defun glcp-ctrex-rewrite (limit pair rule-table state)
+ (declare (xargs :stobjs state :verify-guards nil
+ :measure (list limit 0)))
+ (b* ((pair (magic-ev-partial-lst pair nil state t t))
+ ((when (zp limit)) (list pair))
+ (lhs (car pair))
+ ((when (atom lhs)) (list pair))
+ (fn (car lhs))
+ (rules (cdr (assoc fn rule-table)))
+ ((mv ok new-pairs) (glcp-ctrex-apply-rules pair rules state))
+ ((unless ok) (list pair)))
+ (glcp-ctrex-rewrite-list (1- limit) new-pairs rule-table state)))
+ (defun glcp-ctrex-rewrite-list (limit pairs rule-table state)
+ (declare (xargs :stobjs state :verify-guards nil
+ :well-founded-relation acl2::nat-list-<
+ :measure (list limit (len pairs))))
+ (if (atom pairs)
+ nil
+ (append (glcp-ctrex-rewrite limit (car pairs) rule-table state)
+ (glcp-ctrex-rewrite-list limit (cdr pairs) rule-table state)))))
+
+
+(defun glcp-ctrex-update-assigns (pairs var-alist state)
+ (declare (xargs :stobjs state
+ :verify-guards nil))
+ (b* (((when (atom pairs)) var-alist)
+ (pair1 (car pairs))
+ ((list lhs rhs) pair1)
+ ((unless (symbolp lhs))
+ (and (not (and (consp lhs)
+ (eq (car lhs) 'quote)))
+ (cw "failed ctrex assignment:~%lhs:~%~x0~%rhs:~%~x1~%"
+ lhs rhs))
+ (glcp-ctrex-update-assigns (cdr pairs) var-alist state))
+ ((mv ev-err rhs-val) (magicer-ev rhs var-alist 10000 state t t))
+ ((when ev-err)
+ (cw "Error evaluating RHS in counterexample generation: ~@0~%"
+ (if (eq ev-err t) "T" ev-err))
+ (glcp-ctrex-update-assigns (cdr pairs) var-alist state)))
+ (glcp-ctrex-update-assigns (cdr pairs) (hons-acons lhs rhs-val var-alist) state)))
+
+
+(local (in-theory (enable* acl2::arith-equiv-forwarding)))
+;; Iterates up the bvar-db list chronologically, given a counterexample
+;; assignment (a bfr environment). Builds up a variable alist by applying
+;; rewrites to simplify the assignments induced by the bvar-db.
+;; (defun glcp-ctrex-set-vars1 (n ctrex-assign unparam-ctrex-assign
+;; rule-table bvar-db state)
+;; (declare (xargs :stobjs (state bvar-db)
+;; :guard (natp n)
+;; :verify-guards nil
+;; :measure (nfix n)))
+;; (b* (((when (<= (the integer (lnfix n))
+;; (the integer (base-bvar bvar-db))))
+;; nil)
+;; (n (1- n))
+;; (var-alist (glcp-ctrex-set-vars1
+;; n ctrex-assign unparam-ctrex-assign
+;; rule-table bvar-db state))
+;; (bvar-val (bfr-lookup n unparam-ctrex-assign))
+;; (gobj (get-bvar->term n bvar-db))
+;; (term (gobj->term-partial gobj ctrex-assign))
+;; (lhs1 (magic-ev-partial term nil state t t))
+;; (pair (list lhs1 (kwote bvar-val)))
+;; (assign-pairs (glcp-ctrex-rewrite 10000 pair rule-table state))
+;; (gregs3 (nth 3 (nth 4 (cdr (assoc 'uc::st var-alist)))))
+;; (var-alist (glcp-ctrex-update-assigns assign-pairs var-alist state))
+;; (gregs3-new (nth 3 (nth 4 (cdr (assoc 'uc::st var-alist))))))
+;; (and (not (equal gregs3 gregs3-new))
+;; (cw "gregs3: prev ~x0 new ~x1~%pair: ~x2~%assigns: ~x3~%gobj: ~x4"
+;; gregs3 gregs3-new pair assign-pairs gobj))
+;; var-alist))
+
+(defun glcp-ctrex-set-vars1 (n ctrex-assign unparam-ctrex-assign
+ rule-table var-alist bvar-db state)
+ (declare (xargs :stobjs (state bvar-db)
+ :guard (natp n)
+ :verify-guards nil
+ :measure (nfix n)))
+ (b* (((when (<= (the integer (lnfix n))
+ (the integer (base-bvar bvar-db))))
+ var-alist)
+ (n (1- n))
+ (var-alist (glcp-ctrex-set-vars1
+ n ctrex-assign unparam-ctrex-assign
+ rule-table var-alist bvar-db state))
+ (bvar-val (bfr-lookup n unparam-ctrex-assign))
+ (gobj (get-bvar->term n bvar-db))
+ (term (gobj->term-partial gobj ctrex-assign))
+ (lhs1 (magic-ev-partial term nil state t t))
+ (pair (list lhs1 (kwote bvar-val)))
+ (assign-pairs (glcp-ctrex-rewrite 10000 pair rule-table state)))
+ (glcp-ctrex-update-assigns assign-pairs var-alist state)))
+
+(defun glcp-ctrex-set-vars (ctrex-assign unparam-assign bvar-db state)
+ (declare (xargs :stobjs (bvar-db state)
+ :verify-guards nil))
+ (b* ((rule-table (table-alist 'glcp-ctrex-rewrite (w state)))
+ (var-alist (glcp-ctrex-set-vars1 (next-bvar bvar-db)
+ ctrex-assign
+ unparam-assign
+ rule-table nil bvar-db state)))
+ (glcp-ctrex-set-vars1 (next-bvar bvar-db)
+ ctrex-assign
+ unparam-assign
+ rule-table var-alist bvar-db state)))
+
+(defun glcp-ctrex-bits-to-objs (ctrex-assign param-bfr gobj-alist bvar-db state)
+ (declare (xargs :stobjs (bvar-db state)
+ :verify-guards nil))
+ (b* ((unparam-ctrex-assign (bfr-unparam-env param-bfr ctrex-assign))
+ ((acl2::with-fast unparam-ctrex-assign))
+ (var-alist (glcp-ctrex-set-vars ctrex-assign unparam-ctrex-assign bvar-db state))
+ (env (cons ctrex-assign var-alist))
+ ((mv err alist) (magic-geval gobj-alist env state))
+ ((when err) (list :unknown env)))
+ (list alist env)))
+
+
+
+(defun glcp-bit-to-obj-ctrexamples (assigns sspec-alist gobj-alist param-bfr bvar-db state)
+ (declare (xargs :stobjs (bvar-db state)
+ :verify-guards nil))
+ (if (atom assigns)
+ nil
+ (if (or (atom (car assigns))
+ (atom (cdar assigns)))
+ (glcp-bit-to-obj-ctrexamples (cdr assigns) sspec-alist gobj-alist
+ param-bfr bvar-db state)
+ (cons (cons (caar assigns)
+ (append
+ (acl2::with-fast-alist (cadar assigns)
+ (glcp-ctrex-bits-to-objs
+ (cadar assigns) param-bfr gobj-alist bvar-db state))
+ (ec-call (inspec-show-assign-spec sspec-alist (cddar assigns)))))
+ (glcp-bit-to-obj-ctrexamples (cdr assigns) sspec-alist gobj-alist
+ param-bfr bvar-db state)))))
+
+(defun glcp-gen-ctrexes (ctrex-info alist param-bfr n bvar-db state)
+ (declare (xargs :stobjs (bvar-db state) :verify-guards nil))
+ (b* (((er assigns) (glcp-gen-assignments ctrex-info alist param-bfr n state)))
+ (value (glcp-bit-to-obj-ctrexamples
+ assigns alist
+ (gobj-alist-to-param-space
+ (shape-spec-to-gobj alist) param-bfr)
+ param-bfr bvar-db state))))
+
+(defthm glcp-gen-ctrexes-does-not-fail
+ (not (mv-nth 0 (glcp-gen-ctrexes n param-bfr bdd bound bvar-db state)))
+ :hints(("Goal" :in-theory (disable glcp-gen-assignments))))
+
+(in-theory (disable glcp-gen-ctrexes))
+
+;; Collects violated assumptions in the bvar-db.
+(defun glcp-ctrex-check-bvar-db (n env unparam-env bvar-db state)
+ (declare (xargs :stobjs (bvar-db state)
+ :guard (and (natp n)
+ (consp env)
+ (<= n (next-bvar bvar-db)))
+ ; :verify-guards nil
+ :measure (nfix n)))
+ (b* (((when (<= (lnfix n) (base-bvar bvar-db))) nil)
+ (n (1- (lnfix n)))
+ (rest (glcp-ctrex-check-bvar-db n env unparam-env bvar-db state))
+ (gobj (get-bvar->term n bvar-db))
+ (bvalue (bfr-lookup n unparam-env))
+ ((mv er gvalue) (magic-geval gobj env state))
+ ;; ((when (and (not er) (iff bvalue gvalue)))
+ ;; rest)
+ (partial (gobj->term-partial gobj (car env)))
+ ((when er)
+ (cw "Couldn't evaluate bvar-db term: ~x0, error: ~@1~%"
+ partial (if (eq er t) "T" er))
+ rest))
+ (cons (list (if (iff bvalue gvalue) "GOOD" "FAIL") partial bvalue gobj n) rest)))
+
+(defun glcp-pretty-print-bvar-db-violations (pairs)
+ (declare (xargs :guard t))
+ (b* (((when (atom pairs)) nil)
+ ((unless (true-listp (car pairs)))
+ (glcp-pretty-print-bvar-db-violations (cdr pairs))))
+ (and (equal (caar pairs) "FAIL")
+ (or (cw "~x0 should be ~x1~%" (cadar pairs) (caddar pairs))
+ (cw "gobj: ~x0~%" (gobj-abstract-top (ec-call (nth 3 (car pairs)))))))
+ (glcp-pretty-print-bvar-db-violations (cdr pairs))))
+
+(defun quote-if-needed (obj)
+ (declare (xargs :mode :logic :guard t))
+ (if (or (booleanp obj)
+ (keywordp obj)
+ (acl2-numberp obj)
+ (characterp obj)
+ (stringp obj))
+ obj
+ (list 'quote obj)))
+
+(defun bindings-quote-if-needed (bindings)
+ (declare (xargs :guard (true-list-listp bindings)))
+ (if (atom bindings)
+ nil
+ (cons (list (caar bindings)
+ (quote-if-needed (cadar bindings)))
+ (bindings-quote-if-needed (cdr bindings)))))
+
+(defun glcp-pretty-print-assignments (n ctrexes concl execp param-bfr bvar-db state)
+ (declare (xargs :stobjs (bvar-db state)
+ :guard (and (natp n)
+ (true-list-listp ctrexes)
+ (pseudo-termp concl))))
+ (if (atom ctrexes)
+ nil ;; (value nil)
+ (b* (((list* string assign-alist env assign-spec-alist) (car ctrexes))
+ (bindings (ec-call (bindings-quote-if-needed assign-alist)))
+ (- (if (bfr-mode)
+ (cw "Example ~x2, ~@0~%Assignment:~%~x1~%~%" string bindings n)
+ (cw "Example ~x3, ~@0~%Template:~%~x1~%Assignment:~%~x2~%~%" string assign-spec-alist
+ bindings n)))
+
+ ((unless (and execp (consp env)))
+ (glcp-pretty-print-assignments (1+ n) (cdr ctrexes) concl execp param-bfr
+ bvar-db state))
+
+ (unparam-env (bfr-unparam-env param-bfr (car env)))
+ ((acl2::with-fast unparam-env))
+ (bvar-db-info (glcp-ctrex-check-bvar-db
+ (next-bvar bvar-db) env unparam-env bvar-db
+ state))
+ ;;(state (f-put-global 'bvar-db-info bvar-db-info state))
+ (- (and (hons-assoc-equal "FAIL" bvar-db-info)
+ ;; bozo make error message better
+ (not (cw "Some IF test terms were assigned inconsistent values:~%"))
+ (glcp-pretty-print-bvar-db-violations bvar-db-info)))
+ (- (cw "Running conclusion to verify the counterexample.~%"))
+ ;; ((acl2::cmp concl-term)
+ ;; (acl2::translate-cmp
+ ;; concl t t t 'glcp-print-ctrexamples (w state)
+ ;; (default-state-vars state)))
+
+ ;; assign-alist is actually of the form
+ ;; ((var0 val0) (var1 val1)...) --
+ ;; change it to ((var0 . val0) (var1 . val1) ...)
+ (alist (pairlis$ (acl2::alist-keys assign-alist)
+ (acl2::alist-keys (acl2::alist-vals assign-alist))))
+ ((mv err val)
+ (ec-call (acl2::magic-ev concl alist state t t)))
+ ((mv err val)
+ (if (not err)
+ (mv err val)
+ (progn$
+ (cw "Failed to execute the counterexample: ~@0~%"
+ (if (eq err t) "(t)" err))
+ (cw "Trying to logically simulate it...~%")
+ (ec-call (magicer-ev concl alist 10000 state t t)))))
+ ((when err)
+ (cw "Evaluating the counterexample failed: ~@0~%"
+ (if (eq err t) "(t)" err))
+ ;; (value nil)
+ ))
+ (if val
+ (cw "False counterexample! See :xdoc gl::false-counterexamples.~%")
+ (cw "Counterexample verified.~%"))
+ (glcp-pretty-print-assignments (1+ n) (cdr ctrexes) concl execp param-bfr
+ bvar-db state))))
+
+
+(defun glcp-print-ctrexamples (ctrexes warn-err type concl execp param-bfr bvar-db state)
+ (declare (xargs :stobjs (state bvar-db)
+ :guard (and (true-list-listp ctrexes)
+ (pseudo-termp concl))))
+ (b* ((- (cw "
+*** SYMBOLIC EXECUTION ~@0 ***: ~@1 found." warn-err type))
+ (- (and ctrexes
+ (if (and (bfr-mode)
+ (bfr-counterex-mode))
+ (cw "~%Showing the example produced by SAT.~%~%")
+ (cw "
+Showing ~x0 examples. Each example consists of a template and a
+concrete assignment. The template shows a class of examples, and the
+concrete assignment represents a specific example from that
+class:~%~%" (len ctrexes))))))
+ (glcp-pretty-print-assignments 1 ctrexes concl execp param-bfr bvar-db state)))
+
+
+
+(defun glcp-gen/print-ctrexamples (ctrex-info ;; bdd or alist
+ warn/err type config bvar-db state)
+ (declare (xargs :stobjs (bvar-db state)
+ :verify-guards nil))
+ (b* (((glcp-config config) config)
+ (state (acl2::f-put-global 'glcp-var-bindings config.shape-spec-alist state))
+ (state (acl2::f-put-global 'glcp-counterex ctrex-info state))
+ ((er ctrexes) (glcp-gen-ctrexes ctrex-info
+ config.shape-spec-alist
+ config.param-bfr
+ config.nexamples
+ bvar-db state))
+ (state (acl2::f-put-global 'glcp-counterex-assignments ctrexes state)))
+ (value (glcp-print-ctrexamples
+ ctrexes warn/err type
+ config.top-level-term
+ config.exec-ctrex
+ config.param-bfr
+ bvar-db state))))
+
+
+(defun glcp-print-single-ctrex (bfr-env warn/err type config bvar-db state)
+ (declare (xargs :stobjs (bvar-db state)
+ :verify-guards nil))
+ (b* (((glcp-config config) config)
+ (assign (glcp-ctrex-complete-single-assign
+ type bfr-env config.shape-spec-alist config.param-bfr))
+ (ctrexes (glcp-bit-to-obj-ctrexamples
+ (list assign)
+ config.shape-spec-alist
+ (gobj-alist-to-param-space
+ (shape-spec-to-gobj config.shape-spec-alist)
+ config.param-bfr)
+ config.param-bfr
+ bvar-db state)))
+ (glcp-print-ctrexamples
+ ctrexes warn/err type
+ config.top-level-term
+ config.exec-ctrex
+ config.param-bfr
+ bvar-db state)))
diff -Nru acl2-6.2/books/centaur/gl/def-gl-clause-proc.lisp acl2-6.3/books/centaur/gl/def-gl-clause-proc.lisp
--- acl2-6.2/books/centaur/gl/def-gl-clause-proc.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/def-gl-clause-proc.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,17 +1,33 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-
-
(include-book "parallel/without-waterfall-parallelism" :dir :system)
-;; (include-book "centaur/misc/defapply" :dir :system)
(include-book "gify")
-(local (include-book "gify-thms"))
(include-book "run-gified-cp")
-(local (include-book "general-object-thms"))
(include-book "glcp-templates")
-(include-book "gl-doc-string")
(include-book "generic-geval")
+(local (include-book "gify-thms"))
+(local (include-book "general-object-thms"))
+;; (include-book "centaur/misc/defapply" :dir :system)
+
;; Now that we've proven the correctness of the generic clause processor above,
;; we now define a macro which makes a clause processor for a particular set of
;; pre-Gified functions.
@@ -31,7 +47,7 @@
,@(make-list-of-nths
'actuals 0
(len (wgetprop (car names) 'formals)))
- hyp clk)))
+ hyp clk config bvar-db state)))
(glcp-predef-cases-fn (cdr names) world))))
@@ -105,7 +121,7 @@
;; (defthm open-cdr-kwote-lst
;; (equal (cdr (acl2::kwote-lst lst))
;; (acl2::kwote-lst (cdr lst))))
-
+
;; (defthm gobj-listp-cdr
;; (implies (gobj-listp x)
;; (gobj-listp (cdr x)))
@@ -239,332 +255,360 @@
(true-listp x))
:hints(("Goal" :in-theory (enable gobj-listp)))
:rule-classes :forward-chaining)
-
+
+
+(defthm gobj-depends-on-of-nth
+ (implies (not (gobj-list-depends-on k p x))
+ (not (gobj-depends-on k p (nth n x))))
+ :hints(("Goal" :in-theory (enable nth gobj-list-depends-on))))
+
+(defthm gobj-depends-on-of-nil
+ (not (gobj-depends-on k p nil)))
+
+
(defun def-gl-clause-processor-fn
(clause-proc output state)
(declare (xargs :mode :program :stobjs state))
(b* ((world (w state))
- (current-geval (find-current-geval world))
- (geval (or current-geval
- (incat clause-proc (symbol-name clause-proc) "-GEVAL")))
+ ;; (current-geval (find-current-geval world))
+ (geval ;;(or current-geval
+ (incat clause-proc (symbol-name clause-proc) "-GEVAL"))
+ (geval-ev ;;(or current-geval
+ (incat clause-proc (symbol-name clause-proc) "-GEVAL-EV"))
+ (geval-list (incat clause-proc (symbol-name clause-proc) "-GEVAL-LIST"))
+ (geval-ev-lst ;;(or current-geval
+ (incat clause-proc (symbol-name clause-proc) "-GEVAL-EV-LST"))
(run-gified (incat clause-proc (symbol-name clause-proc) "-RUN-GIFIED"))
(g-fns (strip-cars (table-alist 'gl-function-info world)))
- (ev (incat clause-proc (symbol-name clause-proc) "-EV"))
- (ev-lst (incat clause-proc (symbol-name clause-proc) "-EV-LST"))
- (falsify (incat clause-proc (symbol-name clause-proc) "-EV-FALSIFY"))
- (badguy (incat clause-proc (symbol-name clause-proc)
+ (ev (incat clause-proc (symbol-name geval) "-EV"))
+ (ev-lst (incat clause-proc (symbol-name geval) "-EV-LST"))
+ (ev-rules (incat clause-proc (symbol-name geval) "-EV-RULES"))
+ (falsify (incat clause-proc (symbol-name geval) "-EV-FALSIFY"))
+ (badguy (incat clause-proc (symbol-name geval)
"-EV-META-EXTRACT-GLOBAL-BADGUY"))
(meta-facts
- (incat clause-proc (symbol-name clause-proc) "-EV-META-EXTRACT-GLOBAL-FACTS"))
- (ctrex-thm (incat clause-proc (symbol-name clause-proc)
+ (incat clause-proc (symbol-name geval) "-EV-META-EXTRACT-GLOBAL-FACTS"))
+ (ctrex-thm (incat clause-proc (symbol-name geval)
"-EV-FALSIFY-COUNTEREXAMPLE"))
- (constraints (incat ev (symbol-name ev) "-CONSTRAINTS"))
(f-i-thm (incat geval (symbol-name geval)
"-IS-FUNCTIONAL-INST-OF-GENERIC-GEVAL-FOR-GL-CLAUSE-PROC"))
(run-gified-correct
(incat run-gified (symbol-name run-gified) "-CORRECT"))
- (interp-term (interp-term-fnname clause-proc))
- (interp-list (incat clause-proc (symbol-name clause-proc)
- "-INTERP-LIST"))
- (run-parametrized (incat clause-proc (symbol-name clause-proc)
- "-RUN-PARAMETRIZED"))
- (run-cases (incat clause-proc (symbol-name clause-proc)
- "-RUN-CASES"))
- (subst `((interp-term . ,interp-term)
- (interp-list . ,interp-list)
- (run-parametrized . ,run-parametrized)
- (run-cases . ,run-cases)
- (clause-proc-name . ',clause-proc)
- (clause-proc . ,clause-proc)
- (run-gified . ,run-gified)
- ;; (apply-concrete . ,apply-concrete)
- ))
+ (run-gified-deps
+ (incat run-gified (symbol-name run-gified) "-DEPS"))
+ (interp-term
+ (incat clause-proc (symbol-name clause-proc) "-INTERP-TERM"))
+ ;; (run-parametrized
+ ;; (incat clause-proc (symbol-name clause-proc) "-RUN-PARAMETRIZED"))
+ ;; (run-cases
+ ;; (incat clause-proc (symbol-name clause-proc) "-RUN-CASES"))
+ (subst-names (append '(run-gified
+ geval
+ geval-list
+ geval-ev
+ geval-ev-lst
+ geval-ev-falsify
+ geval-ev-meta-extract-global-badguy)
+ (remove 'clause-proc *glcp-fnnames*)))
+ (fn-names (cons clause-proc (glcp-put-name-each clause-proc subst-names)))
+ (subst (pairlis$ (cons 'clause-proc subst-names) fn-names))
+ (fi-subst (pairlis$ (cons 'glcp-generic (glcp-put-name-each 'glcp-generic subst-names))
+ (pairlis$ fn-names nil)))
(f-i-lemmas (incat clause-proc (symbol-name clause-proc)
"-FUNCTIONAL-INSTANCE-LEMMAS"))
(correct-thm (incat clause-proc (symbol-name clause-proc) "-CORRECT")))
`(with-output
- ,@output
- (encapsulate
- nil
- (set-state-ok t)
- (set-ignore-ok t)
- (set-irrelevant-formals-ok t)
- ,@(if current-geval
- nil
- `((make-geval ,geval nil
- :output nil)))
- (encapsulate nil
- (set-case-split-limitations '(1 1))
- (defun ,run-gified
- (fn actuals hyp clk state)
- (declare (xargs :guard (and (symbolp fn)
- (gobj-listp actuals)
- (natp clk))
- :guard-hints
- (("goal" :in-theory
- (e/d** ((:forward-chaining gobj-listp-true-listp)))
- :do-not '(preprocess)))
- :stobjs state)
- (ignorable state))
- (case fn
- . ,(glcp-predef-cases-fn
- (remove 'if g-fns) world))))
-
-
-
- ;; make the evaluator, falsifier
- (local (defun dummy-label-for-make-evaluator-fn () nil))
- (acl2::defevaluator-fast
- ,ev ,ev-lst
- ,(fns-to-calls
- (append `(if gl-cp-hint shape-spec-obj-in-range
- return-last use-by-hint equal acl2::typespec-check implies iff
- not cons gl-aside gl-ignore gl-error)
- (set-difference-eq
- g-fns
- `(if gl-cp-hint shape-spec-obj-in-range
- return-last use-by-hint equal not cons
- ,geval gl-aside gl-ignore gl-error)))
- world)
- :namedp t)
- (local (def-ruleset! ,constraints
- (set-difference-theories
- (current-theory :here)
- (current-theory 'dummy-label-for-make-evaluator-fn))))
- (acl2::def-meta-extract ,ev ,ev-lst)
- ;; (defchoose ,falsify (a) (x)
- ;; (not (,ev x a)))
- (local (defthm ,ctrex-thm
- (implies (not (,ev x a))
- (not (,ev x (,falsify x))))
- :hints (("goal" :use ,falsify))))
-
-
- ;; Define the interpreter mutual-recursion, the
- ;; run-parametrized and run-cases functions, and the clause proc.
- ,@(sublis subst (list *glcp-interp-template*
- *glcp-run-parametrized-template*
- *glcp-run-cases-template*
- *glcp-clause-proc-template*))
-
- ;; Prep for the run-gified correctness and gobjectp theorems
- (local
- (progn
- (eval-g-prove-f-i ,f-i-thm ,geval generic-geval)
- (eval-g-functional-instance
- gl-eval-car-cdr-of-gobj-listp ,geval generic-geval)
- (eval-g-functional-instance
- gl-eval-consp-when-gobj-listp ,geval generic-geval)
- (eval-g-functional-instance
- gl-eval-of-nil ,geval generic-geval)
- (eval-g-functional-instance
- general-concrete-obj-correct ,geval generic-geval)
-
- ;; Prove correctness of run-gified
- (defthm ,run-gified-correct
- (implies (and (bfr-eval hyp (car env))
- (gobj-listp actuals)
- (mv-nth 0 (,run-gified
- fn actuals hyp clk state)))
- (equal (,geval (mv-nth 1 (,run-gified
- fn actuals hyp clk state))
- env)
- (,ev (cons fn (acl2::kwote-lst
- (,geval actuals env))) nil)))
- :hints (("goal" :clause-processor
- (run-gified-clause-proc
- clause
- '(,(f-i-thmname
- 'gl-eval-consp-when-gobj-listp geval)
- ,(f-i-thmname
- 'gl-eval-car-cdr-of-gobj-listp geval)
- ,(f-i-thmname 'gl-eval-of-nil geval))
- state))
- (use-by-computed-hint clause)))
-
- (in-theory (disable ,run-gified))
-
- ;; Prep to prove the guards of the interpreter and the correctness of
- ;; the clause processor.
- (eval-g-functional-instance shape-spec-to-gobj-eval-env
- ,geval generic-geval)
- (eval-g-functional-instance mk-g-boolean-correct
- ,geval generic-geval)
- (eval-g-functional-instance
- generic-geval-gl-cons ,geval generic-geval)
-
- (eval-g-functional-instance
- gobj-to-param-space-correct ,geval generic-geval)
-
- (eval-g-functional-instance
- generic-geval-non-cons ,geval generic-geval)
-
- (def-ruleset! ,f-i-lemmas
- (append '(car-cons cdr-cons)
- ;; (let ((constr (acl2::ruleset ',constraints)))
- ;; (nthcdr (- (len constr) 18) constr))
- '(,ctrex-thm
- ,run-gified-correct
- ;; ,apply-concrete-lemma
- ;; ,apply-concrete-state
- ,(f-i-thmname 'generic-geval-gl-cons geval)
- (:type-prescription ,run-gified)
- ;; (:type-prescription ,apply-concrete)
- ,(f-i-thmname 'gobj-ite-merge-correct geval)
- ,(f-i-thmname 'gtests-nonnil-correct geval)
- ,(f-i-thmname 'gtests-obj-correct geval)
- ,(f-i-thmname 'shape-spec-to-gobj-eval-env geval)
- ,(f-i-thmname 'mk-g-boolean-correct geval)
- ,(f-i-thmname 'mk-g-concrete-correct geval)
- ,(f-i-thmname 'g-concrete-quote-correct geval)
- ,(f-i-thmname 'mk-g-ite-correct geval)
- ,(f-i-thmname 'generic-geval-non-cons geval)
- ,(f-i-thmname 'gobj-to-param-space-correct geval)
- ,(f-i-thmname 'general-concrete-obj-correct geval))))))
-
- ;; Verify guards of the interpreter.
- (local (in-theory nil))
- (verify-guards
- ,interp-term
- :hints (("goal" :by
- (:functional-instance
- glcp-generic-interp-guards-ok
- (glcp-generic-interp-term ,interp-term)
- (glcp-generic-interp-list ,interp-list)
- (glcp-generic-ev ,ev)
- (glcp-generic-ev-lst ,ev-lst)
- (glcp-generic-geval ,geval)
- (glcp-generic-run-gified ,run-gified)
- (glcp-generic-ev-falsify ,falsify)
- ;; (glcp-generic-apply-concrete ,apply-concrete)
- ;; (glcp-generic-apply-concrete-guard-wrapper ,apply-concrete)
- )
- :in-theory (e/d** ((:ruleset ,f-i-lemmas)))
- :expand ((,interp-list x alist hyp clk obligs config state)
- (,interp-term x alist hyp clk obligs config state))
- :do-not-induct t)
- (and stable-under-simplificationp
- '(:in-theory (e/d** ((:ruleset ,f-i-lemmas)
- (:ruleset ,constraints)))))
- (and stable-under-simplificationp
- '(:in-theory (e/d** ((:ruleset ,f-i-lemmas)
- (:ruleset ,constraints)
- ;; ,apply-concrete
- ,(incat ev (symbol-name ev)
- "-OF-FNCALL-ARGS")))))))
-
- ;; Prove correctness of the clause processor.
- (defthm ,correct-thm
- (implies (and (pseudo-term-listp clause)
- (alistp alist)
- (,meta-facts)
- (,ev (conjoin-clauses
- (acl2::clauses-result
- (,clause-proc clause hints state)))
- (,falsify
- (conjoin-clauses
+ ,@output
+ (encapsulate
+ nil
+ (set-state-ok t)
+ (set-ignore-ok t)
+ (set-irrelevant-formals-ok t)
+ ;; ,@(if current-geval
+ ;; nil
+ (make-geval ,geval nil
+ :output nil)
+ (encapsulate nil
+ (set-case-split-limitations '(1 1))
+ (defun ,run-gified
+ (fn actuals hyp clk config bvar-db state)
+ (declare (xargs :guard (and (symbolp fn)
+ (true-listp actuals)
+ (glcp-config-p config)
+ (natp clk))
+ :guard-hints
+ (("goal" :in-theory
+ (e/d** ((:forward-chaining gobj-listp-true-listp)))
+ :do-not '(preprocess)))
+ :stobjs (bvar-db state))
+ (ignorable state))
+ (case fn
+ . ,(glcp-predef-cases-fn
+ (remove 'if g-fns) world))))
+
+
+
+ ;; ;; make the evaluator, falsifier
+ ;; (local (defun dummy-label-for-make-evaluator-fn () nil))
+ ;; (acl2::defevaluator-fast
+ ;; ,ev ,ev-lst
+ ;; ,(fns-to-calls
+ ;; (append `(if gl-cp-hint shape-spec-obj-in-range
+ ;; return-last use-by-hint equal acl2::typespec-check implies iff
+ ;; not cons gl-aside gl-ignore gl-error)
+ ;; (set-difference-eq
+ ;; g-fns
+ ;; `(if gl-cp-hint shape-spec-obj-in-range
+ ;; return-last use-by-hint equal not cons
+ ;; ,geval gl-aside gl-ignore gl-error)))
+ ;; world)
+ ;; :namedp t)
+ ;; (local (def-ruleset! ,constraints
+ ;; (set-difference-theories
+ ;; (current-theory :here)
+ ;; (current-theory 'dummy-label-for-make-evaluator-fn))))
+ (acl2::def-meta-extract ,ev ,ev-lst)
+ ;; (defchoose ,falsify (a) (x)
+ ;; (not (,ev x a)))
+ (local (defthm ,ctrex-thm
+ (implies (not (,ev x a))
+ (not (,ev x (,falsify x))))
+ :hints (("goal" :use ,falsify))))
+
+
+ ;; Define the interpreter mutual-recursion, the
+ ;; run-parametrized and run-cases functions, and the clause proc.
+ ,@(sublis subst (list *glcp-interp-template*
+ *glcp-clause-proc-template*))
+
+ ;; Prep for the run-gified correctness and gobjectp theorems
+ (local
+ (progn
+ (eval-g-prove-f-i ,f-i-thm ,geval generic-geval)
+ (eval-g-functional-instance
+ gl-eval-car-cdr-of-gobj-listp ,geval generic-geval)
+ (eval-g-functional-instance
+ gl-eval-consp-when-gobj-listp ,geval generic-geval)
+ (eval-g-functional-instance
+ gl-eval-of-nil ,geval generic-geval)
+ (eval-g-functional-instance
+ general-concrete-obj-correct ,geval generic-geval)
+
+
+ ;; Prove correctness of run-gified
+ (defthm ,run-gified-deps
+ (implies (not (gobj-list-depends-on k p actuals))
+ (not (gobj-depends-on
+ k p (mv-nth 1 (,run-gified
+ fn actuals hyp clk config bvar-db state)))))
+ :hints(("Goal" :in-theory (append '(gobj-depends-on-of-nth
+ gobj-depends-on-of-nil
+ ,run-gified)
+ (strip-cdrs
+ (table-alist
+ 'sym-counterpart-dep-thms
+ world))))))
+
+ ;; Prove correctness of run-gified
+ (defthm ,run-gified-correct
+ (implies (and (bfr-eval hyp (car env))
+ (mv-nth 0 (,run-gified
+ fn actuals hyp clk config bvar-db state)))
+ (equal (,geval (mv-nth 1 (,run-gified
+ fn actuals hyp clk config bvar-db state))
+ env)
+ (,ev (cons fn (acl2::kwote-lst
+ (,geval-list actuals env))) nil)))
+ :hints (("goal" :clause-processor
+ (run-gified-clause-proc
+ clause
+ ',(f-i-thmname 'gl-eval-of-nil geval)
+ state))
+ (use-by-computed-hint clause)))
+
+ (in-theory (disable ,run-gified))
+
+ ;; Prep to prove the guards of the interpreter and the correctness of
+ ;; the clause processor.
+ (eval-g-functional-instance shape-spec-to-gobj-eval-env
+ ,geval generic-geval)
+ (eval-g-functional-instance mk-g-boolean-correct
+ ,geval generic-geval)
+ (eval-g-functional-instance
+ generic-geval-gl-cons ,geval generic-geval)
+
+ (eval-g-functional-instance
+ gobj-to-param-space-correct ,geval generic-geval)
+
+ (eval-g-functional-instance
+ generic-geval-non-cons ,geval generic-geval)
+
+ (def-ruleset! ,f-i-lemmas
+ (append '(car-cons cdr-cons)
+ ;; (let ((constr (acl2::ruleset ',constraints)))
+ ;; (nthcdr (- (len constr) 18) constr))
+ '(,ctrex-thm
+ ,run-gified-correct
+ ,run-gified-deps
+ ;; ,apply-concrete-lemma
+ ;; ,apply-concrete-state
+ ,(f-i-thmname 'generic-geval-gl-cons geval)
+ (:type-prescription ,run-gified)
+ ;; (:type-prescription ,apply-concrete)
+ ,(f-i-thmname 'gobj-ite-merge-correct geval)
+ ,(f-i-thmname 'gtests-nonnil-correct geval)
+ ,(f-i-thmname 'gtests-obj-correct geval)
+ ,(f-i-thmname 'shape-spec-to-gobj-eval-env geval)
+ ,(f-i-thmname 'mk-g-boolean-correct geval)
+ ,(f-i-thmname 'mk-g-concrete-correct geval)
+ ,(f-i-thmname 'g-concrete-quote-correct geval)
+ ,(f-i-thmname 'mk-g-ite-correct geval)
+ ,(f-i-thmname 'generic-geval-non-cons geval)
+ ,(f-i-thmname 'gobj-to-param-space-correct geval)
+ ,(f-i-thmname 'general-concrete-obj-correct geval))))))
+
+ ;; Verify guards of the interpreter.
+ (local (in-theory nil))
+ (verify-guards
+ ,interp-term
+ :hints (("goal" :by
+ (:functional-instance
+ glcp-generic-interp-guards-ok
+ . ,fi-subst
+ ;; (glcp-generic-apply-concrete ,apply-concrete)
+ ;; (glcp-generic-apply-concrete-guard-wrapper ,apply-concrete)
+ )
+ :do-not '(preprocess simplify)
+ :in-theory (e/d** ((:ruleset ,f-i-lemmas)))
+ :do-not-induct t)
+ '(:clause-processor dumb-clausify-cp)
+ (let ((term (car (last clause))))
+ (case-match term
+ (('equal (fn . args) . &)
+ (if (member fn ',(set-difference-eq fn-names
+ (list geval-ev
+ geval-ev-lst)))
+ `(:by ,fn
+ :do-not nil)
+ '(:do-not nil)))
+ (& '(:do-not nil))))
+ (and stable-under-simplificationp
+ '(:in-theory (e/d** ((:ruleset ,f-i-lemmas)
+ (:ruleset ,ev-rules)))))
+ (and stable-under-simplificationp
+ '(:in-theory (e/d** ((:ruleset ,f-i-lemmas)
+ (:ruleset ,ev-rules)
+ ;; ,apply-concrete
+ ,(incat ev (symbol-name ev)
+ "-OF-FNCALL-ARGS")))))))
+
+ ;; Prove correctness of the clause processor.
+ (defthm ,correct-thm
+ (implies (and (pseudo-term-listp clause)
+ (alistp alist)
+ (,meta-facts)
+ (,ev (conjoin-clauses
(acl2::clauses-result
- (,clause-proc clause hints state))))))
- (,ev (disjoin clause) alist))
- :hints (("goal" :do-not-induct t
- :in-theory (e/d** (,ctrex-thm))
- :by (:functional-instance
- glcp-generic-correct
- (glcp-generic-interp-term ,interp-term)
- (glcp-generic-interp-list ,interp-list)
- (glcp-generic-ev ,ev)
- (glcp-generic-ev-lst ,ev-lst)
- (glcp-generic-geval ,geval)
- (glcp-generic-run-gified ,run-gified)
- ;; (glcp-generic-apply-concrete ,apply-concrete)
- ;; (glcp-generic-apply-concrete-guard-wrapper ,apply-concrete)
- (glcp-generic-ev-falsify ,falsify)
- (glcp-generic-ev-meta-extract-global-badguy
- ,badguy)
- (glcp-generic-run-parametrized
- ,run-parametrized)
- (glcp-generic-run-cases ,run-cases)
- (glcp-generic ,clause-proc)))
- (case-match clause
- ((('equal (fn . args) . &))
- (and (member fn '(,clause-proc
- ,run-parametrized
- ,run-cases))
- `(:expand ((,fn . ,args)))))
- (((ev ('acl2::meta-extract-global-fact+ . &)
- . &)
- ('not (ev ('acl2::meta-extract-global-fact+ . &)
- . &)))
- '(:use ,badguy))
- ((('true-listp . &) . &)
- '(:use ,badguy))))
- :otf-flg t
- :rule-classes :clause-processor)
-
- (table latest-greatest-gl-clause-proc ',clause-proc t)))))
+ (,clause-proc clause hints state)))
+ (,falsify
+ (conjoin-clauses
+ (acl2::clauses-result
+ (,clause-proc clause hints state))))))
+ (,ev (disjoin clause) alist))
+ :hints (("goal" :do-not-induct t
+ :in-theory (e/d** (,ctrex-thm))
+ :do-not '(preprocess)
+ :by (:functional-instance
+ glcp-generic-correct
+ . ,fi-subst))
+ '(:clause-processor dumb-clausify-cp)
+ (case-match clause
+ ((('equal (fn . args) . &))
+ (and (member fn ',(set-difference-eq fn-names
+ (list geval-ev
+ geval-ev-lst)))
+ `(:by ,fn)))
+ (((ev ('acl2::meta-extract-global-fact+ . &)
+ . &)
+ ('not (ev ('acl2::meta-extract-global-fact+ . &)
+ . &)))
+ '(:use ,badguy :do-not nil))
+ ((('true-listp . &) . &)
+ '(:use ,badguy :do-not nil))))
+ :otf-flg t
+ :rule-classes :clause-processor)
+
+ (table latest-greatest-gl-clause-proc nil ',subst :clear)))))
+
+(defsection def-gl-clause-processor
+ :parents (reference)
+ :short "Define a GL clause processor with a given set of built-in symbolic
+ counterparts."
-(defmacro def-gl-clause-processor
- (name &rest rest-args
- ;; apply-fns &key (output
- ;; '(:off (warning warning! observation prove
- ;; event summary proof-tree
- ;; acl2::expansion)
- ;; :gag-mode nil))
- ;; top-apply-fns
- ;; include-nonrec
- )
- ":Doc-section ACL2::GL
-Define a GL clause processor with a given set of built-in symbolic counterparts.~/
+ :long "Usage:
-Usage:
-~bv[]
+@({
(def-gl-clause-processor my-gl-clause-processor
:output with-output-settings)
-~ev[]
-The above form defines a GL clause processor function named
+})
+
+The above form defines a GL clause processor function named
my-gl-clause-processor. This clause processor is defined so that it can
-execute all existing symbolic counterpart functions.
+execute all existing symbolic counterpart functions.
-There is rarely a necessity for a user to define a new GL clause processor now,
-unless they have added symbolic counterpart functions either by hand-coding
-them or using ~c[MAKE-G-WORLD].~/
+There is rarely a necessity for a user to define a new GL clause processor
+now, unless they have added symbolic counterpart functions either by
+hand-coding them or using @(see make-g-world).
-Each GL clause processor has an associated sets of functions that it can
+Each GL clause processor has an associated sets of functions that it can
directly execute symbolically. DEF-GL-CLAUSE-PROCESSOR makes a new processor
-that can execute the full set of existing symbolic counterparts.
- (Symbolic counterparts may be defined by hand or using ~c[MAKE-G-WORLD].)
+that can execute the full set of existing symbolic counterparts. (Symbolic
+counterparts may be defined by hand or using @(see make-g-world).)
-It used to be the case that the clause processor also had a fixed set of
+It used to be the case that the clause processor also had a fixed set of
functions it could execute concretely. That is no longer the case. We still
accept the old form of def-gl-clause-processor, which takes an additional
argument after the name of the clause processor and before the :output keyword
(if any). However, this is deprecated and a message will be printed saying so.
+
-~l[DEF-GL-THM] and ~il[GL-HINT] for information on using the GL
-clause processor to prove theorems.~/"
- (b* (((mv oldp keys)
- (if (keywordp (car rest-args))
- (mv nil rest-args)
- (mv t (cdr rest-args))))
- (- (and oldp
- (cw "DEPRECATED (def-gl-clause-proc): Def-gl-clause-proc now ~
- takes fewer arguments than it used to; in particular, the ~
- old APPLY-FNS argument is now ignored. See :doc ~
- def-gl-clause-proc for the new syntax.~%")))
- (output-look (assoc-keyword :output keys))
- (output (if output-look
- (cadr output-look)
- '(:off (warning warning! observation prove
- event summary proof-tree
- acl2::expansion)
- :gag-mode nil))))
- `(make-event
- (def-gl-clause-processor-fn
- ',name ',output state))))
+See @(see def-gl-thm) and @(see gl-hint) for information on using the GL
+clause processor to prove theorems.
"
+
+ (defmacro def-gl-clause-processor
+ (name &rest rest-args
+ ;; apply-fns &key (output
+ ;; '(:off (warning warning! observation prove
+ ;; event summary proof-tree
+ ;; acl2::expansion)
+ ;; :gag-mode nil))
+ ;; top-apply-fns
+ ;; include-nonrec
+ )
+ (b* (((mv oldp keys)
+ (if (or (not rest-args)
+ (keywordp (car rest-args)))
+ (mv nil rest-args)
+ (mv t (cdr rest-args))))
+ (- (and oldp
+ (cw "DEPRECATED (def-gl-clause-proc): Def-gl-clause-proc now ~
+ takes fewer arguments than it used to; in particular, ~
+ the old APPLY-FNS argument is now ignored. See :doc ~
+ def-gl-clause-proc for the new syntax.~%")))
+ (output-look (assoc-keyword :output keys))
+ (output (if output-look
+ (cadr output-look)
+ '(:off (warning warning! observation prove
+ event summary proof-tree
+ acl2::expansion)
+ :gag-mode nil))))
+ `(make-event
+ (def-gl-clause-processor-fn
+ ',name ',output state)))))
@@ -711,7 +755,7 @@
:case-split-override case-split-override))
(cov-hints (glcp-coverage-hints
- do-not-expand cov-theory-add cov-hints cov-hints-position))
+ do-not-expand cov-theory-add cov-hints cov-hints-position))
((er trhyp)
(acl2::translate hyp t t nil 'gl-hint-fn (w state) state))
((er trparam)
@@ -730,7 +774,7 @@
(cw "**** WARNING ****~%~@0~%" msg)
;; (er hard? 'gl-hint "~@0" msg)
)))
- (bindings
+ (bindings
(add-var-bindings missing-vars
bindings))
(param-bindings (add-param-var-bindings vars param-bindings))
@@ -740,46 +784,30 @@
state)))
(value (glcp-combine-hints call cov-hints hyp-hints result-hints case-split-hints))))
-(defmacro gl-hint (clause-proc &key
- bindings param-bindings
- (hyp-clk '1000000)
- (concl-clk '1000000)
- cov-hints cov-hints-position
- cov-theory-add do-not-expand
- hyp-hints
- result-hints
- (hyp ''t) param-hyp concl
- (n-counterexamples '3)
- (abort-indeterminate 't)
- (abort-ctrex 't)
- (exec-ctrex 't)
- (abort-vacuous 't)
- (case-split-override 'nil)
- case-split-hints
- run-before-cases run-after-cases
- test-side-goals)
- ":Doc-section ACL2::GL
-Try to prove a goal using GL symbolic simulation.~/
-Usage, as a computed hint (~l[using-computed-hints]):
-~bv[]
+(defsection gl-hint
+ :parents (reference)
+ :short "Try to prove a goal using GL symbolic simulation."
+ :long "Usage, as a computed hint :
+
+@({
(gl-hint my-gl-clause-processor
:bindings `((a ,(g-number (list (mk-number-list 1 1 9))))
(b ,(g-boolean 0)))
:hyp '(bvecp a 8)
:coverage-hints ('(:expand ((bvecp a 8)))))
-~ev[]
+})
-The above hint causes an attempt to apply the clause processor
-my-gl-clause-processor to the current clause. Such a clause processor
-must be created using ~il[DEF-GL-CLAUSE-PROCESSOR]. One such
-clause processor, ~c[GL::GLCP], is predefined in the GL system.
-Various keyword arguments control the symbolic simulation and
-auxilliary proofs.~/
-
-The full interface is as follows, with default values and brief
-descriptions of each keyword argument:
-~bv[]
+The above hint causes an attempt to apply the clause processor
+my-gl-clause-processor to the current clause. Such a clause processor must be
+created using @(see def-gl-clause-processor). One such clause processor, @(see
+glcp), is predefined in the GL system. Various keyword arguments control the
+symbolic simulation and auxilliary proofs.
+
+The full interface is as follows, with default values and brief
+descriptions of each keyword argument:
+
+@({
(gl-hint clause-processor-name
;; bindings of variables to symbolic object specs
@@ -793,7 +821,7 @@
;; conclusion of the theorem
:concl nil
-
+
;; hints for proving coverage
:cov-hints nil
:cov-hints-position nil
@@ -823,19 +851,36 @@
:param-hyp nil
:run-before-cases nil
:run-after-cases nil)
-~ev[]
+})
-The keyword arguments to ~c[GL-HINT] are similar to ones for the
-macros ~il[DEF-GL-THM] and ~il[DEF-GL-PARAM-THM], and are
-documented there.
-~/"
-
- (gl-hint-fn clause-proc bindings param-bindings hyp param-hyp concl
- hyp-clk concl-clk cov-hints cov-hints-position
- cov-theory-add do-not-expand hyp-hints result-hints
- n-counterexamples abort-indeterminate abort-ctrex exec-ctrex abort-vacuous
- run-before-cases run-after-cases
- case-split-override case-split-hints test-side-goals))
+The keyword arguments to @('gl-hint') are similar to ones for the macros
+@(see def-gl-thm) and @(see def-gl-param-thm), and are documented there.
"
+
+ (defmacro gl-hint (clause-proc &key
+ bindings param-bindings
+ (hyp-clk '1000000)
+ (concl-clk '1000000)
+ cov-hints cov-hints-position
+ cov-theory-add do-not-expand
+ hyp-hints
+ result-hints
+ (hyp ''t) param-hyp concl
+ (n-counterexamples '3)
+ (abort-indeterminate 't)
+ (abort-ctrex 't)
+ (exec-ctrex 't)
+ (abort-vacuous 't)
+ (case-split-override 'nil)
+ case-split-hints
+ run-before-cases run-after-cases
+ test-side-goals)
+
+ (gl-hint-fn clause-proc bindings param-bindings hyp param-hyp concl
+ hyp-clk concl-clk cov-hints cov-hints-position
+ cov-theory-add do-not-expand hyp-hints result-hints
+ n-counterexamples abort-indeterminate abort-ctrex exec-ctrex abort-vacuous
+ run-before-cases run-after-cases
+ case-split-override case-split-hints test-side-goals)))
(defun def-gl-thm-fn
@@ -879,15 +924,15 @@
form)))
(defmacro latest-gl-clause-proc ()
- '(caar (table-alist
- 'latest-greatest-gl-clause-proc
- (w state))))
+ '(cdr (assoc 'clause-proc (table-alist
+ 'latest-greatest-gl-clause-proc
+ (w state)))))
(defmacro latest-gl-interp ()
- '(interp-term-fnname
- (caar (table-alist
- 'latest-greatest-gl-clause-proc
- (w state)))))
+ '(cdr (assoc 'interp-term
+ (table-alist
+ 'latest-greatest-gl-clause-proc
+ (w state)))))
;; just wraps with-output around all this stuff and invisiblifies the return value
@@ -898,7 +943,7 @@
(with-output :stack :pop
,form))
(value-triple :invisible))))
-
+
;; If a clause-processor name is supplied, this creates a defthm event
@@ -918,29 +963,12 @@
-;; Define a macro that provides a drop-in replacement for DEF-G-THM and
-;; uses the new clause processor.
-(defmacro def-gl-thm
- (name &key (clause-proc 'nil clause-procp)
- skip-g-proofs
- (hyp 'nil hyp-p)
- (concl 'nil concl-p)
- (g-bindings 'nil g-bindings-p)
- cov-hints cov-hints-position
- cov-theory-add
- do-not-expand
- (hyp-clk '1000000)
- (concl-clk '1000000)
- (n-counterexamples '3)
- (abort-indeterminate 't) (abort-ctrex 't) (exec-ctrex 't) (abort-vacuous 't)
- local
- test-side-goals
- (rule-classes ':rewrite))
- ":Doc-section ACL2::GL
-Prove a theorem using GL symbolic simulation~/
+(defsection def-gl-thm
+ :parents (reference)
+ :short "Prove a theorem using GL symbolic simulation."
+ :long "Usage:
-Usage:
-~bv[]
+@({
(def-gl-thm
:hyp
:concl
@@ -959,123 +987,155 @@
:do-not-expand
:cov-hints
:cov-hints-position <:replace, :before, or :after>
-
+
:test-side-goals )
-~ev[]
+})
+
+This form submits a @(see defthm) event for the theorem
+
+@({(implies )})
+
+and the specified rule-classes, and gives a hint to attempt to prove it by
+symbolic execution using a GL clause processor.
-This form submits a ~c[DEFTHM] event for the theorem
-~c[(implies )] and the specified rule-classes, and gives a hint to
-attempt to prove it by symbolic execution using a GL clause processor.~/
-
-Out of the list of keyword arguments recognized by this macro, three are
-necessary: ~c[:hyp], ~c[:concl], and ~c[:g-bindings]. As noted, the theorem to
-be proved takes the form ~c[(implies )]. The ~c[hyp] is also used
-in proving coverage, explained below.
+Out of the list of keyword arguments recognized by this macro, three are
+necessary: @(':hyp'), @(':concl'), and @(':g-bindings'). As noted, the theorem
+to be proved takes the form @('(implies )'). The @('hyp') is also
+used in proving coverage, explained below.
-The ~c[g-bindings] must be a term evaluating to an alist formatted as follows:
-~bv[]
+The @(':g-bindings') must be a term evaluating to an alist formatted as
+follows:
+
+@({
(( )
( )
...)
-~ev[]
-The shape specs must be well-formed as described in ~il[GL::SHAPE-SPECS]; notably,
-they must not reuse BDD variable numbers or unconstrainted variable names.
-Note also that this is not a dotted alist; the shape spec is the ~c[CADR], not
-the ~c[CDR], of each entry. If any variables mentioned in the theorem are not
-bound in this alist, they will be given an unconstrained variable binding.
-
-The symbolic objects used as the inputs to the symbolic simulation are obtained
-by translating each shape spec into a symbolic object. The hyp is symbolically
-executed on these symbolic inputs. Parametrizing the symbolic objects by the
-resulting predicate object yields (absent any ~c[G-APPLY] or ~c[G-VAR] objects)
-symbolic objects with coverage restricted to only inputs satisfying the hyp.
+})
+
+The shape specs must be well-formed as described in @(see shape-specs);
+notably, they must not reuse BDD variable numbers or unconstrained variable
+names. Note also that this is not a dotted alist; the shape spec is the @(see
+cadr), not the @(see cdr), of each entry. If any variables mentioned in the
+theorem are not bound in this alist, they will be given an unconstrained
+variable binding.
+
+The symbolic objects used as the inputs to the symbolic simulation are
+obtained by translating each shape spec into a symbolic object. The hyp is
+symbolically executed on these symbolic inputs. Parametrizing the symbolic
+objects by the resulting predicate object yields (absent any @('G-APPLY') or
+@('G-VAR') objects) symbolic objects with coverage restricted to only inputs
+satisfying the hyp.
+
+Here is a simple example theorem:
-Here is a simple example theorem:
-~bv[]
+@({
(def-gl-thm commutativity-of-+-up-to-16
:hyp (and (natp a) (natp b)
(< a 16) (< b 16))
:concl (equal (+ a b) (+ b a))
:g-bindings '((a (:g-number (0 2 4 6 8)))
(b (:g-number (1 3 5 7 9)))))
-~ev[]
+})
-This theorem binds its free variables ~c[A] and ~c[B] to symbolic numbers of
-five bits. Note that integers are two's-complement, so to represent natural
+This theorem binds its free variables @('a') and @('b') to symbolic numbers
+of five bits. Note that integers are two's-complement, so to represent natural
numbers one needs one more bit than in the unsigned representation. Therefore,
these shape specs cover negative numbers down to -16 as well as naturals less
than 16. However, parametrization by the hypotheses will yield symbolic
-objects that only cover the specified range.
+objects that only cover the specified range.
-The coverage obligation for a theorem will be a goal like this:
-~bv[]
+The coverage obligation for a theorem will be a goal like this:
+
+@({
(implies
(shape-spec-obj-in-range
(list ...)
(list ...)))
-~ev[]
-In the example above:
-~bv[]
+})
+
+ In the example above:
+
+@({
(implies (and (natp a) (natp b)
(< a 16) (< b 16))
(shape-spec-obj-in-range
'((:g-number (0 2 4 6 8)) (:g-number (1 3 5 7 9)))
(list a b)))
-~ev[]
+})
-It is often convenient to work out the coverage theorem before running the
+It is often convenient to work out the coverage theorem before running the
symbolic simulation, since the symbolic simulation may take a very long time
-even when successful. The keyword argument ~c[:test-side-goals] may be given a
-value of ~c[T] in order to attempt the coverage proof on its own; if
+even when successful. The keyword argument @(':test-side-goals') may be given
+a value of @('T') in order to attempt the coverage proof on its own; if
successful, no theorem will be stored by ACL2, but one can then be fairly sure
-that the coverage proof will go through in the real theorem.
+that the coverage proof will go through in the real theorem.
-Several hints are given by default for proving coverage; see
-~il[GL::SHAPE-SPECS] for details. The keyword arguments ~c[:cov-theory-add],
-~c[:do-not-expand], ~c[:cov-hints], and ~c[cov-hints-position] affect the
-coverage proof.
+Several hints are given by default for proving coverage; see @(see
+shape-specs) for details. The keyword arguments @(':cov-theory-add'),
+@(':do-not-expand'), @(':cov-hints'), and @(':cov-hints-position') affect the
+coverage proof.
-When proof by symbolic simulation fails, the clause processor will print
-randomized counterexamples. The keyword argument ~c[:n-counterexamples]
+When proof by symbolic simulation fails, the clause processor will print
+randomized counterexamples. The keyword argument @(':n-counterexamples')
determines how many it prints. The default is 3. (For SAT-based proofs,
likely only one counterexample is available, so it may print the same
-counterexample each time.)
+counterexample each time.)
-By default, the clause processor will execute conclusion on the counterexamples
-that it finds; this is useful for printing debugging information. However,
-sometimes the conclusion is not executable; in that case, you may turn off
-execution of counterexamples using ~c[:exec-ctrex nil].
+By default, the clause processor will execute conclusion on the
+counterexamples that it finds; this is useful for printing debugging
+information. However, sometimes the conclusion is not executable; in that
+case, you may turn off execution of counterexamples using @(':exec-ctrex
+nil').
-A symbolic simulation may result in a symbolic object that can't be
+A symbolic simulation may result in a symbolic object that can't be
syntactically determined to be non-nil; for example, the result may contain a
-~c[:G-APPLY] object. In these situations, the proof attempt will
-abort, and an example will be shown of inputs for which the symbolic result's
-value could not be determined. To debug this type of problem, see
-~il[GL::DEBUGGING-INDETERMINATE-RESULTS].
+@(':G-APPLY') object. In these situations, the proof attempt will abort, and
+an example will be shown of inputs for which the symbolic result's value could
+not be determined. To debug this type of problem, see @(see
+debugging-indeterminate-results).
-The symbolic interpreter and all symbolic counterpart functions take a clock
+The symbolic interpreter and all symbolic counterpart functions take a clock
argument to ensure termination. The starting clocks for the symbolic
executions of the hyp (for parametrization) and the conclusion may be set using
-the keyword arguments ~c[:hyp-clk] and ~c[:concl-clk]; the defaults are both
-1000000.
-
-The keyword argument ~c[:clause-proc] can be used to select the clause
-processor to be used; see ~c[DEF-GL-CLAUSE-PROCESSOR]. By default, the latest
-clause processor introduced is used. If no ~c[:clause-proc] keyword argument
-is given, then this macro expands to a ~c[make-event], which in turn expands to
-the ~c[defthm] event; otherwise, this expands directly to the ~c[defthm].
-
-The keyword argument ~c[:rule-classes] can be used to select the rule-classes
-for the theorem produced, as in ~c[defthm]; the default is ~c[:rewrite].
-~/
-"
- (declare (ignore skip-g-proofs local))
- (def-gl-thm-find-cp name clause-proc clause-procp
- (list hyp hyp-p concl concl-p g-bindings g-bindings-p cov-hints
- cov-hints-position cov-theory-add do-not-expand hyp-clk concl-clk
- n-counterexamples abort-indeterminate abort-ctrex exec-ctrex abort-vacuous test-side-goals
- rule-classes)))
+the keyword arguments @(':hyp-clk') and @(':concl-clk'); the defaults are both
+1000000.
+The keyword argument @(':clause-proc') can be used to select the clause
+processor to be used; see @(see def-gl-clause-processor). By default, the
+latest clause processor introduced is used. If no @(':clause-proc') keyword
+argument is given, then this macro expands to a @(see make-event), which in
+turn expands to the @(see defthm) event; otherwise, this expands directly to
+the @(see defthm).
+
+The keyword argument @(':rule-classes') can be used to select the
+rule-classes for the theorem produced, as in @(see defthm); the default is
+@(':rewrite').
"
+
+ ;; Define a macro that provides a drop-in replacement for DEF-G-THM and
+ ;; uses the new clause processor.
+ (defmacro def-gl-thm
+ (name &key (clause-proc 'nil clause-procp)
+ skip-g-proofs
+ (hyp 'nil hyp-p)
+ (concl 'nil concl-p)
+ (g-bindings 'nil g-bindings-p)
+ cov-hints cov-hints-position
+ cov-theory-add
+ do-not-expand
+ (hyp-clk '1000000)
+ (concl-clk '1000000)
+ (n-counterexamples '3)
+ (abort-indeterminate 't) (abort-ctrex 't) (exec-ctrex 't) (abort-vacuous 't)
+ local
+ test-side-goals
+ (rule-classes ':rewrite))
+
+ (declare (ignore skip-g-proofs local))
+ (def-gl-thm-find-cp name clause-proc clause-procp
+ (list hyp hyp-p concl concl-p g-bindings g-bindings-p cov-hints
+ cov-hints-position cov-theory-add do-not-expand hyp-clk concl-clk
+ n-counterexamples abort-indeterminate abort-ctrex exec-ctrex abort-vacuous test-side-goals
+ rule-classes))))
@@ -1142,37 +1202,19 @@
,(def-gl-param-thm-fn name clause-proc rest))
`(without-waterfall-parallelism
(make-event
- (let ((clause-proc
- (caar (table-alist
- 'latest-greatest-gl-clause-proc
- (w state)))))
+ (let ((clause-proc (latest-gl-clause-proc)))
(def-gl-param-thm-fn ',name clause-proc ',rest))))))
-(defmacro def-gl-param-thm
- (name &key (clause-proc 'nil clause-procp)
- skip-g-proofs
- (hyp 'nil hyp-p)
- (param-hyp 'nil param-hyp-p)
- (concl 'nil concl-p)
- (cov-bindings 'nil cov-bindings-p)
- (param-bindings 'nil param-bindings-p)
- cov-hints cov-hints-position
- cov-theory-add
- do-not-expand
- (hyp-clk '1000000)
- (concl-clk '1000000)
- (n-counterexamples '3)
- (abort-indeterminate 't) (abort-ctrex 't) (exec-ctrex 't) (abort-vacuous 't)
- run-before-cases run-after-cases
- case-split-override
- case-split-hints local test-side-goals
- (rule-classes ':rewrite))
- ":Doc-section ACL2::GL
-Prove a theorem using GL symbolic simulation with parametrized case-splitting.~/
-Usage:
-~bv[]
+(defsection def-gl-param-thm
+ :parents (reference optimization)
+ :short "Prove a theorem using GL symbolic simulation with parametrized
+case-splitting."
+
+ :long "Usage:
+
+@({
(def-gl-param-thm
:hyp
:concl
@@ -1195,53 +1237,59 @@
:do-not-expand
:cov-hints
:cov-hints-position <:replace, :before, or :after>
-
+
:test-side-goals )
-~ev[]
+})
-This form submits a ~c[DEFTHM] event for the theorem
-~c[(implies )] and the specified rule classes, and gives a hint to
-attempt to prove it using a GL clause processor with parametrized
-case-splitting. See ~il[def-gl-thm] for a simpler version that does not do
-case splitting.~/
-
-Out of the list of keyword arguments recognized by this macro, five are
-necessary: ~c[:hyp], ~c[:concl], ~c[param-hyp], ~c[:cov-bindings], and
-~c[:param-bindings]. As noted, the theorem to be proved takes the form
-~c[(implies )]. The theorem is split into cases based on the
-~c[param-hyp], a term containing some free variables of the theorem and some
+This form submits a @(see defthm) event for the theorem @('(implies
+)') and the specified rule classes, and gives a hint to attempt to prove
+it using a GL clause processor with parametrized case-splitting. See @(see
+def-gl-thm) for a simpler version that does not do case splitting.
+
+Out of the list of keyword arguments recognized by this macro, five are
+necessary: @(':hyp'), @(':concl'), @('param-hyp'), @(':cov-bindings'), and
+@(':param-bindings'). As noted, the theorem to be proved takes the form
+@('(implies )'). The theorem is split into cases based on the
+@('param-hyp'), a term containing some free variables of the theorem and some
additional variables used in case splitting. Values are assigned to these
-variables based on the entries in the ~c[param-bindings], an alist of the
-following form:
-~bv[]
+variables based on the entries in the @('param-bindings'), an alist of the
+following form:
+
+@({
(( )
( )
...)
-~ev[]
-Each of the case-bindings is, in turn, an alist of the following form:
-~bv[]
+})
+
+Each of the case-bindings is, in turn, an alist of the following form:
+
+@({
(( )
( )
...)
-~ev[]
-and each of the var-bindings is an alist of the following form:
-~bv[]
+})
+
+and each of the var-bindings is an alist of the following form:
+
+@({
(( )
( )
...)
-~ev[]
+})
-For each entry in the ~c[param-bindings], the ~c[param-hyp] is instantiated
-with the case variables bound to the objects specified in the entry's
-case-bindings. This term gives a hypothesis about the free variables of the
-theorem, and the set of these terms generated from the param-bindings gives the
-full case-split. The case split must cover the theorem's hypotheses; that is,
-the theorem's hypothesis must imply the disjunction of the case hypotheses. To
-prove this, we symbolically simulate this disjunction using the shape specs
-given in the ~c[cov-bindings], which are formatted like the var-bindings above.
+For each entry in the @('param-bindings'), the @('param-hyp') is
+instantiated with the case variables bound to the objects specified in the
+entry's case-bindings. This term gives a hypothesis about the free variables
+of the theorem, and the set of these terms generated from the param-bindings
+gives the full case-split. The case split must cover the theorem's hypotheses;
+that is, the theorem's hypothesis must imply the disjunction of the case
+hypotheses. To prove this, we symbolically simulate this disjunction using the
+shape specs given in the @('cov-bindings'), which are formatted like the
+var-bindings above.
-A simple example is as follows:
-~bv[]
+A simple example is as follows:
+
+@({
(def-gl-param-thm addititive-inverse-for-5-bits
:hyp (and (integerp n) (<= -16 n) (< n 16))
:concl (equal (- n n) 0)
@@ -1257,52 +1305,70 @@
(((sign nil) (lower-bits 1)) ((n (:g-number (0 1 2 4 5)))))
(((sign nil) (lower-bits 2)) ((n (:g-number (0 1 2 3 5)))))
(((sign nil) (lower-bits 3)) ((n (:g-number (0 1 2 3 4)))))))
-~ev[]
+})
+
+This theorem is proved by symbolic simulation of five cases, in each of
+which the param-hyp is assumed with a different setting of the sign and
+lower-bits case variables; in one case @('N') is required to be negative, and
+in the others it is required to be positive and have a given value on its two
+low-order bits. To show that the case-split is complete, another symbolic
+simulation is performed (using the given @(':cov-bindings')) which proves that
+the disjunction of the case assumptions is complete; effectively,
-This theorem is proved by symbolic simulation of five cases, in each of which
-the param-hyp is assumed with a different setting of the sign and lower-bits
-case variables; in one case ~c[N] is required to be negative, and in the others
-it is required to be positive and have a given value on its two low-order
-bits. To show that the case-split is complete, another symbolic simulation is
-performed (using the given ~c[:cov-bindings]) which proves that the disjunction
-of the case assumptions is complete; effectively,
-~bv[]
+@({
(implies (and (integerp n) (<= -16 n) (< n 16))
(or (< n 0)
(and (<= 0 n) (equal (logand n 3) 0))
(and (<= 0 n) (equal (logand n 3) 1))
(and (<= 0 n) (equal (logand n 3) 2))
(and (<= 0 n) (equal (logand n 3) 3))))
-~ev[]
+})
-Most of the remaining keyword arguments to ~c[DEF-GL-PARAM-THM] are also
-available in ~il[DEF-GL-THM] and are documented there. The rest are as
-follows:
+Most of the remaining keyword arguments to @('DEF-GL-PARAM-THM') are also
+available in @(see def-gl-thm) and are documented there. The rest are as
+follows:
-~c[:RUN-BEFORE-CASES] and ~c[:RUN-AFTER-CASES] cause a user-specified form to
+@(':RUN-BEFORE-CASES') and @(':RUN-AFTER-CASES') cause a user-specified form to
be run between the parametrized symbolic simulations. These may use the
-variable ~c[id], which is bound to the current assignment of the case-splitting
+variable @('id'), which is bound to the current assignment of the case-splitting
variables. These can be used to print a message before and after running each
-case so that the user can monitor the theorem's progress.
+case so that the user can monitor the theorem's progress.
-By default, if a counterexample is encountered on any of the cases, the proof
-will abort. Setting ~c[:ABORT-CTREX] to ~c[NIL] causes it to go on; the proof
+By default, if a counterexample is encountered on any of the cases, the proof
+will abort. Setting @(':ABORT-CTREX') to @('NIL') causes it to go on; the proof
will fail after the clause processor returns because it will produce a goal of
-~c[NIL].
+@('NIL').
-By default, if any case hypothesis is unsatisfiable, the proof will abort.
-Setting ~c[:ABORT-VACUOUS] to ~c[NIL] causes it to go on.
+By default, if any case hypothesis is unsatisfiable, the proof will abort.
+Setting @(':ABORT-VACUOUS') to @('NIL') causes it to go on.
"
-~/
-"
- (declare (ignore skip-g-proofs local))
- (def-gl-param-thm-find-cp name clause-proc clause-procp
- (list hyp hyp-p param-hyp param-hyp-p concl concl-p cov-bindings
- cov-bindings-p param-bindings param-bindings-p cov-hints
- cov-hints-position cov-theory-add do-not-expand hyp-clk concl-clk
- n-counterexamples abort-indeterminate abort-ctrex exec-ctrex
- abort-vacuous run-before-cases run-after-cases case-split-override
- case-split-hints test-side-goals rule-classes)))
+ (defmacro def-gl-param-thm
+ (name &key (clause-proc 'nil clause-procp)
+ skip-g-proofs
+ (hyp 'nil hyp-p)
+ (param-hyp 'nil param-hyp-p)
+ (concl 'nil concl-p)
+ (cov-bindings 'nil cov-bindings-p)
+ (param-bindings 'nil param-bindings-p)
+ cov-hints cov-hints-position
+ cov-theory-add
+ do-not-expand
+ (hyp-clk '1000000)
+ (concl-clk '1000000)
+ (n-counterexamples '3)
+ (abort-indeterminate 't) (abort-ctrex 't) (exec-ctrex 't) (abort-vacuous 'nil)
+ run-before-cases run-after-cases
+ case-split-override
+ case-split-hints local test-side-goals
+ (rule-classes ':rewrite))
+ (declare (ignore skip-g-proofs local))
+ (def-gl-param-thm-find-cp name clause-proc clause-procp
+ (list hyp hyp-p param-hyp param-hyp-p concl concl-p cov-bindings
+ cov-bindings-p param-bindings param-bindings-p cov-hints
+ cov-hints-position cov-theory-add do-not-expand hyp-clk concl-clk
+ n-counterexamples abort-indeterminate abort-ctrex exec-ctrex
+ abort-vacuous run-before-cases run-after-cases case-split-override
+ case-split-hints test-side-goals rule-classes))))
diff -Nru acl2-6.2/books/centaur/gl/def-gl-rewrite.lisp acl2-6.3/books/centaur/gl/def-gl-rewrite.lisp
--- acl2-6.2/books/centaur/gl/def-gl-rewrite.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/def-gl-rewrite.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,200 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "GL")
+(include-book "tools/bstar" :dir :system)
+(include-book "centaur/misc/beta-reduce-full" :dir :system)
+
+(defun scan-lemmas-for-nume (lemmas nume)
+ (declare (xargs :mode :program))
+ (b* (((when (endp lemmas)) nil)
+ (rule (car lemmas))
+ ((when (eql (acl2::access acl2::rewrite-rule rule :nume) nume))
+ rule))
+ (scan-lemmas-for-nume (cdr lemmas) nume)))
+
+(defun scan-props-for-nume-lemma (props nume)
+ (declare (xargs :mode :program))
+ (and (consp props)
+ (or (and (eq (cadar props) 'acl2::lemmas)
+ (scan-lemmas-for-nume (cddar props) nume))
+ (scan-props-for-nume-lemma (cdr props) nume))))
+
+
+(defun find-lemma-for-rune (rune world)
+ (declare (xargs :mode :program))
+ (b* ((nume (acl2::runep rune world))
+ ((unless nume) nil)
+ (segment (acl2::world-to-next-event
+ (cdr (acl2::decode-logical-name (cadr rune) world)))))
+ (scan-props-for-nume-lemma (acl2::actual-props segment nil nil) nume)))
+
+(defun add-gl-rewrite-fn (rune world)
+ (declare (xargs :mode :program))
+ (b* ((rune (if (symbolp rune) `(:rewrite ,rune) rune))
+ (rule (find-lemma-for-rune rune world))
+ ((unless rule)
+ (cw "Failed to find a lemma for rune ~x0~%" rune))
+ (fnsym (car (acl2::access acl2::rewrite-rule rule :lhs)))
+ (entries (cdr (assoc fnsym (table-alist 'gl-rewrite-rules world))))
+ ((when (member-equal rule entries))
+ '(value-triple nil)))
+ `(table gl-rewrite-rules ',fnsym '(,rune . ,entries))))
+
+(defmacro add-gl-rewrite (rune)
+ `(make-event
+ (add-gl-rewrite-fn ',rune (w state))))
+
+(defsection def-gl-rewrite
+ :parents (reference)
+ :short "Define a rewrite rule for GL to use on term-level objects"
+ :long
+ "GL can use ACL2-style rewrite rules to simplify term-level symbolic
+objects. However, typically one wants a different theory for ACL2 theorem
+proving than one wants to use inside GL. @('GL::DEF-GL-REWRITE') defines a
+rewrite rule that is only used inside GL:
+
+@({
+ (gl::def-gl-rewrite my-rewrite-rule
+ (implies (and (syntaxp (and (integerp n) (< 0 (integer-length n))))
+ (< 0 m))
+ (equal (logand n m)
+ (logcons (b-and (logcar n) (logcar m))
+ (logand (logcdr n) (logcdr m)))))
+ :hints ...)
+})
+
+This defines a disabled ACL2 rewrite rule called my-rewrite-rule, and adds
+my-rewrite-rule to the table of rules GL is allowed to use. (GL will still use
+it even though it is disabled, as long it is in that table.)
+
+Def-gl-rewrite supports syntaxp hypotheses, but the term representation used
+is different from ACL2's. Instead of being bound to TERMPs, the variables are
+bound to symbolic objects. See @(see gl::symbolic-objects) for
+reference.
"
+
+ (defmacro def-gl-rewrite (name &rest args)
+ `(progn (defthmd ,name . ,args)
+ (add-gl-rewrite ,name))))
+
+
+
+(defun gl-set-uninterpreted-fn (fn val world)
+ (b* ((formals (getprop fn 'formals :none 'current-acl2-world world))
+ (fn (if (eq formals :none)
+ (cdr (assoc fn (table-alist 'acl2::macro-aliases-table world)))
+ fn))
+ (formals (if (eq formals :none)
+ (getprop fn 'formals :none 'current-acl2-world world)
+ formals))
+ ((when (eq formals :none))
+ (er hard? 'gl-set-uninterpreted-fn
+ "~x0 is neither a function nor a macro-alias for a function~%" fn)))
+ `(table gl-uninterpreted-functions ',fn ,val)))
+
+(defsection gl-set-uninterpreted
+ :parents (reference)
+ :short "Prevent GL from interpreting a function's definition or concretely executing it."
+ :long
+ "Usage:
+@({
+ (gl::gl-set-uninterpreted fnname)
+})
+prevents GL from opening the definition of fnname or concretely executing
+it. GL will still apply rewrite rules to a call of @('fnname'). If the
+call is not rewritten away, symbolic execution of a @('fnname') call will
+simply produce an object (of the :g-apply type) representing a call of
+@('fnname') on the given arguments.
+
+@('gl::gl-unset-uninterpreted') undoes the effect of @('gl::gl-set-uninterpreted').
"
+
+ (defmacro gl-set-uninterpreted (fn)
+ `(make-event
+ (gl-set-uninterpreted-fn ',fn t (w state)))))
+
+(defmacro gl-unset-uninterpreted (fn)
+ `(make-event
+ (gl-set-uninterpreted-fn ',fn nil (w state))))
+
+
+
+(defun gl-branch-merge-find-fnsym (name state)
+ (declare (xargs :mode :program :stobjs state))
+ (b* ((thm (acl2::beta-reduce-full (acl2::meta-extract-formula name state)))
+ (concl
+ (if (eq (car thm) 'implies)
+ (third thm)
+ thm))
+ (equiv (car concl))
+ ((unless (and (symbolp equiv)
+ (getprop equiv 'acl2::coarsenings nil 'current-acl2-world
+ (w state))
+ (consp (second concl))
+ (eq (car (second concl)) 'if)
+ (consp (third (second concl)))
+ (symbolp (car (third (second concl))))))
+ (er hard? 'gl-branch-merge-find-fnsym
+ "The theorem ~x0 did not have the expected form for a branch ~
+ merge rule: conclusion should be:~% (equiv (if c (fn args) b) ~
+ rhs)" name)))
+ (car (third (second concl)))))
+
+(defsection def-gl-branch-merge
+ :parents (reference)
+ :short "Define a rule for GL to use in merging IF branches"
+ :long
+ "Usage:
+
+@({
+ (gl::def-gl-branch-merge my-branch-merge-rule
+ (implies (and (syntaxp (integerp m))
+ (integerp m))
+ (equal (if cond (logcons b n) m)
+ (logcons (if cond b (logcar m))
+ (if cond n (logcdr m)))))
+ :hints ...)
+})
+
+This form creates an ACL2 theorem with :rule-classes nil and installs it in
+a table that GL references when attempting to merge branches of an IF term.
+
+Branch merge rules work similarly to normal rewrite rules, except that:
+
+the LHS must be of the form: @('(if )')
+each rule is indexed by the function symbol of the then-term, so then-term
+must be a function call.
+ "
+
+ (defun def-gl-branch-merge-fn (name body hints otf-flg)
+ `(progn
+ (defthm ,name
+ ,body
+ :hints ,hints
+ :otf-flg ,otf-flg
+ :rule-classes nil)
+ (make-event
+ (let* ((fn (gl-branch-merge-find-fnsym ',name state))
+ (rules (cons ',name (cdr (assoc fn (table-alist
+ 'gl-branch-merge-rules
+ (w state)))))))
+ `(table gl-branch-merge-rules ',fn ',rules)))))
+
+ (defmacro def-gl-branch-merge (name body &key hints otf-flg)
+ (def-gl-branch-merge-fn name body hints otf-flg)))
diff -Nru acl2-6.2/books/centaur/gl/defagg.lisp acl2-6.3/books/centaur/gl/defagg.lisp
--- acl2-6.2/books/centaur/gl/defagg.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/defagg.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,8 +1,24 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-
(include-book "cutil/defaggregate" :dir :system)
(include-book "tools/flag" :dir :system)
(include-book "tools/pattern-match" :dir :system)
@@ -100,8 +116,8 @@
`(cons ,(mk-constructor-aux (car tree))
,(mk-constructor-aux (cdr tree)))))
-(defun mk-constructor (basename tag names tree)
- `(defund-inline ,basename ,names
+(defun mk-constructor (basename tag names tree notinline)
+ `(,(if notinline 'defund 'defund-inline) ,basename ,names
(declare (xargs :guard t))
,(if tag
`(cons ',tag
@@ -136,12 +152,12 @@
:rule-classes (:rewrite :linear))
(accessor-acl2-count-thms basename (cdr accs-alist))))))
-(defun defagg-fn (basename fields tag)
+(defun defagg-fn (basename fields tag notinline)
(b* ((tree (list-to-tree fields))
(accs-alist (mk-accs-alist basename tree))
(?accs (strip-cars accs-alist)))
`(defsection ,basename
- ,(mk-constructor basename tag fields tree)
+ ,(mk-constructor basename tag fields tree notinline)
,@(mk-accessors accs-alist tag)
,@(accessors-of-constructor basename accs-alist fields fields)
,@(accessor-acl2-count-thms basename accs-alist)
@@ -160,9 +176,10 @@
(def-pattern-match-constructor
(x) ,basename (eq (tag x) ',tag) ,accs))))))
-(defmacro defagg (basename fields &key (tag 'nil tag-p))
+(defmacro defagg (basename fields &key (tag 'nil tag-p) notinline)
(defagg-fn basename fields
- (if tag-p tag (intern (symbol-name basename) "KEYWORD"))))
+ (if tag-p tag (intern (symbol-name basename) "KEYWORD"))
+ notinline))
(logic)
@@ -173,7 +190,7 @@
-
+
;; (defun da-accessors (name fields)
;; (if (atom fields)
@@ -258,7 +275,7 @@
;; (or (consp fields)
;; (er hard 'defaggregate "There must be at least one field.~%"))
;; (or (and (tuple-listp 2 require)
-;; (symbol-listp (strip-cars require)))
+;; (symbol-listp (strip-cars require)))
;; (er hard 'defaggregate ":require must be a list of (name requirement) tuples.~%"))
;; (or (no-duplicatesp (strip-cars require))
;; (er hard 'defaggregate "The names given to :require must be unique.~%"))
diff -Nru acl2-6.2/books/centaur/gl/defapply.lisp acl2-6.3/books/centaur/gl/defapply.lisp
--- acl2-6.2/books/centaur/gl/defapply.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/defapply.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,14 +1,29 @@
-
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "clause-processors/generalize" :dir :system)
(include-book "tools/defevaluator-fast" :dir :system)
(include-book "tools/mv-nth" :dir :system)
(include-book "tools/rulesets" :dir :system)
(include-book "gl-util")
-
(include-book "misc/hons-help2" :dir :system)
(defun defeval-fns-to-calls (fns world)
@@ -55,7 +70,7 @@
nil
(cons `(nth ,start ,sym)
(make-list-of-nths sym (1+ start) (1- n)))))
-
+
(defmacro ecc (call)
(declare (xargs :guard (consp call)))
(if (member-eq (car call) acl2::*ec-call-bad-ops*)
@@ -117,7 +132,7 @@
;; ;; (:executable-counterpart-theory :here)
;; (equal) (len) (nth) (binary-+) (not)
;; (zp)
-;; (:definition ,name)
+;; (:definition ,name)
;; len-open-for-defapply
;; nth-open-for-defapply))
;; :do-not '(preprocess))
@@ -126,8 +141,8 @@
;; ;; normalize to a constant.
;; '(:expand ((:free ,formals (,fn . ,formals)))))))
;; (apply-rw-thms (cdr clique) name world)))))
-
-
+
+
;; (defun make-apply-rewrites (name fns world)
@@ -193,7 +208,7 @@
;; (zp) (unary--) (binary-+)
(:rules-of-class :type-prescription :here)))))
(defeval-wrap ,ev ,ev-lst ,fns)
-
+
(defund ,name (f args)
(declare (xargs :guard t
:normalize nil))
@@ -295,8 +310,8 @@
(x (cadr x))))
:in-theory (disable cadr-kwote-lst-count-cdrs-correct-nth)))
:rule-classes ((:meta :trigger-fns (car))))
-
-
+
+
;; (defapply myapp (BINARY-*
diff -Nru acl2-6.2/books/centaur/gl/doc.lisp acl2-6.3/books/centaur/gl/doc.lisp
--- acl2-6.2/books/centaur/gl/doc.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/doc.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,1530 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; doc.lisp
+;
+; Original authors: Sol Swords
+; Jared Davis
+
+(in-package "GL")
+(include-book "xdoc/top" :dir :system)
+
+
+(defxdoc gl
+ :parents (acl2::proof-automation acl2::hardware-verification)
+ :short "A symbolic simulation framework for proving finitely bounded ACL2
+theorems by bit-blasting with a Binary Decision
+Diagram (BDD) package or a SAT
+solver ."
+
+ :long "Overview
+
+GL is a convenient and efficient tool for solving many finite ACL2 theorems
+that arise in @(see acl2::hardware-verification) and other contexts. It plays
+an important role in the verification of arithmetic units and microcode
+routines at Centaur Technology .
+
+GL requires ACL2(h) because it makes extensive use of @(see
+acl2::hons-and-memoization). Some optional parts of GL also require trust tags .
+
+GL translates ACL2 problems into Boolean problems that can be solved by
+automatic @(see acl2::boolean-reasoning) tools. When this approach can be
+used, there are some good reasons to prefer it over @(see acl2::the-method) of
+traditional, interactive theorem proving. For instance, it can:
+
+
+
+Reduce the level of human understanding needed in the initial process of
+developing the proof;
+
+Provide clear counterexamples, whereas failed ACL2 proofs can often be
+difficult to debug; and
+
+Ease the maintenance of the proof, since after the design changes they can
+often find updated proofs without help.
+
+
+
+How does this translation work? You can probably imagine writing a
+bit-based encoding of ACL2 objects. For instance, you might represent an
+integer with some structure that contains a 2's-complement list of bits. GL
+uses an encoding like this, except that Boolean expressions take the place of
+the bits. We call these structures @(see symbolic-objects).
+
+GL provides a way to effectively compute with symbolic objects; e.g., it can
+\"add\" two integers whose bits are expressions, producing a new symbolic
+object that represents their sum. GL can perform similar computations for most
+ACL2 primitives. Building on this capability, it can symbolically
+execute terms. The result of a symbolic execution is a new symbolic object
+that captures all the possible values the result could take.
+
+Symbolic execution can be used as a proof procedure . To prove a
+theorem, we first symbolically execute its goal formula, then show the
+resulting symbolic object cannot represent @('nil'). GL provides a @(see
+def-gl-thm) command that makes it easy to prove theorems with this approach.
+It handles all the details of working with symbolic objects, and only needs to
+be told how to represent the variables in the formula.
+
+GL Documentation
+
+New users should begin with the @(see basic-tutorial), which walks
+through the basic ideas behind how GL works, and includes some examples that
+cover how to use GL.
+
+Once you start to use GL, you will likely be interested in the @(see
+reference) section of this documentation.
+
+Like any automatic procedure, GL has a certain capacity. But when these
+limits are reached, you may be able to work around the problem in various ways.
+The @(see optimization) section explains various ways to improve GL's
+performance.
+
+Occasionally GL proofs will fail due to resource limitations or limitations
+of its symbolic evaluation strategy. When you run into problems, you may be
+interested in some tools and techniques for @(see debugging) failed proofs.
+
+If you want to go further with GL, you will probably want to explore @(see
+other-resources) beyond just this documentation, which include Sol Swords'
+Ph.D. dissertation, as well as many other academic papers and talks.
+
+
+Copyright Information
+
+GL — A Symbolic Simulation Framework for ACL2
+Copyright (C) 2008-2013 Centaur
+Technology .
+
+Contact:
+@({
+Centaur Technology Formal Verification Group
+7600-C N. Capital of Texas Highway, Suite 300
+Austin, TX 78731, USA.
+})
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+details.
+
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
+Street, Suite 500, Boston, MA 02110-1335, USA.
")
+
+
+(defxdoc reference
+ :parents (gl)
+ :short "Reference documentation for using GL.")
+
+
+(defxdoc other-resources
+ :parents (gl)
+ :short "Additional resources (talks, academic papers, a dissertation) for
+learning about GL."
+
+ :long "Besides this @(see xdoc::xdoc) documentation, most GL users will
+probably want to be aware of at least the following resources:
+
+
+
+Sol Swords and Jared Davis. Bit-Blasting ACL2 Theorems .
+In ACL2 Workshop 2011. November, 2011. EPTCS 70. Pages 84-102.
+
+This is an approachable, user-focused introduction to GL as of 2011, which
+also contains many pointers to related work. It's probably a good idea to read
+this first, noting that a few details have changed. Much of this paper has now
+been incorporated into this @(see xdoc::xdoc) documentation.
+
+Sol Swords. A
+Verified Framework for Symbolic Execution in the ACL2 Theorem Prover .
+Ph.D. thesis, University of Texas at Austin. December, 2010.
+
+This is the most comprehensive guide to GL's internals. It covers tricky
+topics like the handling of if statements and the details of BDD
+parametrization. It also covers the logical foundations of GL, such as
+correctness claims for symbolic counterparts, the introduction of symbolic
+interpreters, and the definition and verification of the GL clause processor.
+Some topics are now somewhat dated, but it is good general background for
+anyone who wants to extend GL.
+
+The documentation for @(see acl2::hons-and-memoization).
+
+GL makes heavy use of the ACL2(h) extension for hash consing and
+memoization. GL users will likely want to be aware of the basics of ACL2(h),
+and of commands like @(see hons-summary), @(see hons-wash), and @(see
+acl2::set-max-mem).
+
+
+
+
+Back-end Solvers
+
+
+
+Jared Davis and Sol Swords. Verified AIG Algorithms in
+ACL2. In ACL2 Workshop 2013. May, 2013. EPTCS 114. Pages 95-110.
+This is a more recent paper that's not especially focused on GL, but which
+covers @(see aignet::aignet) and @(see satlink::satlink), which can be used by
+GL in its new @(see gl-satlink-mode). Many problems that are difficult to
+solve using @(see acl2::ubdds) can be solved using @(see
+satlink::satlink).
+
+Sol Swords and Warren A Hunt, Jr. A Mechanically Verified
+AIG to BDD Conversion Algorithm . In ITP 2010, LNCS 6172, Springer. Pages
+435-449.
+This is an older paper about the details of the @('bddify') algorithm that
+is used as the engine for @(see gl-aig-bddify-mode).
+
+
+
+GL Applications
+
+GL has been used at Centaur
+Technology to verify RTL implementations of floating-point addition,
+multiplication, and conversion operations, as well as hundreds of bitwise and
+arithmetic operations on scalar and packed integers. Some papers describing
+some of this work include:
+
+
+
+Anna Slobodova, Jared Davis, Sol Swords, and Warren A. Hunt, Jr. A Flexible Formal
+Verification Framework for Industrial Scale Validation . In Memocode 2011,
+IEEE. Pages 89-97.
+
+Warren A. Hunt, Jr., Sol Swords, Jared Davis, and Anna Slobodova. Use
+of Formal Verification at Centaur Technology . In David Hardin, editor, Design and Verification of
+Microprocessor Systems for High-Assurance Applications , Pages 65-88.
+Springer, 2010.
+
+
+
+History
+
+GL is the successor of Boyer and Hunt's G system, the best
+description of which may be found in:
+
+
+
+The name, GL, its name stands for G in the Logic . The G system was
+written as a raw Lisp extension of the ACL2 kernel, so using it meant trusting
+this additional code. In contrast, GL is implemented as ACL2 books and its
+proof procedure is formally verified by ACL2, so the only code we have to trust
+besides ACL2 is the ACL2(h) extension that provides @(see
+acl2::hons-and-memoization).
")
+
+
+(defxdoc debugging
+ :parents (gl)
+ :short "Advice and tools for debugging performance problems and failed @(see
+gl) proofs."
+
+:long "A GL proof attempt can end in several ways. Ideally, GL will either
+quickly prove your conjecture, or disprove it and show you counterexamples to
+help diagnose the problem. But things will not always end so well.
+
+
+Capacity Problems
+
+
+
+GL is running out of memory.
+
+Symptoms: your ACL2 process is using too much memory and your machine is
+swapping , or you are seeing frequent garbage collection messages
+that seem unsuccessful—that is, few bytes are freed by each GC.
+
+There are @(see memory-management) tools that may help to avoid these
+problems. You may need to look into @(see optimization) techniques.
+
+GL has enough memory, but is running forever.
+
+You may be running into a bad case for GL's symbolic execution strategy, or
+your problem may be too hard for the back-end solver (BDDs, SAT). See @(see
+performance-problems) for some tools and advice for dealing with these
+situations.
+
+
+
+
+Other Problems
+
+
+
+GL is failing to prove coverage.
+
+Symptoms: You are seeing failed ACL2 proof goals after GL says
+it is proving coverage.
+
+It might be that your :g-bindings aren't sufficient to cover your theorem's
+hypotheses, or GL's strategy for proving coverage is misbehaving. See @(see
+coverage-problems) for advice on debugging this situation.
+
+GL produces false counterexamples.
+
+This is easy to identify because GL will print @('False counterexample!')
+and direct you to @(see false-counterexamples).
+
+ ")
+
+
+(defxdoc performance-problems
+ :parents (debugging)
+ :long "
+
+Any bit-blasting tool has capacity limitations. However, you may also run into
+cases where GL is performing poorly due to preventable issues. When GL seems
+to be running forever, it can be helpful to trace the symbolic interpreter to
+see which functions are causing the problem. To trace the symbolic
+interpreter, run
+
+@({
+ (gl::trace-gl-interp :show-values t)
+})
+
+Here, at each call of the symbolic interpreter, the term being interpreted
+and the variable bindings are shown, but since symbolic objects may be too
+large to print, any bindings that are not concrete are hidden. You can also
+get a trace with no variable bindings using @(':show-values nil'). It may also
+be helpful to simply interrupt the computation and look at the Lisp backtrace,
+after executing
+
+@({
+ (set-debugger-enable t)
+})
+
+In many cases, performance problems are due to BDDs growing too large. This
+is likely the case if the interpreter appears to get stuck (not printing any
+more trace output) and the backtrace contains a lot of functions with names
+beginning in @('q-'), which is the convention for BDD operators. In some
+cases, these performance problems may be solved by choosing a more efficient
+BDD order. But note that certain operations like multiplication are
+exponentially hard. If you run into these limits, you may need to refactor or
+decompose your problem into simpler sub-problems, e.g., with @(see
+def-gl-param-thm).
+
+There is one kind of BDD performance problem with a special solution.
+Suppose GL is asked to prove @('(equal spec impl)') when this does not actually
+hold. Sometimes the symbolic objects for @('spec') and @('impl') can be
+created, but the BDD representing their equality is too large to fit in memory.
+The goal may then be restated with @(see always-equal) instead of @('equal') as
+the final comparison. Logically, @('always-equal') is just @('equal'). But
+@('always-equal') has a custom symbolic counterpart that returns @('t') when
+its arguments are equivalent, or else produces a symbolic object that captures
+just one counterexample and is indeterminate in all other cases.
+
+Another possible problem is that the symbolic interpreter never gets stuck,
+but keeps opening up more and more functions. These problems might be due to
+@(see redundant-recursion), which may be avoided by providing a more efficient
+@(see preferred-definitions).
")
+
+
+(defxdoc false-counterexamples
+ :parents (debugging)
+ :long "
+
+Occasionally, GL will abort a proof after printing:
+
+@({
+ False counterexample! See :xdoc gl::false-counterexamples.
+})
+
+Most of the time, you might think of GL as an \"exact\" system where we have
+an explicit Boolean function representation of every bit in all the objects in
+your conjecture. Ideally, this should allow GL to either prove your theorem or
+find a counterexample.
+
+This isn't always the case. Sometimes GL represents objects more abstractly.
+For example, GL tends not to support operations on non-integer rational
+numbers. If it runs into a call of @('(* 1/3 x)'), it may represent the result
+abstractly, as a term-like symbolic object:
+
+@({
+ (:g-apply binary-* 1/3 (:g-number ...))
+})
+
+(assuming @('x') is represented as a @(':g-number') object). This sort of
+abstraction can help to avoid creating potentially very-expensive symbolic
+objects, and is an important part of GL's @(see term-level-reasoning).
+
+This kind of abstraction can be contagious. For example, if we are trying
+to prove @('(not (equal (* 1/3 x) 'not-a-number))'), then using the
+@(':g-apply') representation for the @('*') subterm will likely cause GL to
+also use a @(':g-apply') representation for the whole term. But now, how is GL
+supposed to give this to a SAT solver?
+
+When GL finds a @(':g-apply') object in a Boolean context, such as an IF
+test or a theorem's hypothesis or conclusion, it will create a fresh Boolean
+variable to represent that term. But if, say, that term is something like
+
+@({
+ (:g-apply equal (:g-apply binary-* 1/3 ...)
+ not-a-number)
+})
+
+which is always false, then this Boolean variable is too general, and by
+replacing the term with the Boolean variable, GL has lost track of the fact
+that the term is actually always false. This generally leads to false
+counterexamples.
+
+Dealing with False Counterexamples
+
+
+The first things to check for when you encounter a false counterexample:
+
+
+
+Missing @(':g-bindings'): When a variable is omitted from the
+@(':g-bindings') form, a warning is printed and the missing variable is
+assigned a @(':g-var') object. A @(':g-var') can represent any ACL2 object,
+without restriction. Symbolic counterparts typically produce @(':g-apply')
+objects when called on @(':g-var') arguments, and this can easily lead to false
+counterexamples.
+
+The stack depth limit, or \"clock\", was exhausted. This may happen when
+symbolically executing a recursive function if the termination condition can't
+be detected, though this is often caused by previous introduction of an
+unexpected G-APPLY object.
+
+An unsupported primitive was called. For example, as of August 2013 we do
+not yet support UNARY-/, so any call of UNARY-/ encountered during symbolic
+execution will return a G-APPLY of UNARY-/ to the input argument. It may be
+that you can avoid calling such functions by installing an alternate definition .
+
+A primitive was called on an unsupported type of symbolic object. For
+example, the symbolic counterparts for most arithmetic primitives will produce
+a G-APPLY object if an input seems like it might represent a non-integer
+rational. Since symbolic operations on rationals are absurdly expensive, we
+simply don't implement them for the most part.
+
+
+
+It is common to use GL in such a way that G-VAR forms are not used, and
+G-APPLY forms are unwelcome if they appear at all; when they do, they typically
+result in a symbolic execution failure of some sort. However, there are ways
+of using GL in which G-VAR and G-APPLY forms are expected to exist; see @(see
+term-level-reasoning). If you are not expecting GL to create G-APPLY objects
+but you are encountering false counterexamples, we suggest using the following
+form to determine why a G-APPLY object is first being created:
+
+@({
+ (gl::break-on-g-apply)
+})
+
+Then when GL::G-APPLY is called in order to create the form, @('(BREAK$)')
+will be called. Usually this will allow you to look at the backtrace and
+determine in what context the first G-APPLY object is being created.
+
+Alternatively, if you are expecting some G-APPLY forms to be created but
+unexpected ones are cropping up, you can make the break conditional
+on the function symbol being applied:
+
+@({
+ (gl::break-on-g-apply :allowed-fns (foo bar))
+})")
+
+
+
+
+(defxdoc memory-management
+ :parents (optimization debugging)
+ :long "
+
+Memory management can play a significant role in symbolic execution
+performance. In some cases GL may use too much memory, leading to swapping and
+slow performance. In other cases, garbage collection may run too frequently or
+may not reclaim much space. We have several recommendations for managing
+memory in large-scale GL proofs. Some of these suggestions are specific to
+Clozure Common Lisp.
+
+
+Use set-max-mem
+
+You can load the @('centaur/misc/memory-mgmt') book and use the @(see
+set-max-mem) command to indicate how large you would like the Lisp heap to be.
+For instance,
+
+@({
+ (set-max-mem (* 8 (expt 2 30)))
+})
+
+says to allocate 8 GB of memory. To avoid swapping, you should use somewhat
+less than your available physical memory. This book disables ephemeral garbage
+collection and configures the garbage collector to run only when the threshold
+set above is exceeded, which can boost performance.
+
+
+Optimize hash-consing performance.
+
+GL's representations of BDDs and AIGs use @(see hons) for structure-sharing.
+The @(see hons-summary) command can be used at any time to see how many honses
+are currently in use, and hash-consing performance can be improved by
+pre-allocating space for these honses with @(see hons-resize).
+
+
+Manage hash-consing and memoization overhead.
+
+Symbolic execution can use a lot of hash conses and can populate the
+memoization tables for various functions. The memory used for these purposes
+is not automatically freed during garbage collection, so it may
+sometimes be necessary to manually reclaim it.
+
+A useful function is @('(maybe-wash-memory n)'), which frees this memory and
+triggers a garbage collection only when the amount of free memory is below some
+threshold @('n'). A good choice for @('n') might be 20\% of the @(see
+set-max-mem) threshold.
+
+It can be useful to call @(see maybe-wash-memory) between proofs, or between
+the cases of parametrized theorems; see for instance the @(':run-before-cases')
+argument of @(see def-gl-param-thm).
")
+
+
+
+(defxdoc symbolic-objects
+ :parents (reference)
+ :short "Format of symbolic objects in @(see gl)."
+
+ :long "Symbolic objects represent functions from the set of
+environments (described below) to the set of ACL2 objects. The value of an
+object at an environment is given by an evaluator function. Symbolic objects
+are recursively structured and have a number of constructors. We first briefly
+describe evaluators (and why there can be more than one), then the structure of
+environment objects, and then the symbolic object constructors.
+
+
+Evaluators
+
+A symbolic object evaluator is a function with the interface
+
+@({
+ (EV symbolic-object environment) => value.
+})
+
+There may be several evaluators defined. The differences between evaluators
+have to do with the G-APPLY symbolic object type, which represents a function
+applied to symbolic arguments. In order to evaluate such an object, the
+evaluator must be defined such that it recognizes the particular function
+symbol used in the G-APPLY object. An evaluator may not evaluate a symbolic
+object containing a G-APPLY construct with an unrecognized function symbol.
+One evaluator, named EVAL-G-BASE, is initially defined in the GL library, and
+recognizes function symbols of the predefined primitives included with the
+library.
+
+Environments
+
+The basic components of symbolic objects are data structures containing
+Boolean functions, represented either by BDDs or AIGs (see @(see modes)), and G-VAR
+constructs, which represent unconstrained variables. To evaluate a symbolic
+object, each of these needs to be evaluated to a constant. An environment
+contains the information necessary to evaluate either kind of expression:
+
+a truth assignment for the Boolean variables used in the Boolean function
+representation; in AIG mode, this is an alist mapping variable names to
+Booleans, and in BDD mode, an ordered list of Booleans corresponding to the
+decision levels of the BDDs.
+an alist mapping unconstrained variable names to their values.
+
+
+Symbolic Object Representation
+
+There are eight basic constructions of symbolic objects, some of which may
+recursively contain other symbolic objects. We now describe each such
+construction and its evaluation.
+
+
+
+Representation: (:G-BOOLEAN . bfr)
+Constructor: (G-BOOLEAN bfr)
+
+Takes the values T and NIL. The evaluation of a G-BOOLEAN object is simply
+the evaluation of @('') using the list of Booleans in the
+environment.
+
+Representation: (:G-NUMBER . list-of-lists-of-bdds)
+Constructor: (G-NUMBER list-of-lists-of-bdds)
+
+Evaluates to a (complex rational) number. @('')
+should be a list containing four or fewer lists of UBDDs, which represent (in
+order):
+
+
+the numerator of the real part (two's-complement, default 0)
+the denominator of the real part (unsigned, default 1)
+the numerator of the imaginary part (two's-complement, default 0)
+the denominator of the imaginary part (unsigned, default 1).
+
+
+It is most common to represent an integer, for which only the first list need
+be included. In both the two's-complement and unsigned representations, the
+bits are ordered from least to most significant, with the last bit in the two's
+complement representation giving the sign. Two's complement lists may be
+sign-extended by repeating the final bit, and unsigned lists may be
+zero-extended by appending NILs after the final bit.
+
+Representation (:G-CONCRETE . object)
+Constructor: (G-CONCRETE object)
+
+Evaluates to @(''). While most ACL2 objects evaluate to themselves
+anyway, this construct is useful for representing symbolic objects or objects
+structured similarly to symbolic objects. For example, @({
+ (:G-CONCRETE . (:G-BOOLEAN . (T . NIL))) evaluates to
+ (:G-BOOLEAN . (T . NIL)), whereas
+ (:G-BOOLEAN . (T . NIL)) evaluates to either T or NIL.
+})
+
+Representation: (:G-VAR . name)
+Constructor: (G-VAR . name)
+
+@('') may be any object. Evaluates to the object bound to
+@('') in the environment.
+
+Representation: (:G-ITE test then . else)
+Constructor: (G-ITE test then else)
+
+Each of @(''), @(''), and @('') must be symbolic objects.
+If @('') evaluates to a nonnil value, then this object evaluates to the
+evaluation of @(''); otherwise this evaluates to the evaluation of
+@('').
+
+Representation: (:G-APPLY fn . arglist)
+Constructor: (G-APPLY fnsym arglist)
+
+@('') should be a symbol and @('') should be a symbolic
+object. If the evaluator recognizes @('') and @('') evaluates to
+@(''), a true-list of length equal to the arity of the function
+@(''), then this object evaluates to the application of @('') to
+@(''). Otherwise, the evaluation is undefined.
+
+Representation: atom
+
+Every atom evaluates to itself. However, the keyword symbols
+:G-BOOLEAN, :G-NUMBER, :G-CONCRETE, :G-VAR, :G-ITE, and :G-APPLY are not
+themselves well-formed symbolic objects.
+
+Representation: @('(car . cdr)')
+
+A cons of two symbolic objects evaluates to the cons of their evaluations.
+Note that since the keyword symbols that distinguish symbolic object
+constructions are not themselves well-formed symbolic objects, this
+construction is unambiguous.
+
+
+
+Miscellaneous notes about symbolic objects and evaluation
+
+
+
+Any function from finitely many Boolean values to the universe of
+ACL2 objects can be expressed using only the G-ITE, G-BOOLEAN, and
+G-CONCRETE forms.
+
+Most ACL2 objects are themselves well-formed symbolic objects which
+evaluate to themselves. The exceptions are ones which contain the special
+keyword symbolis :G-BOOLEAN, :G-NUMBER, :G-CONCRETE, :G-VAR,
+:G-ITE, and :G-APPLY. These atoms (and out of all atoms, only these)
+are not well-formed symbolic objects. Since a cons of any two
+well-formed symbolic objects is itself a well-formed symbolic objects,
+only objects containing these atoms may be non-well-formed.
+
+The function that checks well-formedness of symbolic objects is GOBJECTP,
+and the initial evaluator function is GL::EVAL-G-BASE. It may be useful to
+read the definitions of these functions for reference in case the above
+symbolic object documentation is unclear.
+
+ ")
+
+
+
+
+
+(defxdoc alternate-definitions
+ :parents (optimization)
+ :short "Specifying alternative definitions to be used for symbolic
+ execution."
+
+ :long "Sometimes the definition of some function is ill-suited for
+automatic methods of symbolic execution. For example, @('(EVENP X)') is defined
+as
+
+@({
+ (integerp (* x (/ 2)))
+})
+
+and because currently multiplication by a non-integer is not supported in
+GL, this yields a G-APPLY form in most cases.
+
+In this case and several others, one may instead provide an alternate
+definition for the function in question and use that as the basis for GL
+symbolic execution.
+
+In the case of EVENP, the following theorem works as an alternate
+definition:
+
+@({
+ (defthm evenp-is-logbitp
+ (equal (evenp x)
+ (or (not (acl2-numberp x))
+ (and (integerp x)
+ (equal (logbitp 0 x) nil))))
+ :rule-classes nil)
+})
+
+After proving this theorem, the following form sets this alternate
+definition as the one GL will use when symbolically interpreting EVENP:
+
+@({
+ (gl::set-preferred-def evenp evenp-is-logbitp)
+})
+
+This form produces one or more @(see table) events.
")
+
+
+(defxdoc coverage-problems
+ :parents (debugging)
+ :short "Proving the coverage obligation in GL-based proofs."
+
+ :long "In order to prove a theorem using GL, one must show that the
+symbolic objects chosen to represent the inputs are sufficiently general to
+cover the entire set of interest. See @(see SHAPE-SPECS) for a more in-depth
+discussion. The @(see DEF-GL-THM) and @(see DEF-GL-PARAM-THM) events as well
+as the @(see GL-HINT) hints all provide some degree of automation for coverage
+proofs; often this is enough to satisfy the coverage obligation without further
+user interaction. Here we discuss how to debug coverage proofs that do not
+succeed.
+
+First, it is probably important to be able to re-run a coverage proof easily
+without also re-running the associated symbolic execution, which may be quite
+time-consuming. To do this, in either the @(see DEF-GL-THM) or @(see
+DEF-GL-PARAM-THM) forms, add the keyword argument @(':TEST-SIDE-GOALS T').
+This form will then try to prove the coverage obligation in exactly the manner
+it would do during the real proof, but it will not attempt to prove the theorem
+itself, and will not record a new ACL2 theorem even if the proof is
+successful.
+
+During proof output, GL prints a message \"Now proving coverage\" when it
+begins the coverage proof. The initial goal of a coverage proof will also have
+a hypothesis @('(GL::GL-CP-HINT 'GL::COVERAGE)'); this hypothesis is logically
+meaningless, but a useful indicator of the beginning of a coverage proof.
+
+When GL's usual set of heuristics is used, a coverage proof proceeds as
+follows. The initial goal is as follows:
+
+@({
+ (implies
+ (gl::shape-spec-obj-in-range
+
+ ))
+})
+
+The coverage heuristics proceed by repeatedly opening up the
+@('GL::SHAPE-SPEC-OBJ-IN-RANGE') function. This effectively splits the proof
+into cases for each component of each variable; for example, if one variable's
+shape specifier binding is a cons of two :G-NUMBER forms, then its CAR and CDR
+will be considered separately. Eventually, this results in several subgoals,
+each with conjunction of requirements for some component of some input.
+
+During this process of opening the @('GL::SHAPE-SPEC-OBJ-IN-RANGE')
+conclusion, the coverage heuristics also examine and manipulate the hypotheses.
+When the conclusion is focused on a certain input variable or component of that
+variable, and some hypothesis does not mention that variable, that hypothesis
+will be dropped so as to speed up the proof. If a hypothesis does mention that
+variable, it may be expanded (if it is not a primitive) so as to try and gain
+more information about that variable. This is a useful heuristic because often
+the hypotheses consist of a conjunction of predicates about different input
+variables or components of input variables, and some of these predicates are
+often themselves defined as conjunctions of predicates about subcomponents.
+
+However, sometimes this expansion goes too far. In many cases, some
+conjuncts from the hypothesis have nothing to do with the coverage obligation.
+In these cases, the @(':DO-NOT-EXPAND') keyword argument to @('DEF-GL-THM') and
+@('DEF-GL-PARAM-THM') may be used. This argument should evaluate to a list of
+function symbols; the coverage heuristic is then prohibited from expanding any
+of these functions.
+
+For efficiency, the set of rules used in coverage proofs is very restricted.
+Because of this, you may see in the proof output a goal which should be
+obvious, but is not proven because the necessary rule is not included. The
+keyword argument @(':COV-THEORY-ADD') may be used to enable certain additional
+rules that are not included. The set of rules that are used is defined in the
+ruleset @('GL::SHAPE-SPEC-OBJ-IN-RANGE-OPEN'), which can be listed using
+
+@({
+ (get-ruleset 'gl::shape-spec-obj-in-range-open (w state)).
+})
+
+The default heuristics for coverage proofs may not always be useful.
+Therefore, the user may also supplement or replace the coverage heuristics with
+arbitrary computed hints. The keyword argument @(':COV-HINTS') gives a list of
+computed hint forms which, according to the value of the keyword argument
+@(':COV-HINTS-POSITION'), either replaces or supplements the default hints.
+@(':COV-HINTS-POSITION') may be either @(':REPLACE'), in which case the
+defaults are not used at all; @(':FIRST'), in which case the user-provided
+@(':COV-HINTS') are tried first and the defaults afterward, or the default,
+@(':LAST'), in which case the default coverage heuristic is tried before the
+user-provided hints.
+
+Note that subgoal names will be different between a @(':TEST-SIDE-GOALS')
+and an actual attempt at proving the theorem. Therefore, it is best not to
+write computed hints that depend on the @('ID') variable.
")
+
+
+
+
+
+(defxdoc optimization
+ :parents (gl)
+ :short "How to optimize GL's symbolic simulations for faster or
+larger-scale proofs."
+
+ :long "
+
+
+
+Using different @(see modes) to solve the problem. Some modes vastly
+outperform others on particular problems and it is very easy to switch modes,
+so this is often a good first thing to try when you run into a performance
+problem.
+
+Decomposing difficult problems into easier subgoals. GL provides some
+support for @(see case-splitting) hard proofs, and in some cases this kind of
+decomposition can tremendously boost performance.
+
+Using other @(see optimization) techniques to make GL's symbolic execution
+strategy more efficient.
+
+
+
+
+The scope of theorems GL can handle is directly impacted by its symbolic
+execution performance. It is actually quite easy to customize the way certain
+terms are interpreted, and this can sometimes provide important speedups.
+
+GL's symbolic interpreter operates much like a basic Lisp interpreter. To
+symbolically interpret a function call, GL first eagerly interprets its
+arguments to obtain symbolic objects for the actuals. Then GL symbolically
+executes the function in one of three ways:
+
+
+
+As a special case, if the actuals evaluate to concrete objects, then GL may
+be able to stop symbolically executing and just call the actual ACL2 function
+on these arguments; see @(see concrete-execution).
+
+For primitive ACL2 functions like @(see +), @(see consp), @(see equal), and
+for some defined functions like @(see logand) and @(see ash) where performance
+is important, GL uses hand-written functions called symbolic
+counterparts that can operate on symbolic objects. The advanced GL user
+can write new @(see custom-symbolic-counterparts) to speed up symbolic
+execution.
+
+Otherwise, GL looks up the definition of the function, and recursively
+interprets its body in a new environment binding the formals to the symbolic
+actuals. The way a function is written can impact its symbolic execution
+performance; see @(see redundant-recursion). It is easy to instruct GL to use
+more efficient, @(see preferred-definitions) for particular functions.
+
+
+
+GL symbolically executes functions strictly according to the ACL2 logic and
+does not consider guards. An important consequence is that when @(see mbe) is
+used, GL's interpreter follows the @(':logic') definition instead of the
+@(':exec') definition, since it might be unsound to use the @(':exec') version
+of a definition without establishing the guard is met. Also, while GL can
+symbolically simulate functions that take user-defined stobjs or even the ACL2
+@(see state), it does not operate on \"real\" @(see acl2::stobj)s; instead, it
+uses the logical definitions of the relevant stobj operations, which do not
+provide the performance benefits of destructive operations. Non-executable
+functions cannot be symbolically executed.
")
+
+
+(defxdoc modes
+ :parents (optimization)
+ :short "GL modes allow you to control major aspects of how GL carries out its
+symbolic simulation and how it should solve Boolean formulas that arise during
+proofs."
+
+ :long "For some general background, see section
+@(see |4. Proving Theorems by Symbolic Execution|) of the @(see basic-tutorial).
+
+By default, GL operates in @(see gl-bdd-mode). In this mode, the Boolean
+formulas within @(see symbolic-objects) are represented using @(see ubdds), and
+questions about these formulas are resolved using BDD operations.
+
+But GL also supports other modes, and you can easily switch between modes on
+a proof-by-proof basis. Typically this looks like:
+
+@({
+ (local (gl::gl-bdd-mode))
+ (def-gl-thm foo ...)
+
+ (local (gl::gl-satlink-mode))
+ (def-gl-thm bar ...)
+})
+
+GL's other modes use And-Inverter Graphs (@(see aig)s) as the Boolean
+function representation. Unlike BDDs, AIGs are non-canonical, and this affects
+performance in fundamental ways: AIGs are generally much cheaper to construct
+than BDDs, but it can be hard to determine whether AIGs are equivalent, whereas
+with BDDs this is just a pointer-equality check.
+
+A very convenient feature of AIGs is that you do not have to come up with a
+good variable ordering—this may be especially helpful on problems where
+@(see case-splitting) would be necessary because there's not a universally good
+BDD ordering. On the other hand, BDDs can provide especially nice
+counterexamples, whereas with AIGs we typically get just one, essentially
+random counterexample.
+
+Performance-wise, AIGs are better for some problems and BDDs for others.
+Many operations combine bits from data buses in a regular, orderly way; in
+these cases, there is often a good BDD ordering and BDDs may be faster than our
+AIG modes. But when the operations are less regular, when no good BDD ordering
+is apparent, or when case-splitting seems necessary to get good BDD
+performance, the AIG modes may do better. For many of our proofs, AIG mode
+performs well and saves us the trouble of finding a good BDD ordering.
+
+Solving AIGs
+
+When AIGs are used to carry out GL proofs, we need some way to answer
+whether the final AIG is satisfiable. To do this, GL can use one of two
+back-end solvers.
+
+Usually the better and higher-performance option is to send the AIG to an
+external SAT solver; see @(see gl-satlink-mode). In this mode, GL uses the
+@(see satlink) library to call upon an off-the-shelf SAT solver. Using
+external SAT solvers raises questions of trust, and GL does not yet implement
+any sort of proof-checking for the SAT solver's output. But pragmatically, for
+most verification efforts, it is probably reasonable to trust a SAT solver.
+
+Another option is to simply convert the AIG into BDDs; see @(see
+gl-aig-bddify-mode). This isn't necessarily a good idea, and you still have to
+worry about the variable order in this case. Occasionally this may
+out-perform just using BDDs to begin with, because there are certain
+optimizations you can make when converting from AIGs to BDDs that aren't
+possible when you just use BDDs for everything. This is also a high-confidence
+mode, where the whole proof is carried out within ACL2, with just some minimal
+trust-tags to boost performance.
+
+")
+
+(defxdoc gl-mode-implementation
+ :parents (modes)
+ :short "Implementation details about switching between GL reasoning modes"
+ :long "
+
+GL's various reasoning modes are implemented using @(see defattach). There
+are several functions that need to have proper attachments in order for GL to
+function; when the GL library is loaded, they are set up to a default
+configuration in which GL will use BDD-based reasoning.
+
+The functions that need attachments follow. Here, BFR stands for Boolean
+function representation.
+
+
+BFR-MODE: 0-ary with no constraints. This detemines whether the Boolean
+function components in the symbolic object representation are BDDs or AIGs, and
+thus the functions used to combine them. E.g., the definition of BFR-NOT
+is (basically):
+
+@({
+ (if (bfr-mode) (aig-not x) (q-not x)).
+})
+
+Similarly, BFR-EVAL either applies EVAL-BDD or AIG-EVAL, depending on
+BFR-MODE.
+
+By default the function BFR-BDD (which returns NIL) is attached to BFR-MODE,
+and thus BFR-NOT uses the BDD operation Q-NOT. To use AIGs instead, attach
+BFR-AIG, which returns T.
+
+BFR-SAT: Unary, returning three values: SAT, SUCCEEDED, CTREX. The main
+constraint of BFR-SAT is that if it returns SAT=NIL and SUCCEEDED=T, then
+BFR-EVAL of the input on any environment must be NIL, i.e., the input must be
+an unsatisfiable BDD or AIG (depending on the BFR-MODE.) The CTREX value
+should be a counterexample in the case of a SAT result, represented either as a
+BDD or an alist mapping variables to Boolean values; see below under
+BFR-COUNTEREX-MODE.
+
+To satisfy the constraint in the BDD case, it suffices to simply check whether
+the input BDD is NIL; if so, it is satisfiable, and otherwise, it isn't. This
+method is implemented as BFR-SAT-BDD, which is the default attachment of
+BFR-SAT. For AIG mode, we provide an attachment BFR-SAT-BDDIFY which solves an
+AIG satisfiability query by transforming the input AIG into a BDD. However,
+one might instead hook up a SAT solver into ACL2 so that it can take an AIG as
+input. Given a way of calling such an external tool, it would not be difficult
+to produce a function that conforms to the constraint described above. :-)
+
+BFR-COUNTEREX-MODE: 0-ary, no constraints. This says whether the
+counterexample value sometimes returned by BFR-SAT is in the form of a BDD or
+an association list. If it is set up wrong, then output in case of a
+counterexample will be garbled. In both the default BDD mode and in the AIG
+BDDIFY mode provided, the counterexample is in the form of a BDD, and so we
+attach BFR-COUNTEREX-BDD by default. However, if an external SAT solver is
+used, then there will likely be a single assignment returned, which might more
+conveniently be provided as an alist. Then one would instead attach
+BFR-COUNTEREX-ALIST.
")
+
+(defxdoc redundant-recursion
+ :parents (optimization)
+ :long "
+
+Here is a way to write a list-filtering function.
+
+@({
+ (defun filter1 (x)
+ (cond ((atom x)
+ nil)
+ ((element-okp (car x)) ;; keep it
+ (cons (car x) (filter1 (cdr x))))
+ (t ;; skip it
+ (filter1 (cdr x)))))
+})
+
+This definition can be inefficient for symbolic execution. Suppose we are
+symbolically executing @('filter1'), and the @('element-okp') check has
+produced a symbolic object that can take both @('nil') and non-@('nil') values.
+Then, we proceed by symbolically executing both the keep- and skip-branches,
+and construct a @(':g-ite') form for the result. Since we have to evaluate the
+recursive call twice, this execution becomes exponential in the length of
+@('x').
+
+We can avoid this blow-up by consolidating the recursive calls, as
+follows.
+
+@({
+ (defun filter2 (x)
+ (if (atom x)
+ nil
+ (let ((rest (filter2 (cdr x))))
+ (if (element-okp (car x))
+ (cons (car x) rest)
+ rest))))
+})
+
+Of course, @('filter1') is probably slightly better for concrete execution
+since it has a tail call in at least some cases. If we do not want to change
+the definition of @('filter1'), we can simply tell GL to use the @('filter2')
+definition instead, as described in the next section.
")
+
+
+(defxdoc preferred-definitions
+ :parents (optimization)
+ :long "To instruct GL to symbolically execute @('filter2') in place of
+@('filter1'), we can do the following:
+
+@({
+ (defthm filter1-for-gl
+ (equal (filter1 x) (filter2 x))
+ :rule-classes nil)
+
+ (gl::set-preferred-def filter1 filter1-for-gl)
+})
+
+The @(see gl::set-preferred-def) form extends a table that GL consults when
+expanding a function's definition. Each entry in the table pairs a function
+name with the name of a theorem. The theorem must state that a call of the
+function is unconditionally equal to some other term.
+
+When GL encounters a call of a function in this table, it replaces the call
+with the right-hand side of the theorem, which is justified by the theorem. So
+after the above event, GL will replace calls of @('filter1') with
+@('filter2').
+
+As another example of a preferred definition, GL automatically optimizes the
+definition of @(see evenp), which ACL2 defines as follows:
+
+@({
+ (evenp x) = (integerp (* x (/ 2)))
+})
+
+This definition is basically unworkable since GL provides little support for
+rational numbers. However, GL has an efficient, built-in implementation of
+@(see logbitp). So to permit the efficient execution of @('evenp'), GL proves
+the following identity and uses it as @('evenp')'s preferred definition.
+
+@({
+ (defthm evenp-is-logbitp
+ (equal (evenp x)
+ (or (not (acl2-numberp x))
+ (and (integerp x)
+ (equal (logbitp 0 x) nil)))))
+})")
+
+
+(defxdoc custom-symbolic-counterparts
+ :parents (optimization)
+ :long "
+
+The advanced GL user can write custom symbolic counterparts to get better
+performance.
+
+This is somewhat involved. Generally, such a function operates by cases on
+what kinds of symbolic objects it has been given. Most of these cases are
+easy; for instance, the symbolic counterpart for @(see consp) just returns
+@('nil') when given a @(':g-boolean') or @(':g-number'). But in other cases
+the operation can require combining the Boolean expressions making up the
+arguments in some way, e.g., the symbolic counterpart for @(see binary-*)
+implements a simple binary multiplier.
+
+Once the counterpart has been defined, it must be proven sound with respect
+to the semantics of ACL2 and the symbolic object format. This is an ordinary
+ACL2 proof effort that requires some understanding of GL's implementation.
+
+An example of a more sophisticated symbolic counterpart is an @(see aig) to
+ubdd conversion algorithm. This function
+serves as a symbolic counterpart for AIG evaluation. This algorithm and its
+correctness proof can be found in the book @('centaur/aig/g-aig-eval').
")
+
+
+
+(defxdoc case-splitting
+ :parents (optimization)
+ :long "
+
+BDD performance can sometimes be improved by breaking a problem into
+subcases. The standard example is floating-point addition, which benefits from
+separating the problem into cases based on the difference between the two
+inputs' exponents. (See for instance work by Chen and Bryant and Aagard, Jones, and
+Seger .)
+
+For each exponent difference, the two mantissas are aligned differently
+before being added together, so a different BDD order is necessary to
+interleave their bits at the right offset. Without case splitting, a single
+BDD ordering has to be used for the whole problem; no matter what ordering we
+choose, the mantissas will be poorly interleaved for some exponent differences,
+causing severe performance problems. Separating the cases allows the
+appropriate order to be used for each difference.
+
+GL provides a @(see def-gl-param-thm) command that supports this technique.
+This command splits the goal formula into several subgoals and attempts to
+prove each of them using the @(see def-gl-thm) approach, so for each subgoal
+there is a symbolic execution step and coverage proof. To show the subgoals
+suffice to prove the goal formula, it also does another @(see def-gl-thm)-style
+proof that establishes that any inputs satisfying the hypothesis are covered by
+some case.
+
+Here is how we might split the proof for @('fast-logcount-32') into five
+subgoals. One goal handles the case where the most significant bit is 1. The
+other four goals assume the most significant bit is 0, and separately handle
+the cases where the lower two bits are 0, 1, 2, or 3. Each case has a
+different symbolic binding for @('x'), giving the BDD variable order. Of
+course, splitting into cases and varying the BDD ordering is unnecessary for
+this theorem, but it illustrates how the @(see def-gl-param-thm) command
+works.
+
+@({
+ (def-gl-param-thm fast-logcount-32-correct-alt
+ :hyp (unsigned-byte-p 32 x)
+ :concl (equal (fast-logcount-32 x)
+ (logcount x))
+ :param-bindings
+ `((((msb 1) (low nil)) ((x ,(g-int 32 -1 33))))
+ (((msb 0) (low 0)) ((x ,(g-int 0 1 33))))
+ (((msb 0) (low 1)) ((x ,(g-int 5 1 33))))
+ (((msb 0) (low 2)) ((x ,(g-int 0 2 33))))
+ (((msb 0) (low 3)) ((x ,(g-int 3 1 33)))))
+ :param-hyp (and (equal msb (ash x -31))
+ (or (equal msb 1)
+ (equal (logand x 3) low)))
+ :cov-bindings `((x ,(g-int 0 1 33))))
+})
+
+We specify the five subgoals to consider using two new variables, @('msb')
+and @('low'). Here, @('msb') will determine the most significant bit of
+@('x'); @('low') will determine the two least significant bits of @('x'), but
+only when @('msb') is 0.
+
+The @(':param-bindings') argument describes the five subgoals by assigning
+different values to @('msb') and @('low'). It also gives the @('g-bindings')
+to use in each case. We use different bindings for @('x') for each subgoal to
+show how it is done.
+
+The @(':param-hyp') argument describes the relationship between @('msb'),
+@('low'), and @('x') that will be assumed in each subgoal. In the symbolic
+execution performed for each subgoal, the @(':param-hyp') is used to reduce the
+space of objects represented by the symbolic binding for @('x'). For example,
+in the subgoal where @('msb = 1'), this process will assign @('t') to
+@('x[31]'). The @(':param-hyp') will also be assumed to hold for the coverage
+proof for each case.
+
+How do we know the case-split is complete? One final proof is needed to
+show that whenever the hypothesis holds for some @('x'), then at least one of
+the settings of @('msb') and @('low') satisfies the @(':param-hyp') for this
+@('x'). That is:
+
+@({
+ (implies (unsigned-byte-p 32 x)
+ (or (let ((msb 1) (low nil))
+ (and (equal msb (ash x -31))
+ (or (equal msb 1)
+ (equal (logand x 3) low))))
+ (let ((msb 0) (low 0)) ...)
+ (let ((msb 0) (low 1)) ...)
+ (let ((msb 0) (low 2)) ...)
+ (let ((msb 0) (low 3)) ...)))
+})
+
+This proof is also done in the @(see def-gl-thm) style, so we need we need
+one last set of symbolic bindings, which is provided by the @(':cov-bindings')
+argument.
")
+
+
+
+
+(defxdoc term-level-reasoning
+ :parents (gl optimization)
+ :short "GL's term-level proof support"
+ :long
+
+ "The traditional way of using GL to prove a theorem is to give a bit-level
+description of each variable of the theorem as a shape spec in the :g-bindings
+argument of def-gl-thm -- X is a 10-bit integer, Y is a three-entry Boolean
+list, etc. In this mode of operation, the goal is for every function to be
+able to symbolically execute and produce a purely bit-level symbolic object as
+its output.
+
+This style of reasoning is somewhat restrictive. ACL2 code is often
+written in a way that makes this sort of symbolic execution expensive. For
+example, suppose we want a structure that maps integer keys to values. For
+best execution speed, we might represent this as a stobj array. For best
+ease of reasoning, we might represent it as a record (as in
+books/misc/records.lisp), since these have nice, intuitive, hypothesis-free
+rules about them. For symbolic execution performance, on the other hand,
+we might decide that a simple alist is the best representation. But if we've
+written the code in one of the other styles, then we'd like to be able to
+escape the suboptimal symbolic execution this entails.
+
+We have added features to GL which provide a way around these problems by
+allowing for term-level reasoning as well as bit-level:
+
+
+
+
+rewrite rules, conditional/unconditional, supporting syntaxp hypotheses
+
+uninterpreted functions
+
+rules for merging IF branches that resolve to term- rather than bit-level
+objects
+
+automatic generation of new Boolean variables for IF tests that resolve to
+terms rather than bits
+
+
+
+Warning: These features require careful setup of a rewriting theory with good
+normal forms. It's difficult to debug problems with them. In many ways
+they may not yet be ready for prime time.
+
+Rewriting
+
+Elaborating on our memory example, suppose we are trying to prove something
+about a program that loads and stores from computed addresses in a 1024-entry
+memory of 32-bit unsigned numbers. For good execution speed when running
+concrete simulations, we might represent this memory as a stobj containing a
+1024-element array. However, this doesn't perform well when proving theorems
+about this representation using GL, because at each update to a symbolic
+address we must modify several (perhaps all) entries in the array
+representation: if our update is
+
+@({
+ (update-mem )
+})
+
+then at each address i of the array we must store an object representing:
+
+@({
+ if (sym_address == i) then sym_value else arr[i].
+})
+
+We might do better if we didn't try to compute an explicit interpretation of
+the array after each update, but instead simply tracked the updates in
+chronological order, as in an alist. To illustrate how to do this, suppose
+that our updater, accessor, and creator functions are, respectively,
+
+
+@('(update-mem addr val mem)')
+@('(access-mem addr mem)')
+@('(create-mem)')
+
+
+First, tell GL never to open the definitions of these functions:
+
+@({
+ (gl::gl-set-uninterpreted update-mem)
+ (gl::gl-set-uninterpreted access-mem)
+ (gl::gl-set-uninterpreted create-mem)
+})
+
+Now, when GL encounters updates, rather than computing a new explicit
+symbolic representation for the memory, it will return a term representation,
+such as
+
+@({
+ (update-mem addr1 val1 (update-mem addr2 val2 (create-mem))).
+})
+
+To make this work, we just need to provide rewrite rules so that GL can reason
+about accesses:
+
+@({
+ (gl::def-gl-rewrite access-of-create
+ (equal (access-mem addr (create-mem))
+ (and (natp addr) (< addr 1024) 0)))
+
+ (gl::def-gl-rewrite access-of-update
+ (equal (access-mem addr (update-mem waddr val mem))
+ (if (equal (nfix addr) (nfix waddr))
+ val
+ (access-mem addr mem))))
+})
+
+Branch Merging
+
+Suppose that somewhere in our program we have an update as follows:
+
+@({
+ (let ((mem (if special-condition
+ (update-mem addr val mem)
+ mem)))
+ ...)
+})
+
+At this point, simulating with just the rules we have above, our proof will
+probably fail because a subsequent access of the memory won't be resolved by
+the access-of-update rule: we no longer have a term of the form
+
+@({
+ (access-mem addr (update-mem waddr val mem))
+})
+
+but rather
+
+@({
+ (access-mem addr (if cond (update-mem waddr val mem) mem)).
+})
+
+We could fix this by introducing a new rule:
+
+@({
+ (gl::def-gl-rewrite access-of-if
+ (equal (access-mem addr (if c mem1 mem2))
+ (if c (access-mem addr mem1) (access-mem addr mem2))))
+})
+
+This is probably the easiest solution if ACCESS-MEM is the only important
+function that must interact with UPDATE-MEM. An alternative is to write a rule
+that merges the two branches into a single term. A branch merge rule can
+accomplish this:
+
+@({
+ (gl::def-gl-branch-merge merge-conditional-update
+ (equal (if cond (update-mem addr val mem) mem)
+ (update-mem addr (if cond val (access-mem addr mem)) mem)))
+})
+
+This isn't necessarily cheap -- in order to apply this rule, we need to find
+the previous value of addr in mem, and this symbolic lookup is relatively
+expensive, since it may need to traverse all the updates in mem to construct
+the symbolic value of the access.
+
+
+Term-level shape specifiers
+
+Traditionally, to do a proof in GL one must supply, for each free variable of
+the theorem, a shape specifier, which tells GL how to create a symbolic object
+to represent that variable. After GL finishes the symbolic execution portion
+of the proof, the shape specifiers must be shown to be appropriate given the
+assumptions about each variable; it therefore generates proof obligations of
+the form:
+
+@({
+ (implies ( var)
+ (shape-spec-obj-in-range var))
+})
+
+These are called coverage obligations. Shape-spec-obj-in-range says that the
+value var is expressible by the given shape-spec; that is, the shape-spec
+covers all possible values of var satisfying the hyps. For example, if the
+shape-spec is the :g-number construct for a 10-bit integer, then the
+shape-spec-obj-in-range term reduces to:
+
+@({
+ (and (integerp var)
+ (< var (expt 2 9))
+ (<= (- (expt 2 9)) var)).
+})
+
+Since the new GL capabilities described above allow manipulation of
+term-level symbolic objects, it can be useful to supply term-level shape
+specifiers. This can be done using the G-CALL and G-VAR constructs.
+
+A G-VAR construct is simply a free variable; it can represent any object
+whatsoever, so its coverage obligations are trivial.
+
+A G-CALL represents a function call. It takes three arguments:
+
+
+FN, a function symbol
+ARGS, a list of arguments, each (recursively) a shape spec
+INV, a 1-argument function symbol or lambda, the inverse function.
+
+
+The symbolic term resulting from this shape spec is simply the application
+(G-APPLY) of FN to the symbolic objects derived from ARGS. INV is an extra
+piece of information that tells us how to prove coverage. Its usage is
+discussed in @(see g-call).
+
+Automatic Boolean Variable Generation
+
+GL now has the ability to generate fresh Boolean variables in addition to
+the ones existing in the user-provided shape spec. It does this anytime an IF
+condition's value ends up as a term-level object, i.e. a G-APPLY (function
+call) or G-VAR (free variable). The mapping between these term-level objects
+and the generated Boolean variables are stored as we symbolically execute and
+can be reused if the same condition is encountered again. Careful use of this
+feature can allow GL to work without giving such detailed shape specifiers.
+
+For example, suppose that we don't want to assume anything about our memory
+variable, but we know that for any slot we access, we'll only use 5 bits of the
+stored value: perhaps our accessors always take (LOGHEAD 5 x) of the slot. We
+can assign a G-VAR object to the memory; that way it can represent any object
+at all. We then want to arrange things so that at every access, we generate 5
+new Boolean variables for the integer bits of that access (if we haven't
+already done so). Here is one rule that will accomplish that:
+
+@({
+ (gl::def-gl-rewrite loghead-5-of-access-mem
+ ;; We don't want this rule to apply to an update-mem term, so this syntaxp
+ ;; hyp prevents that. We also should only apply this if ADDR is a concrete
+ ;; object; we'd need a different strategy for symbolic addresses.
+ (implies (syntaxp (and (not (and (consp mem)
+ (gl::g-apply-p mem)
+ (eq (gl::g-apply->fn mem) 'update-mem)))
+ (gl::general-concrete-p addr)))
+ (equal (loghead 5 (access-mem addr mem))
+ (logcons
+ (if (logbitp 0 (access-mem addr mem)) 1 0)
+ (logcons
+ (if (logbitp 1 (access-mem addr mem)) 1 0)
+ (logcons
+ (if (logbitp 2 (access-mem addr mem)) 1 0)
+ (logcons
+ (if (logbitp 3 (access-mem addr mem)) 1 0)
+ (logcons
+ (if (logbitp 4 (access-mem addr mem)) 1 0)
+ 0))))))))
+})
+
+Performing this rewrite will causes GL to generate a Boolean variable for each
+of these LOGBITP terms, because they produce term-level objects that are then
+used in IF tests.
+
+Using this strategy makes it harder to generate counterexamples. In fact, it
+is impossible to generally solve the problem of generating counterexamples when
+using this strategy. A satisfying assignment from a SAT solver gives us an
+assignment of values to our Boolean variables. But these Boolean variables
+each just correspond to some term, which may be an arbitrary nesting of
+functions. To map this Boolean-level counterexample to an ACL2-level
+counterexample, we are then left with finding an assignment for some variables
+that makes a series of terms take certain truth values, which is undecidable.
+In the next section, we describe a heuristic method for generating
+counterexamples that works in practice when applied carefully.
+
+Furthermore, unless this strategy is used with utmost care, it is likely that
+proofs will fail due to detection of \"counterexamples\" that are actually
+impossible. For example, we might generate a Boolean variable for (integerp x)
+and another one for (logbitp 0 x). But these two terms are not independent; in
+fact, (logbitp 0 x) implies (integerp x). Currently, GL has no mechanism to
+pass this restriction to a SAT solver, so we may find false counterexamples
+that violate this constraint. This can't render GL unsound, but may lead to
+failed proofs.
+
+The situation described above (where every field is accessed via LOGHEAD and
+via concrete address) is a particularly good one for this strategy, since then
+all we need to know about each field are its LOGBITPs, which are all
+independent.
+
+Counterexamples with Automatic Boolean Variable Generation
+
+Our strategy for generating counterexamples when using automatic Boolean
+variable generation is to provide rules for manipulating assignments. For
+example:
+
+@({
+ (gl::def-glcp-ctrex-rewrite
+ ((logbitp n x) t)
+ (x (logior (ash 1 n) x)))
+
+ (gl::def-glcp-ctrex-rewrite
+ ((logbitp n x) nil)
+ (x (logand (lognot (ash 1 n)) x)))
+})
+
+These two rules, respectively, say:
+
+
+\"if (logbitp n x) should be T, then assign X = (logior (ash 1 n) x)\"
+\"if (logbitp n x) should be NIL, then assign X = (logand (lognot (ash 1 n)) x)\".
+
+
+DEF-GLCP-CTREX-REWRITE can also take a keyword argument :test, which can do
+a syntactic check on the variables matched. E.g., we could ensure that N was a
+constant in the rules above:
+
+@({
+ (gl::def-glcp-ctrex-rewrite
+ ((logbitp n x) t)
+ (x (logior (ash 1 n) x))
+ :test (quotep n))
+})
+
+Note that these rules are purely heuristic, have no bearing on the soundness of
+GL, and do not require any proofs. Getting them wrong may cause GL to generate
+false counterexamples, however.
+
+Another rule that would be useful in the memory example above:
+
+@({
+ (gl::def-glcp-ctrex-rewrite
+ ((access-mem addr mem) val)
+ (mem (update-mem addr val mem))
+ :test (quotep addr))
+})")
+
+
+
+
diff -Nru acl2-6.2/books/centaur/gl/eval-f-i-cp.lisp acl2-6.3/books/centaur/gl/eval-f-i-cp.lisp
--- acl2-6.2/books/centaur/gl/eval-f-i-cp.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/eval-f-i-cp.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,6 +1,24 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "gl-util")
(include-book "tools/bstar" :dir :system)
(include-book "tools/mv-nth" :dir :system)
@@ -267,7 +285,7 @@
default-cdr
eval-conds
conds-match)))))
-
+
(defun apply-cond-cp (clause)
(if (consp clause)
diff -Nru acl2-6.2/books/centaur/gl/eval-g-base-help.lisp acl2-6.3/books/centaur/gl/eval-g-base-help.lisp
--- acl2-6.2/books/centaur/gl/eval-g-base-help.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/eval-g-base-help.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,28 +1,42 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "eval-g-base")
-
+(include-book "g-if")
(include-book "gify-clause-proc")
-
(include-book "general-object-thms")
-
(include-book "tools/def-functional-instance" :dir :system)
-
-
-
-
(acl2::def-functional-instance
eval-g-base-alt-def
generic-geval-alt-def
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base))
- :hints ('(:in-theory (e/d* (eval-g-base-ev-constraint-0
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list))
+ :hints ('(:in-theory (e/d* (eval-g-base-ev-of-fncall-args
eval-g-base-apply-agrees-with-eval-g-base-ev)
(eval-g-base-apply))
- :expand ((eval-g-base x env))))
+ :expand ((eval-g-base x env)
+ (eval-g-base-list x env))))
;; :do-not-induct
;; t
;; :expand ((eval-g-base x env))))
@@ -34,7 +48,8 @@
mk-g-boolean-correct
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
@@ -43,14 +58,16 @@
gtests-obj-correct
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(acl2::def-functional-instance
gtests-nonnil-correct-for-eval-g-base
gtests-nonnil-correct
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(local
(progn
@@ -62,7 +79,8 @@
mk-g-ite-correct
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(acl2::def-functional-instance
@@ -70,28 +88,32 @@
gobj-ite-merge-correct
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))))
(acl2::def-functional-instance
eval-g-base-g-apply
generic-geval-g-apply
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(acl2::def-functional-instance
general-consp-car-correct-for-eval-g-base
general-consp-car-correct
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(acl2::def-functional-instance
general-consp-cdr-correct-for-eval-g-base
general-consp-cdr-correct
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(in-theory (disable general-consp-car-correct-for-eval-g-base
general-consp-cdr-correct-for-eval-g-base))
@@ -101,14 +123,16 @@
generic-geval-cons
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(acl2::def-functional-instance
eval-g-base-non-cons
generic-geval-non-cons
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(in-theory (disable eval-g-base-non-cons))
@@ -117,49 +141,63 @@
;; generic-geval-gobj-fix
;; ((apply-stub eval-g-base-apply)
;; (generic-geval-apply eval-g-base-apply)
-;; (generic-geval eval-g-base)))
+;; (generic-geval eval-g-base)
(acl2::def-functional-instance
general-concrete-obj-when-consp-for-eval-g-base
general-concrete-obj-when-consp
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(acl2::def-functional-instance
not-general-numberp-not-acl2-numberp-for-eval-g-base
not-general-numberp-not-acl2-numberp
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(acl2::def-functional-instance
mk-g-number-correct-for-eval-g-base
mk-g-number-correct
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(acl2::def-functional-instance
mk-g-concrete-correct-for-eval-g-base
mk-g-concrete-correct
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(acl2::def-functional-instance
g-concrete-quote-correct-for-eval-g-base
g-concrete-quote-correct
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
(acl2::def-functional-instance
eval-g-base-of-gl-cons
generic-geval-gl-cons
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base)))
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
+
+(acl2::def-functional-instance
+ eval-g-base-list-of-gl-cons
+ generic-geval-list-gl-cons
+ ((generic-geval-ev eval-g-base-ev)
+ (generic-geval-ev-lst eval-g-base-ev-lst)
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list)))
diff -Nru acl2-6.2/books/centaur/gl/eval-g-base.lisp acl2-6.3/books/centaur/gl/eval-g-base.lisp
--- acl2-6.2/books/centaur/gl/eval-g-base.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/eval-g-base.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,13 +1,31 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-;; (include-book "defapply")
(include-book "generic-geval")
-
+(include-book "symbolic-arithmetic-fns")
+;; (include-book "defapply")
(def-eval-g eval-g-base
(BINARY-*
+ cons if
BINARY-+
PKG-WITNESS
; UNARY-/
@@ -49,6 +67,7 @@
truncate
rem
acl2::boolfix
+ hons-assoc-equal
;; these are from the constant *expandable-boot-strap-non-rec-fns*.
NOT IMPLIES
@@ -56,7 +75,8 @@
PLUSP MINUSP LISTP ;; RETURN-LAST causes guard violation
;; FORCE CASE-SPLIT
;; DOUBLE-REWRITE
- ))
+
+ logapp int-set-sign maybe-integer))
(in-theory (disable eval-g-base))
diff -Nru acl2-6.2/books/centaur/gl/factor-fns.lisp acl2-6.3/books/centaur/gl/factor-fns.lisp
--- acl2-6.2/books/centaur/gl/factor-fns.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/factor-fns.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,9 +1,24 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-
-
(include-book "tools/bstar" :dir :system)
(include-book "rws")
(include-book "clause-processors/generalize" :dir :system)
@@ -12,9 +27,6 @@
(program)
-; what is the reason for this switch over to program mode?
-; who did it? ????? -- Boyer
-
(defun constant-syntax-p (name)
;; This is adapted from legal-variable-or-constant-namep, but only performs
;; the checks necessary to distinguish variable from constant.
@@ -40,7 +52,7 @@
(incat 'gl-fact::foo
(symbol-package-name fn) "::" (symbol-name fn) "-LAMBDA-"
(acl2::nat-to-str idx)))
-
+
(mutual-recursion
(defun calldepth-greaterp (term depth)
(cond ((or (atom term)
@@ -252,7 +264,7 @@
events
(b* ((fn (car clique))
(body (norm-function-body fn world))
- (- (or body
+ (- (or body
(er hard 'factor-fn-clique
"No body retrieved for ~x0~%" fn)))
(vars (wgetprop fn 'formals))
@@ -280,5 +292,5 @@
`(progn (logic)
,@(reverse (factor-fn-clique clique world nil))
(local (in-theory (disable* (:ruleset factor-ruleset)))))))))
-
-
+
+
diff -Nru acl2-6.2/books/centaur/gl/g-always-equal.lisp acl2-6.3/books/centaur/gl/g-always-equal.lisp
--- acl2-6.2/books/centaur/gl/g-always-equal.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-always-equal.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,23 +1,38 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-primitives-help")
-
-
(include-book "g-if")
(include-book "symbolic-arithmetic-fns")
-(local (include-book "eval-g-base-help"))
(include-book "eval-g-base")
-(local (include-book "hyp-fix-logic"))
(include-book "always-equal-prep")
(include-book "g-equal")
+(local (include-book "eval-g-base-help"))
+(local (include-book "hyp-fix-logic"))
(def-g-fn acl2::always-equal
;; Once we've ruled out the case where they're both atoms, start by recurring
;; down to non-ITEs on both a and b:
- `(bfr-case :bdd (g-always-equal-core x y hyp clk)
- :aig (glr equal x y hyp clk)))
+ `(bfr-case :bdd (g-always-equal-core x y hyp clk config bvar-db state)
+ :aig (glr equal x y hyp clk config bvar-db state)))
@@ -32,7 +47,7 @@
;; (:type-prescription booleanp)
;; (:type-prescription gobj-fix)
;; equal-of-booleans-rewrite))
-;; :expand ((,gfn x y hyp clk)))))
+;; :expand ((,gfn x y hyp clk config bvar-db state)))))
(verify-g-guards
acl2::always-equal
@@ -40,7 +55,10 @@
-
+(def-gobj-dependency-thm acl2::always-equal
+ :hints `(("Goal" :in-theory (e/d (,gfn)
+ (g-always-equal-core
+ gobj-depends-on)))))
(def-g-correct-thm acl2::always-equal eval-g-base
diff -Nru acl2-6.2/books/centaur/gl/g-ash.lisp acl2-6.3/books/centaur/gl/g-ash.lisp
--- acl2-6.2/books/centaur/gl/g-ash.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-ash.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,8 +1,24 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-(set-inhibit-warnings "theory")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
@@ -11,7 +27,8 @@
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-
+(local (include-book "clause-processors/just-expand" :dir :system))
+(set-inhibit-warnings "theory")
(defun g-ash-of-numbers (i c)
(declare (xargs :guard (and (general-numberp i)
@@ -22,22 +39,27 @@
(general-number-components c))
((mv iintp iintp-known)
(if (equal ird '(t))
- (mv (bfr-or (=-ss iin nil) (=-uu iid nil)) t)
+ (mv (bfr-or (bfr-=-ss iin nil) (bfr-=-uu iid nil)) t)
(mv nil nil)))
((mv cintp cintp-known)
(if (equal crd '(t))
- (mv (bfr-or (=-ss cin nil) (=-uu cid nil)) t)
+ (mv (bfr-or (bfr-=-ss cin nil) (bfr-=-uu cid nil)) t)
(mv nil nil))))
(if (and cintp-known iintp-known)
(mk-g-number
(rlist-fix
- (ash-ss 1 (bfr-ite-bss-fn iintp irn nil)
+ (bfr-ash-ss 1 (bfr-ite-bss-fn iintp irn nil)
(bfr-ite-bss-fn cintp crn nil))))
(g-apply 'ash (gl-list i c)))))
(in-theory (disable (g-ash-of-numbers)))
-
+(defthm deps-of-g-ash-of-numbers
+ (implies (and (not (gobj-depends-on k p i))
+ (not (gobj-depends-on k p c))
+ (general-numberp i)
+ (general-numberp c))
+ (not (gobj-depends-on k p (g-ash-of-numbers i c)))))
(local
(progn
@@ -47,9 +69,9 @@
;; :hints(("Goal" :in-theory (enable bfr-listp))))
- ;; (defthm not-integerp-ash-ss
- ;; (not (integerp (ash-ss place n shamt)))
- ;; :hints(("Goal" :in-theory (enable ash-ss))))
+ ;; (defthm not-integerp-bfr-ash-ss
+ ;; (not (integerp (bfr-ash-ss place n shamt)))
+ ;; :hints(("Goal" :in-theory (enable bfr-ash-ss))))
(defthm ash-complex-1
@@ -121,6 +143,12 @@
(equal (ash x y) (ash x 0))))
:hints(("Goal" :in-theory (enable ash)))))
+(def-gobj-dependency-thm ash
+ :hints `(("goal" :in-theory (e/d ((:i ,gfn))
+ ((:d ,gfn)
+ gobj-depends-on)))
+ (acl2::just-induct-and-expand ,gcall)))
+
(def-g-correct-thm ash eval-g-base
:hints
`(("goal" :in-theory (e/d* (general-concretep-atom
@@ -136,14 +164,13 @@
member-equal
general-number-components-ev
general-concretep-def
- v2n-is-v2i-when-sign-nil
general-concretep-def
rationalp-implies-acl2-numberp
+ ash
(:rules-of-class :type-prescription :here))
((:type-prescription bfr-eval)))
- :induct (,gfn i c hyp clk)
- :do-not-induct t
- :expand ((,gfn i c hyp clk)))
+ :do-not-induct t)
+ (acl2::just-induct-and-expand ,gcall)
(and stable-under-simplificationp
(flag::expand-calls-computed-hint
clause '(eval-g-base)))))
diff -Nru acl2-6.2/books/centaur/gl/g-binary-+.lisp acl2-6.3/books/centaur/gl/g-binary-+.lisp
--- acl2-6.2/books/centaur/gl/g-binary-+.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-binary-+.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,6 +1,24 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
@@ -9,6 +27,7 @@
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
+(local (include-book "clause-processors/just-expand" :dir :system))
;(local (allow-arith5-help))
;; (include-book "univ-gl-eval")
@@ -24,12 +43,9 @@
(equal yrd '(t))
(equal xid '(t))
(equal yid '(t)))
- (let* ((rsum (+-ss nil xrn yrn))
- (isum (+-ss nil xin yin)))
- (mk-g-number
- (if (boolean-listp rsum) (v2i rsum) rsum)
- 1
- (if (boolean-listp isum) (v2i isum) isum)))
+ (let* ((rsum (bfr-+-ss nil xrn yrn))
+ (isum (bfr-+-ss nil xin yin)))
+ (mk-g-number rsum 1 isum))
(g-apply 'binary-+ (gl-list x y)))))
(in-theory (disable (g-binary-+-of-numbers)))
@@ -40,34 +56,34 @@
(equal (bfr-eval-list x env)
x))))
-(local (defthm rewrite-v2i-of-boolean-list
- (implies (and (syntaxp (not (and (consp x)
- (eq (car x) 'bfr-eval-list))))
- (bind-free '((env . (car env))) (env))
- (boolean-listp x))
- (equal (v2i x)
- (v2i (bfr-eval-list x env))))
- :hints(("Goal" :in-theory (enable bfr-eval-list-when-boolean-listp)))
- :rule-classes ((:rewrite :backchain-limit-lst 0))))
-
-(local (defthm rewrite-v2n-of-boolean-list
- (implies (and (syntaxp (not (and (consp x)
- (eq (car x) 'bfr-eval-list))))
- (bind-free '((env . (car env))) (env))
- (boolean-listp x))
- (equal (v2n x)
- (v2n (bfr-eval-list x env))))
- :hints(("Goal" :in-theory (enable bfr-eval-list-when-boolean-listp)))
- :rule-classes ((:rewrite :backchain-limit-lst 0))))
-
-(defthm bfr-eval-list-of-bfr-ite-bvv-fn-under-v2n
- (equal (v2n (bfr-eval-list (bfr-ite-bvv-fn c a b) env))
- (v2n (if (bfr-eval c env)
- (bfr-eval-list a env)
- (bfr-eval-list b env))))
- :hints(("Goal" :in-theory (enable bfr-ite-bvv-fn v2n)
- :induct t)
- (bfr-reasoning)))
+;; (local (defthm rewrite-v2i-of-boolean-list
+;; (implies (and (syntaxp (not (and (consp x)
+;; (eq (car x) 'bfr-eval-list))))
+;; (bind-free '((env . (car env))) (env))
+;; (boolean-listp x))
+;; (equal (v2i x)
+;; (bfr-list->s x env)))
+;; :hints(("Goal" :in-theory (enable bfr-eval-list-when-boolean-listp)))
+;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+;; (local (defthm rewrite-v2n-of-boolean-list
+;; (implies (and (syntaxp (not (and (consp x)
+;; (eq (car x) 'bfr-eval-list))))
+;; (bind-free '((env . (car env))) (env))
+;; (boolean-listp x))
+;; (equal (v2n x)
+;; (bfr-list->u x env)))
+;; :hints(("Goal" :in-theory (enable bfr-eval-list-when-boolean-listp)))
+;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+;; (defthm bfr-eval-list-of-bfr-ite-bvv-fn-unde
+;; (equal (bfr-list->u (bfr-ite-bvv-fn c a b) env)
+;; (if (bfr-eval c env)
+;; (bfr-list->u a env)
+;; (bfr-list->u b env))))
+;; :hints(("Goal" :in-theory (enable bfr-ite-bvv-fn v2n)
+;; :induct t)
+;; (bfr-reasoning)))
(local
@@ -82,6 +98,16 @@
general-number-components))
:do-not-induct t))))
+(local
+ (defthm dependencies-of-g-binary-+-of-numbers
+ (implies (and (general-numberp x)
+ (general-numberp y)
+ (not (gobj-depends-on n p x))
+ (not (gobj-depends-on n p y)))
+ (not (gobj-depends-on n p (g-binary-+-of-numbers x y))))
+ :hints (("goal" :do-not-induct t))
+ :otf-flg t))
+
(in-theory (disable g-binary-+-of-numbers))
(def-g-binary-op binary-+
@@ -95,7 +121,7 @@
(verify-g-guards
binary-+
- :hints `(("goal" :in-theory (disable* ,gfn
+ :hints `(("goal" :in-theory (disable* ,gfn
(:rules-of-class :type-prescription
:here)))))
@@ -108,12 +134,18 @@
(equal (+ x y)
(+ x 0))))))
+(def-gobj-dependency-thm binary-+
+ :hints `(("goal" :in-theory (disable (:d ,gfn)
+ gobj-depends-on)
+ :induct ,gcall
+ :expand (,gcall))))
+
(def-g-correct-thm binary-+ eval-g-base
:hints
`(("goal" :in-theory (e/d* (general-concretep-atom
(:ruleset general-object-possibilities))
((:definition ,gfn)
- i2v n2v v2i +-ss
+ i2v n2v bfr-+-ss
general-numberp-eval-to-numberp
general-boolean-value-correct
bool-cond-itep-eval
@@ -124,14 +156,14 @@
member-equal
general-number-components-ev
general-concretep-def
- v2n-is-v2i-when-sign-nil
general-concretep-def
rationalp-implies-acl2-numberp
(:rules-of-class :type-prescription :here))
- ((:type-prescription bfr-eval)))
- :induct (,gfn x y hyp clk)
+ ((:type-prescription bfr-eval)
+ (:type-prescription components-to-number-fn)))
+ :induct ,gcall
:do-not-induct t
- :expand ((,gfn x y hyp clk)))
+ :expand (,gcall))
(and stable-under-simplificationp
(flag::expand-calls-computed-hint
clause '(eval-g-base)))))
diff -Nru acl2-6.2/books/centaur/gl/g-binary-mult.lisp acl2-6.3/books/centaur/gl/g-binary-mult.lisp
--- acl2-6.2/books/centaur/gl/g-binary-mult.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-binary-mult.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,7 +1,24 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
@@ -23,19 +40,25 @@
(equal yrd '(t))
(equal xid '(t))
(equal yid '(t)))
- (let* ((rprod (+-ss nil (*-ss xrn yrn)
- (unary-minus-s
- (*-ss xin yin))))
- (iprod (+-ss nil (*-ss xrn yin)
- (*-ss xin yrn))))
+ (let* ((rprod (bfr-+-ss nil (bfr-*-ss xrn yrn)
+ (bfr-unary-minus-s
+ (bfr-*-ss xin yin))))
+ (iprod (bfr-+-ss nil (bfr-*-ss xrn yin)
+ (bfr-*-ss xin yrn))))
(mk-g-number
- (if (boolean-listp rprod) (v2i rprod) rprod)
- 1
- (if (boolean-listp iprod) (v2i iprod) iprod)))
+ rprod
+ 1 iprod))
(g-apply 'binary-* (gl-list x y)))))
(in-theory (disable (g-binary-*-of-numbers)))
+(defthm deps-of-g-binary-*-of-numbers
+ (implies (and (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))
+ (general-numberp x)
+ (general-numberp y))
+ (not (gobj-depends-on k p (g-binary-*-of-numbers x y)))))
+
(local
(progn
;; (defthm gobjectp-g-binary-*-of-numbers
@@ -120,6 +143,12 @@
(* x 0))))))
+(def-gobj-dependency-thm binary-*
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)
+ gobj-depends-on))))
+
(def-g-correct-thm binary-* eval-g-base
:hints
@@ -137,14 +166,13 @@
member-equal
general-number-components-ev
general-concretep-def
- v2n-is-v2i-when-sign-nil
general-concretep-def
rationalp-implies-acl2-numberp
(:rules-of-class :type-prescription :here))
((:type-prescription bfr-eval)))
- :induct (,gfn x y hyp clk)
+ :induct ,gcall
:do-not-induct t
- :expand ((,gfn x y hyp clk)))
+ :expand (,gcall))
;; '(:use ((:instance possibilities-for-x)
;; (:instance possibilities-for-x (x y))))
(and stable-under-simplificationp
diff -Nru acl2-6.2/books/centaur/gl/g-code-char.lisp acl2-6.3/books/centaur/gl/g-code-char.lisp
--- acl2-6.2/books/centaur/gl/g-code-char.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-code-char.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,16 +1,36 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "eval-g-base")
(include-book "symbolic-arithmetic-fns")
+(include-book "g-lessthan")
(local (include-book "symbolic-arithmetic"))
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-(include-book "g-lessthan")
(local (include-book "arithmetic/top-with-meta" :dir :system))
+(local (include-book "centaur/bitops/ihsext-basics" :dir :system))
+(local (include-book "tools/trivial-ancestors-check" :dir :system))
+(local (acl2::use-trivial-ancestors-check))
;; (defaxiom completion-of-code-char
;; (equal (code-char x)
@@ -38,6 +58,10 @@
(t ;; cons
(code-char 0))))
+(defthm deps-of-g-code-char-concrete
+ (implies (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p (g-code-char-concrete x)))))
+
(local
(progn
;; (defthm gobjectp-characterp
@@ -104,6 +128,7 @@
general-booleanp
general-consp
eval-g-base
+ eval-g-base-list
g-keyword-symbolp)
((code-char)
eval-g-base-alt-def))
@@ -123,6 +148,10 @@
;; :hints(("Goal" :in-theory (enable bfr-listp))))
))
+(local (defthm floor-1
+ (implies (integerp n)
+ (equal (floor n 1) n))
+ :hints(("Goal" :in-theory (enable floor)))))
(defun code-char-s (n x acc hyp)
(declare (xargs :guard (and (natp n)
@@ -131,13 +160,24 @@
(natp acc)
(<= acc (- 256 (ash 1 n))))
:guard-hints ((and stable-under-simplificationp
- '(:in-theory (enable ash))))))
+ '(:in-theory (enable ash expt))))))
(if (zp n)
(code-char acc)
(g-if (mk-g-boolean (nth (1- n) x))
(code-char-s (1- n) x (+ (ash 1 (1- n)) acc) hyp)
(code-char-s (1- n) x acc hyp))))
+(defthm pbfr-depends-on-nth
+ (implies (not (pbfr-list-depends-on k p x))
+ (not (pbfr-depends-on k p (nth n x)))))
+
+(defthm deps-of-code-char-s
+ (implies (not (pbfr-list-depends-on k p x))
+ (not (gobj-depends-on k p (code-char-s n x acc hyp))))
+ :hints (("goal" :induct (code-char-s n x acc hyp)
+ :in-theory (disable (:d code-char-s))
+ :expand ((code-char-s n x acc hyp)))))
+
;; (local (defun first-n (n x)
;; (if (zp n)
;; nil
@@ -163,17 +203,24 @@
(append (bfr-eval-list a env)
(bfr-eval-list b env))))
- (defthm v2n-append
- (equal (v2n (append a b))
- (+ (v2n a)
- (* (v2n b) (expt 2 (len a)))))
- :hints(("Goal" :in-theory (enable v2n ash))))
+ ;; (defthm v2n-append
+ ;; (equal (v2n (append a b))
+ ;; (+ (v2n a)
+ ;; (* (v2n b) (expt 2 (len a)))))
+ ;; :hints(("Goal" :in-theory (enable v2n ash))))
+ (defthm bfr-list->u-of-append
+ (equal (bfr-list->u (append a b) env)
+ (+ (bfr-list->u a env)
+ (* (bfr-list->u b env) (expt 2 (len a)))))
+ :hints(("Goal" :in-theory (e/d* (acl2::logapp** logcons
+ acl2::bool->bit)
+ (logapp)))))
;; (defthm bfr-eval-list-first-n
;; (implies (not (zp n))
-;; (equal (v2n (bfr-eval-list (first-n n x) env))
+;; (equal (bfr-list->u (first-n n x) env)
;; (+ (if (bfr-eval (nth (1- n) x) env) (expt 2 (1- n)) 0)
-;; (v2n (bfr-eval-list (first-n (1- n) x) env)))))
+;; (bfr-list->u (first-n (1- n) x) env))))
;; :hints (("goal" :induct (first-n n x)
;; :in-theory (e/d (ash) ((:definition first-n)))
;; :expand ((first-n n x)
@@ -182,28 +229,30 @@
(defthm floor-1
(implies (integerp n)
- (equal (floor n 1) n)))
+ (equal (floor n 1) n))
+ :hints(("Goal" :in-theory (enable floor))))
(defthm len-bfr-eval-list
(equal (len (Bfr-eval-list x env))
(len x)))
(defthm code-char-s-correct1
- (implies (and (< (+ acc (v2n (bfr-eval-list (first-n n x) (car env)))) 256)
+ (implies (and (< (+ acc (bfr-list->u (first-n n x) (car env))) 256)
(integerp acc)
(bfr-eval hyp (car env)))
(equal (eval-g-base (code-char-s n x acc hyp) env)
- (code-char (+ acc (v2n (bfr-eval-list (first-n n x) (car
- env)))))))
+ (code-char (+ acc (bfr-list->u (first-n n x) (car env))))))
:hints (("goal" :induct (code-char-s n x acc hyp)
:expand ((code-char-s n x acc hyp)
(code-char-s 0 x acc hyp))
:in-theory (e/d (ash) (floor (:definition code-char-s))))))
- (defthm v2i-when-<=-0
- (implies (<= 0 (v2i x))
- (equal (v2i x) (v2n x)))
- :hints(("Goal" :in-theory (enable v2i v2n ash))))
+ (defthm bfr-list->s-when-<=-0
+ (implies (<= 0 (bfr-list->s x env))
+ (equal (bfr-list->s x env) (bfr-list->u x env)))
+ :hints(("Goal" :in-theory (enable scdr s-endp))))
+
+
(defthm bfr-eval-list-nth
(equal (nth n (bfr-eval-list x env))
@@ -223,24 +272,31 @@
(equal (first-n n x)
(first-n-alt n x)))
- (defthm v2n-first-n
- (implies (< (v2n x) (expt 2 (nfix n)))
- (equal (v2n (first-n n x))
- (v2n x)))
- :hints(("Goal" :in-theory (enable v2n ash first-n-is-first-n-alt)
- :induct (first-n-alt n x)
- :expand ( ;; (v2n x)
- (:free (a b) (v2n (cons a b)))))))
+ (defthm bfr-list->u-of-first-n
+ (implies (< (bfr-list->u x env) (expt 2 (nfix n)))
+ (equal (bfr-list->u (first-n n x) env)
+ (bfr-list->u x env)))
+ :hints(("Goal" :in-theory (enable first-n-is-first-n-alt
+ logcons acl2::bool->bit
+ expt))))
+
+ ;; (defthm v2n-first-n
+ ;; (implies (< (v2n x) (expt 2 (nfix n)))
+ ;; (equal (v2n (first-n n x))
+ ;; (v2n x)))
+ ;; :hints(("Goal" :in-theory (enable v2n ash first-n-is-first-n-alt)
+ ;; :induct (first-n-alt n x)
+ ;; :expand ( ;; (v2n x)
+ ;; (:free (a b) (v2n (cons a b)))))))
(defthm code-char-s-correct
(implies (and (bfr-eval hyp (car env))
- (<= 0 (v2i (bfr-eval-list x (car env))))
- (< (v2i (bfr-eval-list x (car env))) 256))
+ (<= 0 (bfr-list->s x (car env)))
+ (< (bfr-list->s x (car env)) 256))
(equal (eval-g-base (code-char-s 8 x 0 hyp) env)
- (code-char (v2i (bfr-eval-list x (car env))))))
- :hints(("Goal" :in-theory (disable v2n-is-v2i-when-sign-nil
- code-char-s))))))
-
+ (code-char (bfr-list->s x (car env)))))
+ :hints(("Goal" :in-theory (disable code-char-s))))))
+
;; (defun g-code-char-of-integer (x hyp clk)
;; (declare (xargs :guard (and (gobjectp x) (g-number-p x)
@@ -248,26 +304,37 @@
;; (g-if (glr < x 0 hyp clk)
;; nil
;; (glr < x 256 hyp clk))
-
-(defun g-code-char-of-number (x hyp clk)
+
+(defun g-code-char-of-number (x hyp clk config bvar-db state)
(declare (xargs :guard (and (consp x)
(g-number-p x)
+ (glcp-config-p config)
(natp clk))
+ :stobjs (bvar-db state)
:guard-hints(("Goal" :in-theory
(disable code-char-s)))))
(mv-let (xrn xrd xin xid)
(break-g-number (g-number->num x))
(if (equal xrd '(t))
- (g-if (g-if (mk-g-boolean (bfr-or (=-ss xin nil)
- (=-uu xid nil)))
- (g-if (glr < x 0 hyp clk)
+ (g-if (g-if (mk-g-boolean (bfr-or (bfr-=-ss xin nil)
+ (bfr-=-uu xid nil)))
+ (g-if (glr < x 0 hyp clk config bvar-db state)
nil
- (glr < x 256 hyp clk))
+ (glr < x 256 hyp clk config bvar-db state))
nil)
- (code-char-s 8 xrn 0 hyp)
+ (code-char-s 8 (rlist-fix xrn) 0 hyp)
(code-char 0))
(g-apply 'code-char (list x)))))
+(defthm deps-of-g-code-char-of-number
+ (implies (and (not (gobj-depends-on k p x))
+ (g-number-p x))
+ (not (gobj-depends-on k p (g-code-char-of-number x hyp clk config
+ bvar-db state))))
+ :hints (("goal" :in-theory (e/d ((force))
+ (gobj-depends-on
+ code-char-s)))))
+
;; (defun g-code-char-of-number (x hyp clk)
;; (declare (xargs :guard (and (gobjectp x)
@@ -279,8 +346,8 @@
;; (mv-let (xrn xrd xin xid)
;; (break-g-number (g-number->num x))
;; (if (equal xrd '(t))
-;; (g-if (mk-g-boolean (bfr-or (=-ss xin nil)
-;; (=-uu xid nil)))
+;; (g-if (mk-g-boolean (bfr-or (bfr-=-ss xin nil)
+;; (bfr-=-uu xid nil)))
;; (g-if (glr < x 0 hyp clk)
;; (code-char 0)
;; (g-if (glr < x 256 hyp clk)
@@ -312,13 +379,13 @@
(not (equal (/ x) 0))))
(defthm not-integerp-when-imag-parts-nonzero
- (implies (and (not (equal (v2i (bfr-eval-list
+ (implies (and (not (equal (bfr-list->s
(mv-nth 2 (break-g-number (g-number->num x)))
- (car env)))
+ (car env))
0))
- (not (equal (v2n (bfr-eval-list
+ (not (equal (bfr-list->u
(mv-nth 3 (break-g-number (g-number->num x)))
- (car env)))
+ (car env))
0))
(g-number-p x))
(not (integerp (eval-g-base x env))))
@@ -337,17 +404,16 @@
(defthm g-code-char-of-number-correct
(implies (and (bfr-eval hyp (car env))
(g-number-p x))
- (equal (eval-g-base (g-code-char-of-number x hyp clk) env)
+ (equal (eval-g-base (g-code-char-of-number x hyp clk config
+ bvar-db state) env)
(code-char (eval-g-base x env))))
- :hints(("Goal" :in-theory (e/d (eval-g-base)
+ :hints(("Goal" :in-theory (e/d (eval-g-base eval-g-base-list)
(code-char-s
- v2i-when-<=-0
- v2n-is-v2i-when-sign-nil
equal-of-booleans-rewrite
- s-sign-correct
code-char-s-correct1
code-char-s-correct
bfr-eval-list
+ bfr-list->s-when-<=-0
eval-g-base-alt-def))
:do-not-induct t
:do-not '(generalize fertilize eliminate-destructors))
@@ -367,13 +433,13 @@
(def-g-fn code-char
`(cond ((atom x) (g-code-char-concrete x))
- ((g-number-p x) (g-code-char-of-number x hyp clk))
+ ((g-number-p x) (g-code-char-of-number x hyp clk config bvar-db state))
((g-ite-p x)
(if (zp clk)
(g-apply 'code-char (gl-list x))
(g-if (g-ite->test x)
- (,gfn (g-ite->then x) hyp clk)
- (,gfn (g-ite->else x) hyp clk))))
+ (,gfn (g-ite->then x) hyp clk config bvar-db state)
+ (,gfn (g-ite->else x) hyp clk config bvar-db state))))
(t (g-code-char-concrete x))))
;;(def-gobjectp-thm code-char)
@@ -381,6 +447,12 @@
(verify-g-guards code-char
:hints `(("goal" :in-theory (Disable ,gfn))))
+(def-gobj-dependency-thm code-char
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn) gobj-depends-on
+ g-code-char-of-number))))
+
(def-g-correct-thm code-char eval-g-base
:hints `(("goal" :in-theory (e/d ()
@@ -388,8 +460,8 @@
g-code-char-of-number
eval-g-base-alt-def
(:definition ,gfn)))
- :expand ((,gfn x hyp clk))
- :induct (,gfn x hyp clk))
+ :expand (,gcall)
+ :induct ,gcall)
(and stable-under-simplificationp
'(:expand ((:with eval-g-base (eval-g-base x env))
(:with eval-g-base (eval-g-base nil env)))))))
diff -Nru acl2-6.2/books/centaur/gl/g-coerce.lisp acl2-6.3/books/centaur/gl/g-coerce.lisp
--- acl2-6.2/books/centaur/gl/g-coerce.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-coerce.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,20 +1,41 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
(local (in-theory (disable acl2::revappend-removal)))
-
-
+;; [Jared] I suspect we could get this easily working with implode/explode, but
+;; it seems easiest to just say, "this book is low level and wants to deal with
+;; coerce on its own."
+(local (in-theory (e/d (str::implode
+ str::explode)
+ (str::coerce-to-string-removal
+ str::coerce-to-list-removal))))
;; ;; This brings if-then-elses up from atoms to the top level of a cons tree.
;; (defun propagate-ites-above-conses (x )
@@ -42,6 +63,10 @@
(revappend-concrete (cdr a)
(gl-cons (mk-g-concrete (car a)) b))))
+(defthm no-deps-of-revappend-concrete
+ (implies (not (gobj-depends-on k p b))
+ (not (gobj-depends-on k p (revappend-concrete a b)))))
+
(local
(progn
;; (defthm gobjectp-revappend-concrete
@@ -65,7 +90,7 @@
;; (cond ((or (atom x) (not (eq (tag x) :g-ite))) 0)
;; (t (+ 1 (max (g-ite-depth (g-ite->then x))
;; (g-ite-depth (g-ite->else x)))))))
-
+
;; (defthm g-ite-depth-of-g-ite->then
;; (implies (eq (tag x) :g-ite)
;; (< (g-ite-depth (g-ite->then x)) (g-ite-depth x)))
@@ -138,6 +163,13 @@
(&
(coerce-string (cdr x) (cons (code-char 0) pre) hyp))))))))
+(defthm deps-of-coerce-string
+ (implies (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p (coerce-string x pre hyp))))
+ :hints (("goal" :induct (coerce-string x pre hyp)
+ :expand ((coerce-string x pre hyp))
+ :in-theory (disable (:d coerce-string)))))
+
(local
(progn
@@ -302,6 +334,7 @@
(coerce (revappend pre (eval-g-base x env)) 'string)))
:hints(("Goal" :in-theory (e/d* ( general-concrete-obj
concrete-gobjectp-def
+ eval-g-base-list
general-concretep-def)
((:definition coerce-string)
member eval-g-base
@@ -347,6 +380,13 @@
((g-var &) (g-apply 'coerce (gl-list x 'list)))
(& nil))))
+(defthm deps-of-coerce-list
+ (implies (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p (coerce-list x hyp))))
+ :hints (("goal" :induct (coerce-list x hyp)
+ :expand ((coerce-list x hyp))
+ :in-theory (disable (:d coerce-list)))))
+
;; (local
;; (defthm gobjectp-coerce-list
@@ -366,15 +406,16 @@
(encapsulate nil
(local (in-theory (disable member-equal)))
- (local (defthm stringp-eval-g-base
- (implies (and (not (general-concretep x))
- (not (g-ite-p x))
- (not (g-apply-p x))
- (not (g-var-p x)))
- (not (stringp (eval-g-base x env))))
- :hints(("Goal" :in-theory (e/d ((:induction eval-g-base)
- general-concretep-def))
- :induct (eval-g-base x env)
+ (local (defthm-gobj-flag
+ (defthm stringp-eval-g-base
+ (implies (and (not (general-concretep x))
+ (not (g-ite-p x))
+ (not (g-apply-p x))
+ (not (g-var-p x)))
+ (not (stringp (eval-g-base x env))))
+ :flag gobj)
+ :skip-others t
+ :hints(("Goal" :in-theory (e/d (general-concretep-def))
:expand ((:with eval-g-base (eval-g-base x env)))))))
@@ -385,7 +426,7 @@
(coerce (eval-g-base x env) 'list)))
:hints(("Goal" :in-theory (e/d* (; (:ruleset g-correct-lemmas)
eval-g-base-general-concrete-obj
- eval-g-base)
+ eval-g-base eval-g-base-list)
((:definition coerce-list)
eval-g-base-alt-def))
:induct (coerce-list x hyp)
@@ -405,8 +446,8 @@
(if (zp clk)
(g-apply 'coerce (gl-list x y))
(g-if ytest
- (,gfn x ythen hyp clk)
- (,gfn x yelse hyp clk))))
+ (,gfn x ythen hyp clk config bvar-db state)
+ (,gfn x yelse hyp clk config bvar-db state))))
((g-apply & &)
(g-apply 'coerce (gl-list x y)))
((g-var &)
@@ -425,17 +466,23 @@
coerce
:hints `(("Goal" :in-theory (disable ,gfn))))
+(def-gobj-dependency-thm coerce
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(local
- (defthm eval-g-base-not-equal-list
- (implies (and (not (general-concretep y))
- (not (g-ite-p y))
- (not (g-apply-p y))
- (not (g-var-p y)))
- (not (equal (eval-g-base y env) 'list)))
- :hints(("Goal" :in-theory (e/d ((:induction eval-g-base)
- general-concretep-def)
+ (defthm-gobj-flag
+ (defthm eval-g-base-not-equal-list
+ (implies (and (not (general-concretep y))
+ (not (g-ite-p y))
+ (not (g-apply-p y))
+ (not (g-var-p y)))
+ (not (equal (eval-g-base y env) 'list)))
+ :flag gobj)
+ :skip-others t
+ :hints(("Goal" :in-theory (e/d (general-concretep-def)
(eval-g-base-alt-def))
- :induct (eval-g-base y env)
:expand ((:with eval-g-base (eval-g-base y env)))))))
@@ -462,8 +509,8 @@
; eval-g-base-g-apply-p
eval-g-base-alt-def
eval-g-base-not-equal-list))
- :induct (,gfn x y hyp clk)
- :expand ((,gfn x y hyp clk)))
+ :induct ,gcall
+ :expand (,gcall))
(and stable-under-simplificationp
'(:in-theory (enable general-concrete-obj-correct
eval-g-base-not-equal-list)))))
diff -Nru acl2-6.2/books/centaur/gl/g-cons.lisp acl2-6.3/books/centaur/gl/g-cons.lisp
--- acl2-6.2/books/centaur/gl/g-cons.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-cons.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,11 +1,28 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
-(local (include-book "eval-g-base-help"))
(include-book "eval-g-base")
+(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
(def-g-fn cdr
@@ -15,7 +32,8 @@
((g-ite test then else)
(if (zp clk)
(g-apply 'cdr (gl-list x))
- (g-if test (,gfn then hyp clk) (,gfn else hyp clk))))
+ (g-if test (,gfn then . ,params)
+ (,gfn else . ,params))))
((g-boolean &) nil)
((g-number &) nil)
((g-apply & &) (g-apply 'cdr (gl-list x)))
@@ -32,11 +50,17 @@
cdr
:hints `(("goal" :in-theory (disable ,gfn))))
+(def-gobj-dependency-thm cdr
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
+
(def-g-correct-thm cdr eval-g-base
:hints `(("goal" :in-theory (e/d (eval-g-base general-concrete-obj)
((:definition ,gfn)))
- :induct (,gfn x hyp clk)
- :expand ((,gfn x hyp clk)))))
+ :induct (,gfn x . ,params)
+ :expand ((,gfn x . ,params)))))
(def-g-fn car
@@ -46,7 +70,7 @@
((g-ite test then else)
(if (zp clk)
(g-apply 'car (gl-list x))
- (g-if test (,gfn then hyp clk) (,gfn else hyp clk))))
+ (g-if test (,gfn then . ,params) (,gfn else . ,params))))
((g-boolean &) nil)
((g-number &) nil)
((g-apply & &) (g-apply 'car (gl-list x)))
@@ -56,18 +80,23 @@
;; (def-gobjectp-thm car
;; :hints `(("goal" :in-theory (disable (:definition ,gfn))
-;; :induct (,gfn x hyp clk)
-;; :expand ((,gfn x hyp clk)))))
+;; :induct (,gfn x . ,params)
+;; :expand ((,gfn x . ,params)))))
(verify-g-guards
car
:hints `(("goal" :in-theory (disable ,gfn))))
+(def-gobj-dependency-thm car
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(def-g-correct-thm car eval-g-base
:hints `(("goal" :in-theory (e/d (eval-g-base general-concrete-obj)
((:definition ,gfn)))
- :induct (,gfn x hyp clk)
- :expand ((,gfn x hyp clk)))))
+ :induct (,gfn x . ,params)
+ :expand ((,gfn x . ,params)))))
@@ -78,4 +107,6 @@
(verify-g-guards cons)
+(def-gobj-dependency-thm cons)
+
(def-g-correct-thm cons eval-g-base)
diff -Nru acl2-6.2/books/centaur/gl/g-equal.lisp acl2-6.3/books/centaur/gl/g-equal.lisp
--- acl2-6.2/books/centaur/gl/g-equal.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-equal.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,16 +1,33 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-(set-inhibit-warnings "theory")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
-(local (include-book "eval-g-base-help"))
(include-book "eval-g-base")
-; (include-book "tools/with-arith5-help" :dir :system)
+(local (include-book "eval-g-base-help"))
(local (include-book "symbolic-arithmetic"))
(local (include-book "hyp-fix-logic"))
+(local (include-book "var-bounds"))
+(set-inhibit-warnings "theory")
(local (defthm eval-g-base-apply-of-equal
(equal (eval-g-base-ev (cons 'equal (kwote-lst (list x y))) a)
@@ -85,12 +102,12 @@
(general-number-components a))
((mv brn brd bin bid)
(general-number-components b)))
- (g-if (mk-g-boolean (bfr-and (=-uu ard brd)
- (=-uu aid bid)))
- (mk-g-boolean (bfr-and (bfr-or (=-uu nil ard)
- (=-ss arn brn))
- (bfr-or (=-uu nil aid)
- (=-ss ain bin))))
+ (g-if (mk-g-boolean (bfr-and (bfr-=-uu ard brd)
+ (bfr-=-uu aid bid)))
+ (mk-g-boolean (bfr-and (bfr-or (bfr-=-uu nil ard)
+ (bfr-=-ss arn brn))
+ (bfr-or (bfr-=-uu nil aid)
+ (bfr-=-ss ain bin))))
(g-apply 'equal (gl-list a b)))))
@@ -106,8 +123,16 @@
(e/d* ((:ruleset general-object-possibilities)
boolean-list-bfr-eval-list))))))
+(local (defthm dependencies-of-equal-of-numbers
+ (implies (and (not (gobj-depends-on k p a))
+ (not (gobj-depends-on k p b))
+ (general-numberp a)
+ (general-numberp b))
+ (not (gobj-depends-on k p (equal-of-numbers a b hyp))))))
+
(in-theory (Disable equal-of-numbers))
+
(def-g-fn equal
;; Once we've ruled out the case where they're both atoms, start by recurring
;; down to non-ITEs on both a and b:
@@ -115,10 +140,28 @@
(cond ((hqual a b) t)
((and (general-concretep a) (general-concretep b))
(hons-equal (general-concrete-obj a) (general-concrete-obj b)))
+ ((and (consp a) (eq (tag a) :g-ite))
+ (if (zp clk)
+ (g-apply 'equal (gl-list a b))
+ (let* ((test (g-ite->test a))
+ (then (g-ite->then a))
+ (else (g-ite->else a)))
+ (g-if test
+ (,gfn then b hyp clk config bvar-db state)
+ (,gfn else b hyp clk config bvar-db state)))))
+ ((and (consp b) (eq (tag b) :g-ite))
+ (if (zp clk)
+ (g-apply 'equal (gl-list a b))
+ (let* ((test (g-ite->test b))
+ (then (g-ite->then b))
+ (else (g-ite->else b)))
+ (g-if test
+ (,gfn a then hyp clk config bvar-db state)
+ (,gfn a else hyp clk config bvar-db state)))))
((or (atom a)
- (not (member-eq (tag a) '(:g-ite :g-var :g-apply))))
+ (not (member-eq (tag a) '(:g-var :g-apply))))
(cond ((or (atom b)
- (not (member-eq (tag b) '(:g-ite :g-var :g-apply))))
+ (not (member-eq (tag b) '(:g-var :g-apply))))
(cond ((general-booleanp a)
(and (general-booleanp b)
(mk-g-boolean (bfr-iff (general-boolean-value a)
@@ -130,31 +173,13 @@
(and (general-consp b)
(g-if (,gfn (general-consp-car a)
(general-consp-car b)
- hyp clk)
+ hyp clk config bvar-db state)
(,gfn (general-consp-cdr a)
(general-consp-cdr b)
- hyp clk)
+ hyp clk config bvar-db state)
nil)))
(t nil)))
- ((eq (tag b) :g-ite)
- (if (zp clk)
- (g-apply 'equal (gl-list a b))
- (let* ((test (g-ite->test b))
- (then (g-ite->then b))
- (else (g-ite->else b)))
- (g-if test
- (,gfn a then hyp clk)
- (,gfn a else hyp clk)))))
(t (g-apply 'equal (gl-list a b)))))
- ((eq (tag a) :g-ite)
- (if (zp clk)
- (g-apply 'equal (gl-list a b))
- (let* ((test (g-ite->test a))
- (then (g-ite->then a))
- (else (g-ite->else a)))
- (g-if test
- (,gfn then b hyp clk)
- (,gfn else b hyp clk)))))
(t (g-apply 'equal (gl-list a b))))))
;; (cond ((and (general-concretep a) (general-concretep b))
@@ -164,20 +189,20 @@
;; (t (pattern-match a
;; ((g-ite test then else)
;; (g-if test
-;; (,gfn then b hyp clk)
-;; (,gfn else b hyp clk)))
+;; (,gfn then b hyp clk config bvar-db state)
+;; (,gfn else b hyp clk config bvar-db state)))
;; (& (pattern-match b
;; ((g-ite test then else)
;; (g-if test
-;; (,gfn a then hyp clk)
-;; (,gfn a else hyp clk)))
+;; (,gfn a then hyp clk config bvar-db state)
+;; (,gfn a else hyp clk config bvar-db state)))
;; ((g-var &)
;; (or (equal a b)
;; (g-apply 'equal (gl-list a b))))
;; ((g-apply fn args)
;; (pattern-match a
;; ((g-apply !fn aargs)
-;; (g-if (,gfn args aargs hyp clk)
+;; (g-if (,gfn args aargs hyp clk config bvar-db state)
;; t
;; (g-apply 'equal (gl-list a b))))
;; (& (g-apply 'equal (gl-list a b)))))
@@ -199,10 +224,10 @@
;; (if (general-consp b)
;; (g-if (,gfn (general-consp-car a)
;; (general-consp-car b)
-;; hyp clk)
+;; hyp clk config bvar-db state)
;; (,gfn (general-consp-cdr a)
;; (general-consp-cdr b)
-;; hyp clk)
+;; hyp clk config bvar-db state)
;; nil)
;; nil))
;; (t nil))))))))))))
@@ -227,9 +252,9 @@
;; (:rules-of-class :type-prescription :here)
;; (:ruleset gl-wrong-tag-rewrites)
;; (:ruleset gl-tag-forward)))
-;; :induct (,gfn x y hyp clk)
-;; :expand ((,gfn x y hyp clk)
-;; (,gfn x x hyp clk)))
+;; :induct (,gfn x y hyp clk config bvar-db state)
+;; :expand ((,gfn x y hyp clk config bvar-db state)
+;; (,gfn x x hyp clk config bvar-db state)))
;; (and stable-under-simplificationp
;; '(:in-theory (e/d* (booleanp-gobjectp)
;; ((:definition ,gfn)
@@ -258,7 +283,7 @@
(:type-prescription general-booleanp)
(:type-prescription general-numberp)
(:type-prescription general-concretep)
- (:type-prescription =-uu)
+ (:type-prescription bfr-=-uu)
hyp-fix-of-hyp-fixedp
(:meta mv-nth-cons-meta)
zp-open default-<-2 default-<-1
@@ -279,12 +304,31 @@
(local (include-book "clause-processors/just-expand" :dir :System))
+
+
+(def-gobj-dependency-thm equal
+ :hints `((acl2::just-induct-and-expand
+ (,gfn x y hyp clk config bvar-db state))
+ '(:in-theory (disable ,gfn))
+ (and stable-under-simplificationp
+ `(:expand ((,',gfn x y hyp clk config bvar-db state)
+ (,',gfn x x hyp clk config bvar-db state)
+ (,',gfn x y hyp clk config bvar-db state)
+ (,',gfn x x hyp clk config bvar-db state)
+ (eval-g-base x env)
+ (eval-g-base y env)
+ (eval-g-base nil env)
+ (eval-g-base-list nil env)
+ (eval-g-base t env))
+ :do-not-induct t))))
+
+
(encapsulate nil
(local
(in-theory (e/d** (
possibilities-for-x-1
-
+
possibilities-for-x-2
possibilities-for-x-3
possibilities-for-x-4
@@ -301,7 +345,11 @@
mk-g-boolean-correct-for-eval-g-base
geval-g-if-marker-eval-g-base
geval-g-or-marker-eval-g-base
-
+
+ gobj-depends-on-of-g-apply
+ gobj-depends-on-of-gl-cons
+ gobj-list-depends-on-of-gl-cons
+
general-concretep-not-general-consp
general-concretep-not-general-booleanp
general-concretep-not-general-numberp
@@ -317,14 +365,13 @@
booleanp-compound-recognizer
gtests-g-test-marker
-
+
bfr-eval-bfr-binary-and
bfr-eval-bfr-not
bfr-eval-bfr-binary-or
bfr-eval-booleanp
gtests-nonnil-correct-for-eval-g-base
hyp-fix-correct
- (:type-prescription v2i)
bfr-eval-g-hyp-marker
cons-equal
@@ -332,32 +379,35 @@
bfr-eval-bfr-iff
equal-of-numbers-correct
general-numberp-of-atom
-
+
+ eval-g-base-list-of-gl-cons
hons-equal
general-concrete-obj-of-atomic-constants
general-concretep-of-atomic-constants)
((general-concrete-obj)
- (general-concretep)))))
+ (general-concretep)
+ (kwote-lst)))))
(local
(make-event
`(in-theory
(enable (:induction ,(gl-fnsym 'equal))))))
-
- (def-g-correct-thm equal eval-g-base
+
+ (def-g-correct-thm equal eval-g-base
:hints `((acl2::just-induct-and-expand
- (,gfn x y hyp clk))
+ (,gfn x y hyp clk config bvar-db state))
(and stable-under-simplificationp
- `(:expand ((,',gfn x y hyp clk)
- (,',gfn x x hyp clk)
- (,',gfn x y hyp clk)
- (,',gfn x x hyp clk)
+ `(:expand ((,',gfn x y hyp clk config bvar-db state)
+ (,',gfn x x hyp clk config bvar-db state)
+ (,',gfn x y hyp clk config bvar-db state)
+ (,',gfn x x hyp clk config bvar-db state)
(eval-g-base x env)
(eval-g-base y env)
(eval-g-base nil env)
+ (eval-g-base-list nil env)
(eval-g-base t env))
:do-not-induct t))
;; (case-match id
@@ -372,7 +422,7 @@
;; possibilities-for-x-7
;; possibilities-for-x-8
;; possibilities-for-x-9)
- ;; :expand ((,',gfn x y hyp clk)
+ ;; :expand ((,',gfn x y hyp clk config bvar-db state)
;; (eval-g-base ,(if (eql n 3) 'x 'y) env)
;; (eval-g-base nil env)
;; (eval-g-base t env)))
diff -Nru acl2-6.2/books/centaur/gl/g-floor.lisp acl2-6.3/books/centaur/gl/g-floor.lisp
--- acl2-6.2/books/centaur/gl/g-floor.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-floor.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,15 +1,31 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
(defun g-floor-of-numbers (x y)
(declare (xargs :guard (and (general-numberp x)
@@ -18,17 +34,24 @@
(general-number-components x))
((mv yrn yrd yin yid)
(general-number-components y)))
- (if (and (eq (=-uu xrd '(t)) t)
- (eq (=-uu yrd '(t)) t)
- (eq (bfr-or (=-ss xin nil)
- (=-uu xid nil)) t)
- (eq (bfr-or (=-ss yin nil)
- (=-uu yid nil)) t))
- (mk-g-number (rlist-fix (floor-ss xrn yrn)))
+ (if (and (eq (bfr-=-uu xrd '(t)) t)
+ (eq (bfr-=-uu yrd '(t)) t)
+ (eq (bfr-or (bfr-=-ss xin nil)
+ (bfr-=-uu xid nil)) t)
+ (eq (bfr-or (bfr-=-ss yin nil)
+ (bfr-=-uu yid nil)) t))
+ (mk-g-number (rlist-fix (bfr-floor-ss xrn yrn)))
(g-apply 'floor (gl-list x y)))))
(in-theory (disable (g-floor-of-numbers)))
+(defthm deps-of-g-floor-of-numbers
+ (implies (and (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))
+ (general-numberp x)
+ (general-numberp y))
+ (not (gobj-depends-on k p (g-floor-of-numbers x y)))))
+
;; (local
;; (defthm gobjectp-g-floor-of-numbers
;; (implies (and (gobjectp x)
@@ -39,14 +62,14 @@
(local (include-book "arithmetic/top-with-meta" :dir :system))
-;; (local (defthm not-integerp-floor-ss
+;; (local (defthm not-integerp-bfr-floor-ss
;; (implies (and (bfr-listp a) (bfr-listp b))
-;; (not (integerp (floor-ss a b))))
-;; :hints (("goal" :use ((:instance bfr-listp-floor-ss))
-;; :in-theory (e/d (bfr-listp) (bfr-listp-floor-ss))))))
+;; (not (integerp (bfr-floor-ss a b))))
+;; :hints (("goal" :use ((:instance bfr-listp-bfr-floor-ss))
+;; :in-theory (e/d (bfr-listp) (bfr-listp-bfr-floor-ss))))))
-(local (add-bfr-fn-pat =-uu))
-(local (add-bfr-fn-pat =-ss))
+(local (add-bfr-fn-pat bfr-=-uu))
+(local (add-bfr-fn-pat bfr-=-ss))
(local
(defthm g-floor-of-numbers-correct
@@ -83,17 +106,22 @@
;; gobj-fix-when-gobjectp
;; (:rules-of-class :type-prescription :here)
;; (:ruleset gl-wrong-tag-rewrites)))
-;; :induct (,gfn i j hyp clk)
+;; :induct (,gfn i j . ,params)
;; :do-not-induct t
-;; :expand ((,gfn i j hyp clk)
+;; :expand ((,gfn i j . ,params)
;; (gobjectp (floor (gobj-fix i) (gobj-fix j)))))))
(verify-g-guards
floor
:hints `(("goal" :in-theory
- (disable* ,gfn
+ (disable* ,gfn
(:rules-of-class :type-prescription :here)))))
+(def-gobj-dependency-thm floor
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(local (defthm floor-when-not-numberp
(and (implies (not (acl2-numberp i))
(equal (floor i j) (floor 0 j)))
@@ -112,19 +140,18 @@
general-consp-cdr-correct-for-eval-g-base
boolean-listp
components-to-number-alt-def
- member-equal
+ member-equal
general-number-components-ev
general-concretep-def
- v2n-is-v2i-when-sign-nil
general-concretep-def
floor
hons-assoc-equal
rationalp-implies-acl2-numberp
(:rules-of-class :type-prescription :here))
((:type-prescription bfr-eval)))
- :induct (,gfn i j hyp clk)
+ :induct (,gfn i j . ,params)
:do-not-induct t
- :expand ((,gfn i j hyp clk)))
+ :expand ((,gfn i j . ,params)))
(and stable-under-simplificationp
(flag::expand-calls-computed-hint
clause '(eval-g-base)))))
diff -Nru acl2-6.2/books/centaur/gl/g-gl-mbe.lisp acl2-6.3/books/centaur/gl/g-gl-mbe.lisp
--- acl2-6.2/books/centaur/gl/g-gl-mbe.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-gl-mbe.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,22 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
(include-book "bfr-sat")
@@ -15,7 +34,7 @@
(def-g-fn gl-mbe
- `(b* ((equal? (glr acl2::always-equal spec impl hyp clk))
+ `(b* ((equal? (glr acl2::always-equal spec impl . ,params))
(tests (gtests equal? hyp))
(false (bfr-and hyp
(bfr-not (gtests-unknown tests))
@@ -23,8 +42,15 @@
((mv false-sat false-succ ?false-ctrex)
(bfr-sat false))
((when (and false-sat false-succ))
+ (make-fast-alist false-ctrex)
;; (acl2::sneaky-save 'gl-mbe-ctrex false-ctrex)
- (er hard? 'gl-mbe "GL-MBE assertion failed. Ctrex: ~x0" false-ctrex)
+ (er hard? 'gl-mbe "GL-MBE assertion failed. Ctrex: ~x0 Args: ~x1 ~
+ ~x2. Other: ~x3~%"
+ false-ctrex
+ ;; BOZO this is all assuming aig/alist-ctrex mode
+ (gobj->term spec (list false-ctrex))
+ (gobj->term impl (list false-ctrex))
+ (gobj->term other-info (list false-ctrex)))
spec)
((when (not false-succ))
(er hard? 'gl-mbe "GL-MBE assertion failed to prove.")
@@ -58,6 +84,11 @@
(instantiate-bfr-sat-hint (cdr clause) env)))
(& (instantiate-bfr-sat-hint (cdr clause) env)))))))
+(def-gobj-dependency-thm gl-mbe
+ :hints `(("goal"
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(def-g-correct-thm gl-mbe eval-g-base
:hints '(("goal" :do-not-induct t
:in-theory (disable bfr-sat-unsat))
diff -Nru acl2-6.2/books/centaur/gl/g-hide.lisp acl2-6.3/books/centaur/gl/g-hide.lisp
--- acl2-6.2/books/centaur/gl/g-hide.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-hide.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,10 +1,27 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-; (include-book "g-if")
(include-book "g-primitives-help")
(include-book "eval-g-base")
+(include-book "gtypes")
(local (include-book "gobjectp-thms"))
(def-g-fn hide 'x)
@@ -17,6 +34,10 @@
(verify-g-guards hide)
+(def-gobj-dependency-thm hide
+ :hints `(("goal"
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
(def-g-correct-thm hide eval-g-base
:hints `(("Goal" :in-theory '(hide-open ,gfn))))
diff -Nru acl2-6.2/books/centaur/gl/g-if.lisp acl2-6.3/books/centaur/gl/g-if.lisp
--- acl2-6.2/books/centaur/gl/g-if.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-if.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,7 +1,24 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "ite-merge")
(include-book "gtests")
@@ -32,7 +49,7 @@
(defmacro def-g-identity (name top-p)
(def-g-identity-fn name top-p))
-
+
(def-g-identity g-if-marker t)
(def-g-identity g-or-marker t)
@@ -47,6 +64,10 @@
(equal (bfr-eval (g-hyp-marker x) env)
(bfr-eval x env)))
+(defthm pbfr-depends-on-of-g-hyp-marker
+ (equal (pbfr-depends-on n p (g-hyp-marker x))
+ (pbfr-depends-on n p x)))
+
(in-theory (disable g-hyp-marker (:t g-hyp-marker)
(g-hyp-marker)))
@@ -79,13 +100,14 @@
(and (hide else-hyp)
(let ((hyp else-hyp))
(declare (ignorable hyp))
- (g-branch-marker$inline ,else))))
- (merge (gobj-ite-merge (gtests-nonnil gtests) then else
- (bfr-and (bfr-not (gtests-unknown gtests))
- hyp))))
+ (g-branch-marker$inline ,else)))))
(mk-g-bdd-ite (gtests-unknown gtests)
(mk-g-ite (gtests-obj gtests) then else)
- merge hyp)))))
+ (gobj-ite-merge (gtests-nonnil gtests)
+ then else
+ (bfr-and (bfr-not (gtests-unknown gtests))
+ hyp))
+ hyp)))))
(defmacro g-or (test else)
`(g-or-marker$inline
@@ -101,10 +123,10 @@
(and (hide else-hyp)
(let ((hyp else-hyp))
(declare (ignorable hyp))
- (g-branch-marker$inline ,else))))
- (merge (gobj-ite-merge (gtests-nonnil gtests) test else
- (bfr-and (bfr-not (gtests-unknown gtests))
- hyp))))
+ (g-branch-marker$inline ,else)))))
(mk-g-bdd-ite (gtests-unknown gtests)
(mk-g-ite (gtests-obj gtests) test else)
- merge hyp)))))
+ (gobj-ite-merge (gtests-nonnil gtests) test else
+ (bfr-and (bfr-not (gtests-unknown gtests))
+ hyp))
+ hyp)))))
diff -Nru acl2-6.2/books/centaur/gl/g-integer-length.lisp acl2-6.3/books/centaur/gl/g-integer-length.lisp
--- acl2-6.2/books/centaur/gl/g-integer-length.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-integer-length.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,18 +1,43 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-(set-inhibit-warnings "theory")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
-
+(set-inhibit-warnings "theory")
+
+;; (defthm true-listp-of-bfr-integer-length-s1
+;; (true-listp (mv-nth 1 (bfr-integer-length-s1 offset x)))
+;; :hints(("Goal" :in-theory (enable bfr-integer-length-s1)))
+;; :rule-classes :type-prescription)
+
+;; (defthm true-listp-of-bfr-integer-length-s
+;; (true-listp (bfr-integer-length-s x))
+;; :hints(("Goal" :in-theory (enable bfr-integer-length-s)))
+;; :rule-classes :type-prescription)
+
(def-g-fn integer-length
`(let ((x i))
@@ -23,8 +48,8 @@
(if (zp clk)
(g-apply 'integer-length (gl-list x))
(g-if test
- (,gfn then hyp clk)
- (,gfn else hyp clk))))
+ (,gfn then . ,params)
+ (,gfn else . ,params))))
((g-apply & &)
(g-apply 'integer-length (gl-list x)))
((g-var &)
@@ -34,10 +59,10 @@
((g-number num)
(mv-let (arn ard ain aid)
(break-g-number num)
- (g-if (mk-g-boolean (hyp-fix (bfr-or (=-uu aid nil)
- (=-ss ain nil)) hyp))
+ (g-if (mk-g-boolean (hyp-fix (bfr-or (bfr-=-uu aid nil)
+ (bfr-=-ss ain nil)) hyp))
(g-if (equal ard '(t))
- (let ((res (integer-length-s arn)))
+ (let ((res (rlist-fix (bfr-integer-length-s arn))))
(mk-g-number res 1 0 1))
(g-apply 'integer-length (gl-list x)))
0)))
@@ -55,14 +80,19 @@
;; (def-gobjectp-thm integer-length
;; :hints `(("Goal" :in-theory (e/d ()
;; ((:definition ,gfn)))
-;; :induct (,gfn i hyp clk)
-;; :expand ((,gfn i hyp clk)))))
+;; :induct (,gfn i . ,params)
+;; :expand ((,gfn i . ,params)))))
(verify-g-guards
integer-length
:hints `(("Goal" :in-theory (disable ,gfn))))
+(def-gobj-dependency-thm integer-length
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(local (defthm non-integerp-integer-length
(implies (not (integerp x))
@@ -92,7 +122,7 @@
general-concretep-def
eval-g-base-alt-def
integer-length))
- :induct (,gfn i hyp clk)
- :expand ((,gfn i hyp clk)))
+ :induct (,gfn i . ,params)
+ :expand ((,gfn i . ,params)))
(and stable-under-simplificationp
'(:expand ((:with eval-g-base (eval-g-base i env)))))))
diff -Nru acl2-6.2/books/centaur/gl/g-intern.lisp acl2-6.3/books/centaur/gl/g-intern.lisp
--- acl2-6.2/books/centaur/gl/g-intern.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-intern.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,12 +1,28 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-primitives-help")
(include-book "eval-g-base")
-(local (include-book "eval-g-base-help"))
(include-book "g-if")
-
+(local (include-book "eval-g-base-help"))
(local (in-theory (enable general-concretep-atom)))
(def-g-binary-op intern-in-package-of-symbol
@@ -30,6 +46,11 @@
(verify-g-guards intern-in-package-of-symbol
:hints `(("Goal" :in-theory (disable ,gfn))))
+(def-gobj-dependency-thm intern-in-package-of-symbol
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(local
(progn
;; (defthm gobjectp-not-g-keyword-symbolp
@@ -70,20 +91,22 @@
mk-g-ite-correct
((generic-geval-ev eval-g-base-ev)
(generic-geval-ev-lst eval-g-base-ev-lst)
- (generic-geval eval-g-base))
- :hints ('(:in-theory (e/d* (eval-g-base-ev-constraint-0
+ (generic-geval eval-g-base)
+ (generic-geval-list eval-g-base-list))
+ :hints ('(:in-theory (e/d* (eval-g-base-ev-of-fncall-args
eval-g-base-apply-agrees-with-eval-g-base-ev)
(eval-g-base-apply))
- :expand ((:with eval-g-base (eval-g-base x env))))))))
+ :expand ((:with eval-g-base (eval-g-base x env))
+ (eval-g-base-list x env)))))))
(def-g-correct-thm intern-in-package-of-symbol eval-g-base
- :hints `(("goal" :induct (,gfn acl2::str acl2::sym hyp clk)
+ :hints `(("goal" :induct (,gfn acl2::str acl2::sym . ,params)
:in-theory (e/d (general-concrete-obj)
((:definition ,gfn)
bfr-eval-list
eval-g-base-alt-def))
- :expand ((,gfn acl2::str acl2::sym hyp clk)
+ :expand ((,gfn acl2::str acl2::sym . ,params)
(:with eval-g-base (eval-g-base nil env))))
(and stable-under-simplificationp
'(:expand ((:with eval-g-base
diff -Nru acl2-6.2/books/centaur/gl/g-lessthan.lisp acl2-6.3/books/centaur/gl/g-lessthan.lisp
--- acl2-6.2/books/centaur/gl/g-lessthan.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-lessthan.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,16 +1,31 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
-
(defun g-<-of-numbers (a b)
(declare (xargs :guard (and (general-numberp a)
@@ -19,23 +34,70 @@
(general-number-components a))
((mv brn brd bin bid)
(general-number-components b)))
-
+
(if (and (equal ard brd)
(equal aid bid))
- (b* (((mv r< r=) (<-=-ss arn brn)))
+ (b* (((mv r< r=) (bfr-<-=-ss arn brn)))
(mk-g-boolean
- (bfr-ite (=-uu ard nil)
- (bfr-and (bfr-not (=-uu aid nil))
- (<-ss ain bin))
+ (bfr-ite (bfr-=-uu ard nil)
+ (bfr-and (bfr-not (bfr-=-uu aid nil))
+ (bfr-<-ss ain bin))
(bfr-or r<
(bfr-and r=
- (bfr-not (=-uu aid nil))
- (<-ss ain bin))))))
+ (bfr-not (bfr-=-uu aid nil))
+ (bfr-<-ss ain bin))))))
(g-apply '< (gl-list a b)))))
+(defthm deps-of-g-<-of-numbers
+ (implies (and (not (gobj-depends-on k p a))
+ (not (gobj-depends-on k p b))
+ (general-numberp a)
+ (general-numberp b))
+ (not (gobj-depends-on k p (g-<-of-numbers a b)))))
+
(in-theory (disable (g-<-of-numbers)))
(local
+ (encapsulate nil
+ (local
+ (defthm rationalp-complex
+ (equal (rationalp (complex a b))
+ (equal (rfix b) 0))
+ :hints (("goal" :use ((:instance
+ (:theorem (implies (rationalp x)
+ (equal (imagpart x) 0)))
+ (x (complex a b))))))))
+
+
+ (defthm realpart-of-complex
+ (equal (realpart (complex a b))
+ (rfix a))
+ :hints (("goal" :cases ((rationalp b)))))
+
+ (defthm imagpart-of-complex
+ (equal (imagpart (complex a b))
+ (rfix b))
+ :hints (("goal" :cases ((rationalp a)))))
+
+
+ (defthm complex-<-1
+ (equal (< (complex a b) c)
+ (or (< (rfix a) (realpart c))
+ (and (equal (rfix a) (realpart c))
+ (< (rfix b) (imagpart c)))))
+ :hints (("goal" :use ((:instance completion-of-<
+ (x (complex a b)) (y c))))))
+
+
+ (defthm complex-<-2
+ (equal (< a (complex b c))
+ (or (< (realpart a) (rfix b))
+ (and (equal (realpart a) (rfix b))
+ (< (imagpart a) (rfix c)))))
+ :hints (("goal" :use ((:instance completion-of-<
+ (x a) (y (complex b c)))))))))
+
+(local
(progn
;; (defthm gobjectp-g-<-of-numbers
;; (implies (and (gobjectp a)
@@ -80,6 +142,11 @@
(verify-g-guards
< :hints `(("Goal" :in-theory (disable* ,gfn general-concretep-def))))
+(def-gobj-dependency-thm <
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(def-g-correct-thm < eval-g-base
:hints `(("Goal" :in-theory (e/d* ((:ruleset general-object-possibilities)
@@ -91,9 +158,8 @@
components-to-number-alt-def
eval-g-base-non-cons
acl2::/r-when-abs-numerator=1
- v2n-is-v2i-when-sign-nil
default-unary-/
- s-sign-correct default-car default-cdr
+ default-car default-cdr
hons-assoc-equal))
- :induct (,gfn x y hyp clk)
- :expand ((,gfn x y hyp clk)))))
+ :induct ,gcall
+ :expand (,gcall))))
diff -Nru acl2-6.2/books/centaur/gl/g-logand.lisp acl2-6.3/books/centaur/gl/g-logand.lisp
--- acl2-6.2/books/centaur/gl/g-logand.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-logand.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,16 +1,31 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
-
(defun g-binary-logand-of-numbers (x y)
(declare (xargs :guard (and (general-numberp x)
@@ -21,23 +36,30 @@
(general-number-components y))
((mv xintp xintp-known)
(if (equal xrd '(t))
- (mv (bfr-or (=-ss xin nil)
- (=-uu xid nil)) t)
+ (mv (bfr-or (bfr-=-ss xin nil)
+ (bfr-=-uu xid nil)) t)
(mv nil nil)))
((mv yintp yintp-known)
(if (equal yrd '(t))
- (mv (bfr-or (=-ss yin nil)
- (=-uu yid nil)) t)
+ (mv (bfr-or (bfr-=-ss yin nil)
+ (bfr-=-uu yid nil)) t)
(mv nil nil))))
(if (and xintp-known yintp-known)
(mk-g-number
- (logand-ss (bfr-ite-bss-fn xintp xrn nil)
+ (bfr-logand-ss (bfr-ite-bss-fn xintp xrn nil)
(bfr-ite-bss-fn yintp yrn nil)))
(g-apply 'binary-logand (gl-list x y)))))
(in-theory (disable (g-binary-logand-of-numbers)))
+(defthm deps-of-g-binary-logand-of-numbers
+ (implies (and (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))
+ (general-numberp x)
+ (general-numberp y))
+ (not (gobj-depends-on k p (g-binary-logand-of-numbers x y)))))
+
(local (defthm logand-non-integers
(and (implies (not (integerp i))
(equal (logand i j) (logand 0 j)))
@@ -84,8 +106,8 @@
;; gobj-fix-when-gobjectp
;; (:ruleset gl-wrong-tag-rewrites)
;; (:rules-of-class :type-prescription :here)))
-;; :induct (,gfn i j hyp clk)
-;; :expand ((,gfn i j hyp clk)
+;; :induct (,gfn i j . ,params)
+;; :expand ((,gfn i j . ,params)
;; (gobjectp (logand (gobj-fix i)
;; (gobj-fix j)))))))
@@ -94,6 +116,11 @@
:hints `(("Goal" :in-theory (disable* ,gfn
general-concretep-def))))
+(def-gobj-dependency-thm binary-logand
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(local (defthm logand-non-acl2-numbers
(and (implies (not (acl2-numberp i))
(equal (logand i j) (logand 0 j)))
@@ -108,11 +135,9 @@
general-concretep-def
binary-logand
components-to-number-alt-def
- v2n-is-v2i-when-sign-nil
- s-sign-correct
hons-assoc-equal
default-car default-cdr
(:rules-of-class :type-prescription :here)))
- :induct (,gfn i j hyp clk)
+ :induct (,gfn i j . ,params)
:do-not-induct t
- :expand ((,gfn i j hyp clk)))))
+ :expand ((,gfn i j . ,params)))))
diff -Nru acl2-6.2/books/centaur/gl/g-logapp.lisp acl2-6.3/books/centaur/gl/g-logapp.lisp
--- acl2-6.2/books/centaur/gl/g-logapp.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-logapp.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,640 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "GL")
+(include-book "g-if")
+(include-book "g-primitives-help")
+(include-book "symbolic-arithmetic-fns")
+(include-book "eval-g-base")
+(local (include-book "symbolic-arithmetic"))
+(local (include-book "eval-g-base-help"))
+(local (include-book "hyp-fix-logic"))
+(local (include-book "centaur/bitops/ihsext-basics" :dir :system))
+(local (include-book "arithmetic/top-with-meta" :dir :system))
+
+(defun s-take (n x)
+ (declare (xargs :guard (natp n)))
+ (b* (((when (zp n)) (bfr-sterm nil))
+ ((mv first rest &) (first/rest/end x)))
+ (bfr-ucons first (s-take (1- n) rest))))
+
+(defthm deps-of-s-take
+ (implies (not (pbfr-list-depends-on k p x))
+ (not (pbfr-list-depends-on k p (s-take n x)))))
+
+
+(defthm s-take-correct
+ (equal (bfr-list->u (s-take n x) env)
+ (loghead n (bfr-list->s x env)))
+ :hints (("goal" :induct (s-take n x)
+ :in-theory (enable* acl2::ihsext-recursive-redefs))))
+
+
+
+;; (local (defthm v2i-of-append
+;; (implies (consp y)
+;; (equal (v2i (append x y))
+;; (logapp (len x) (v2n x) (v2i y))))
+;; :hints (("goal" :induct (append x y)
+;; :in-theory (enable* acl2::ihsext-recursive-redefs
+;; v2i v2n)))))
+
+;; (defthm bfr-eval-list-of-append
+;; (equal (bfr-eval-list (append a b) env)
+;; (append (bfr-eval-list a env)
+;; (bfr-eval-list b env))))
+
+;; (defthm len-of-bfr-eval-list
+;; (equal (len (bfr-eval-list x env))
+;; (len x)))
+
+;; (defthm len-of-s-take
+;; (equal (len (s-take w x))
+;; (nfix w)))
+
+;; (defun append-us (x y)
+;; (declare (xargs :guard (true-listp x)))
+;; (append x (if (consp y) y '(nil))))
+
+;; (defthm append-us-correct
+;; (equal (bfr-list->s (append-us x y) env)
+;; (logapp (len x) (bfr-list->u x env)
+;; (bfr-list->s y env)))
+;; :hints(("Goal" :in-theory (enable append-us))))
+
+
+(defun logapp-uss (w n x y)
+ (declare (xargs :measure (len n)
+ :guard (natp w)))
+ (if (atom n)
+ y
+ (bfr-ite-bss
+ (car n)
+ (bfr-logapp-nus (lnfix w) (s-take w x)
+ (logapp-uss (ash (lnfix w) 1) (cdr n) (logtail-ns w x)
+ y))
+ (logapp-uss (ash (lnfix w) 1) (cdr n) x y))))
+
+(defthm deps-of-logapp-uss
+ (implies (and (not (pbfr-list-depends-on k p n))
+ (not (pbfr-list-depends-on k p x))
+ (not (pbfr-list-depends-on k p y)))
+ (not (pbfr-list-depends-on k p (logapp-uss w n x y)))))
+
+(local
+ (progn
+ (defthm logapp-of-logapp
+ (implies (equal w (logapp m y z))
+ (equal (logapp n x w)
+ (logapp (+ (nfix n) (nfix m)) (logapp n x y) z)))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs)
+ :induct (loghead n x))))
+
+ (defthm logcar-non-integer
+ (implies (not (integerp x))
+ (equal (logcar x) 0))
+ :hints(("Goal" :in-theory (enable logcar)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm logcdr-non-integer
+ (implies (not (integerp x))
+ (equal (logcdr x) 0))
+ :hints(("Goal" :in-theory (enable logcdr)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm remake-*-n-w
+ (and (implies (equal (logcar n) 1)
+ (equal (+ (nfix w) (* 2 (logcdr n) (nfix w)))
+ (* (ifix n) (nfix w))))
+ (implies (equal (logcar n) 0)
+ (equal (* 2 (logcdr n) (nfix w))
+ (* (ifix n) (nfix w)))))
+ :hints(("Goal" :in-theory (e/d (logcons)
+ (acl2::logcons-destruct))
+ :use ((:instance acl2::logcar-logcdr-elim
+ (i n))))))
+
+
+ (defthm logapp-loghead-logtail
+ (equal (logapp n (loghead n x) (logtail n x))
+ (ifix x))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs)
+ :induct (loghead n x))))))
+
+;; (defthm true-listp-append-us
+;; (implies (true-listp y)
+;; (true-listp (append-us x y)))
+;; :hints(("Goal" :in-theory (enable append-us)))
+;; :rule-classes :type-prescription)
+
+;; (defthm true-listp-logapp-uss
+;; (implies (true-listp y)
+;; (true-listp (logapp-uss w n x y)))
+;; :rule-classes :type-prescription)
+
+;; (defun logapp-uss-conc (w n x y)
+;; (if (zp n)
+;; (ifix y)
+;; (if (equal (logcar n) 1)
+;; (logapp w (loghead w x)
+;; (logapp-uss-conc (* 2 (nfix w)) (logcdr n)
+;; (logtail w x) y))
+;; (logapp-uss-conc (* 2 (nfix w)) (logcdr n) x y))))
+
+;; (defthm logapp-uss-conc-correct
+;; (equal (logapp-uss-conc w n x y)
+;; (logapp (* (nfix w) (nfix n)) x y)))
+
+
+
+
+
+
+;; (local (in-theory (disable append-us)))
+
+
+
+(defthm logapp-uss-correct
+ (equal (bfr-list->s (logapp-uss w n x y) env)
+ (logapp (* (bfr-list->u n env)
+ (nfix w))
+ (bfr-list->s x env)
+ (bfr-list->s y env)))
+ :hints(("Goal" :in-theory (enable acl2::ash** logcons))))
+
+(local (in-theory (disable logapp-uss)))
+
+
+
+(defun g-logapp-of-numbers (n x y)
+ (declare (xargs :guard (and (general-numberp n)
+ (general-numberp x)
+ (general-numberp y))))
+ (b* (((mv nrn nrd nin nid)
+ (general-number-components n))
+ ((mv xrn xrd xin xid)
+ (general-number-components x))
+ ((mv yrn yrd yin yid)
+ (general-number-components y))
+ ((mv nintp nintp-known)
+ (if (equal nrd '(t))
+ (mv (bfr-or (bfr-=-ss nin nil)
+ (bfr-=-uu nid nil)) t)
+ (mv nil nil)))
+ ((mv xintp xintp-known)
+ (if (equal xrd '(t))
+ (mv (bfr-or (bfr-=-ss xin nil)
+ (bfr-=-uu xid nil)) t)
+ (mv nil nil)))
+ ((mv yintp yintp-known)
+ (if (equal yrd '(t))
+ (mv (bfr-or (bfr-=-ss yin nil)
+ (bfr-=-uu yid nil)) t)
+ (mv nil nil)))
+ ((unless (and nintp-known xintp-known yintp-known))
+ (g-apply 'logapp (gl-list n x y)))
+ ;; nfix
+ (nbits (bfr-ite-bvv-fn (bfr-and (bfr-not (s-sign nrn)) nintp)
+ nrn nil))
+ ;; ifix
+ (xbits (bfr-ite-bss-fn xintp xrn nil))
+ (ybits (bfr-ite-bss-fn yintp yrn nil))
+ (resbits (logapp-uss 1 nbits xbits ybits)))
+ (mk-g-number (rlist-fix resbits))))
+
+
+(in-theory (disable (g-logapp-of-numbers)))
+
+(defthm deps-of-g-logapp-of-numbers
+ (implies (and (not (gobj-depends-on k p n))
+ (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))
+ (general-numberp n)
+ (general-numberp x)
+ (general-numberp y))
+ (not (gobj-depends-on k p (g-logapp-of-numbers n x y)))))
+
+(local (defthm logapp-zp-n
+ (implies (zp n)
+ (equal (logapp n x y)
+ (ifix y)))
+ :hints(("Goal" :in-theory (enable acl2::logapp**)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+(local (defthm logapp-zip-x
+ (implies (and (syntaxp (not (equal x ''0)))
+ (zip x))
+ (equal (logapp n x y)
+ (logapp n 0 y)))
+ :hints(("Goal" :in-theory (enable acl2::logapp**)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+(local (defthm logapp-zip-y
+ (implies (and (syntaxp (not (equal y ''0)))
+ (zip y))
+ (equal (logapp n x y)
+ (logapp n x 0)))
+ :hints(("Goal" :in-theory (enable acl2::logapp**)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+(local (defthm bfr-list->s-when-gte-0
+ (implies (<= 0 (bfr-list->s x env))
+ (equal (bfr-list->s x env)
+ (bfr-list->u x env)))
+ :hints(("Goal" :in-theory (enable scdr s-endp)))))
+
+(defthm g-logapp-of-numbers-correct
+ (implies (and (general-numberp n)
+ (general-numberp x)
+ (general-numberp y))
+ (equal (eval-g-base (g-logapp-of-numbers n x y) env)
+ (logapp (eval-g-base n env)
+ (eval-g-base x env)
+ (eval-g-base y env))))
+ :hints (("goal" :in-theory (e/d* ((:ruleset general-object-possibilities)
+ )
+ (general-numberp
+ bfr-list->s
+ general-number-components))
+ :do-not-induct t)))
+
+(in-theory (disable g-logapp-of-numbers))
+
+(def-g-fn logapp
+ `(let ((size acl2::size))
+ (b* (((when (and (general-concretep size)
+ (general-concretep i)
+ (general-concretep j)))
+ (ec-call (logapp (general-concrete-obj size)
+ (general-concrete-obj i)
+ (general-concrete-obj j))))
+ ((unless (or (atom size)
+ (not (member-eq (tag size) '(:g-ite :g-var :g-apply)))))
+ (if (and (eq (tag size) :g-ite)
+ (not (zp clk)))
+ (let* ((test (g-ite->test size))
+ (then (g-ite->then size))
+ (else (g-ite->else size)))
+ (g-if test
+ (,gfn then i j . ,params)
+ (,gfn else i j . ,params)))
+ (g-apply 'logapp (gl-list size i j))))
+ ((unless (or (atom i)
+ (not (member-eq (tag i) '(:g-ite :g-var :g-apply)))))
+ (if (and (eq (tag i) :g-ite)
+ (not (zp clk)))
+ (let* ((test (g-ite->test i))
+ (then (g-ite->then i))
+ (else (g-ite->else i)))
+ (g-if test
+ (,gfn size then j . ,params)
+ (,gfn size else j . ,params)))
+ (g-apply 'logapp (gl-list size i j))))
+ ((unless (or (atom j)
+ (not (member-eq (tag j) '(:g-ite :g-var :g-apply)))))
+ (if (and (eq (tag j) :g-ite)
+ (not (zp clk)))
+ (let* ((test (g-ite->test j))
+ (then (g-ite->then j))
+ (else (g-ite->else j)))
+ (g-if test
+ (,gfn size i then . ,params)
+ (,gfn size i else . ,params)))
+ (g-apply 'logapp (gl-list size i j))))
+ (size (if (general-numberp size) size 0))
+ (i (if (general-numberp i) i 0))
+ (j (if (general-numberp j) j 0)))
+ (g-logapp-of-numbers size i j))))
+
+(verify-g-guards logapp
+ :hints `(("Goal" :in-theory (disable* ,gfn
+ general-concretep-def))))
+
+(def-gobj-dependency-thm logapp
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
+(local (defthm logapp-non-acl2-numbers
+ (and (implies (not (acl2-numberp size))
+ (equal (logapp size i j) (ifix j)))
+ (implies (not (acl2-numberp i))
+ (equal (logapp size i j) (logapp size 0 j)))
+ (implies (not (acl2-numberp j))
+ (equal (logapp size i j) (logapp size i 0))))))
+
+
+
+(def-g-correct-thm logapp eval-g-base
+ :hints `(("Goal" :in-theory (e/d* (general-concretep-atom
+ (:ruleset general-object-possibilities)
+ not-general-numberp-not-acl2-numberp
+ eval-g-base-non-cons)
+ ((:definition ,gfn)
+ general-concretep-def
+ logapp
+ member-equal
+ eval-g-base-alt-def
+ components-to-number-alt-def
+ hons-assoc-equal
+ sets::double-containment
+ equal-of-booleans-rewrite
+ bfr-eval-list
+ acl2::cancel_times-equal-correct
+ acl2::cancel_plus-equal-correct
+ default-car default-cdr
+ (:rules-of-class :type-prescription
+ :here))
+ ((:t logapp)))
+ :induct (,gfn acl2::size i j . ,params)
+ :do-not-induct t
+ :expand ((,gfn acl2::size i j . ,params)))
+ (and stable-under-simplificationp
+ (intersectp-equal '((not (equal (tag$inline acl2::size) ':g-ite))
+ (not (general-concretep acl2::size)))
+ clause)
+ '(:expand ((eval-g-base acl2::size env))))
+ (and stable-under-simplificationp
+ (intersectp-equal '((not (equal (tag$inline i) ':g-ite))
+ (not (general-concretep i)))
+ clause)
+ '(:expand ((eval-g-base i env))))
+ (and stable-under-simplificationp
+ (intersectp-equal '((not (equal (tag$inline j) ':g-ite))
+ (not (general-concretep j)))
+ clause)
+ '(:expand ((eval-g-base j env))))))
+
+
+
+
+
+
+(defun g-int-set-sign-of-number (negp y hyp)
+ (declare (xargs :guard (general-numberp y)))
+ (b* (((mv yrn yrd yin yid)
+ (general-number-components y))
+ ((mv yintp yintp-known)
+ (if (equal yrd '(t))
+ (mv (bfr-or (bfr-=-ss yin nil)
+ (bfr-=-uu yid nil)) t)
+ (mv nil nil)))
+ (negtest (gtests negp hyp))
+ ((unless (and yintp-known
+ (not (gtests-unknown negtest))))
+ (g-apply 'int-set-sign (gl-list negp y)))
+ (negbfr (gtests-nonnil negtest))
+ (ybits (bfr-ite-bss-fn yintp yrn nil))
+ (ylen (bfr-integer-length-s ybits))
+ (resbits (logapp-uss 1 ylen ybits (bfr-ite-bss-fn negbfr '(t) '(nil)))))
+ (mk-g-number (rlist-fix resbits))))
+
+(defthm deps-of-g-int-set-sign-of-number
+ (implies (and (not (gobj-depends-on k p negp))
+ (not (gobj-depends-on k p y))
+ (general-numberp y))
+ (not (gobj-depends-on k p (g-int-set-sign-of-number negp y hyp)))))
+
+
+(local (defthm bfr-integer-length-s-correct-v2n
+ (equal (bfr-list->u (bfr-integer-length-s x) env)
+ (integer-length (bfr-list->s x env)))
+ :hints(("Goal" :use ((:instance bfr-integer-length-s-correct))
+ :in-theory (disable bfr-integer-length-s-correct)))))
+
+(local (defthm integer-length-zip
+ (implies (zip x)
+ (equal (integer-length x) 0))))
+
+
+(defthm g-int-set-sign-of-number-correct
+ (implies (and (bfr-eval hyp (car env))
+ (general-numberp y))
+ (equal (eval-g-base (g-int-set-sign-of-number negp y hyp) env)
+ (int-set-sign (eval-g-base negp env)
+ (eval-g-base y env))))
+ :hints (("goal" :in-theory (e/d* ((:ruleset general-object-possibilities)
+ int-set-sign)
+ (general-numberp
+ bfr-list->s-when-gte-0
+ general-number-components))
+ :do-not-induct t)))
+
+(in-theory (disable g-int-set-sign-of-number))
+
+
+(def-g-binary-op int-set-sign
+ (b* ((i-num (if (general-numberp i) i 0)))
+ (g-int-set-sign-of-number negp i-num hyp)))
+
+(verify-g-guards
+ int-set-sign
+ :hints `(("Goal" :in-theory
+ (disable* ,gfn
+ (:rules-of-class :type-prescription :here)))))
+
+(def-gobj-dependency-thm int-set-sign
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
+(local (defthm int-set-sign-non-acl2-number
+ (implies (not (acl2-numberp i))
+ (equal (int-set-sign negp i)
+ (int-set-sign negp 0)))
+ :hints(("Goal" :in-theory (enable int-set-sign)))))
+
+(def-g-correct-thm int-set-sign eval-g-base
+ :hints `(("Goal" :in-theory (e/d* (general-concretep-atom
+ (:ruleset general-object-possibilities))
+ ((:definition ,gfn)
+ general-numberp-eval-to-numberp
+ general-boolean-value-correct
+ bool-cond-itep-eval
+ boolean-listp
+ eval-g-base-alt-def
+ components-to-number-alt-def
+ member-equal
+ general-number-components-ev
+ general-concretep-def
+ general-concretep-def
+ rationalp-implies-acl2-numberp
+ hons-assoc-equal
+ default-car default-cdr
+ bfr-eval-list-consts
+ mv-nth-cons-meta
+ possibilities-for-x-5
+ possibilities-for-x-3
+ general-boolean-value-cases
+ (:rules-of-class :type-prescription :here))
+ ((:type-prescription bfr-eval)
+ eval-g-base-non-cons))
+ :induct (,gfn negp i . ,params)
+ :expand ((,gfn negp i . ,params)))
+ (and stable-under-simplificationp
+ (intersectp-equal '((not (equal (tag$inline negp) ':g-ite))
+ (not (general-concretep negp)))
+ clause)
+ '(:expand ((eval-g-base negp env))))
+ (and stable-under-simplificationp
+ (intersectp-equal '((not (equal (tag$inline i) ':g-ite))
+ (not (general-concretep i)))
+ clause)
+ '(:expand ((eval-g-base i env))))))
+
+
+
+(defund g-ifix-of-number (i)
+ (declare (xargs :guard (general-numberp i)))
+ (b* (((mv irn ird iin iid)
+ (general-number-components i))
+ ((mv iintp iintp-known)
+ (if (equal ird '(t))
+ (mv (bfr-or (bfr-=-ss iin nil)
+ (bfr-=-uu iid nil)) t)
+ (mv nil nil)))
+ ((unless iintp-known) (mv t nil)) ;; error
+ ;; ifix
+ (ibits (bfr-ite-bss-fn iintp irn nil)))
+ (mv nil (mk-g-number ibits))))
+
+(defthm deps-of-g-ifix-of-number
+ (implies (and (not (gobj-depends-on k p i))
+ (general-numberp i))
+ (not (gobj-depends-on k p (mv-nth 1 (g-ifix-of-number i)))))
+ :hints(("Goal" :in-theory (enable g-ifix-of-number))))
+
+(defthm g-ifix-of-number-correct
+ (b* (((mv erp res) (g-ifix-of-number i)))
+ (implies (and (not erp)
+ (general-numberp i))
+ (equal (eval-g-base res env)
+ (ifix (eval-g-base i env)))))
+ :hints(("Goal" :in-theory (enable g-ifix-of-number))))
+
+
+
+(def-g-fn maybe-integer
+ `(b* (((when (and (general-concretep i)
+ (general-concretep x)
+ (general-concretep intp)))
+ (g-concrete-quote
+ (ec-call (maybe-integer (general-concrete-obj i)
+ (general-concrete-obj x)
+ (general-concrete-obj intp)))))
+ ;; ((unless (or (atom intp)
+ ;; (not (member-eq (tag intp) '(:g-ite :g-var :g-apply)))))
+ ;; (if (and (eq (tag intp) :g-ite)
+ ;; (not (zp clk)))
+ ;; (let* ((test (g-ite->test intp))
+ ;; (then (g-ite->then intp))
+ ;; (else (g-ite->else intp)))
+ ;; (g-if test
+ ;; (,gfn i x then . ,params)
+ ;; (,gfn i x else . ,params)))
+ ;; (g-apply 'maybe-integer (gl-list i x intp))))
+ ((when (and (consp i)
+ (member (tag i) '(:g-ite :g-var :g-apply))))
+ (if (and (eq (tag i) :g-ite)
+ (not (zp clk)))
+ (let* ((test (g-ite->test i))
+ (then (g-ite->then i))
+ (else (g-ite->else i)))
+ (g-if test
+ (,gfn then x intp . ,params)
+ (,gfn else x intp . ,params)))
+ (g-apply 'maybe-integer (gl-list i x intp))))
+ ;; ((when (and (consp x) (eq (tag x) :g-ite)))
+ ;; (if (not (zp clk))
+ ;; (let* ((test (g-ite->test x))
+ ;; (then (g-ite->then x))
+ ;; (else (g-ite->else x)))
+ ;; (g-if test
+ ;; (,gfn i then intp . ,params)
+ ;; (,gfn i else intp . ,params)))
+ ;; (g-apply 'maybe-integer (gl-list i x intp))))
+ (i (if (general-numberp i) i 0))
+ ((mv undef ifix) (g-ifix-of-number i))
+ ((when undef)
+ (g-apply 'maybe-integer (gl-list i x intp))))
+ (g-if intp
+ ifix
+ (g-apply 'maybe-integer (gl-list i x intp)))))
+
+
+
+(verify-g-guards
+ maybe-integer
+ :hints `(("Goal" :in-theory
+ (disable* ,gfn
+ (:rules-of-class :type-prescription :here)))))
+
+(def-gobj-dependency-thm maybe-integer
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
+
+(def-g-correct-thm maybe-integer eval-g-base
+ :hints `(("Goal" :in-theory (e/d* (general-concretep-atom
+ maybe-integer
+ (:ruleset general-object-possibilities))
+ ((:definition ,gfn)
+ (g-ifix-of-number)
+ general-numberp-eval-to-numberp
+ general-boolean-value-correct
+ bool-cond-itep-eval
+ boolean-listp
+ eval-g-base-alt-def
+ components-to-number-alt-def
+ member-equal
+ general-number-components-ev
+ general-concretep-def
+ general-concretep-def
+ rationalp-implies-acl2-numberp
+ hons-assoc-equal
+ default-car default-cdr
+ bfr-eval-list-consts
+ mv-nth-cons-meta
+ possibilities-for-x-5
+ possibilities-for-x-3
+ general-boolean-value-cases
+ (:rules-of-class :type-prescription :here))
+ ((:type-prescription bfr-eval)
+ eval-g-base-non-cons))
+ :induct (,gfn i x intp . ,params)
+ :expand ((,gfn i x intp . ,params)))
+ (and stable-under-simplificationp
+ (intersectp-equal '((not (equal (tag$inline i) ':g-ite))
+ (not (general-concretep i))
+ (general-numberp i))
+ clause)
+ '(:expand ((eval-g-base i env))))
+ (and stable-under-simplificationp
+ (intersectp-equal '((not (equal (tag$inline intp) ':g-ite))
+ (not (general-concretep intp)))
+ clause)
+ '(:expand ((eval-g-base intp env))))
+ (and stable-under-simplificationp
+ (intersectp-equal '((not (equal (tag$inline x) ':g-ite))
+ (not (general-concretep x)))
+ clause)
+ '(:expand ((eval-g-base x env))))))
+
diff -Nru acl2-6.2/books/centaur/gl/g-logbitp.lisp acl2-6.3/books/centaur/gl/g-logbitp.lisp
--- acl2-6.2/books/centaur/gl/g-logbitp.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-logbitp.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,18 +1,32 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-(set-inhibit-warnings "theory")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
-
+(set-inhibit-warnings "theory")
(defun g-logbitp-of-numbers (a b)
(declare (xargs :guard (and (general-numberp a)
@@ -23,16 +37,16 @@
(general-number-components b))
((mv aintp aintp-known)
(if (equal ard '(t))
- (mv (bfr-or (=-ss ain nil) (=-uu aid nil)) t)
+ (mv (bfr-or (bfr-=-ss ain nil) (bfr-=-uu aid nil)) t)
(mv nil nil)))
((mv bintp bintp-known)
(if (equal brd '(t))
- (mv (bfr-or (=-ss bin nil) (=-uu bid nil)) t)
+ (mv (bfr-or (bfr-=-ss bin nil) (bfr-=-uu bid nil)) t)
(mv nil nil))))
(if (and bintp-known aintp-known)
(mk-g-boolean
- (logbitp-n2v 1
- (bfr-ite-bss-fn (bfr-and
+ (bfr-logbitp-n2v 1
+ (bfr-ite-bvv-fn (bfr-and
aintp (bfr-not (s-sign arn)))
arn nil)
(bfr-ite-bss-fn bintp brn nil)))
@@ -40,6 +54,14 @@
(in-theory (disable (g-logbitp-of-numbers)))
+
+(defthm deps-of-g-logbitp-of-numbers
+ (implies (and (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))
+ (general-numberp x)
+ (general-numberp y))
+ (not (gobj-depends-on k p (g-logbitp-of-numbers x y)))))
+
;; (local
;; (defthm gobjectp-g-logbitp-of-numbers
;; (implies (and (gobjectp a)
@@ -57,6 +79,12 @@
(equal (logbitp a b) (logbitp a 0))))
:hints(("Goal" :in-theory (enable logbitp)))))
+(local (defthm bfr-list->s-when-positive
+ (implies (<= 0 (bfr-list->s x env))
+ (equal (bfr-list->s x env)
+ (bfr-list->u x env)))
+ :hints(("Goal" :in-theory (enable scdr s-endp)))))
+
(local
(defthm g-logbitp-of-numbers-correct
(implies (and (general-numberp a)
@@ -66,7 +94,8 @@
(eval-g-base b env))))
:hints (("goal" :in-theory (e/d* ((:ruleset general-object-possibilities))
(general-numberp
- general-number-components))
+ general-number-components
+ logbitp))
:do-not-induct t))))
(in-theory (disable g-logbitp-of-numbers))
@@ -89,8 +118,8 @@
;; (:ruleset gl-tag-rewrites)
;; mv-nth-cons-meta
;; bfr-ite-bss-fn))
-;; :induct (,gfn i j hyp clk)
-;; :expand ((,gfn i j hyp clk)))))
+;; :induct (,gfn i j . ,params)
+;; :expand ((,gfn i j . ,params)))))
(verify-g-guards
logbitp
@@ -99,6 +128,11 @@
(:rules-of-class :type-prescription :here)))))
+(def-gobj-dependency-thm logbitp
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(local (defthm logbitp-when-not-numbers
(and (implies (not (acl2-numberp a))
(equal (logbitp a b) (logbitp 0 b)))
@@ -118,7 +152,6 @@
member-equal
general-number-components-ev
general-concretep-def
- v2n-is-v2i-when-sign-nil
general-concretep-def
rationalp-implies-acl2-numberp
hons-assoc-equal
@@ -128,7 +161,8 @@
possibilities-for-x-5
possibilities-for-x-3
general-boolean-value-cases
+ logbitp bfr-list->s bfr-list->u
(:rules-of-class :type-prescription :here))
((:type-prescription bfr-eval)))
- :induct (,gfn i j hyp clk)
- :expand ((,gfn i j hyp clk)))))
+ :induct (,gfn i j . ,params)
+ :expand ((,gfn i j . ,params)))))
diff -Nru acl2-6.2/books/centaur/gl/g-logior.lisp acl2-6.3/books/centaur/gl/g-logior.lisp
--- acl2-6.2/books/centaur/gl/g-logior.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-logior.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,16 +1,32 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
-
+(local (include-book "centaur/misc/arith-equivs" :dir :system))
(defun g-binary-logior-of-numbers (x y)
(declare (xargs :guard (and (general-numberp x)
@@ -21,22 +37,28 @@
(general-number-components y))
((mv xintp xintp-known)
(if (equal xrd '(t))
- (mv (bfr-or (=-ss xin nil)
- (=-uu xid nil)) t)
+ (mv (bfr-or (bfr-=-ss xin nil)
+ (bfr-=-uu xid nil)) t)
(mv nil nil)))
((mv yintp yintp-known)
(if (equal yrd '(t))
- (mv (bfr-or (=-ss yin nil)
- (=-uu yid nil)) t)
+ (mv (bfr-or (bfr-=-ss yin nil)
+ (bfr-=-uu yid nil)) t)
(mv nil nil))))
(if (and xintp-known yintp-known)
(mk-g-number
- (logior-ss (bfr-ite-bss-fn xintp xrn nil)
+ (bfr-logior-ss (bfr-ite-bss-fn xintp xrn nil)
(bfr-ite-bss-fn yintp yrn nil)))
(g-apply 'binary-logior (gl-list x y)))))
(in-theory (disable (g-binary-logior-of-numbers)))
+(defthm deps-of-g-binary-logior-of-numbers
+ (implies (and (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))
+ (general-numberp x)
+ (general-numberp y))
+ (not (gobj-depends-on k p (g-binary-logior-of-numbers x y)))))
(local (defthm logior-non-integers
(and (implies (not (integerp i))
@@ -83,6 +105,11 @@
:hints `(("Goal" :in-theory (disable* ,gfn
general-concretep-def))))
+(def-gobj-dependency-thm binary-logior
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(local (defthm logior-non-acl2-numbers
(and (implies (not (acl2-numberp i))
(equal (logior i j) (logior 0 j)))
@@ -97,12 +124,10 @@
general-concretep-def
binary-logior
components-to-number-alt-def
- v2n-is-v2i-when-sign-nil
- s-sign-correct
hons-assoc-equal
eval-g-base-non-cons
default-car default-cdr
(:rules-of-class :type-prescription :here)))
- :induct (,gfn i j hyp clk)
+ :induct (,gfn i j . ,params)
:do-not-induct t
- :expand ((,gfn i j hyp clk)))))
+ :expand ((,gfn i j . ,params)))))
diff -Nru acl2-6.2/books/centaur/gl/g-lognot.lisp acl2-6.3/books/centaur/gl/g-lognot.lisp
--- acl2-6.2/books/centaur/gl/g-lognot.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-lognot.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,19 +1,32 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-(set-inhibit-warnings "theory")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
-
-
+(set-inhibit-warnings "theory")
(def-g-fn lognot
`(let ((x i))
@@ -24,8 +37,8 @@
(if (zp clk)
(g-apply 'lognot (gl-list x))
(g-if test
- (,gfn then hyp clk)
- (,gfn else hyp clk))))
+ (,gfn then . ,params)
+ (,gfn else . ,params))))
((g-apply & &)
(g-apply 'lognot (gl-list x)))
((g-concrete obj)
@@ -38,10 +51,10 @@
(break-g-number num))
((mv intp intp-known)
(if (equal rd '(t))
- (mv (bfr-or (=-ss in nil) (=-uu id nil)) t)
+ (mv (bfr-or (bfr-=-ss in nil) (bfr-=-uu id nil)) t)
(mv nil nil))))
(if intp-known
- (mk-g-number (lognot-s (bfr-ite-bss-fn intp rn nil)))
+ (mk-g-number (bfr-lognot-s (bfr-ite-bss-fn intp rn nil)))
(g-apply 'lognot (gl-list x)))))
(& -1)))))
@@ -54,14 +67,19 @@
;; (def-gobjectp-thm lognot
;; :hints `(("Goal" :in-theory (e/d ()
;; ((:definition ,gfn) lognot))
-;; :induct (,gfn i hyp clk)
-;; :expand ((,gfn i hyp clk)
+;; :induct (,gfn i . ,params)
+;; :expand ((,gfn i . ,params)
;; (:free (x) (gobjectp (- x)))))))
(verify-g-guards
lognot
:hints `(("Goal" :in-theory (disable ,gfn))))
+(def-gobj-dependency-thm lognot
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(local
(progn
(defthm lognot-non-acl2-numberp
@@ -81,7 +99,7 @@
general-number-components-ev
general-numberp-eval-to-numberp
lognot))
- :induct (,gfn i hyp clk)
- :expand ((,gfn i hyp clk)
+ :induct (,gfn i . ,params)
+ :expand ((,gfn i . ,params)
(:with eval-g-base (eval-g-base i env))))))
diff -Nru acl2-6.2/books/centaur/gl/g-make-fast-alist.acl2 acl2-6.3/books/centaur/gl/g-make-fast-alist.acl2
--- acl2-6.2/books/centaur/gl/g-make-fast-alist.acl2 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-make-fast-alist.acl2 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,22 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(set-waterfall-parallelism nil)
diff -Nru acl2-6.2/books/centaur/gl/g-make-fast-alist.lisp acl2-6.3/books/centaur/gl/g-make-fast-alist.lisp
--- acl2-6.2/books/centaur/gl/g-make-fast-alist.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-make-fast-alist.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,13 +1,29 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "centaur/gl/g-primitives-help" :dir :system)
(include-book "centaur/gl/eval-g-base" :dir :system)
(include-book "centaur/gl/g-if" :dir :system)
(local (include-book "centaur/gl/eval-g-base-help" :dir :system))
-
(def-g-fn acl2::make-fast-alist
`(let ((x acl2::alist))
(if (general-concretep x)
@@ -18,8 +34,8 @@
(if (zp clk)
x
(g-if test
- (,gfn then hyp clk)
- (,gfn else hyp clk))))
+ (,gfn then . ,params)
+ (,gfn else . ,params))))
((g-apply & &) x)
((g-var &) x)
((g-boolean &) x)
@@ -36,9 +52,14 @@
(verify-g-guards acl2::make-fast-alist)
+(def-gobj-dependency-thm acl2::make-fast-alist
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(def-g-correct-thm acl2::make-fast-alist eval-g-base
- :hints `(("Goal" :induct (,gfn acl2::alist hyp clk)
- :expand (,gfn acl2::alist hyp clk)
+ :hints `(("Goal" :induct (,gfn acl2::alist . ,params)
+ :expand (,gfn acl2::alist . ,params)
:in-theory (disable (:definition ,gfn)))
(and stable-under-simplificationp
'(:expand ((:with eval-g-base (eval-g-base acl2::alist
diff -Nru acl2-6.2/books/centaur/gl/g-mod.lisp acl2-6.3/books/centaur/gl/g-mod.lisp
--- acl2-6.2/books/centaur/gl/g-mod.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-mod.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,16 +1,31 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
(defun g-mod-of-numbers (x y)
(declare (xargs :guard (and (general-numberp x)
@@ -19,32 +34,38 @@
(general-number-components x))
((mv yrn yrd yin yid)
(general-number-components y)))
- (if (and (eq (=-uu xrd '(t)) t)
- (eq (=-uu yrd '(t)) t)
- (eq (bfr-or (=-ss xin nil)
- (=-uu xid nil)) t)
- (eq (bfr-or (=-ss yin nil)
- (=-uu yid nil)) t))
- (mk-g-number (rlist-fix (mod-ss xrn yrn)))
+ (if (and (eq (bfr-=-uu xrd '(t)) t)
+ (eq (bfr-=-uu yrd '(t)) t)
+ (eq (bfr-or (bfr-=-ss xin nil)
+ (bfr-=-uu xid nil)) t)
+ (eq (bfr-or (bfr-=-ss yin nil)
+ (bfr-=-uu yid nil)) t))
+ (mk-g-number (rlist-fix (bfr-mod-ss xrn yrn)))
(g-apply 'mod (gl-list x y)))))
(in-theory (disable (g-mod-of-numbers)))
+(defthm deps-of-g-mod-of-numbers
+ (implies (and (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))
+ (general-numberp x)
+ (general-numberp y))
+ (not (gobj-depends-on k p (g-mod-of-numbers x y)))))
(local (include-book "arithmetic/top-with-meta" :dir :system))
-;; (local (defthm not-integerp-mod-ss
+;; (local (defthm not-integerp-bfr-mod-ss
;; (implies (and (bfr-listp a) (bfr-listp b))
-;; (not (integerp (mod-ss a b))))
-;; :hints (("goal" :use ((:instance bfr-listp-mod-ss))
-;; :in-theory (e/d (bfr-listp) (bfr-listp-mod-ss))))))
+;; (not (integerp (bfr-mod-ss a b))))
+;; :hints (("goal" :use ((:instance bfr-listp-bfr-mod-ss))
+;; :in-theory (e/d (bfr-listp) (bfr-listp-bfr-mod-ss))))))
(local (defthm rationalp-mod
(implies (and (integerp x) (integerp y))
(rationalp (mod x y)))))
-(local (add-bfr-fn-pat =-uu))
-(local (add-bfr-fn-pat =-ss))
+(local (add-bfr-fn-pat bfr-=-uu))
+(local (add-bfr-fn-pat bfr-=-ss))
(local
(defthm g-mod-of-numbers-correct
@@ -81,17 +102,22 @@
;; gobj-fix-when-gobjectp
;; (:rules-of-class :type-prescription :here)
;; (:ruleset gl-wrong-tag-rewrites)))
-;; :induct (,gfn x y hyp clk)
+;; :induct (,gfn x y . ,params)
;; :do-not-induct t
-;; :expand ((,gfn x y hyp clk)
+;; :expand ((,gfn x y . ,params)
;; (gobjectp (mod (gobj-fix i) (gobj-fix j)))))))
(verify-g-guards
mod
:hints `(("goal" :in-theory
- (disable* ,gfn
+ (disable* ,gfn
(:rules-of-class :type-prescription :here)))))
+(def-gobj-dependency-thm mod
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(local (defthm mod-when-not-numberp
(and (implies (not (acl2-numberp x))
(equal (mod x y) (mod 0 y)))
@@ -113,16 +139,15 @@
member-equal
general-number-components-ev
general-concretep-def
- v2n-is-v2i-when-sign-nil
general-concretep-def
mod floor
hons-assoc-equal
rationalp-implies-acl2-numberp
(:rules-of-class :type-prescription :here))
((:type-prescription bfr-eval)))
- :induct (,gfn x y hyp clk)
+ :induct (,gfn x y . ,params)
:do-not-induct t
- :expand ((,gfn x y hyp clk)))
+ :expand ((,gfn x y . ,params)))
(and stable-under-simplificationp
(flag::expand-calls-computed-hint
clause '(eval-g-base)))))
diff -Nru acl2-6.2/books/centaur/gl/g-predicates.lisp acl2-6.3/books/centaur/gl/g-predicates.lisp
--- acl2-6.2/books/centaur/gl/g-predicates.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-predicates.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,15 +1,31 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
(local (defthm nth-open-when-constant-idx
(implies (syntaxp (quotep n))
@@ -58,8 +74,8 @@
(if (zp clk)
(g-apply ',',fn (list ,',x))
(g-if test
- (,gfn then hyp clk)
- (,gfn else hyp clk))))
+ (,gfn then . ,params)
+ (,gfn else . ,params))))
((g-apply & &) (g-apply ',',fn (list ,',x)))
((g-var &) (g-apply ',',fn (list ,',x)))
. ,',cases)))
@@ -111,8 +127,8 @@
;; ,@gobj-encap
;; (def-gobjectp-thm ,fn
;; :hints `(("goal"
-;; :induct (,gfn ,',x hyp clk)
-;; :expand ((,gfn ,',x hyp clk)))
+;; :induct (,gfn ,',x . ,params)
+;; :expand ((,gfn ,',x . ,params)))
;; . ,',gobj-hints)))
(encapsulate nil
(local (in-theory
@@ -161,6 +177,10 @@
,@guard-encap
(verify-g-guards ,fn
:hints ',guard-hints))
+ (def-gobj-dependency-thm ,fn
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (e/d ((:i ,gfn)) ((:d ,gfn))))))
(encapsulate nil
(local (in-theory (e/d* (;; gobjectp-tag-rw-to-types
;; gobjectp-gobj-fix
@@ -179,12 +199,13 @@
g-if-geval-meta-correct-eval-g-base
g-or-geval-meta-correct-eval-g-base
eval-g-base-atom
+ eval-g-base-list
;; booleanp-gobjectp
)
(;; bfr-p-of-boolean
general-number-components-ev
(:type-prescription booleanp)
-
+
bfr-eval-booleanp
general-boolean-value-correct
bool-cond-itep-eval
@@ -196,8 +217,8 @@
,@corr-encap
(def-g-correct-thm ,fn eval-g-base
:hints `(("goal" :in-theory (enable (:induction ,gfn))
- :induct (,gfn ,',x hyp clk)
- :expand ((,gfn ,',x hyp clk)))
+ :induct (,gfn ,',x . ,params)
+ :expand ((,gfn ,',x . ,params)))
(and stable-under-simplificationp
'(:expand ((:with eval-g-base (eval-g-base ,',x env))
(:with eval-g-base (eval-g-base nil env))
@@ -206,11 +227,11 @@
(defmacro def-g-predicate
- (fn cases &key
+ (fn cases &key
corr-hints guard-hints gobj-hints encap
gobj-encap guard-encap corr-encap (formals '(x)))
(declare (ignorable gobj-hints gobj-encap))
- (def-g-predicate-fn
+ (def-g-predicate-fn
fn cases corr-hints guard-hints
encap guard-encap corr-encap formals))
@@ -245,7 +266,7 @@
(& t)))
-
+
(encapsulate nil
(def-g-predicate integerp
@@ -255,17 +276,17 @@
(declare (ignore arn))
(if (equal ard '(t))
(mk-g-boolean
- (bfr-or (=-ss ain nil)
- (=-uu aid nil)))
+ (bfr-or (bfr-=-ss ain nil)
+ (bfr-=-uu aid nil)))
(g-apply 'integerp (list x)))))
(& nil))
:encap ((local (in-theory (enable bfr-eval-bfr-binary-or
bfr-or-of-t
- =-uu-correct
- =-ss-correct
+ bfr-=-uu-correct
+ bfr-=-ss-correct
(:type-prescription break-g-number)))))
:guard-encap ((local (bfr-reasoning-mode t))
- (local (add-bfr-pats (=-uu . &) (=-ss . &))))
+ (local (add-bfr-pats (bfr-=-uu . &) (bfr-=-ss . &))))
:corr-hints ((and stable-under-simplificationp
(append '(:in-theory (enable components-to-number-alt-def))
(flag::expand-calls-computed-hint
@@ -279,12 +300,12 @@
(break-g-number num)
(declare (ignore arn ard))
(mk-g-boolean
- (bfr-or (=-ss ain nil)
- (=-uu aid nil)))))
+ (bfr-or (bfr-=-ss ain nil)
+ (bfr-=-uu aid nil)))))
(& nil))
:encap ((local (in-theory (enable bfr-eval-bfr-binary-or
- =-uu-correct
- =-ss-correct
+ bfr-=-uu-correct
+ bfr-=-ss-correct
bfr-or-of-t
(:type-prescription break-g-number)))))
:guard-encap ((local (bfr-reasoning-mode t)))
diff -Nru acl2-6.2/books/centaur/gl/g-primitives-help.lisp acl2-6.3/books/centaur/gl/g-primitives-help.lisp
--- acl2-6.2/books/centaur/gl/g-primitives-help.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-primitives-help.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,10 +1,28 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "tools/flag" :dir :system)
(include-book "gl-util")
-
+(include-book "bvar-db")
+(include-book "glcp-config")
(program)
@@ -27,19 +45,22 @@
;; :exec ,(car formals)))
;; (mbe-gobj-fix-formals-list (cdr formals)))))
-(defmacro def-g-fn (fn body)
+(defmacro def-g-fn (fn body &key measure)
`(make-event
- (let* ((gfn (gl-fnsym ',fn))
- (world (w state))
- (formals (wgetprop ',fn 'formals)))
+ (b* ((gfn (gl-fnsym ',fn))
+ (world (w state))
+ (formals (wgetprop ',fn 'formals))
+ (params '(hyp clk config bvar-db state))
+ (measure (or ',measure `(+ . ,(acl2-count-formals-list
+ formals)))))
`(progn
- (defun ,gfn (,@formals hyp clk)
- (declare (xargs :guard (natp clk)
- :measure
- (+ . ,(acl2-count-formals-list
- formals))
- :verify-guards nil)
- (ignorable ,@formals hyp clk))
+ (defun ,gfn (,@formals hyp clk config bvar-db state)
+ (declare (xargs :guard (and (natp clk)
+ (glcp-config-p config))
+ :measure ,measure
+ :verify-guards nil
+ :stobjs (bvar-db state))
+ (ignorable ,@formals . ,params))
,,body)
(table g-functions ',',fn ',gfn)))))
@@ -56,30 +77,30 @@
(mk-g-concrete
(ec-call (,fn (general-concrete-obj ,a)
(general-concrete-obj ,b)))))
- ((or (atom ,a)
- (not (member-eq (tag ,a) '(:g-ite :g-var :g-apply))))
- (cond ((or (atom ,b)
- (not (member-eq (tag ,b) '(:g-ite :g-var :g-apply))))
- ,',',body)
- ((eq (tag ,b) :g-ite)
- (if (zp clk)
- (g-apply ',fn (gl-list ,a ,b))
- (let* ((test (g-ite->test ,b))
- (then (g-ite->then ,b))
- (else (g-ite->else ,b)))
- (g-if test
- (,gfn ,a then hyp clk)
- (,gfn ,a else hyp clk)))))
- (t (g-apply ',fn (gl-list ,a ,b)))))
- ((eq (tag ,a) :g-ite)
+ ((and (consp ,a) (eq (tag ,a) :g-ite))
(if (zp clk)
(g-apply ',fn (gl-list ,a ,b))
(let* ((test (g-ite->test ,a))
(then (g-ite->then ,a))
(else (g-ite->else ,a)))
(g-if test
- (,gfn then ,b hyp clk)
- (,gfn else ,b hyp clk)))))
+ (,gfn then ,b hyp clk config bvar-db state)
+ (,gfn else ,b hyp clk config bvar-db state)))))
+ ((and (consp ,b) (eq (tag ,b) :g-ite))
+ (if (zp clk)
+ (g-apply ',fn (gl-list ,a ,b))
+ (let* ((test (g-ite->test ,b))
+ (then (g-ite->then ,b))
+ (else (g-ite->else ,b)))
+ (g-if test
+ (,gfn ,a then hyp clk config bvar-db state)
+ (,gfn ,a else hyp clk config bvar-db state)))))
+ ((or (atom ,a)
+ (not (member-eq (tag ,a) '(:g-var :g-apply))))
+ (cond ((or (atom ,b)
+ (not (member-eq (tag ,b) '( :g-var :g-apply))))
+ ,',',body)
+ (t (g-apply ',fn (gl-list ,a ,b)))))
(t (g-apply ',fn (gl-list ,a ,b)))))))))
;; (defun gobjectp-thmname (fn)
@@ -89,8 +110,8 @@
(defun correct-thmname (fn)
(incat 'gl-thm::foo (symbol-name fn) "-CORRECT"))
-(defun correct-thmname-appalist (fn)
- (incat 'gl-thm::foo (symbol-name fn) "-CORRECT-APPALIST"))
+;; (defun correct-thmname-appalist (fn)
+;; (incat 'gl-thm::foo (symbol-name fn) "-CORRECT-APPALIST"))
(defun correct1-thmname (fn)
(incat 'gl-thm::foo (symbol-name fn) "-CORRECT1"))
@@ -103,7 +124,7 @@
;; (thmname (gobjectp-thmname gfn)))
;; `(progn
;; (defthm ,thmname
-;; (gobjectp (,gfn ,@formals hyp clk))
+;; (gobjectp (,gfn ,@formals hyp clk config bvar-db state))
;; :hints ,hints)
;; (add-to-ruleset! g-gobjectp-lemmas '(,thmname)))))
@@ -122,13 +143,13 @@
(cons `(,ev ,(car formals) env)
(ev-formals-list ev (cdr formals)))))
-(defun ev-formals-appalist-list (ev formals aps)
- (declare (xargs :mode :logic
- :guard t))
- (if (atom formals)
- nil
- (cons `(,ev ,(car formals) env ,aps)
- (ev-formals-appalist-list ev (cdr formals) aps))))
+;; (defun ev-formals-appalist-list (ev formals aps)
+;; (declare (xargs :mode :logic
+;; :guard t))
+;; (if (atom formals)
+;; nil
+;; (cons `(,ev ,(car formals) env ,aps)
+;; (ev-formals-appalist-list ev (cdr formals) aps))))
;; (defun gobj-fix-formals-list (formals)
;; (if (atom formals)
@@ -145,34 +166,79 @@
(defun def-g-correct-thm-fn (gfn fn ev hints world)
(b* ((formals (wgetprop fn 'formals))
(thmname (correct-thmname gfn))
- (thmname2 (correct-thmname-appalist gfn))
- (ev-appalist
- (cadr (assoc ev (table-alist 'eval-g-table world)))))
+ ;;(thmname2 (correct-thmname-appalist gfn))
+ ;; (ev-appalist
+ ;; (cadr (assoc ev (table-alist 'eval-g-table world))))
+ )
`(encapsulate nil
(defthm ,thmname
(implies (bfr-eval hyp (car env))
- (equal (,ev (,gfn ,@formals hyp clk) env)
+ (equal (,ev (,gfn ,@formals hyp clk config bvar-db state) env)
(,fn . ,(ev-formals-list ev formals))))
:hints ,hints)
(in-theory (disable ,gfn))
- (defthm ,thmname2
- (implies (bfr-eval hyp (car env))
- (equal (,ev-appalist (,gfn ,@formals hyp clk) env appalist)
- (,fn . ,(ev-formals-appalist-list ev-appalist formals
- 'appalist))))
- :hints ((geval-appalist-functional-inst-hint
- ',thmname ',ev)))
-
- (table sym-counterparts-table ',fn '(,gfn ,thmname2))
+ ;; (defthm ,thmname2
+ ;; (implies (bfr-eval hyp (car env))
+ ;; (equal (,ev-appalist (,gfn ,@formals hyp clk config bvar-db state) env appalist)
+ ;; (,fn . ,(ev-formals-appalist-list ev-appalist formals
+ ;; 'appalist))))
+ ;; :hints ((geval-appalist-functional-inst-hint
+ ;; ',thmname ',ev)))
+
+ (table sym-counterparts-table ',fn '(,gfn ,thmname))
(table gl-function-info ',fn '(,gfn (,thmname . ,ev))))))
-(defmacro def-g-correct-thm (fn ev &key hints)
+(defun def-g-correct-thm-macro (fn ev hints)
`(make-event
- (let ((gfn (gl-fnsym ',fn)))
+ (b* ((fn ',fn)
+ (gfn (gl-fnsym fn))
+ (world (w state))
+ (formals (wgetprop fn 'formals))
+ (params '(hyp clk config bvar-db state))
+ (?gcall (cons gfn
+ (append formals params)))
+ (?fcall (cons fn formals)))
(def-g-correct-thm-fn gfn ',fn ',ev ,hints (w state)))))
+(defmacro def-g-correct-thm (fn ev &key hints)
+ (def-g-correct-thm-macro fn ev hints))
+
(defmacro verify-g-guards (fn &key hints)
`(make-event
(let ((gfn (gl-fnsym ',fn)))
`(verify-guards ,gfn :hints ,,hints))))
+
+
+(defun not-gobj-depends-on-hyps (formals)
+ (if (atom formals)
+ nil
+ (cons `(not (gobj-depends-on badvar parambfr ,(car formals)))
+ (not-gobj-depends-on-hyps (cdr formals)))))
+
+(defun dependency-thmname (fn)
+ (incat 'gl-thm::foo (symbol-name fn) "-DEPENDENCIES"))
+
+(defun def-gobj-dependency-thm-fn (gcall fn hints world)
+ (b* ((formals (wgetprop fn 'formals))
+ (thmname (dependency-thmname fn)))
+ `(encapsulate nil
+ (defthm ,thmname
+ (implies (and . ,(not-gobj-depends-on-hyps formals))
+ (not (gobj-depends-on badvar parambfr ,gcall)))
+ :hints ,hints)
+ (table sym-counterpart-dep-thms ',fn ',thmname))))
+
+(defun def-gobj-dependency-thm-macro (fn hints)
+ `(make-event
+ (b* ((fn ',fn)
+ (gfn (gl-fnsym fn))
+ (world (w state))
+ (formals (wgetprop fn 'formals))
+ (params '(hyp clk config bvar-db state))
+ (gcall (cons gfn
+ (append formals params))))
+ (def-gobj-dependency-thm-fn gcall ',fn ,hints (w state)))))
+
+(defmacro def-gobj-dependency-thm (fn &key hints)
+ (def-gobj-dependency-thm-macro fn hints))
diff -Nru acl2-6.2/books/centaur/gl/g-rem.lisp acl2-6.3/books/centaur/gl/g-rem.lisp
--- acl2-6.2/books/centaur/gl/g-rem.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-rem.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,16 +1,31 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
(defun g-rem-of-numbers (x y)
(declare (xargs :guard (and (general-numberp x)
@@ -19,32 +34,39 @@
(general-number-components x))
((mv yrn yrd yin yid)
(general-number-components y)))
- (if (and (eq (=-uu xrd '(t)) t)
- (eq (=-uu yrd '(t)) t)
- (eq (bfr-or (=-ss xin nil)
- (=-uu xid nil)) t)
- (eq (bfr-or (=-ss yin nil)
- (=-uu yid nil)) t))
- (mk-g-number (rlist-fix (rem-ss xrn yrn)))
+ (if (and (eq (bfr-=-uu xrd '(t)) t)
+ (eq (bfr-=-uu yrd '(t)) t)
+ (eq (bfr-or (bfr-=-ss xin nil)
+ (bfr-=-uu xid nil)) t)
+ (eq (bfr-or (bfr-=-ss yin nil)
+ (bfr-=-uu yid nil)) t))
+ (mk-g-number (rlist-fix (bfr-rem-ss xrn yrn)))
(g-apply 'rem (gl-list x y)))))
(in-theory (disable (g-rem-of-numbers)))
+(defthm deps-of-g-rem-of-numbers
+ (implies (and (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))
+ (general-numberp x)
+ (general-numberp y))
+ (not (gobj-depends-on k p (g-rem-of-numbers x y)))))
+
(local (include-book "arithmetic/top-with-meta" :dir :system))
-;; (local (defthm not-integerp-rem-ss
+;; (local (defthm not-integerp-bfr-rem-ss
;; (implies (and (bfr-listp a) (bfr-listp b))
-;; (not (integerp (rem-ss a b))))
-;; :hints (("goal" :use ((:instance bfr-listp-rem-ss))
-;; :in-theory (e/d (bfr-listp) (bfr-listp-rem-ss))))))
+;; (not (integerp (bfr-rem-ss a b))))
+;; :hints (("goal" :use ((:instance bfr-listp-bfr-rem-ss))
+;; :in-theory (e/d (bfr-listp) (bfr-listp-bfr-rem-ss))))))
(local (defthm rationalp-rem
(implies (and (integerp x) (integerp y))
(rationalp (rem x y)))))
-(local (add-bfr-fn-pat =-uu))
-(local (add-bfr-fn-pat =-ss))
+(local (add-bfr-fn-pat bfr-=-uu))
+(local (add-bfr-fn-pat bfr-=-ss))
(local
(defthm g-rem-of-numbers-correct
@@ -77,6 +99,13 @@
(disable* ,gfn
(:rules-of-class :type-prescription :here)))))
+(def-gobj-dependency-thm rem
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
+
+
(local (defthm rem-when-not-numberp
(and (implies (not (acl2-numberp x))
(equal (rem x y) (rem 0 y)))
@@ -98,16 +127,15 @@
member-equal
general-number-components-ev
general-concretep-def
- v2n-is-v2i-when-sign-nil
general-concretep-def
rem floor
hons-assoc-equal
rationalp-implies-acl2-numberp
(:rules-of-class :type-prescription :here))
((:type-prescription bfr-eval)))
- :induct (,gfn x y hyp clk)
+ :induct (,gfn x y . ,params)
:do-not-induct t
- :expand ((,gfn x y hyp clk)))
+ :expand ((,gfn x y . ,params)))
(and stable-under-simplificationp
(flag::expand-calls-computed-hint
clause '(eval-g-base)))))
diff -Nru acl2-6.2/books/centaur/gl/g-truncate.lisp acl2-6.3/books/centaur/gl/g-truncate.lisp
--- acl2-6.2/books/centaur/gl/g-truncate.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-truncate.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,15 +1,32 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
+(local (include-book "arithmetic/top-with-meta" :dir :system))
(defun g-truncate-of-numbers (x y)
(declare (xargs :guard (and (general-numberp x)
@@ -18,22 +35,26 @@
(general-number-components x))
((mv yrn yrd yin yid)
(general-number-components y)))
- (if (and (eq (=-uu xrd '(t)) t)
- (eq (=-uu yrd '(t)) t)
- (eq (bfr-or (=-ss xin nil)
- (=-uu xid nil)) t)
- (eq (bfr-or (=-ss yin nil)
- (=-uu yid nil)) t))
- (mk-g-number (rlist-fix (truncate-ss xrn yrn)))
+ (if (and (eq (bfr-=-uu xrd '(t)) t)
+ (eq (bfr-=-uu yrd '(t)) t)
+ (eq (bfr-or (bfr-=-ss xin nil)
+ (bfr-=-uu xid nil)) t)
+ (eq (bfr-or (bfr-=-ss yin nil)
+ (bfr-=-uu yid nil)) t))
+ (mk-g-number (rlist-fix (bfr-truncate-ss xrn yrn)))
(g-apply 'truncate (gl-list x y)))))
(in-theory (disable (g-truncate-of-numbers)))
-(local (include-book "arithmetic/top-with-meta" :dir :system))
+(defthm deps-of-g-truncate-of-numbers
+ (implies (and (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))
+ (general-numberp x)
+ (general-numberp y))
+ (not (gobj-depends-on k p (g-truncate-of-numbers x y)))))
-
-(local (add-bfr-fn-pat =-uu))
-(local (add-bfr-fn-pat =-ss))
+(local (add-bfr-fn-pat bfr-=-uu))
+(local (add-bfr-fn-pat bfr-=-ss))
(local
(defthm g-truncate-of-numbers-correct
@@ -67,6 +88,11 @@
(disable* ,gfn
(:rules-of-class :type-prescription :here)))))
+(def-gobj-dependency-thm truncate
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(local (defthm truncate-when-not-numberp
(and (implies (not (acl2-numberp i))
(equal (truncate i j) (truncate 0 j)))
@@ -88,16 +114,15 @@
member-equal
general-number-components-ev
general-concretep-def
- v2n-is-v2i-when-sign-nil
general-concretep-def
truncate
hons-assoc-equal
rationalp-implies-acl2-numberp
(:rules-of-class :type-prescription :here))
((:type-prescription bfr-eval)))
- :induct (,gfn i j hyp clk)
+ :induct (,gfn i j . ,params)
:do-not-induct t
- :expand ((,gfn i j hyp clk)))
+ :expand ((,gfn i j . ,params)))
(and stable-under-simplificationp
(flag::expand-calls-computed-hint
clause '(eval-g-base)))))
diff -Nru acl2-6.2/books/centaur/gl/g-unary--.lisp acl2-6.3/books/centaur/gl/g-unary--.lisp
--- acl2-6.2/books/centaur/gl/g-unary--.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-unary--.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,18 +1,33 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-(set-inhibit-warnings "theory")
-
(include-book "g-if")
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
-
+(local (include-book "arithmetic/top-with-meta" :dir :system))
+(set-inhibit-warnings "theory")
(def-g-fn unary--
`(if (atom x)
@@ -22,8 +37,8 @@
(if (zp clk)
(g-apply 'unary-- (gl-list x))
(g-if test
- (,gfn then hyp clk)
- (,gfn else hyp clk))))
+ (,gfn then . ,params)
+ (,gfn else . ,params))))
((g-apply & &)
(g-apply 'unary-- (gl-list x)))
((g-concrete obj)
@@ -34,24 +49,28 @@
((g-number num)
(mv-let (rn rd in id)
(break-g-number num)
- (mk-g-number (unary-minus-s rn)
- rd
- (unary-minus-s in)
- id)))
+ (mk-g-number (bfr-unary-minus-s rn)
+ (rlist-fix rd)
+ (bfr-unary-minus-s in)
+ (rlist-fix id))))
(& 0))))
;; (def-gobjectp-thm unary--
;; :hints `(("Goal" :in-theory (e/d () ((:definition ,gfn)))
-;; :induct (,gfn x hyp clk)
-;; :expand ((,gfn x hyp clk)
+;; :induct (,gfn x . ,params)
+;; :expand ((,gfn x . ,params)
;; (:free (x) (gobjectp (- x)))))))
(verify-g-guards
unary--
:hints `(("Goal" :in-theory (disable ,gfn))))
+(def-gobj-dependency-thm unary--
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
-(local (include-book "arithmetic/top-with-meta" :dir :system))
(local
@@ -96,7 +115,7 @@
((:definition ,gfn)
general-number-components-ev
general-numberp-eval-to-numberp))
- :induct (,gfn x hyp clk)
+ :induct (,gfn x . ,params)
:do-not-induct t
- :expand ((,gfn x hyp clk)
+ :expand ((,gfn x . ,params)
(:with eval-g-base (eval-g-base x env))))))
diff -Nru acl2-6.2/books/centaur/gl/g-unary-concrete.lisp acl2-6.3/books/centaur/gl/g-unary-concrete.lisp
--- acl2-6.2/books/centaur/gl/g-unary-concrete.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/g-unary-concrete.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,22 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
@@ -5,12 +24,9 @@
(include-book "g-primitives-help")
(include-book "symbolic-arithmetic-fns")
(include-book "eval-g-base")
-;(include-book "tools/with-arith5-help" :dir :system)
(local (include-book "symbolic-arithmetic"))
(local (include-book "eval-g-base-help"))
(local (include-book "hyp-fix-logic"))
-;(local (allow-arith5-help))
-
(in-theory (disable (mk-g-concrete)))
(defthm mk-g-concrete-of-atomic-constant
@@ -39,8 +55,8 @@
(if (zp clk)
(g-apply ',fn (gl-list ,x))
(g-if test
- (,gfn then hyp clk)
- (,gfn else hyp clk))))
+ (,gfn then . ,params)
+ (,gfn else . ,params))))
((g-apply & &) (g-apply ',fn (gl-list ,x)))
((g-var &) (g-apply ',fn (gl-list ,x)))
((g-number &) ,',number-case)
@@ -51,18 +67,23 @@
;; (e/d ()
;; ((force)
;; (:definition ,gfn)))
- ;; :induct (,gfn ,',x hyp clk)
- ;; :expand ((,gfn ,',x hyp clk)))))
+ ;; :induct (,gfn ,',x . ,params)
+ ;; :expand ((,gfn ,',x . ,params)))))
(verify-g-guards
,fn
:hints `(("Goal" :in-theory (Disable ,gfn))))
+ (def-gobj-dependency-thm ,fn
+ :hints `(("goal" :induct ,gcall
+ :expand (,gcall)
+ :in-theory (disable (:d ,gfn)))))
+
(def-g-correct-thm ,fn eval-g-base
:hints `(("Goal" :in-theory (e/d ((:induction ,gfn)
general-concrete-obj)
((:definition ,gfn)))
- :induct (,gfn ,',x hyp clk)
- :expand ((,gfn ,',x hyp clk)
+ :induct (,gfn ,',x . ,params)
+ :expand ((,gfn ,',x . ,params)
(:with eval-g-base (eval-g-base ,',x env))))
. ,',hints)))))
@@ -118,7 +139,7 @@
(mv-let (rn rd in id)
(break-g-number (g-number->num x))
(declare (ignore in id))
- (mk-g-number rn rd))
+ (mk-g-number (rlist-fix rn) (rlist-fix rd)))
:boolean-case 0
:cons-case 0)
@@ -127,7 +148,7 @@
(mv-let (rn rd in id)
(break-g-number (g-number->num x))
(declare (ignore rn rd))
- (mk-g-number in id))
+ (mk-g-number (rlist-fix in) (rlist-fix id)))
:boolean-case 0
:cons-case 0)
diff -Nru acl2-6.2/books/centaur/gl/general-object-thms.lisp acl2-6.3/books/centaur/gl/general-object-thms.lisp
--- acl2-6.2/books/centaur/gl/general-object-thms.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/general-object-thms.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,12 +1,28 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "gtype-thms")
(include-book "general-objects")
-
(defthmd generic-geval-g-boolean
(implies (g-boolean-p x)
(equal (generic-geval x env)
@@ -49,6 +65,13 @@
:hints (("goal" :in-theory (enable generic-geval)))
:rule-classes ((:rewrite :backchain-limit-lst 0)))
+(defthm pbfr-depends-on-of-general-boolean-value
+ (implies (and (not (gobj-depends-on k p x))
+ (general-booleanp x))
+ (not (pbfr-depends-on k p (general-boolean-value x))))
+ :hints(("Goal" :in-theory (enable general-booleanp general-boolean-value
+ booleanp))))
+
(in-theory (disable general-booleanp general-boolean-value))
@@ -67,11 +90,11 @@
(defthm boolean-listp-n2v
(boolean-listp (n2v n))
- :hints(("Goal" :in-theory (enable n2v))))
+ :hints(("Goal" :in-theory (e/d (n2v bfr-ucons) (logcar logcdr)))))
(defthm boolean-listp-i2v
(boolean-listp (i2v n))
- :hints(("Goal" :in-theory (enable i2v))))
+ :hints(("Goal" :in-theory (e/d (i2v bfr-scons) (logcar logcdr)))))
(defthm number-to-components-boolean-listps
(and (boolean-listp (mv-nth 0 (number-to-components n)))
@@ -81,39 +104,33 @@
-(defthm v2n-us
- (implies (natp n)
- (equal (v2n (n2v n)) n))
- :hints (("goal" :in-theory (disable floor))))
-
-(defthm v2n-non-natp
- (implies (not (natp n))
- (equal (v2n (n2v n)) 0)))
-
-(defthm acl2-numberp-v2n
- (and (acl2-numberp (v2n x))
- (rationalp (v2n x))
- (integerp (v2n x))
- (natp (v2n x)))
- :rule-classes (:rewrite :type-prescription))
+;; (defthm v2n-us
+;; (implies (natp n)
+;; (equal (v2n (n2v n)) n))
+;; :hints (("goal" :in-theory (disable floor))))
+
+;; (defthm v2n-non-natp
+;; (implies (not (natp n))
+;; (equal (v2n (n2v n)) 0)))
+
+;; (defthm acl2-numberp-v2n
+;; (and (acl2-numberp (v2n x))
+;; (rationalp (v2n x))
+;; (integerp (v2n x))
+;; (natp (v2n x)))
+;; :rule-classes (:rewrite :type-prescription))
(defthm number-to-components-components-to-number
(b* (((mv rnum rden inum iden)
(number-to-components n)))
(implies (acl2-numberp n)
- (and (equal (components-to-number
- (v2i rnum)
- (v2n rden)
- (v2i inum)
- (v2n iden))
- n)
- (equal (components-to-number
- (v2i (bfr-eval-list rnum env))
- (v2n (bfr-eval-list rden env))
- (v2i (bfr-eval-list inum env))
- (v2n (bfr-eval-list iden env)))
- n))))
+ (equal (components-to-number
+ (bfr-list->s rnum env)
+ (bfr-list->u rden env)
+ (bfr-list->s inum env)
+ (bfr-list->u iden env))
+ n)))
:hints (("goal" :in-theory (enable components-to-number-alt-def))))
@@ -138,9 +155,9 @@
(mv-let (rn rd in id)
(general-number-components a)
(flet ((uval (n env)
- (v2n (bfr-eval-list n (car env))))
+ (bfr-list->u n (car env)))
(sval (n env)
- (v2i (bfr-eval-list n (car env)))))
+ (bfr-list->s n (car env))))
(equal (generic-geval a env)
(components-to-number
(sval rn env)
@@ -153,6 +170,18 @@
(in-theory (disable general-number-components
general-numberp))
+(defthm pbfr-depends-on-of-general-number-components
+ (implies (and (general-numberp x)
+ (not (gobj-depends-on k p x)))
+ (b* (((mv rn rd in id) (general-number-components x)))
+ (and (not (pbfr-list-depends-on k p rn))
+ (not (pbfr-list-depends-on k p rd))
+ (not (pbfr-list-depends-on k p in))
+ (not (pbfr-list-depends-on k p id)))))
+ :hints(("Goal" :in-theory (enable general-number-components)
+ :expand ((gobj-depends-on k p x)
+ (general-numberp x)))))
+
(local (defthm nth-open-when-constant-idx
@@ -160,7 +189,7 @@
(equal (nth n x)
(if (zp n) (car x)
(nth (1- n) (cdr x)))))))
-
+
(defthm general-numberp-of-atom
(implies (not (consp x))
@@ -227,6 +256,17 @@
:hints (("goal" :in-theory (enable mk-g-concrete g-concrete g-concrete->obj)))
:rule-classes (:rewrite :linear))
+(defthm gobj-depends-on-of-general-consp
+ (implies (and (not (gobj-depends-on k p x))
+ (general-consp x))
+ (and (not (gobj-depends-on k p (general-consp-car x)))
+ (not (gobj-depends-on k p (general-consp-cdr x)))))
+ :hints(("Goal" :in-theory (enable general-consp
+ general-consp-car
+ general-consp-cdr
+ g-keyword-symbolp-def))))
+
+
(in-theory (disable general-consp general-consp-car general-consp-cdr))
@@ -338,7 +378,7 @@
(verify-guards
general-concrete-obj)
-
+
;; (defun general-concretep (x)
;; (declare (xargs :guard (gobjectp x)))
@@ -358,14 +398,16 @@
(implies (concrete-gobjectp x)
(equal (generic-geval x env)
x))
- :hints(("Goal" :in-theory (enable concrete-gobjectp-def)))
+ :hints(("Goal" :in-theory (enable concrete-gobjectp
+ gobject-hierarchy-lite
+ generic-geval)))
:rule-classes ((:rewrite :backchain-limit-lst 0)))
(defthmd general-concrete-obj-correct
(implies (general-concretep x)
(equal (generic-geval x env)
(general-concrete-obj x)))
- :hints(("Goal"
+ :hints(("Goal"
:induct (general-concrete-obj x)
:expand ((general-concretep x)
@@ -467,7 +509,7 @@
-;; (local
+;; (local
;; (defthm g-concrete-p-impl-not-general-concretep-car
;; (implies (g-concrete-p x)
;; (not (general-concretep (car x))))
@@ -506,9 +548,9 @@
(b* (((mv rn rd in id)
(general-number-components x)))
(flet ((uval (n env)
- (v2n (bfr-eval-list n (car env))))
+ (bfr-list->u n (car env)))
(sval (n env)
- (v2i (bfr-eval-list n (car env)))))
+ (bfr-list->s n (car env))))
(components-to-number (sval rn env)
(uval rd env)
(sval in env)
@@ -521,18 +563,19 @@
(generic-geval (g-ite->then x) env)
(generic-geval (g-ite->else x) env)))
((g-apply-p x)
- (generic-geval-ev
- (cons (g-apply->fn x)
- (kwote-lst
- (generic-geval (g-apply->args x) env)))
- nil))
+ (and (not (eq (g-apply->fn x) 'quote))
+ (generic-geval-ev
+ (cons (g-apply->fn x)
+ (kwote-lst
+ (generic-geval-list (g-apply->args x) env)))
+ nil)))
(t
(cdr (hons-assoc-equal (g-var->name x) (cdr env))))))
:hints (("goal" ;; :induct (generic-geval x env)
:in-theory (e/d** (general-concretep-def
(:induction generic-geval)
general-numberp general-booleanp
- general-consp eq
+ general-consp eq
atom
acl2::cons-car-cdr
concrete-gobjectp-def
@@ -549,7 +592,10 @@
hons-get))
:do-not-induct t
:expand ((generic-geval x env))))
- :rule-classes :definition)
+ :rule-classes
+ ((:definition :clique (generic-geval generic-geval-list)
+ :controller-alist ((generic-geval t nil)
+ (generic-geval-list t nil)))))
(in-theory (disable generic-geval-alt-def))
@@ -786,10 +832,10 @@
(general-number-components x)
(equal (general-concrete-obj x)
(components-to-number-fn
- (v2i (bfr-eval-list rn (car env)))
- (v2n (bfr-eval-list rd (car env)))
- (v2i (bfr-eval-list in (car env)))
- (v2n (bfr-eval-list id (car env)))))))
+ (bfr-list->s rn (car env))
+ (bfr-list->u rd (car env))
+ (bfr-list->s in (car env))
+ (bfr-list->u id (car env))))))
:hints(("Goal" :in-theory (enable ;general-concretep-def
general-numberp
general-concrete-obj
diff -Nru acl2-6.2/books/centaur/gl/general-objects.lisp acl2-6.3/books/centaur/gl/general-objects.lisp
--- acl2-6.2/books/centaur/gl/general-objects.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/general-objects.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,7 +1,24 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "gtypes")
diff -Nru acl2-6.2/books/centaur/gl/generic-geval.lisp acl2-6.3/books/centaur/gl/generic-geval.lisp
--- acl2-6.2/books/centaur/gl/generic-geval.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/generic-geval.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,13 +1,28 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "gobjectp")
(include-book "bvecs")
(include-book "tools/bstar" :dir :system)
(include-book "tools/templates" :dir :system)
-;; (include-book "defapply")
-;; (include-book "defapply-proofs")
(include-book "cutil/defmvtypes" :dir :system)
(include-book "../misc/defapply")
@@ -42,12 +57,16 @@
(mv (car x) (cdr x))
(mv nil nil)))
(imag-denom (if (consp x) (car x) '(t))))
- (mv (rlist-fix real-numer)
- (rlist-fix real-denom)
- (rlist-fix imag-numer)
- (rlist-fix imag-denom))))
+ ;; (mv (rlist-fix real-numer)
+ ;; (rlist-fix real-denom)
+ ;; (rlist-fix imag-numer)
+ ;; (rlist-fix imag-denom))
+ (mv real-numer
+ real-denom
+ imag-numer
+ imag-denom)))
-(acl2::defmvtypes break-g-number (true-listp true-listp true-listp true-listp))
+;; (acl2::defmvtypes break-g-number (true-listp true-listp true-listp true-listp))
@@ -126,138 +145,198 @@
(implies (symbol-alistp x)
(eqlable-alistp x)))
+(mutual-recursion
+ (defun gobj->term (x env)
+ (declare (xargs :guard (consp env)
+ :measure (acl2-count x)
+ :hints (("goal" :in-theory '(measure-for-geval atom)))))
+ (if (atom x)
+ (kwote x)
+ (pattern-match x
+ ((g-concrete obj) (kwote obj))
+
+ ((g-boolean bool) (kwote (bfr-eval bool (car env))))
+
+ ((g-number num)
+ (b* (((mv real-num
+ real-denom
+ imag-num
+ imag-denom)
+ (break-g-number num)))
+ (flet ((uval (n env)
+ (bfr-list->u n (car env)))
+ (sval (n env)
+ (bfr-list->s n (car env))))
+ (kwote
+ (components-to-number (sval real-num env)
+ (uval real-denom env)
+ (sval imag-num env)
+ (uval imag-denom env))))))
+
+ ((g-ite test then else)
+ (list 'if
+ (gobj->term test env)
+ (gobj->term then env)
+ (gobj->term else env)))
+
+ ((g-var name) (kwote (cdr (hons-get name (cdr env)))))
+
+ ((g-apply fn args)
+ (and (not (eq fn 'quote))
+ (cons fn (gobj-list->terms args env))))
+
+ (& ;; cons
+ (list 'cons
+ (gobj->term (car x) env)
+ (gobj->term (cdr x) env))))))
+
+ (defun gobj-list->terms (x env)
+ (declare (xargs :guard (consp env)
+ :measure (acl2-count x)))
+ (if (atom x)
+ nil
+ (cons (gobj->term (car x) env)
+ (gobj-list->terms (cdr x) env)))))
+
+(mutual-recursion
+ (defun gobj-ind (x env)
+ (declare (xargs :guard (consp env)
+ :measure (acl2-count x)
+ :hints (("goal" :in-theory '(measure-for-geval atom)))))
+ (if (atom x)
+ (kwote x)
+ (pattern-match x
+ ((g-concrete obj) (kwote obj))
+
+ ((g-boolean bool) (kwote (bfr-eval bool (car env))))
+
+ ((g-number num)
+ (b* (((mv real-num
+ real-denom
+ imag-num
+ imag-denom)
+ (break-g-number num)))
+ (flet ((uval (n env)
+ (bfr-list->u n (car env)))
+ (sval (n env)
+ (bfr-list->s n (car env))))
+ (kwote
+ (components-to-number (sval real-num env)
+ (uval real-denom env)
+ (sval imag-num env)
+ (uval imag-denom env))))))
+
+ ((g-ite test then else)
+ (list 'if
+ (gobj-ind test env)
+ (gobj-ind then env)
+ (gobj-ind else env)))
+
+ ((g-var name) (kwote (cdr (hons-get name (cdr env)))))
+
+ ((g-apply fn args)
+ (cons fn (gobj-list-ind args env)))
+
+ (& ;; cons
+ (list 'cons
+ (gobj-ind (car x) env)
+ (gobj-ind (cdr x) env))))))
+
+ (defun gobj-list-ind (x env)
+ (declare (xargs :guard (consp env)
+ :measure (acl2-count x)))
+ (if (atom x)
+ nil
+ (cons (gobj-ind (car x) env)
+ (gobj-list-ind (cdr x) env)))))
+
+
+(flag::make-flag gobj-flag gobj-ind
+ :flag-mapping ((gobj-ind . gobj)
+ (gobj-list-ind . list)))
+
+(in-theory (disable gobj-ind gobj-list-ind))
(defconst *geval-template*
'(progn
(acl2::defapply/ev/concrete-ev _geval_ _apply-fns_)
;; (defapply _geval_-apply _apply-fns_)
- (defun _geval_ (x env)
- (declare (xargs :guard (consp env)
- :measure (acl2-count x)
- :verify-guards nil
- :hints (("goal" :in-theory '(measure-for-geval atom)))))
- (if (atom x)
- ;; Every atom represents itself.
- x
- (pattern-match x
-
- ;; A Concrete is like an escape sequence; we take (cdr x) as a concrete
- ;; object even if it looks symbolic.
- ((g-concrete obj) obj)
-
- ;; Boolean
- ((g-boolean bool) (bfr-eval bool (car env)))
-
- ;; Number. This is the hairy case. Can represent all ACL2-NUMBERPs,
- ;; but naturals are more compact than integers, which are more compact
- ;; than rationals, which are more compact than complexes. Denominators
- ;; are coerced to 1 if they evaluate to 0 -- ugly.
- ((g-number num)
- (b* (((mv real-num
- real-denom
- imag-num
- imag-denom)
- (break-g-number num)))
- (flet ((uval (n env)
- (v2n (bfr-eval-list n (car env))))
- (sval (n env)
- (v2i (bfr-eval-list n (car env)))))
- (components-to-number (sval real-num env)
- (uval real-denom env)
- (sval imag-num env)
- (uval imag-denom env)))))
-
- ;; If-then-else.
- ((g-ite test then else)
- (if (_geval_ test env)
- (_geval_ then env)
- (_geval_ else env)))
-
- ;; Apply: Unevaluated function call.
- ((g-apply fn args)
- (let* ((args (_geval_ args env)))
- (mbe :logic (_geval_-ev (cons fn (kwote-lst args)) nil)
- :exec (b* ((args (acl2::list-fix args))
- ((mv ok val) (_geval_-apply fn args))
- ((when ok) val))
- (_geval_-ev (cons fn (kwote-lst args))
- nil)))))
-
- ;; Var: untyped variable.
- ((g-var name) (cdr (het name (cdr env))))
-
- ;; Conses where the car is not a recognized flag represent conses.
- (& (cons (_geval_ (car x) env)
- (_geval_ (cdr x) env))))))
-
- (defun _geval_-appalist (x env appal)
- (declare (xargs :guard (and (consp env) (symbol-alistp appal))
- :measure (acl2-count x)
- :guard-hints (("goal" :in-theory
- '((:type-prescription v2i)
- (alistp)
- (:type-prescription v2n)
- (:type-prescription hons-assoc-equal)
- hons-get
- acl2::true-listp-of-list-fix
- acl2::assoc-eql-exec-is-assoc-equal
- eqlablep-compound-recognizer
- consp-assoc-equal-of-cons
- symbol-alistp-implies-eqlable-alistp)))
- :hints (("goal" :in-theory '(measure-for-geval atom)))))
- (if (atom x)
- ;; Every atom represents itself.
- x
- (pattern-match x
-
- ;; A Concrete is like an escape sequence; we take (cdr x) as a concrete
- ;; object even if it looks symbolic.
- ((g-concrete obj) obj)
-
- ;; Boolean
- ((g-boolean bool) (bfr-eval bool (car env)))
-
- ;; Number. This is the hairy case. Can represent all ACL2-NUMBERPs,
- ;; but naturals are more compact than integers, which are more compact
- ;; than rationals, which are more compact than complexes. Denominators
- ;; are coerced to 1 if they evaluate to 0 -- ugly.
- ((g-number num)
- (b* (((mv real-num
- real-denom
- imag-num
- imag-denom)
- (break-g-number num)))
- (flet ((uval (n env)
- (v2n (bfr-eval-list n (car env))))
- (sval (n env)
- (v2i (bfr-eval-list n (car env)))))
- (components-to-number (sval real-num env)
- (uval real-denom env)
- (sval imag-num env)
- (uval imag-denom env)))))
-
- ;; If-then-else.
- ((g-ite test then else)
- (if (_geval_-appalist test env appal)
- (_geval_-appalist then env appal)
- (_geval_-appalist else env appal)))
-
- ;; Apply: Unevaluated function call.
- ((g-apply fn args)
- (let* ((args (_geval_-appalist args env appal)))
- (ec-call (_geval_-ev-concrete (cons fn (kwote-lst (acl2::list-fix args))) nil appal))))
-
- ;; Var: untyped variable.
- ((g-var name) (cdr (het name (cdr env))))
-
- ;; Conses where the car is not a recognized flag represent conses.
- (& (cons (_geval_-appalist (car x) env appal)
- (_geval_-appalist (cdr x) env appal))))))
-
- (table eval-g-table '_geval_ '(_geval_-appalist
+ (mutual-recursion
+ (defun _geval_ (x env)
+ (declare (xargs :guard (consp env)
+ :measure (acl2-count x)
+ :verify-guards nil
+ :hints (("goal" :in-theory '(measure-for-geval atom)))))
+ (if (atom x)
+ ;; Every atom represents itself.
+ x
+ (pattern-match x
+
+ ;; A Concrete is like an escape sequence; we take (cdr x) as a concrete
+ ;; object even if it looks symbolic.
+ ((g-concrete obj) obj)
+
+ ;; Boolean
+ ((g-boolean bool) (bfr-eval bool (car env)))
+
+ ;; Number. This is the hairy case. Can represent all ACL2-NUMBERPs,
+ ;; but naturals are more compact than integers, which are more compact
+ ;; than rationals, which are more compact than complexes. Denominators
+ ;; are coerced to 1 if they evaluate to 0 -- ugly.
+ ((g-number num)
+ (b* (((mv real-num
+ real-denom
+ imag-num
+ imag-denom)
+ (break-g-number num)))
+ (flet ((uval (n env)
+ (bfr-list->u n (car env)))
+ (sval (n env)
+ (bfr-list->s n (car env))))
+ (components-to-number (sval real-num env)
+ (uval real-denom env)
+ (sval imag-num env)
+ (uval imag-denom env)))))
+
+ ;; If-then-else.
+ ((g-ite test then else)
+ (if (_geval_ test env)
+ (_geval_ then env)
+ (_geval_ else env)))
+
+ ;; Apply: Unevaluated function call.
+ ((g-apply fn args)
+ (and (not (eq fn 'quote))
+ (let* ((args (_geval_-list args env)))
+ (mbe :logic (_geval_-ev (cons fn (kwote-lst args)) nil)
+ :exec (b* ((args (acl2::list-fix args))
+ ((mv ok val) (_geval_-apply fn args))
+ ((when ok) val))
+ (_geval_-ev (cons fn (kwote-lst args))
+ nil))))))
+
+ ;; Var: untyped variable.
+ ((g-var name) (cdr (het name (cdr env))))
+
+ ;; Conses where the car is not a recognized flag represent conses.
+ (& (cons (_geval_ (car x) env)
+ (_geval_ (cdr x) env))))))
+
+ (defun _geval_-list (x env)
+ (declare (xargs :guard (consp env)
+ :measure (acl2-count x)))
+ (if (atom x)
+ nil
+ (cons (_geval_ (car x) env)
+ (_geval_-list (cdr x) env)))))
+
+ (in-theory (disable _geval_ _geval_-list))
+
+ (table eval-g-table '_geval_ '(_geval_-list
_geval_-ev
_geval_-ev-lst
+ _geval_-apply
_geval_-ev-concrete
_geval_-ev-concrete-lst
. _apply-fns_))))
@@ -276,7 +355,9 @@
(def-geval-fn geval fns))
-(def-geval generic-geval nil)
+(def-geval base-geval nil)
+
+
;; (defthm generic-geval-apply-ev-lst-of-kwote-lst
;; (equal (generic-geval-apply-ev-lst (kwote-lst x) a)
@@ -384,51 +465,51 @@
;; :do-not-induct t))
;; :rule-classes nil
;; :otf-flg t)
-
-
-(local (defthm generic-geval-appalist-is-instance-of-generic-geval
- t
- :hints (("goal" :use ((:functional-instance
- generic-geval
- (generic-geval
- (lambda (x env)
- (generic-geval-appalist x env appalist)))
- (generic-geval-ev
- (lambda (x a)
- (generic-geval-ev-concrete x a appalist)))
- (generic-geval-ev-lst
- (lambda (x a)
- (generic-geval-ev-concrete-lst
- x a appalist)))))
- ;; '(generic-geval-apply-ev-lst-of-atom
- ;; generic-geval-apply-ev-substitution)
- ;; :in-theory '(generic-geval-apply
- ;; generic-geval-apply-arities
- ;; member-equal
- ;; generic-geval-appalist)
- :do-not-induct t)
- ;; (and stable-under-simplificationp
- ;; '(:in-theory (enable
- ;; generic-geval-apply-ev-of-fncall-args)
- ;; :expand ((:free (a)
- ;; (generic-geval-apply-ev-substitution
- ;; x a appalist))
- ;; (:free (x y a)
- ;; (generic-geval-apply-ev-substitution
- ;; (cons x y) a appalist)))))
- ;; (and stable-under-simplificationp
- ;; '(:in-theory (enable
- ;; generic-geval-apply-ev-substitution
- ;; generic-geval-apply-ev-of-fncall-args)))
- ;; (and stable-under-simplificationp
- ;; '(:expand ((generic-geval-ev-concrete-lst
- ;; acl2::x-lst a appalist)
- ;; (generic-geval-apply-ev-substitution
- ;; x a appalist))))
- )
- :rule-classes nil
- :otf-flg t))
+
+
+;; (local (defthm generic-geval-appalist-is-instance-of-generic-geval
+;; t
+;; :hints (("goal" :use ((:functional-instance
+;; generic-geval
+;; (generic-geval
+;; (lambda (x env)
+;; (generic-geval-appalist x env appalist)))
+;; (generic-geval-ev
+;; (lambda (x a)
+;; (generic-geval-ev-concrete x a appalist)))
+;; (generic-geval-ev-lst
+;; (lambda (x a)
+;; (generic-geval-ev-concrete-lst
+;; x a appalist)))))
+;; ;; '(generic-geval-apply-ev-lst-of-atom
+;; ;; generic-geval-apply-ev-substitution)
+;; ;; :in-theory '(generic-geval-apply
+;; ;; generic-geval-apply-arities
+;; ;; member-equal
+;; ;; generic-geval-appalist)
+;; :do-not-induct t)
+;; ;; (and stable-under-simplificationp
+;; ;; '(:in-theory (enable
+;; ;; generic-geval-apply-ev-of-fncall-args)
+;; ;; :expand ((:free (a)
+;; ;; (generic-geval-apply-ev-substitution
+;; ;; x a appalist))
+;; ;; (:free (x y a)
+;; ;; (generic-geval-apply-ev-substitution
+;; ;; (cons x y) a appalist)))))
+;; ;; (and stable-under-simplificationp
+;; ;; '(:in-theory (enable
+;; ;; generic-geval-apply-ev-substitution
+;; ;; generic-geval-apply-ev-of-fncall-args)))
+;; ;; (and stable-under-simplificationp
+;; ;; '(:expand ((generic-geval-ev-concrete-lst
+;; ;; acl2::x-lst a appalist)
+;; ;; (generic-geval-apply-ev-substitution
+;; ;; x a appalist))))
+;; )
+;; :rule-classes nil
+;; :otf-flg t))
(defun get-guard-verification-theorem (name state)
(declare (xargs :mode :program
@@ -447,44 +528,46 @@
(make-event
(b* (((er thm) (get-guard-verification-theorem
- 'generic-geval state)))
- (value `(defthm generic-geval-guards-ok
+ 'base-geval state)))
+ (value `(defthm base-geval-guards-ok
,thm
:hints (("goal" :do-not-induct t))
:rule-classes nil))))
;; (prove-congruences (gobj-equiv) generic-geval)
-(defconst *geval-appalist-func-inst-template*
- '(:computed-hint-replacement
- ((and stable-under-simplificationp
- '(:expand ((:free (f ar)
- (_geval_-apply f ar))))))
- :use
- ((:functional-instance
- _theorem_
- (_geval_ (lambda (x env)
- (_geval_-appalist x env appalist)))
- (_geval_-ev (lambda (x a)
- (_geval_-ev-concrete x a appalist)))
- (_geval_-ev-lst
- (lambda (x a)
- (_geval_-ev-concrete-lst x a appalist)))))
- :in-theory '(nth-of-_geval_-ev-concrete-lst
- acl2::car-to-nth-meta-correct
- acl2::nth-of-cdr
- _geval_-ev-concrete-lst-of-kwote-lst
- acl2::list-fix-when-true-listp
- acl2::kwote-list-list-fix
- (:t _geval_-ev-concrete-lst)
- (:t acl2::list-fix)
- car-cons cdr-cons nth-0-cons (nfix))
- :expand ((_geval_-ev-concrete x a appalist)
- (:free (f ar)
- (_geval_-ev-concrete (cons f ar) nil appalist))
- (_geval_-ev-concrete-lst acl2::x-lst a appalist)
- (_geval_-appalist x env appalist))
- :do-not-induct t))
+;; (defconst *geval-appalist-func-inst-template*
+;; '(:computed-hint-replacement
+;; ((and stable-under-simplificationp
+;; '(:expand ((:free (f ar)
+;; (_geval_-apply f ar))
+;; (:free (x) (hide x))))))
+;; :use
+;; ((:functional-instance
+;; _theorem_
+;; (_geval_ (lambda (x env)
+;; (_geval_-appalist x env appalist)))
+;; (_geval_-ev (lambda (x a)
+;; (_geval_-ev-concrete x a appalist)))
+;; (_geval_-ev-lst
+;; (lambda (x a)
+;; (_geval_-ev-concrete-lst x a appalist)))))
+;; :in-theory '(nth-of-_geval_-ev-concrete-lst
+;; acl2::car-to-nth-meta-correct
+;; acl2::nth-of-cdr
+;; _geval_-ev-concrete-lst-of-kwote-lst
+;; acl2::list-fix-when-true-listp
+;; acl2::kwote-list-list-fix
+;; (:t _geval_-ev-concrete-lst)
+;; (:t acl2::list-fix)
+;; car-cons cdr-cons nth-0-cons (nfix))
+;; :expand ((_geval_-ev-concrete x a appalist)
+;; (:free (f ar)
+;; (_geval_-ev-concrete (cons f ar) nil appalist))
+;; (:free (x) (hide x))
+;; (_geval_-ev-concrete-lst acl2::x-lst a appalist)
+;; (_geval_-appalist x env appalist))
+;; :do-not-induct t))
;; (:use ((:functional-instance
@@ -536,14 +619,14 @@
;; :in-theory nil
;; :do-not '(preprocess simplify)))
-(defun geval-appalist-functional-inst-hint (thm geval)
- (declare (xargs :mode :program))
- (acl2::template-subst
- *geval-appalist-func-inst-template*
- :atom-alist `((_geval_ . ,geval)
- (_theorem_ . ,thm))
- :str-alist `(("_GEVAL_" . ,(symbol-name geval)))
- :pkg-sym geval))
+;; (defun geval-appalist-functional-inst-hint (thm geval)
+;; (declare (xargs :mode :program))
+;; (acl2::template-subst
+;; *geval-appalist-func-inst-template*
+;; :atom-alist `((_geval_ . ,geval)
+;; (_theorem_ . ,thm))
+;; :str-alist `(("_GEVAL_" . ,(symbol-name geval)))
+;; :pkg-sym geval))
(defconst *def-eval-g-template*
@@ -566,20 +649,24 @@
(def-geval _geval_ _apply-fns_)
(verify-guards _geval_
:hints (("goal" :use ((:functional-instance
- generic-geval-guards-ok
- (generic-geval _geval_)
- (generic-geval-ev _geval_-ev)
- (generic-geval-ev-lst _geval_-ev-lst)))
- :in-theory (e/d* (_geval_-ev-constraint-0
+ base-geval-guards-ok
+ (base-geval _geval_)
+ (base-geval-list _geval_-list)
+ (base-geval-ev _geval_-ev)
+ (base-geval-ev-lst _geval_-ev-lst)))
+ :in-theory (e/d* (_geval_-ev-of-fncall-args
_geval_-apply-agrees-with-_geval_-ev
eq atom
- generic-geval-apply)
+ _geval_
+ _geval_-list
+ base-geval-apply)
(_geval_-apply))))
:otf-flg t)
- (local (defthm _geval_-appalist-is-instance-of-_geval_
- t
- :hints ((geval-appalist-functional-inst-hint '_geval_ '_geval_))
- :rule-classes nil))))
+ ;; (local (defthm _geval_-appalist-is-instance-of-_geval_
+ ;; t
+ ;; :hints ((geval-appalist-functional-inst-hint '_geval_ '_geval_))
+ ;; :rule-classes nil))
+ ))
(defmacro def-eval-g (geval fns)
(acl2::template-subst
@@ -589,6 +676,30 @@
:str-alist `(("_GEVAL_" . ,(symbol-name geval)))
:pkg-sym geval))
+(def-eval-g generic-geval (cons if))
+
+(defthm-gobj-flag
+ (defthm generic-geval-is-generic-geval-ev-of-gobj->term
+ (equal (generic-geval-ev (gobj->term x env) a)
+ (generic-geval x env))
+ :hints('(:in-theory (enable generic-geval-ev-of-fncall-args
+ generic-geval gobj->term)
+ :expand ((gobj->term x env)))
+ (and stable-under-simplificationp
+ '(:cases ((eq (g-apply->fn x) 'quote))
+ :expand ((gobj-list->terms (g-apply->args x) env)))))
+ :flag gobj)
+ (defthm generic-geval-list-is-generic-geval-ev-lst-of-gobj-list->terms
+ (equal (generic-geval-ev-lst (gobj-list->terms x env) a)
+ (generic-geval-list x env))
+ :hints ('(:expand ((generic-geval-list x env)
+ (gobj-list->terms x env))))
+ :flag list))
+
+
+
+
+
(local
;; test
(def-eval-g implies-geval
@@ -633,7 +744,7 @@
(local
;; test
(def-eval-g little-geval
- (BINARY-*
+ (BINARY-* if cons
BINARY-+
PKG-WITNESS
; UNARY-/
diff -Nru acl2-6.2/books/centaur/gl/gify-clause-proc.lisp acl2-6.3/books/centaur/gl/gify-clause-proc.lisp
--- acl2-6.2/books/centaur/gl/gify-clause-proc.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gify-clause-proc.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,13 +1,36 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "g-if")
(include-book "clause-processors/unify-subst" :dir :system)
-(local (include-book "tools/def-functional-instance" :dir :system))
(include-book "tools/defevaluator-fast" :dir :system)
-
+(local (include-book "tools/def-functional-instance" :dir :system))
+(local (include-book "hyp-fix-logic"))
(local (defun dummy-for-g-if-ev-start () nil))
+(defun-nx gobj-depends-on-g-if (n p x)
+ (gobj-depends-on n p (g-if-marker x)))
+
+(defun-nx gobj-depends-on-g-or (n p x)
+ (gobj-depends-on n p (g-or-marker x)))
(acl2::defevaluator-fast g-if-ev g-if-ev-lst
((g-if-marker$inline x)
@@ -32,11 +55,16 @@
(mk-g-boolean bdd)
(cons a b)
(binary-+ a b)
-; (generic-geval x env)
+ ; (generic-geval x env)
(hide x)
(bfr-eval x env)
+ (pbfr-depends-on n p x)
+ (gobj-depends-on n p x)
+ (gobj-depends-on-g-if n p x)
+ (gobj-depends-on-g-or n p x)
(car x)
- (equal x y))
+ (equal x y)
+ (force x))
:namedp t)
(local (encapsulate nil
@@ -226,6 +254,156 @@
(local (include-book "gtype-thms"))
+
+
+(make-event
+ `(defthm gobj-depends-on-of-g-if-pattern
+ (implies (and (not (gobj-depends-on n p test-term))
+ (not (gobj-depends-on n p then-term))
+ (not (gobj-depends-on n p else-term)))
+ (not (gobj-depends-on-g-if n p ,(cadr *g-if-pattern*))))
+ :hints (("goal" :expand ((:free (x) (hide x)))
+ :in-theory (enable g-if-marker
+ g-test-marker
+ g-branch-marker
+ mk-g-bdd-ite)))))
+
+(defthm gobj-depends-on-of-g-if-marker
+ (equal (gobj-depends-on n p (g-if-marker x))
+ (gobj-depends-on-g-if n p x)))
+
+(in-theory (disable gobj-depends-on-g-if))
+
+
+(make-event
+ `(defthm gobj-depends-on-of-g-or-pattern
+ (implies (and (not (gobj-depends-on n p test-term))
+ (not (gobj-depends-on n p else-term)))
+ (not (gobj-depends-on-g-or n p ,(cadr *g-or-pattern*))))
+ :hints (("goal" :expand ((:free (x) (hide x)))
+ :in-theory (enable g-or-marker
+ g-test-marker
+ g-branch-marker
+ mk-g-bdd-ite)))))
+
+(defthm gobj-depends-on-of-g-or-marker
+ (equal (gobj-depends-on n p (g-or-marker x))
+ (gobj-depends-on-g-or n p x)))
+
+(in-theory (disable gobj-depends-on-g-or))
+
+
+
+(defun simp-if-term (x)
+ (beta-reduce-to-fns
+ (remove-return-lasts x)
+ '(g-test-marker$inline g-branch-marker$inline g-hyp-marker$inline)))
+
+(defthm simp-if-term-correct
+ (implies (pseudo-termp x)
+ (equal (g-if-ev (simp-if-term x) a)
+ (g-if-ev x a))))
+
+(defthm pseudo-termp-of-simp-if-term
+ (implies (pseudo-termp x)
+ (pseudo-termp (simp-if-term x))))
+
+(local (in-theory (disable simp-if-term)))
+
+(local (defthm pseudo-termp-fourth
+ (implies (pseudo-termp x)
+ (pseudo-termp (fourth x)))))
+
+
+(defun gobj-depends-on-g-or-hyp (x)
+ (b* (((unless (and (consp x) (eq (car x) 'gobj-depends-on-g-or)))
+ ''nil)
+ (n-term (second x))
+ (p-term (third x))
+ (x-term (fourth x))
+ (x-simp (simp-if-term x-term))
+ ((mv match alist) (acl2::simple-one-way-unify (cadr *g-or-pattern*)
+ x-simp nil))
+ ((unless match) ''nil))
+ `(if (force (not (gobj-depends-on ,n-term ,p-term ,(cdr (assoc 'test-term alist)))))
+ (force (not (gobj-depends-on ,n-term ,p-term ,(cdr (assoc 'else-term alist)))))
+ 'nil)))
+
+(defun gobj-depends-on-g-or-res (x)
+ (declare (ignore x))
+ ''nil)
+
+(defthm gobj-depends-on-g-or-meta
+ (implies (and (pseudo-termp x)
+ (g-if-ev (gobj-depends-on-g-or-hyp x) a))
+ (equal (g-if-ev x a)
+ (g-if-ev (gobj-depends-on-g-or-res x) a)))
+ :hints(("Goal" :in-theory (e/d (g-if-ev-of-fncall-args)
+ (gobj-depends-on
+ assoc-equal
+ gobj-depends-on-of-g-or-pattern)))
+ (let* ((unify '(mv-nth 1 (acl2::simple-one-way-unify
+ (cadr *g-or-pattern*)
+ (simp-if-term (cadddr x))
+ nil))))
+ `(:use ((:instance gobj-depends-on-of-g-or-pattern
+ (n (g-if-ev (cadr x) a))
+ (p (g-if-ev (caddr x) a))
+ (test-term (g-if-ev (cdr (assoc 'test-term ,unify)) a))
+ (else-term (g-if-ev (cdr (assoc 'else-term ,unify)) a))
+ (hyp (g-if-ev (cdr (assoc 'hyp ,unify)) a))))))
+ (and stable-under-simplificationp
+ '(:expand ((:free (x) (hide x))))))
+ :rule-classes ((:meta :trigger-fns (gobj-depends-on-g-or))))
+
+
+(defun gobj-depends-on-g-if-hyp (x)
+ (b* (((unless (and (consp x) (eq (car x) 'gobj-depends-on-g-if)))
+ ''nil)
+ (n-term (second x))
+ (p-term (third x))
+ (x-term (fourth x))
+ (x-simp (simp-if-term x-term))
+ ((mv match alist) (acl2::simple-one-way-unify (cadr *g-if-pattern*)
+ x-simp nil))
+ ((unless match) ''nil))
+ `(if (force (not (gobj-depends-on ,n-term ,p-term ,(cdr (assoc 'test-term alist)))))
+ (if (force (not (gobj-depends-on ,n-term ,p-term ,(cdr (assoc 'then-term alist)))))
+ (force (not (gobj-depends-on ,n-term ,p-term ,(cdr (assoc 'else-term alist)))))
+ 'nil)
+ 'nil)))
+
+(defun gobj-depends-on-g-if-res (x)
+ (declare (ignore x))
+ ''nil)
+
+(defthm gobj-depends-on-g-if-meta
+ (implies (and (pseudo-termp x)
+ (g-if-ev (gobj-depends-on-g-if-hyp x) a))
+ (equal (g-if-ev x a)
+ (g-if-ev (gobj-depends-on-g-if-res x) a)))
+ :hints(("Goal" :in-theory (e/d (g-if-ev-of-fncall-args)
+ (gobj-depends-on
+ assoc-equal
+ gobj-depends-on-of-g-if-pattern)))
+ (let* ((unify '(mv-nth 1 (acl2::simple-one-way-unify
+ (cadr *g-if-pattern*)
+ (simp-if-term (cadddr x))
+ nil))))
+ `(:use ((:instance gobj-depends-on-of-g-if-pattern
+ (n (g-if-ev (cadr x) a))
+ (p (g-if-ev (caddr x) a))
+ (test-term (g-if-ev (cdr (assoc 'test-term ,unify)) a))
+ (then-term (g-if-ev (cdr (assoc 'then-term ,unify)) a))
+ (else-term (g-if-ev (cdr (assoc 'else-term ,unify)) a))
+ (hyp (g-if-ev (cdr (assoc 'hyp ,unify)) a))))))
+ (and stable-under-simplificationp
+ '(:expand ((:free (x) (hide x))))))
+ :rule-classes ((:meta :trigger-fns (gobj-depends-on-g-if))))
+
+
+
+
(encapsulate
(((geval-for-meta * *) => *))
(local (defun geval-for-meta (x env)
@@ -271,7 +449,7 @@
(geval-for-meta x b)
(geval-for-meta y b)))))
-
+
@@ -289,7 +467,7 @@
(local (add-bfr-pat (bfr-fix . &)))
(local (in-theory (disable bfr-eval-booleanp
equal-of-booleans-rewrite)))
-
+
(defthm geval-for-meta-mk-g-bdd-ite-correct
@@ -298,9 +476,11 @@
(if (bfr-eval bdd (car env))
(geval-for-meta then env)
(geval-for-meta else env))))
- :hints(("Goal" :in-theory (enable true-under-hyp
- false-under-hyp
- mk-g-bdd-ite)
+ :hints(("Goal" :in-theory (e/d (mk-g-bdd-ite
+ hyp-ops-correct)
+ (hyp-fix
+ true-under-hyp
+ false-under-hyp))
:do-not-induct t)
(bfr-reasoning)))
@@ -487,7 +667,7 @@
;; :do-not-induct t)))))
;; (in-theory (disable g-or-gobjectp-extract))
-
+
;; (defun g-or-gobjectp-meta-hyp (x)
;; (b* (((mv ok term) (g-or-gobjectp-extract x 'extract))
@@ -556,7 +736,7 @@
;; :do-not-induct t)))))
;; (in-theory (disable g-if-gobjectp-extract))
-
+
;; (defun g-if-gobjectp-meta-hyp (x)
;; (b* (((mv ok term) (g-if-gobjectp-extract x 'extract))
@@ -617,7 +797,12 @@
(bfr-eval x env)
(car x)
(equal x y)
- (geval x env))
+ (geval x env)
+ (force x)
+ (pbfr-depends-on n p x)
+ (gobj-depends-on n p x)
+ (gobj-depends-on-g-if n p x)
+ (gobj-depends-on-g-or n p x))
:namedp t)
(local (def-ruleset! g-if-or-meta-evaluator-constraints
@@ -674,7 +859,7 @@
(geval-for-meta geval)
(g-if-ev eval)
(g-if-ev-lst eval-lst))))))
-
+
(local
(defthm geval-of-g-or-term-subst
@@ -760,7 +945,7 @@
(defun g-or-geval-meta-subterms-wrapper (x)
(declare (xargs :guard t))
(ec-call (g-or-geval-meta-subterms x 'subterms)))
-
+
(defthm g-or-geval-meta-subterms-correct
(mv-let (ok hyp test else env)
@@ -780,7 +965,7 @@
(in-theory (disable g-or-geval-meta-subterms))
(memoize 'g-or-geval-meta-subterms-wrapper :condition nil)
-
+
(defun g-or-geval-meta-hyp (x)
(b* (((mv ok hyp & & env)
(g-or-geval-meta-subterms-wrapper x))
@@ -854,7 +1039,7 @@
:do-not-induct t)))))
(in-theory (disable g-if-geval-extract))
-
+
(defun g-if-geval-meta-subterms (x dummy)
(declare (ignore dummy))
@@ -875,7 +1060,7 @@
(defun g-if-geval-meta-subterms-wrapper (x)
(declare (xargs :guard t))
(ec-call (g-if-geval-meta-subterms x 'subterms)))
-
+
(defthm g-if-geval-meta-subterms-correct
(mv-let (ok hyp test then else env)
@@ -897,7 +1082,7 @@
(in-theory (disable g-if-geval-meta-subterms))
(memoize 'g-if-geval-meta-subterms-wrapper :condition nil)
-
+
(defun g-if-geval-meta-hyp (x)
(b* (((mv ok hyp & & & env)
(g-if-geval-meta-subterms-wrapper x))
@@ -1000,7 +1185,7 @@
;; test.
(local (def-geval-meta generic-geval generic-gify-ev generic-gify-ev-lst))
-
+
@@ -1106,10 +1291,10 @@
;; (mv erp (cons x gobj-assms) gnorm-assms obligs)))
;; (mv "bad or" gobj-assms gnorm-assms obligs))))
;; (&
-
-
-
-
+
+
+
+
diff -Nru acl2-6.2/books/centaur/gl/gify-thms.lisp acl2-6.3/books/centaur/gl/gify-thms.lisp
--- acl2-6.2/books/centaur/gl/gify-thms.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gify-thms.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,14 +1,31 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "gify-clause-proc")
-
+(include-book "std/misc/two-nats-measure" :dir :system)
(local (include-book "gtype-thms"))
(local (include-book "gobjectp-thms"))
(local (include-book "general-object-thms"))
(local (include-book "hyp-fix-logic"))
-(include-book "std/misc/two-nats-measure" :dir :system)
+
;; These events are included here redundantly to avoid having to include all
;; the above (locally-included) books everywhere we want a GL clause processor.
@@ -68,6 +85,26 @@
(cons (generic-geval x env)
(generic-geval y env))))
+(defthm generic-geval-list-gl-cons
+ (equal (generic-geval-list (gl-cons x y) env)
+ (cons (generic-geval x env)
+ (generic-geval-list y env)))
+ :hints(("Goal" :expand ((:free (x) (generic-geval-list (cons x y) env))))))
+
+(defthm generic-geval-list-atom
+ (implies (not (consp x))
+ (equal (generic-geval-list x env) nil))
+ :hints(("Goal" :expand ((generic-geval-list x env))))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+(defthm generic-geval-g-apply
+ (implies (not (equal fn 'quote))
+ (equal (generic-geval (g-apply fn args) env)
+ (generic-geval-ev (cons fn (kwote-lst (generic-geval-list args env)))
+ nil)))
+ :hints (("goal" :expand ((generic-geval (g-apply fn args) env))
+ :in-theory (enable generic-geval-apply))))
+
(defthm generic-geval-nil
(equal (generic-geval nil env) nil))
@@ -76,10 +113,11 @@
(equal (generic-geval x env) x))
:rule-classes ((:rewrite :backchain-limit-lst 0)))
-(defthm generic-geval-g-apply
- (equal (generic-geval (g-apply fn args) env)
- (generic-geval-ev (cons fn (kwote-lst (generic-geval args env)))
- nil)))
+;; (defthm generic-geval-g-apply
+;; (implies (not (eq fn 'quote))
+;; (equal (generic-geval (g-apply fn args) env)
+;; (generic-geval-ev (cons fn (kwote-lst (generic-geval-list args env)))
+;; nil))))
;; (defthm generic-geval-gobj-fix
;; (equal (generic-geval (gobj-fix x) env)
@@ -120,7 +158,7 @@
;; (add-to-ruleset! g-gobjectp-lemmas '(g-if-gobjectp-meta-correct
;; gobjectp-g-if-marker
;; g-or-gobjectp-meta-correct
-;; gobjectp-g-or-marker
+;; gobjectp-g-or-marker
;; gobjectp-g-apply
;; gobjectp-gobj-fix
;; gobjectp-g-test-marker
@@ -146,6 +184,8 @@
'(generic-geval-gl-cons
generic-geval-nil
generic-geval-g-apply
+ generic-geval-list-gl-cons
+ generic-geval-list-atom
mk-g-ite-correct
mk-g-boolean-correct
mk-g-concrete-correct
@@ -169,7 +209,11 @@
bfr-and-of-nil
bfr-or-of-t
(g-keyword-symbolp)
- gl-aside gl-error-is-nil))
+ gl-aside gl-error-is-nil
+ gobj-depends-on-of-g-if-marker
+ gobj-depends-on-of-g-or-marker
+ gobj-depends-on-g-if-meta
+ gobj-depends-on-g-or-meta))
;; (defthm bfr-fix-x-is-x-when-bfr-p
;; (implies (bfr-p x)
diff -Nru acl2-6.2/books/centaur/gl/gify.lisp acl2-6.3/books/centaur/gl/gify.lisp
--- acl2-6.2/books/centaur/gl/gify.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gify.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,7 +1,24 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "tools/bstar" :dir :system)
(include-book "defapply")
(include-book "misc/hons-help" :dir :system)
@@ -30,7 +47,7 @@
acc
(collect-fns-lst (cdr lst) clique
(collect-fns (car lst) clique acc)))))
-
+
(defun clique-bodies (clique world)
(if (atom clique)
@@ -101,13 +118,13 @@
(else (gify-term (cadddr x) fn)))
`(g-if ,test ,then ,else))))
((consp (car x))
- (er hard 'gify-term
+ (er hard 'gify-term
"We expect lambdas to all have been factored out of functions to
be gified. If not, implement this case. Culprit (in function ~x0): ~x1~%"
fn (car x)))
(t (cons (gl-fnsym (car x))
(append (gify-term-list (cdr x) fn)
- '(hyp clk))))))
+ '(hyp clk config bvar-db state))))))
(defun gify-term-list (x fn)
(if (endp x)
nil
@@ -168,13 +185,15 @@
(gbody (gify-body body (car fns)))
(formals (wgetprop fn 'formals))
(recursivep (wgetprop top-fn 'recursivep))
- (guards `(natp clk))
+ (guards `(and (natp clk)
+ (glcp-config-p config)))
(name (gl-fnsym (if endp top-fn fn)))
(defun
- `(defun ,name ,(append formals '(hyp clk))
+ `(defun ,name ,(append formals '(hyp clk config bvar-db state))
(declare
(xargs
:guard ,guards
+ :stobjs (bvar-db state)
:verify-guards nil
. ,(and recursivep
`(:measure
@@ -183,7 +202,7 @@
`(:hints (("goal" :in-theory
(e/d** ((:ruleset
clk-measure-rules))))))))))
- (ignorable hyp clk . ,formals))
+ (ignorable hyp clk config bvar-db state . ,formals))
,(if endp
(let ((clkbody `(if (zp clk)
(prog2$
@@ -209,7 +228,7 @@
(gify-factored-fns top-fn (cdr fns) (1+ idx) world
(cons defun defuns))))))
-
+
(defmacro factored-fns (fn)
`(cdr (assoc-eq ,fn (table-alist 'factored-fns world))))
@@ -232,7 +251,7 @@
(if (and recp (<= 2 (length defuns)))
`(mutual-recursion . ,defuns)
`(progn . ,(reverse defuns)))))
-
+
(defun gify-stub (fn world)
(let* ((formals (wgetprop fn 'formals))
@@ -241,8 +260,10 @@
(wgetprop fn 'non-executablep)
(assoc-eq fn (table-alist 'do-not-execute
world)))))
- `(defun ,name (,@formals hyp clk)
- (declare (xargs :guard (natp clk)
+ `(defun ,name (,@formals hyp clk config bvar-db state)
+ (declare (xargs :guard (and (natp clk)
+ (glcp-config-p config))
+ :stobjs (bvar-db state)
:verify-guards nil))
,(if nonexec
`(g-apply ',fn (gl-list . ,formals))
@@ -282,7 +303,7 @@
-
+
;; (defun gobjectp-thmname (fn)
;; (incat 'gl-thm::foo "GOBJECTP-" (symbol-name fn)))
@@ -298,7 +319,7 @@
;; (endp (endp (cdr fns)))
;; (name (gl-fnsym (if endp top-fn fn)))
;; (gobjectp-thm `(,name
-;; (gobjectp (,name ,@formals hyp clk))
+;; (gobjectp (,name ,@formals hyp clk config bvar-db state))
;; :name ,(gobjectp-thmname name))))
;; (if endp
;; (cons gobjectp-thm entries)
@@ -321,10 +342,10 @@
;; (thmname (gobjectp-thmname name))
;; (formals (wgetprop fn 'formals)))
;; (cons `(defthm ,thmname
-;; (gobjectp (,name ,@formals hyp clk)))
+;; (gobjectp (,name ,@formals hyp clk config bvar-db state)))
;; (gobjectp-redundant-top-thms (cdr clique) world)))))
-
-
+
+
(defmacro defname (name)
@@ -343,9 +364,9 @@
;; (defname (defname name))
;; (gobjectp-thm
;; `(defthm ,gobjectp-name
-;; (gobjectp (,name ,@formals hyp clk))
+;; (gobjectp (,name ,@formals hyp clk config bvar-db state))
;; :hints (("goal" :expand ((:with (:definition ,defname)
-;; (,name ,@formals hyp clk)))
+;; (,name ,@formals hyp clk config bvar-db state)))
;; :do-not '(preprocess)))))
;; (gobjectp-thm (if endp gobjectp-thm `(local ,gobjectp-thm))))
;; (if endp
@@ -530,7 +551,7 @@
-(defun g-factored-fns-verify-guards (top-fn fns world)
+(defun g-factored-fns-verify-guards (top-fn fns world)
(if (endp fns)
(er hard 'g-factored-fns-verify-guards
"Empty list of functions; top: ~x0~%" top-fn)
@@ -554,7 +575,7 @@
(cons `(:type-prescription ,(car clique))
(type-prescriptions-of-mv-fns (cdr clique) world))
(type-prescriptions-of-mv-fns (cdr clique) world)))))
-
+
(defun g-guards-fns-and-deps1 (deps world)
@@ -588,7 +609,7 @@
zp natp)
((immediate-force-modep) not))))
. ,(g-guards-fns-and-deps1 deps world))))
-
+
@@ -622,7 +643,7 @@
(name (gl-fnsym fn))
(g-correct-thm `(,name
(implies (bfr-eval hyp (car env))
- (equal (,ev (,name ,@formals hyp clk) env)
+ (equal (,ev (,name ,@formals hyp clk config bvar-db state) env)
(,fn . ,(eval-list-env ev formals))))
. ,(if endp
`(:name ,(correct-thmname name))
@@ -662,10 +683,10 @@
(g-correct-thm
`(defthm ,g-correct-name
(implies (bfr-eval hyp (car env))
- (equal (,ev (,name ,@formals hyp clk) env)
+ (equal (,ev (,name ,@formals hyp clk config bvar-db state) env)
(,fn . ,(eval-list-env ev formals))))
:hints (("goal" :expand
- ((,name ,@formals hyp clk))
+ ((,name ,@formals hyp clk config bvar-db state))
,@(and endp definedp
`(:in-theory (e/d ()
,(factored-fn-correct-thms
@@ -789,7 +810,7 @@
`(:expand (,term)))))))
(and stable-under-simplificationp
'(:expand ((:free (x) (hide x))))))))
-
+
;; BOZO. This is an ugly sort of desperation move. Blech.
;; (and stable-under-simplificationp
;; '(:in-theory (union-theories
@@ -857,7 +878,7 @@
(if (hons-get-any clique al)
(remove-cliques-in-al (cdr fns) al world)
(cons fn (remove-cliques-in-al (cdr fns) al world))))))
-
+
(defun lambda-for-apply-stub-fi (oldfns newfns world)
`(lambda (f args)
@@ -897,7 +918,7 @@
;; (applyfns
;; (cdr (assoc apply (table-alist 'g-apply-table world))))
;; (oldapplyfns
-;; (cdr (assoc oldapply (table-alist 'g-apply-table world)))))
+;; (cdr (assoc oldapply (table-alist 'g-apply-table world)))))
;; `(:functional-instance
;; ,thmname
;; ,@(if (eq oldapply 'apply-stub)
@@ -909,15 +930,16 @@
(defun eval-g-fi (eval oldeval thmname world)
- (b* (((list ?new-appalist new-ev new-evlst)
+ (b* (((list eval-list new-ev new-evlst)
(cdr (assoc eval (table-alist 'eval-g-table world))))
- ((list ?old-appalist old-ev old-evlst)
+ ((list oldeval-list old-ev old-evlst)
(cdr (assoc oldeval (table-alist 'eval-g-table world)))))
`(:functional-instance
,thmname
(,old-ev ,new-ev)
(,old-evlst ,new-evlst)
- (,oldeval ,eval))))
+ (,oldeval ,eval)
+ (,oldeval-list ,eval-list))))
(defconst *eval-g-prove-f-i-template*
'(:computed-hint-replacement
@@ -930,11 +952,12 @@
((:functional-instance
_theorem_
(_oldgeval_ _newgeval_)
+ (_oldgeval_-list _newgeval_-list)
(_oldgeval_-ev _newgeval_-ev)
(_oldgeval_-ev-lst _newgeval_-ev-lst)))
:in-theory (e/d**
- (nth-of-_oldgeval_-ev-concrete-lst
- nth-of-_newgeval_-ev-concrete-lst
+ (;; nth-of-_oldgeval_-ev-concrete-lst
+ ;; nth-of-_newgeval_-ev-concrete-lst
acl2::car-to-nth-meta-correct
acl2::nth-of-cdr
acl2::list-fix-when-true-listp
@@ -944,11 +967,12 @@
_newgeval_-apply-agrees-with-_newgeval_-ev-rev
_oldgeval_-ev-rules
_newgeval_-ev-rules
- _newgeval_-ev-constraint-0
- _oldgeval_-ev-constraint-0
+ _newgeval_-ev-of-fncall-args
+ _oldgeval_-ev-of-fncall-args
car-cons cdr-cons nth-0-cons (nfix)))
- :expand ((_oldgeval_ x env)
- (_newgeval_ x env))
+ :expand (; (_oldgeval_ x env)
+ (:with _newgeval_ (_newgeval_ x env))
+ (:with _newgeval_-list (_newgeval_-list x env)))
:do-not-induct t))
(defun eval-g-prove-f-i-fn (eval oldeval thmname)
@@ -990,7 +1014,7 @@
;; `(:theorem (equal (,oldeval x env)
;; (,oldeval x env)))
;; world))
-
+
;; :do-not '(preprocess simplify)
;; :in-theory nil))
;; :rule-classes nil)))
@@ -1006,12 +1030,17 @@
(incat 'gl-thm::foo (symbol-name thm) "-FOR-" (symbol-name eval)))
(defun eval-g-functional-instance-fn (eval oldeval thmname world)
- (let* ((apply (caddr (assoc eval (table-alist 'eval-g-table world))))
- (oldapply (caddr (assoc oldeval (table-alist 'eval-g-table world))))
- (thmbody (wgetprop thmname 'theorem))
- (subst-body (subst-fns-term thmbody (list (cons oldeval eval)
- (cons oldapply apply))))
- (newthmname (f-i-thmname thmname eval)))
+ (b* (((list neweval-list new-ev new-evlst new-apply)
+ (cdr (assoc eval (table-alist 'eval-g-table world))))
+ ((list oldeval-list old-ev old-evlst old-apply)
+ (cdr (assoc oldeval (table-alist 'eval-g-table world))))
+ (thmbody (wgetprop thmname 'theorem))
+ (subst-body (subst-fns-term thmbody (list (cons oldeval eval)
+ (cons old-apply new-apply)
+ (cons oldeval-list neweval-list)
+ (cons old-ev new-ev)
+ (cons old-evlst new-evlst))))
+ (newthmname (f-i-thmname thmname eval)))
`(defthm ,newthmname
,subst-body
:hints (("goal" :in-theory (theory 'minimal-theory)
@@ -1019,8 +1048,8 @@
(defmacro eval-g-functional-instance (thmname eval oldeval)
`(make-event (eval-g-functional-instance-fn ',eval ',oldeval ',thmname (w state))))
-
-
+
+
(defun correctness-lemmas-for-new-apply11
@@ -1035,7 +1064,7 @@
((mv thms done-finsts)
(if (member thmeval done-finsts)
(mv thms done-finsts)
- (mv (cons `(local (eval-g-prove-f-i
+ (mv (cons `(local (eval-g-prove-f-i
,(incat 'gl-thm::foo
(symbol-name eval)
"-IS-FUNCTIONAL-INSTANCE-OF-"
@@ -1054,7 +1083,7 @@
(cdr alist) eval world done-finsts thms (cons thmbase theory))))))
-
+
(defun correctness-lemmas-for-new-apply1 (alist eval world
done-finsts thms theory)
(if (atom alist)
@@ -1182,7 +1211,7 @@
`(in-theory (disable ,thmname))
`(table preferred-defs ',fn ',thmname)
(make-unnorm-preferred-defs1 (cdr fns) world)))))
-
+
(defun make-unnorm-preferred-defs (fns world)
`(progn . ,(make-unnorm-preferred-defs1 fns world)))
@@ -1225,7 +1254,9 @@
(new-fns (set-difference-eq
(collect-fn-deps fns world)
'(acl2::return-last)))
- (apply-fns (union-eq new-fns (prev-apply-fns world))))
+ (apply-fns (union-eq new-fns
+ (prev-apply-fns world)
+ (strip-cars (table-alist 'gl-function-info world)))))
`(encapsulate nil
(logic)
(local (table acl2::theory-invariant-table nil nil :clear))
@@ -1241,8 +1272,8 @@
(make-event (gify-fns-and-deps ',new-fns (w state)))
(make-event (flagify-g-fns-and-deps ',new-fns (w state)))
-
-
+
+
;; (make-event (gobjectp-fns-and-deps ',new-fns (w state)))
(make-event (g-guards-fns-and-deps ',new-fns (w state)))
@@ -1267,10 +1298,14 @@
state))))
(defun make-geval-fn (geval new-fns state)
- (declare (xargs :stobjs state))
+ (declare (xargs :stobjs state :mode :program))
(b* ((world (w state))
- (new-fns (collect-fn-deps new-fns world))
- (fns (union-eq new-fns (prev-apply-fns world)))
+ (new-fns (set-difference-eq
+ (collect-fn-deps new-fns world)
+ '(acl2::return-last)))
+ (fns (union-eq new-fns
+ (strip-cars (table-alist 'gl-function-info world))
+ (prev-apply-fns world)))
;; (ap (incat geval (symbol-name geval) "-APPLY"))
)
`(encapsulate nil
diff -Nru acl2-6.2/books/centaur/gl/gl-doc-string.lisp acl2-6.3/books/centaur/gl/gl-doc-string.lisp
--- acl2-6.2/books/centaur/gl/gl-doc-string.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gl-doc-string.lisp 1970-01-01 00:00:00.000000000 +0000
@@ -1,21 +0,0 @@
-
-(in-package "GL")
-
-(defdoc acl2::gl ":Doc-section GL
-G in the Logic: a symbolic simulation framework for ACL2~/
-
-This library supports bit-level symbolic execution of ACL2 logic-mode
-programs. Symbolic execution is supported in two ways: by a code
-transformation which translates an ACL2 logic-mode function into a new
-function called its *symbolic counterpart*; or by an interpreter which
-traverses a term symbolically evaluating its contents. A symbolic
-execution performs analogous operations to a normal, concrete
-execution, but these operations are on *symbolic objects* rather than
-ordinary ACL2 objects.
-
-Various subtopics are linked below. To begin proving theorems using
-GL, first read ~il[DEF-GL-THM], ~il[DEF-GL-CLAUSE-PROCESSOR], and
-~il[GL::SHAPE-SPECS].
-~/
-~/")
-
diff -Nru acl2-6.2/books/centaur/gl/gl-generic-clause-proc.lisp acl2-6.3/books/centaur/gl/gl-generic-clause-proc.lisp
--- acl2-6.2/books/centaur/gl/gl-generic-clause-proc.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gl-generic-clause-proc.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,1361 +1,111 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-
-(include-book "param")
-(include-book "g-if")
+(include-book "tools/clone-stobj" :dir :system)
+(include-book "var-bounds")
+(include-book "shape-spec")
+(include-book "gl-generic-interp-defs")
+(include-book "ctrex-utils")
+(include-book "shape-spec")
(include-book "gify")
(include-book "bfr-sat")
-(include-book "glcp-templates")
-
(include-book "misc/untranslate-patterns" :dir :system)
-(include-book "data-structures/no-duplicates" :dir :system)
(include-book "clause-processors/use-by-hint" :dir :system)
(include-book "clause-processors/decomp-hint" :dir :system)
(include-book "centaur/misc/interp-function-lookup" :dir :system)
-
+(include-book "constraint-db-deps")
+(local (include-book "gl-generic-interp"))
(local (include-book "general-object-thms"))
+(local (include-book "hyp-fix-logic"))
+(local (include-book "data-structures/no-duplicates" :dir :system))
(local (include-book "centaur/misc/hons-sets" :dir :system))
(local (include-book "tools/with-quoted-forms" :dir :system))
-(local (include-book "hyp-fix-logic"))
-(local (in-theory (disable* sets::double-containment
- w)))
-
-
-(defmacro glcp-value (res)
- `(mv nil obligs ,res state))
-
-;; (defmacro glcp-er-let* (alist body)
-;; (declare (xargs :guard (and (acl2::doubleton-list-p alist)
-;; (symbol-alistp alist))))
-;; (if (null alist)
-;; `(check-vars-not-free
-;; (glcp-er-let*-use-nowhere-else)
-;; ,body)
-;; `(mv-let (glcp-er-let*-use-nowhere-else
-;; obligs ,(caar alist) state)
-;; ,(cadar alist)
-;; (if glcp-er-let*-use-nowhere-else
-;; (mv glcp-er-let*-use-nowhere-else
-;; obligs ,(caar alist) state)
-;; (glcp-er-let* ,(cdr alist) ,body)))))
-
-(defmacro patbind-glcp-er (args bindings expr)
- (declare (xargs :guard (and (consp args) (eq (cdr args) nil))))
- `(b* (((mv patbind-glcp-er-error obligs ,(car args) state)
- ,(car bindings))
- ((when patbind-glcp-er-error)
- (mv patbind-glcp-er-error obligs nil state)))
- (check-vars-not-free
- (patbind-glcp-er-error) ,expr)))
-
-(verify-termination acl2::evisc-tuple)
-(verify-guards acl2::evisc-tuple)
-
-(defmacro glcp-if (test then else)
- `(b* (((glcp-er test) ,test)
- (gtests (gtests test hyp))
- (then-hyp (hf (bfr-or (gtests-unknown gtests)
- (gtests-nonnil gtests))))
- (else-hyp (hf (bfr-or (gtests-unknown gtests)
- (bfr-not (gtests-nonnil gtests)))))
- ((glcp-er then)
- (if then-hyp
- (let ((hyp (bfr-and hyp then-hyp)))
- (declare (ignorable hyp))
- ,then)
- (glcp-value nil)))
- ((glcp-er else)
- (if else-hyp
- (let ((hyp (bfr-and hyp else-hyp)))
- (declare (ignorable hyp))
- ,else)
- (glcp-value nil)))
- (merge (gobj-ite-merge (gtests-nonnil gtests) then else
- (bfr-and (bfr-not (gtests-unknown gtests))
- hyp))))
- (if (hf (gtests-unknown gtests))
- (glcp-value
- (mk-g-ite (mk-g-boolean (gtests-unknown gtests))
- (mk-g-ite (gtests-obj gtests) then else)
- merge))
- (glcp-value merge))))
-
-
-(defmacro glcp-or (test else)
- `(b* (((glcp-er test) ,test)
- (gtests (gtests test hyp))
- (else-hyp (hf (bfr-or (gtests-unknown gtests)
- (bfr-not (gtests-nonnil gtests)))))
- ((glcp-er else)
- (if else-hyp
- (let ((hyp (bfr-and hyp else-hyp)))
- (declare (ignorable hyp))
- ,else)
- (glcp-value nil)))
- (merge (gobj-ite-merge (gtests-nonnil gtests) test else
- (bfr-and (bfr-not (gtests-unknown gtests))
- hyp))))
- (if (hf (gtests-unknown gtests))
- (glcp-value
- (mk-g-ite (mk-g-boolean (gtests-unknown gtests))
- (mk-g-ite (gtests-obj gtests) test else)
- merge))
- (glcp-value merge))))
-
-
-(local
- (defthmd gl-eval-of-atom
- (implies (atom x)
- (equal (generic-geval x env) x))
- :hints (("goal" :in-theory (enable tag)
- :expand ((generic-geval x env))))
- :rule-classes ((:rewrite :backchain-limit-lst 0))))
-
-(set-state-ok t)
-
-(defun gl-cp-hint (x)
- (declare (ignore x))
- t)
-
-(in-theory (disable gl-cp-hint (:type-prescription gl-cp-hint) (gl-cp-hint)))
-
-
-
-(encapsulate
- (((glcp-generic-run-gified * * * * state)
- => (mv * *)
- :formals (fn actuals hyp clk state)
- :guard (and (symbolp fn)
- (gobj-listp actuals)
- (natp clk)))
- ((glcp-generic-ev * *) => *)
- ((glcp-generic-ev-lst * *) => *)
- ((glcp-generic-geval * *) => *))
-
- (local (defun glcp-generic-geval (x env)
- (generic-geval x env)))
-
- (local (defun glcp-generic-run-gified (fn actuals hyp clk state)
- (declare (xargs :stobjs state
- :guard (and (symbolp fn)
- (natp clk)))
- (ignorable fn actuals hyp clk state))
- (mv nil nil)))
-
- (local (acl2::defevaluator-fast
- glcp-generic-ev glcp-generic-ev-lst
- ((if a b c)
- (gl-cp-hint x)
- (shape-spec-obj-in-range a b)
- (return-last fn arg1 arg2)
- (use-by-hint x)
- (equal a b)
- (acl2::typespec-check ts x)
- (implies a b)
- (iff a b)
- (not x)
- (cons a b)
- (gl-aside x)
- (gl-ignore x)
- (gl-error x))
- :namedp t))
-
- (defthm glcp-generic-run-gified-correct
- (implies (and (bfr-eval hyp (car env))
- (gobj-listp actuals)
- (mv-nth 0 (glcp-generic-run-gified fn actuals hyp
- clk state)))
- (equal (glcp-generic-geval
- (mv-nth 1 (glcp-generic-run-gified
- fn actuals hyp clk state))
- env)
- (glcp-generic-ev
- (cons fn
- (acl2::kwote-lst
- (glcp-generic-geval actuals env))) nil))))
-
- (defthm true-listp-glcp-generic-run-gified
- (true-listp (glcp-generic-run-gified fn actuals hyp clk state)))
-
- (make-event
- `(progn
- . ,(acl2::defevaluator-fast-form/defthms-named
- 'glcp-generic-ev 'glcp-generic-ev-lst
- '((if a b c)
- (gl-cp-hint x)
- (shape-spec-obj-in-range a b)
- (return-last fn arg1 arg2)
- (use-by-hint x)
- (equal a b)
- (acl2::typespec-check ts x)
- (implies a b)
- (iff a b)
- (not x)
- (cons a b)
- (gl-aside x)
- (gl-ignore x)
- (gl-error x)))))
-
-
- (defthm glcp-generic-geval-atom
- (implies (atom x)
- (equal (glcp-generic-geval x env) x))
- :hints(("Goal" :in-theory (enable gl-eval-of-atom)))
- :rule-classes ((:rewrite :backchain-limit-lst 0)))
-
- (defthm glcp-generic-geval-mk-g-boolean-correct
- (equal (glcp-generic-geval (mk-g-boolean x) env)
- (bfr-eval x (car env))))
-
-
- (defthm glcp-generic-geval-gobj-ite-merge-correct
- (implies (bfr-eval hyp (car env))
- (equal (glcp-generic-geval (gobj-ite-merge c x y hyp)
- env)
- (if (bfr-eval c (car env))
- (glcp-generic-geval x env)
- (glcp-generic-geval y env))))
- :hints(("Goal" :in-theory (disable generic-geval))))
-
- (defthmd glcp-generic-geval-gtests-nonnil-correct
- (implies (and (not (bfr-eval (gtests-unknown (gtests x hyp))
- (car env)))
- (bfr-eval hyp (car env)))
- (equal (bfr-eval (gtests-nonnil (gtests x hyp))
- (car env))
- (if (glcp-generic-geval x env) t nil)))
- :hints (("goal" :expand ((glcp-generic-geval x env))
- :in-theory (e/d** (gtests-nonnil-correct)))))
-
- (defthm glcp-generic-geval-gtests-obj-correct
- (implies (and (bfr-eval (gtests-unknown (gtests x hyp))
- (car env))
- (bfr-eval hyp (car env)))
- (iff (glcp-generic-geval (gtests-obj (gtests x hyp))
- env)
- (glcp-generic-geval x env)))
- :hints (("Goal" :in-theory
- (e/d** (glcp-generic-geval
- gtests-obj-correct)))))
-
- (defthm glcp-generic-geval-mk-g-ite-correct
- (equal (glcp-generic-geval (mk-g-ite c x y) b)
- (if (glcp-generic-geval c b)
- (glcp-generic-geval x b)
- (glcp-generic-geval y b)))
- :hints (("Goal" :in-theory
- (e/d** (glcp-generic-geval
- mk-g-ite-correct)))))
-
- (defthm glcp-generic-geval-mk-g-concrete-correct
- (equal (glcp-generic-geval (mk-g-concrete x) env)
- x)
- :hints (("goal" :in-theory
- (e/d** (glcp-generic-geval mk-g-concrete-correct)))))
-
- (defthm glcp-generic-geval-g-concrete-quote-correct
- (equal (glcp-generic-geval (g-concrete-quote x) env)
- x)
- :hints (("goal" :in-theory
- (e/d** (glcp-generic-geval g-concrete-quote-correct)))))
-
- (defthm glcp-generic-geval-general-concrete-obj-correct
- (implies (general-concretep x)
- (equal (glcp-generic-geval x env)
- (general-concrete-obj x)))
- :hints (("goal" :in-theory
- (e/d** (glcp-generic-geval general-concrete-obj-correct)))))
-
- (defthm glcp-generic-geval-shape-spec-to-gobj-eval-env
- (implies (and (shape-specp x)
- (no-duplicatesp-equal (shape-spec-indices x))
- (no-duplicatesp-equal (shape-spec-vars x))
- (shape-spec-obj-in-range x obj))
- (equal (glcp-generic-geval
- (shape-spec-to-gobj x)
- (shape-spec-to-env x obj))
- obj))
- :hints (("goal" :in-theory
- (e/d** (glcp-generic-geval
-; [Removed by Matt K. to handle changes to member, assoc, etc. after ACL2 4.2.]
-; acl2::no-duplicatesp-is-no-duplicatesp-equal
- shape-spec-to-gobj-eval-env)))))
-
- (defthm glcp-generic-geval-gobj-to-param-space-correct
- (implies (bfr-eval p (car env))
- (equal (glcp-generic-geval (gobj-to-param-space x p)
- (genv-param p env))
- (glcp-generic-geval x env)))
- :hints (("goal" :in-theory
- (e/d** (glcp-generic-geval
- gobj-to-param-space-correct)))))
-
- (defthm glcp-generic-geval-of-gl-cons
- (equal (glcp-generic-geval (gl-cons x y) env)
- (cons (glcp-generic-geval x env)
- (glcp-generic-geval y env)))))
-
-
-(local (in-theory (enable glcp-generic-geval-gtests-nonnil-correct)))
-
-;; (defun univ-run-gified-guard-wrapper (fn actuals hyp clk state)
-;; (declare (xargs :guard (and (symbolp fn)
-;; (gobject-listp actuals)
-;; (bfr-p hyp)
-;; (natp clk))
-;; :stobjs state))
-;; (ec-call (univ-run-gified fn actuals hyp clk state)))
-
-;; (defun glcp-generic-apply-concrete-guard-wrapper
-;; (fn actuals state)
-;; (declare (xargs :guard (true-listp actuals)
-;; :stobjs state))
-;; (ec-call (glcp-generic-apply-concrete fn actuals state)))
-
-
-(local
- (progn
- ;; (defun-nx glcp-generic-geval-lst (x env)
- ;; (if (atom x)
- ;; nil
- ;; (cons (glcp-generic-geval (car x) env)
- ;; (glcp-generic-geval-lst (cdr x) env))))
-
- ;; (defthmd glcp-generic-geval-of-gobj-list
- ;; (implies (gobj-listp x)
- ;; (equal (glcp-generic-geval x env)
- ;; (glcp-generic-geval-lst x env)))
- ;; :hints
- ;; (("goal" :induct (gobject-listp x)
- ;; :in-theory (enable gobject-listp-impl-gobjectp
- ;; glcp-generic-geval-of-gobject-car
- ;; gobject-listp))))
-
-
-
-
+(local (include-book "std/lists/acl2-count" :dir :system))
+(local (include-book "clause-processors/find-matching" :dir :system))
+(local (include-book "clause-processors/just-expand" :dir :system))
+(local (in-theory (disable* sets::double-containment w)))
- (defthm nonnil-symbol-listp-impl-eqlable-listp
- (implies (nonnil-symbol-listp x)
- (eqlable-listp x))
- :hints(("Goal" :in-theory (enable nonnil-symbol-listp))))
-
-
-
-
- ;; (defthm univ-run-gified-wrapper-unwrap
- ;; (equal (univ-run-gified-guard-wrapper fn actuals hyp clk state)
- ;; (univ-run-gified fn actuals hyp clk state)))
-
-
-
-
- ;; (defthm glcp-generic-apply-concrete-wrapper-unwrap
- ;; (equal (glcp-generic-apply-concrete-guard-wrapper fn actuals state)
- ;; (glcp-generic-apply-concrete fn actuals state)))
-
- ;; (in-theory (disable univ-run-gified-guard-wrapper
- ;; ;; glcp-generic-apply-concrete-guard-wrapper
- ;; ))
- ))
-
-
-
-
-(defun general-concrete-listp (x)
- (declare (xargs :guard t))
- (if (atom x)
- (eq x nil)
- (and (general-concretep (car x))
- (general-concrete-listp (cdr x)))))
-
-(defun general-concrete-obj-list (x)
- (declare (xargs :guard (general-concrete-listp x)))
- (if (atom x)
- nil
- (cons (general-concrete-obj (car x))
- (general-concrete-obj-list (cdr x)))))
+(defun shape-spec-to-gobj-param (spec p)
+ (declare (xargs :guard (shape-specp spec)))
+ (gobj-to-param-space (shape-spec-to-gobj spec) p))
+(defun shape-spec-to-env-param (x obj p)
+ (declare (xargs :guard (shape-specp x)))
+ (genv-param p (shape-spec-to-env x obj)))
-(mutual-recursion
- (defun sublis-into-term (x alist)
- (declare (xargs :guard t))
- (cond ((null x) nil)
- ((atom x)
- (let ((look (hons-assoc-equal x alist)))
- (if look (acl2::kwote (cdr look)) x)))
- ((eq (car x) 'quote) x)
- (t (cons (car x) (sublis-into-list (cdr x) alist)))))
- (defun sublis-into-list (x alist)
- (declare (xargs :guard t))
- (if (atom x)
- nil
- (cons (sublis-into-term (car x) alist)
- (sublis-into-list (cdr x) alist)))))
-(local (flag::make-flag sublis-into-term-flg sublis-into-term))
-
-;; (defthm assoc-equal-nonnil-of-append
-;; (implies x
-;; (equal (assoc-equal x (append a b))
-;; (or (assoc-equal x a)
-;; (assoc-equal x b))))
-;; :hints(("Goal" :in-theory (enable append assoc-equal))))
-
-;; (defthm-sublis-into-term-flg
-;; sublis-into-term-correct-lemma
-;; (sublis-into-term
-;; (implies (pseudo-termp x)
-;; (equal (glcp-generic-ev (sublis-into-term x subst) alist)
-;; (glcp-generic-ev x (append subst alist))))
-;; :name sublis-into-term-correct)
-;; (sublis-into-list
-;; (implies (pseudo-term-listp x)
-;; (equal (glcp-generic-ev-lst (sublis-into-list x subst) alist)
-;; (glcp-generic-ev-lst x (append subst alist))))
-;; :name sublis-into-list-correct)
-;; :hints (("goal" :induct (sublis-into-term-flg flag x alist))
-;; (and stable-under-simplificationp
-;; '(:in-theory (enable glcp-generic-ev-constraint-0)))))
(local
- (progn
- (defthm len-sublis-into-list
- (implies (pseudo-term-listp x)
- (equal (length (sublis-into-list x subst))
- (length x)))
- :hints (("goal" :induct (len x)
- :in-theory (enable length))))
-
- (defthm-sublis-into-term-flg
- sublis-into-term-pseudo-term-lemma
- (sublis-into-term
- (implies (pseudo-termp x)
- (pseudo-termp (sublis-into-term x subst)))
- :name pseudo-termp-sublis-into-term)
- (sublis-into-list
- (implies (pseudo-term-listp x)
- (pseudo-term-listp (sublis-into-list x subst)))
- :name pseudo-term-listp-sublis-into-list)
- :hints (("goal" :induct (sublis-into-term-flg flag x alist)
- :expand ((pseudo-termp x)
- (:free (args) (pseudo-termp (cons (car x)
- args)))))))))
-
-
-(defconst *glcp-generic-template-subst*
- `((interp-term . glcp-generic-interp-term)
- (interp-list . glcp-generic-interp-list)
- (run-cases . glcp-generic-run-cases)
- (run-parametrized . glcp-generic-run-parametrized)
- (clause-proc . glcp-generic)
- (clause-proc-name . (glcp-generic-clause-proc-name))
- (run-gified . glcp-generic-run-gified)))
-
-(defund gl-aside-wormhole (term alist)
- (declare (xargs :guard t))
- (wormhole 'glcp-interp-gl-aside
- '(lambda (whs) whs)
- nil
- `(prog2$ ,(sublis-into-term
- term alist)
- (value :q))
- :ld-prompt nil
- :ld-pre-eval-print nil
- :ld-post-eval-print nil
- :ld-verbose nil))
-
-(defun glcp-interp-error-fn (msg state)
- (declare (xargs :guard t :stobjs state))
- (mv msg nil nil state))
-
-(defmacro glcp-interp-error (msg)
- (declare (xargs :guard t))
- `(glcp-interp-error-fn ,msg state))
-
-(add-macro-alias glcp-interp-error glcp-interp-error-fn)
-
-
-(defthmd acl2-count-last-cdr-when-cadr-hack
- (implies (< 1 (len x))
- (< (acl2-count (car (last x)))
- (+ 1 (acl2-count (cdr x)))))
- :rule-classes (:rewrite :linear))
-
-;; (defun gobject-vals-alistp (x)
-;; (declare (Xargs :guard t))
-;; (if (atom x)
-;; (equal x nil)
-;; (and (or (atom (car x))
-;; (gobjectp (cdar x)))
-;; (gobject-vals-alistp (cdr x)))))
-
-
-;; (defthm lookup-in-gobject-vals-alistp
-;; (implies (gobject-vals-alistp x)
-;; (gobjectp (cdr (hons-assoc-equal k x)))))
-
-;; (defthm gobject-vals-alistp-pairlis$
-;; (implies (gobject-listp vals)
-;; (gobject-vals-alistp (pairlis$ keys vals)))
-;; :hints(("Goal" :in-theory (enable gobject-listp
-;; pairlis$))))
-
-
-(cutil::defaggregate glcp-config
- ((abort-unknown booleanp :default t)
- (abort-ctrex booleanp :default t)
- (exec-ctrex booleanp :default t)
- (abort-vacuous booleanp :default t)
- (nexamples natp :rule-classes :type-prescription :default 3)
- (hyp-clk natp :rule-classes :type-prescription :default 1000000)
- (concl-clk natp :rule-classes :type-prescription :default 1000000)
- (clause-proc-name symbolp :rule-classes :type-prescription)
- (overrides) ;; acl2::interp-defs-alistp but might be too expensive to check the guards in clause processors
- run-before
- run-after
- case-split-override)
- :tag :glcp-config)
-
-
-
-
-
-(make-event
- (sublis *glcp-generic-template-subst*
- *glcp-interp-template*))
-
-(in-theory (disable glcp-generic-interp-term glcp-generic-interp-list))
-
-(local (in-theory (disable* general-concretep-def acl2-count
-; sets::double-containment
- integer-abs
-; sets::nonempty-means-set
- equal-of-booleans-rewrite
- put-global
- acl2::true-list-listp-forward-to-true-listp-assoc-equal)))
-
-(defchoose glcp-generic-ev-falsify (a) (x)
- (not (glcp-generic-ev x a)))
-
-
-;; (defthmd gobject-listp-true-listp
-;; (implies (gobject-listp x)
-;; (true-listp x))
-;; :hints(("Goal" :in-theory (enable gobject-listp)))
-;; :rule-classes (:rewrite :forward-chaining))
-
-(acl2::def-meta-extract glcp-generic-ev glcp-generic-ev-lst)
-
-(defthm glcp-generic-geval-of-gobj-list
- (implies (and (gobj-listp x)
- (consp x))
- (equal (glcp-generic-geval x env)
- (cons (glcp-generic-geval (car x) env)
- (glcp-generic-geval (cdr x) env))))
- :hints(("Goal" :use ((:instance glcp-generic-geval-of-gl-cons
- (x (car x)) (y (cdr x))))
- :in-theory (enable gl-cons gobj-listp))))
-
-
-(local
- (progn
-
-
- (defun-nx glcp-generic-geval-alist (al env)
- (if (atom al)
- nil
- (if (consp (car al))
- (cons (cons (caar al)
- (glcp-generic-geval (cdar al)
- env))
- (glcp-generic-geval-alist (cdr al) env))
- (glcp-generic-geval-alist (cdr al) env))))
-
- (defthm glcp-generic-geval-alist-pairlis$
- (implies (gobj-listp actuals)
- (equal (glcp-generic-geval-alist
- (pairlis$ formals actuals)
- env)
- (pairlis$ formals
- (glcp-generic-geval actuals env))))
- :hints(("Goal" :in-theory (enable default-cdr pairlis$ gobj-listp)
- :induct (pairlis$ formals actuals))))
-
-
-
- (flag::make-flag glcp-generic-interp-flg glcp-generic-interp-term
- :hints (("goal" :in-theory
- (e/d (acl2-count
- acl2-count-last-cdr-when-cadr-hack)
- (last)))))
-
- (defthm assoc-in-add-pair
- (implies (not (equal k1 k2))
- (equal (assoc k1 (add-pair k2 v a))
- (assoc k1 a))))
-
-
- (defthm w-of-put-global
- (implies (not (eq var 'current-acl2-world))
- (equal (w (put-global var val state))
- (w state)))
- :hints(("Goal" :in-theory (enable w put-global add-pair))))
-
- (local (in-theory (disable w)))
-
- (defthm-glcp-generic-interp-flg
- (defthm glcp-generic-interp-term-w-state-preserved
- (equal (w (mv-nth 3 (glcp-generic-interp-term
- x alist hyp clk obligs config state)))
- (w state))
- :hints ('(:expand ((glcp-generic-interp-term
- x alist hyp clk obligs config state)
- (glcp-generic-interp-term
- nil alist hyp clk obligs config state))))
- :flag glcp-generic-interp-term)
- (defthm glcp-generic-interp-list-w-state-preserved
- (equal (w (mv-nth 3 (glcp-generic-interp-list
- x alist hyp clk obligs config state)))
- (w state))
- :hints ('(:expand ((glcp-generic-interp-list
- x alist hyp clk obligs config state))))
- :flag glcp-generic-interp-list))
-
-
-
- ;; (defthm-glcp-generic-interp-flg
- ;; (defthm gobjectp-glcp-generic-interp-term
- ;; (implies (and (glcp-generic-ev-meta-extract-global-facts)
- ;; (equal (w st) (w state))
- ;; (sym-counterparts-ok (w st))
- ;; (bfr-p hyp)
- ;; (not (mv-nth 0 (glcp-generic-interp-term
- ;; x alist hyp clk obligs config st))))
- ;; (gobjectp (mv-nth 2 (glcp-generic-interp-term
- ;; x alist hyp clk obligs config st))))
- ;; :flag glcp-generic-interp-term)
-
- ;; (defthm gobject-listp-glcp-generic-interp-list
- ;; (implies (and (glcp-generic-ev-meta-extract-global-facts)
- ;; (equal (w st) (w state))
- ;; (sym-counterparts-ok (w st))
- ;; (bfr-p hyp)
- ;; (not (mv-nth 0 (glcp-generic-interp-list
- ;; x alist hyp clk obligs config st))))
- ;; (gobject-listp (mv-nth 2 (glcp-generic-interp-list
- ;; x alist hyp clk obligs config st))))
- ;; :flag glcp-generic-interp-list)
- ;; :hints (("goal" :induct (glcp-generic-interp-flg flag x alist hyp clk obligs config st)
- ;; :expand ((glcp-generic-interp-term x alist hyp clk obligs config st)
- ;; (glcp-generic-interp-list x alist hyp clk obligs config st)
- ;; (glcp-generic-interp-term nil alist hyp clk obligs config st)
- ;; (glcp-generic-interp-list nil alist hyp clk obligs config st)
- ;; (gobject-listp nil)
- ;; (:free (a b) (gobject-listp (cons a b))))
- ;; :in-theory (e/d** ( ;; gobjectp-gobj-ite-merge
- ;; ;; gobjectp-cons
- ;; ;; gtests-wfp
- ;; ;; bfr-p-of-bfr-and
- ;; ;; bfr-p-of-bfr-not
- ;; ;; bfr-p-of-bfr-or
- ;; ;; hyp-fix-bfr-p
- ;; ;; (gobjectp)
- ;; gobjectp-g-apply
- ;; gobjectp-gobj-fix
- ;; gtests-wfp
- ;; gobjectp-cons
- ;; bfr-p-bfr-binary-and
- ;; bfr-p-bfr-not
- ;; bfr-p-bfr-binary-or
- ;; gobjectp-mk-g-concrete
- ;; gobjectp-g-concrete-quote
- ;; hyp-fix-bfr-p
- ;; glcp-generic-interp-list-w-state-preserved
- ;; glcp-generic-interp-term-w-state-preserved
- ;; gl-aside gl-ignore gl-error-is-nil
- ;; gobjectp-of-atomic-constants
- ;; gobjectp-gobj-ite-merge
- ;; gobjectp-mk-g-ite
- ;; gobjectp-mk-g-boolean
- ;; car-cons cdr-cons (bfr-p)
- ;; glcp-interp-error
- ;; glcp-generic-interp-flg-equivalences
- ;; (:induction glcp-generic-interp-flg)
- ;; booleanp-compound-recognizer
- ;; bfr-p-bfr-binary-or
- ;; gobjectp-mk-g-boolean
- ;; (g-keyword-symbolp)))
- ;; :do-not-induct t)))
-
-
-
-
-
- (defthm pseudo-termp-car
- (implies (pseudo-term-listp x)
- (pseudo-termp (car x))))
-
- (defthm pseudo-term-listp-cdr
- (implies (pseudo-term-listp x)
- (pseudo-term-listp (cdr x))))
-
- (defthmd pseudo-term-listp-cdr-pseudo-term
- (implies (and (pseudo-termp x)
- (consp x)
- (not (equal (car x) 'quote)))
- (pseudo-term-listp (cdr x))))
-
- (defthmd pseudo-termp-symbolp-car-x
- (implies (and (pseudo-termp x)
- (not (consp (car x))))
- (symbolp (car x))))
-
- (defthmd pseudo-termp-lambda-body
- (implies (and (pseudo-termp x)
- (consp (car x)))
- (pseudo-termp (caddar x))))
-
- (defthmd pseudo-termp-car-last-of-pseudo-term-listp
- (implies (and (pseudo-term-listp x)
- (consp x))
- (pseudo-termp (car (last x)))))
-
- (defthm pseudo-termp-car-last
- (implies (and (pseudo-termp x)
- (< 1 (len x))
- (not (equal (car x) 'quote)))
- (pseudo-termp (car (last x))))
- :hints(("Goal" :expand ((pseudo-termp x))
- :in-theory (enable pseudo-termp-car-last-of-pseudo-term-listp))))
-
-
- (defthm-glcp-generic-interp-flg
- (defthm obligs-okp-glcp-generic-interp-term
- (implies (and (pseudo-termp x)
- (acl2::interp-defs-alistp obligs)
- (acl2::interp-defs-alistp (glcp-config->overrides config))
- (not (mv-nth 0 (glcp-generic-interp-term
- x alist hyp clk obligs config state))))
- (acl2::interp-defs-alistp
- (mv-nth 1 (glcp-generic-interp-term
- x alist hyp clk obligs config state))))
- :flag glcp-generic-interp-term)
-
- (defthm obligs-okp-glcp-generic-interp-list
- (implies (and (pseudo-term-listp x)
- (acl2::interp-defs-alistp obligs)
- (acl2::interp-defs-alistp (glcp-config->overrides config))
- (not (mv-nth 0 (glcp-generic-interp-list
- x alist hyp clk obligs config state))))
- (acl2::interp-defs-alistp
- (mv-nth 1 (glcp-generic-interp-list
- x alist hyp clk obligs config state))))
- :flag glcp-generic-interp-list)
- :hints (("goal" ;; :induct (glcp-generic-interp-flg flag x alist hyp clk obligs config state)
- :expand ((glcp-generic-interp-term x alist hyp clk obligs config state)
- (glcp-generic-interp-list x alist hyp clk obligs config state)
- (glcp-generic-interp-term nil alist hyp clk obligs config state)
- (glcp-generic-interp-list nil alist hyp clk obligs config state)
- (:free (a b) (acl2::interp-defs-alistp (cons a b))))
- :in-theory (e/d** (glcp-generic-interp-flg-equivalences
- car-cons cdr-cons ; pseudo-termp
-; pseudo-term-listp
- pseudo-termp-car
- pseudo-termp-car-last
- pseudo-term-listp-cdr
- pseudo-term-listp-cdr-pseudo-term
- pseudo-termp-symbolp-car-x
- pseudo-termp-lambda-body
- glcp-interp-error
- ;; Jared: changed from hons-get-fn-do-hopy to hons-get for new hons
- hons-get
- hons-acons hons-copy
- acl2::hons-assoc-equal-interp-defs-alistp
- acl2::interp-function-lookup-wfp
- acl2::interp-function-lookup-defs-alistp
- (:induction glcp-generic-interp-flg))))))
-
-
+ (defsection glcp-generic-geval
+ (local (in-theory (enable glcp-generic-geval)))
+ (acl2::def-functional-instance
+ glcp-generic-geval-shape-spec-oblig-term-correct
+ shape-spec-oblig-term-correct
+ ((sspec-geval-ev glcp-generic-geval-ev)
+ (sspec-geval-ev-lst glcp-generic-geval-ev-lst)
+ (sspec-geval glcp-generic-geval)
+ (sspec-geval-list glcp-generic-geval-list))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-apply-agrees-with-glcp-generic-geval-ev)
+ (glcp-generic-geval-apply))
+ :expand ((:with glcp-generic-geval (glcp-generic-geval x
+ env))))))
+ (acl2::def-functional-instance
+ glcp-generic-geval-shape-spec-list-oblig-term-correct
+ shape-spec-list-oblig-term-correct
+ ((sspec-geval-ev glcp-generic-geval-ev)
+ (sspec-geval-ev-lst glcp-generic-geval-ev-lst)
+ (sspec-geval glcp-generic-geval)
+ (sspec-geval-list glcp-generic-geval-list))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-apply-agrees-with-glcp-generic-geval-ev)
+ (glcp-generic-geval-apply))
+ :expand ((:with glcp-generic-geval (glcp-generic-geval x env))))))
- (in-theory (disable equal-of-booleans-rewrite))
-
- (defthm-glcp-generic-interp-flg
- (defthm true-listp-glcp-generic-interp-list
- (true-listp (mv-nth 2 (glcp-generic-interp-list
- x alist hyp clk obligs config state)))
- :hints(("Goal" :induct (len x)
- :expand (glcp-generic-interp-list
- x alist hyp clk obligs config state)))
- :flag list)
- :skip-others t)
-
- (include-book "system/f-put-global" :dir :system)
-
- (defthm-glcp-generic-interp-flg
- (defthm state-p1-glcp-generic-interp-term
- (implies (state-p1 state)
- (state-p1
- (mv-nth 3 (glcp-generic-interp-term
- x alist hyp clk obligs config state))))
- :flag glcp-generic-interp-term)
-
- (defthm state-p1-glcp-generic-interp-list
- (implies (state-p1 state)
- (state-p1
- (mv-nth 3 (glcp-generic-interp-list
- x alist hyp clk obligs config state))))
- :flag glcp-generic-interp-list)
- :hints (("goal" :induct (glcp-generic-interp-flg flag x alist hyp clk obligs config state)
- :expand ((glcp-generic-interp-term x alist hyp clk obligs config state)
- (glcp-generic-interp-list x alist hyp clk obligs config state)
- (glcp-generic-interp-term nil alist hyp clk obligs config state)
- (glcp-generic-interp-list nil alist hyp clk obligs config state))
- :in-theory (e/d** (glcp-generic-interp-flg-equivalences
- acl2::state-p1-put-global
- glcp-interp-error-fn
- ;; state-p1-glcp-generic-apply-concrete
- ;; glcp-generic-apply-concrete-guard-wrapper
- (:induction glcp-generic-interp-flg))))))
-
-
- (defthm true-listp-gl-cons
- (equal (true-listp (gl-cons x y))
- (true-listp y))
- :hints(("Goal" :in-theory (enable gl-cons))))
-
- (defthm-glcp-generic-interp-flg
- (defthm true-listp-glcp-generic-interp-list
- (true-listp (mv-nth 2 (glcp-generic-interp-list
- x alist hyp clk obligs config state)))
- :hints ('(:expand
- ((glcp-generic-interp-list
- x alist hyp clk obligs config state))))
- :rule-classes :type-prescription
- :flag glcp-generic-interp-list)
- :skip-others t)
-
- (defthm-glcp-generic-interp-flg
- (defthm gobj-listp-glcp-generic-interp-list
- (gobj-listp (mv-nth 2 (glcp-generic-interp-list
- x alist hyp clk obligs config state)))
- :hints ('(:expand
- ((glcp-generic-interp-list
- x alist hyp clk obligs config state))))
- :flag glcp-generic-interp-list)
- :skip-others t)))
-
-
-(local
- (defthm consp-last
- (equal (consp (last x))
- (consp x))))
-
-
-
-(set-ignore-ok t)
-
-(local (defthm plist-worldp-of-w-state
- (implies (state-p1 state)
- (plist-worldp (w state)))
- :hints(("Goal" :in-theory (e/d (state-p1 get-global w)
- (all-boundp))))))
-
-;; (defun get-guard-verification-theorem (name state)
-;; (declare (xargs :mode :program
-;; :stobjs state))
-;; (b* ((wrld (w state))
-;; (ctx 'get-guard-verification-theorem)
-;; ((er names) (acl2::chk-acceptable-verify-guards
-;; name ctx wrld state))
-;; (ens (acl2::ens state))
-;; ((mv clauses & state)
-;; (acl2::guard-obligation-clauses
-;; names nil ens wrld state))
-;; (term (acl2::termify-clause-set clauses)))
-;; (value term)))
+ (acl2::def-functional-instance
+ glcp-generic-geval-gobj-to-param-space-correct
+ gobj-to-param-space-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-apply-agrees-with-glcp-generic-geval-ev)
+ (glcp-generic-geval-apply))
+ :expand ((:with glcp-generic-geval (glcp-generic-geval x env))))))))
+;; redundant but included only locally
(make-event
(b* (((er &) (in-theory nil))
((er thm) (get-guard-verification-theorem 'glcp-generic-interp-term state)))
(value
`(defthm glcp-generic-interp-guards-ok
,thm
- :hints (("goal" :in-theory
- (e/d* (pseudo-termp-car-last-of-pseudo-term-listp
- gl-aside gl-ignore gl-error-is-nil)
- (glcp-generic-interp-term
- glcp-generic-interp-list
- consp-assoc-equal
- pseudo-term-listp
- w
- nonnil-symbol-listp-pseudo-term-listp true-listp symbol-listp
- not no-duplicatesp-equal
- fgetprop plist-worldp
- hons-assoc-equal
-; bfr-and-is-bfr-and
-; bfr-not-is-bfr-not
-; bfr-p-is-bfr-p
- assoc table-alist
- general-concrete-listp
- general-concretep-def
- state-p-implies-and-forward-to-state-p1
- (:rules-of-class :forward-chaining :here)
- (:rules-of-class :type-prescription :here)
- (force))
- ((:type-prescription glcp-generic-interp-term)
- (:type-prescription glcp-generic-interp-list)
- (:type-prescription acl2::interp-function-lookup)
- (:type-prescription general-concrete-obj-list)
- (:type-prescription hons-assoc-equal)))
- :do-not-induct t))
:rule-classes nil))))
-
-(local (defthm car-last-when-length-4
- (implies (equal (len x) 4)
- (equal (car (last x))
- (cadddr x)))
- :hints(("Goal" :in-theory (enable len last)))))
-
-(local
- (progn
- (include-book "tools/def-functional-instance" :dir :system)
-
- (acl2::def-functional-instance
- glcp-generic-interp-function-lookup-correct
- acl2::interp-function-lookup-correct
- ((acl2::ifl-ev glcp-generic-ev)
- (acl2::ifl-ev-lst glcp-generic-ev-lst)
- (acl2::ifl-ev-falsify glcp-generic-ev-falsify)
- (acl2::ifl-ev-meta-extract-global-badguy
- glcp-generic-ev-meta-extract-global-badguy))
- :hints ((and stable-under-simplificationp
- '(:use (glcp-generic-ev-of-fncall-args
- glcp-generic-ev-falsify
- glcp-generic-ev-meta-extract-global-badguy)))))
-
- (acl2::def-functional-instance
- glcp-generic-interp-function-lookup-theoremp-defs-history
- acl2::interp-function-lookup-theoremp-defs-history
- ((acl2::ifl-ev glcp-generic-ev)
- (acl2::ifl-ev-lst glcp-generic-ev-lst)
- (acl2::ifl-ev-falsify glcp-generic-ev-falsify)))
-
-
-
- (defthm glcp-generic-interp-function-lookup-theoremp-defs-history-rev
- (b* (((mv erp & & out-defs)
- (acl2::interp-function-lookup fn in-defs overrides world)))
- (implies (and (not (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses in-defs))))
- (not erp))
- (not (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses out-defs)))))))
-
- (defthm-glcp-generic-interp-flg
- (defthm glcp-generic-interp-term-bad-obligs
- (implies (and (not (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses obligs))))
- (not (mv-nth 0 (glcp-generic-interp-term
- x alist hyp clk obligs config state))))
- (not (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses
- (mv-nth 1 (glcp-generic-interp-term
- x alist hyp clk obligs config state)))))))
- :flag glcp-generic-interp-term)
- (defthm glcp-generic-interp-list-bad-obligs
- (implies (and (not (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses obligs))))
- (not (mv-nth 0 (glcp-generic-interp-list
- x alist hyp clk obligs config state))))
- (not (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses
- (mv-nth 1 (glcp-generic-interp-list
- x alist hyp clk obligs config state)))))))
- :flag glcp-generic-interp-list)
- :hints (("goal" :induct (glcp-generic-interp-flg flag x alist hyp clk obligs config state)
- :expand ((glcp-generic-interp-term x alist hyp clk obligs config state)
- (glcp-generic-interp-list x alist hyp clk obligs config state)
- (glcp-generic-interp-term nil alist hyp clk obligs config state)
- (glcp-generic-interp-list nil alist hyp clk obligs config state))
- :in-theory (e/d** (glcp-generic-interp-flg-equivalences
- hons-acons car-cons cdr-cons
- glcp-interp-error
- glcp-generic-interp-function-lookup-correct
- glcp-generic-interp-function-lookup-theoremp-defs-history
- acl2::interp-function-lookup-defs-alistp
- (:induction
- glcp-generic-interp-flg))))))
-
-
- (defthm glcp-generic-interp-term-ok-obligs
- (implies (and (not (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses obligs))))
- (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses
- (mv-nth 1 (glcp-generic-interp-term
- x alist hyp clk obligs config state))))))
- (mv-nth 0 (glcp-generic-interp-term
- x alist hyp clk obligs config state))))
-
- (defthm len-gl-cons
- (equal (len (gl-cons x y))
- (+ 1 (len y)))
- :hints(("Goal" :in-theory (enable gl-cons))))
-
-
- (defthm-glcp-generic-interp-flg
- glcp-generic-interp-list-len-lemma
- (glcp-generic-interp-term t :skip t)
- (glcp-generic-interp-list
- (mv-let (erp obligs res)
- (glcp-generic-interp-list
- x alist hyp clk obligs config state)
- (declare (ignore obligs))
- (implies (not erp)
- (equal (len res)
- (len x))))
- :name len-glcp-generic-interp-list)
- :hints (("goal" :induct (glcp-generic-interp-flg flag x alist hyp clk obligs
- config state)
- :expand ((glcp-generic-interp-list x alist hyp clk obligs config state)
- (glcp-generic-interp-list nil alist hyp clk obligs config state)))))
-
-
- (defthm glcp-generic-obligs-okp-final-implies-start
- (implies (and (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses
- (mv-nth 1 (glcp-generic-interp-term
- x alist hyp clk obligs config state)))))
- (not (mv-nth 0 (glcp-generic-interp-term
- x alist hyp clk obligs config state))))
- (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses
- obligs))))
- :rule-classes :forward-chaining)
-
-
- (defthm assoc-eq-glcp-generic-geval-alist
- (implies (alistp alist)
- (equal (cdr (assoc-eq x (glcp-generic-geval-alist alist env)))
- (glcp-generic-geval (cdr (hons-assoc-equal x alist)) env))))
-
-
- (defthm glcp-generic-geval-lst-general-concrete-obj-list
- (implies (and (general-concrete-listp x)
- (gobj-listp x))
- (equal (glcp-generic-geval x env)
- (general-concrete-obj-list x)))
- :hints(("Goal" :in-theory (e/d (gobj-listp) ()))))
-
-
- (defthm glcp-generic-ev-nil
- (equal (glcp-generic-ev nil a) nil))
-
-
-
-
- (defun glcp-generic-ev-constraint-hint (clause)
- (declare (xargs :guard (true-listp clause)))
- (cond
- ((member-equal '(not (equal flag 'glcp-generic-interp-term)) clause)
- (cond
- ((member-equal '(not (consp x)) clause)
- (cond
- ((member-equal '(not (equal (car x) 'if)) clause)
- '(:in-theory (enable glcp-generic-ev-of-if-call)))
- ((member-equal '(not (equal (car x) 'return-last)) clause)
- '(:in-theory (enable glcp-generic-ev-of-return-last-call)))
- ((member-equal '(not (equal (car x) 'gl-aside)) clause)
- '(:in-theory (enable glcp-generic-ev-of-gl-aside-call)))
- ((member-equal '(not (equal (car x) 'gl-ignore)) clause)
- '(:in-theory (enable glcp-generic-ev-of-gl-ignore-call)))
- ((member-equal '(not (equal (car x) 'gl-error)) clause)
- '(:in-theory (enable glcp-generic-ev-of-gl-error-call)))
- ((member-equal '(not (equal (car x) 'quote)) clause)
- '(:in-theory (enable glcp-generic-ev-of-quote)))
- ((member-equal '(not (consp (car x))) clause)
- '(:in-theory (enable glcp-generic-ev-of-lambda)))))
- ((member-equal '(not (symbolp x)) clause)
- '(:in-theory (enable glcp-generic-ev-of-variable)))))
- ((member-equal '(equal flag 'glcp-generic-interp-term) clause)
- (cond
- ((member-equal '(consp x) clause)
- '(:in-theory (enable glcp-generic-ev-lst-of-atom)))
- ((member-equal '(not (consp x)) clause)
- '(:in-theory (enable glcp-generic-ev-lst-of-cons)))))))
-
- (encapsulate nil
- (local
- (in-theory (e/d** (glcp-generic-geval-gobj-ite-merge-correct
- ; glcp-generic-geval-atom
- (:rules-of-class :executable-counterpart :here)
- pseudo-termp-car-last
- car-last-when-length-4
- gl-aside gl-ignore gl-error-is-nil
- (:induction glcp-generic-interp-flg)
- glcp-generic-interp-flg-equivalences
- ;; glcp-generic-apply-concrete-correct
- alistp-pairlis
- acl2::cons-car-cdr
- glcp-generic-ev-nil
- glcp-interp-error
- glcp-generic-geval-lst-general-concrete-obj-list
- gobj-listp-glcp-generic-interp-list
- acl2::hons-assoc-equal-interp-defs-alistp
- obligs-okp-glcp-generic-interp-list
- assoc-eq-glcp-generic-geval-alist
- glcp-generic-interp-term-w-state-preserved
- glcp-generic-interp-list-w-state-preserved
- ;; w-state-of-glcp-generic-apply-concrete
- ;; glcp-generic-ev-constraint-9
- ;; glcp-generic-ev-constraint-3
- ;; glcp-generic-ev-constraint-6
- ;; glcp-generic-ev-constraint-2
- ;; glcp-generic-ev-constraint-1
- ;; glcp-generic-ev-constraint-5
- ;; glcp-generic-ev-constraint-4
- pseudo-termp-car
- pseudo-term-listp-cdr
- pseudo-termp-symbolp-car-x
- len-glcp-generic-interp-list
- pseudo-term-listp-cdr-pseudo-term
- pseudo-termp-lambda-body
- car-cons cdr-cons hons-equal
- ;; glcp-generic-apply-concrete-wrapper-unwrap
- glcp-generic-geval-alist-pairlis$
- obligs-okp-glcp-generic-interp-term
- obligs-okp-glcp-generic-interp-list
- acl2::interp-function-lookup-defs-alistp
- acl2::interp-function-lookup-wfp
- glcp-generic-interp-function-lookup-correct
- glcp-generic-interp-function-lookup-theoremp-defs-history-rev
- ;; Jared: blah blah hons-get-fn-do-hopy
- hons-get
- eql
- glcp-generic-obligs-okp-final-implies-start
- glcp-generic-interp-term-bad-obligs
- glcp-generic-interp-list-bad-obligs
- ;; glcp-generic-obligs-okp-implies-glcp-generic-ev-fncall-equals-body-arbitrary-args
- ;; glcp-generic-ev-theoremp-implies-glcp-generic-ev-fncall-equals-body-arbitrary-args
- ;;glcp-generic-obligs-okp-hons-acons-implies
- ;;glcp-generic-obligs-okp-hons-assoc-equal
- ;; glcp-generic-ev-lst-pairlis-nonnil-symbol-list
- glcp-generic-run-gified-correct
- bfr-eval-consts
- bfr-and-of-nil (bfr-not)
- bfr-eval-bfr-not bfr-eval-bfr-binary-and
- bfr-eval-bfr-binary-or
- glcp-generic-geval-mk-g-boolean-correct
- glcp-generic-geval-mk-g-ite-correct
- glcp-generic-geval-gtests-nonnil-correct
- hyp-fix-correct
- glcp-generic-geval-gtests-obj-correct
- glcp-generic-geval-mk-g-concrete-correct
- glcp-generic-geval-g-concrete-quote-correct
- GLCP-GENERIC-GEVAL-OF-GL-CONS)
- ())))
-
- ;; (local (add-bfr-fn-pat hyp-fix))
- ;; (local (add-bfr-fn-pat bfr-and))
- ;; (local (add-bfr-fn-pat bfr-or))
- ;; (local (add-bfr-fn-pat bfr-not))
- ;; (local (add-bfr-fn-pat gtests-unknown))
- ;; (local (add-bfr-fn-pat gtests-nonnil))
- ;; (local (bfr-reasoning-mode t))
-
-;; (local (defthm hyp-fix-iff-bfr-and
-;; (iff (hyp-fix x hyp)
-;; (bfr-and x hyp))
-;; :hints(("Goal" :in-theory (enable hyp-fix acl2::bfr-and-of-nil
-;; bfr-and)))))
-
- (local
- (encapsulate nil
- (local (bfr-reasoning-mode t))
- (local (acl2::set-bdd-patterns '((hyp-fix . &) 't 'nil)))
- (defthm bfr-eval-gtests-unknown
- (implies (and (not (hf (gtests-unknown (gtests test hyp))))
- (bfr-eval hyp env))
- (not (bfr-eval (gtests-unknown (gtests test hyp)) env))))
-
- (defthm bfr-eval-gtests-unknown-or
- (implies (and (not (hf (bfr-or (gtests-unknown (gtests test hyp)) other)))
- (bfr-eval hyp env))
- (not (bfr-eval (gtests-unknown (gtests test hyp)) env))))
-
-
- (defthm geval-of-interp-res-hyp-fix-unknown-false
- (implies (and (not (glcp-generic-geval interp-res env))
- (bfr-eval hyp (car env)))
- (hyp-fix (bfr-or
- (gtests-unknown (gtests interp-res hyp))
- (bfr-not
- (gtests-nonnil (gtests interp-res hyp))))
- hyp)))
-
- (defthm geval-of-interp-res-hyp-fix-unknown-true
- (implies (and (glcp-generic-geval interp-res env)
- (bfr-eval hyp (car env)))
- (hyp-fix (bfr-or
- (gtests-unknown (gtests interp-res hyp))
- (gtests-nonnil (gtests interp-res hyp)))
- hyp)))
-
- (defthm gtests-nonnil-or-not
- (implies
- (and
- (bfr-eval hyp (car env))
- (not
- (hyp-fix
- (bfr-or
- (gtests-unknown (gtests test hyp))
- (gtests-nonnil (gtests test hyp)))
- hyp)))
- (hyp-fix
- (bfr-or
- (gtests-unknown (gtests test hyp))
- (bfr-not (gtests-nonnil (gtests test hyp))))
- hyp)))))
-
-
- (defthm glcp-generic-interp-function-lookup-correct-special
- (mv-let (erp body formals out-defs)
- (acl2::interp-function-lookup fn in-defs overrides (w state))
- (implies (and (not erp)
- (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses out-defs)))
- (acl2::interp-defs-alistp in-defs)
- (acl2::interp-defs-alistp overrides)
- (equal (len formals) (len actuals))
- (not (eq fn 'quote))
- (glcp-generic-ev-meta-extract-global-facts :state state1)
- (equal (w state) (w state1)))
- (equal (glcp-generic-ev body (pairlis$ formals
- (glcp-generic-ev-lst actuals a)))
- (glcp-generic-ev (cons fn actuals) a)))))
-
- (defthm glcp-generic-ev-magic-ev-fncall-special
- (b* (((mv erp val)
- (acl2::magic-ev-fncall f args st t nil)))
- (implies (and (glcp-generic-ev-meta-extract-global-facts)
- (equal (w st) (w state))
- (not erp))
- (equal val
- (glcp-generic-ev (cons f (kwote-lst args)) nil))))
- :hints(("Goal" :in-theory (enable glcp-generic-ev-meta-extract-fncall))))
-
- (in-theory (disable glcp-generic-ev-meta-extract-fncall))
- (local (in-theory (disable glcp-generic-interp-term-ok-obligs
- (:type-prescription hyp-fix)
- hyp-fix-of-hyp-fixedp)))
-
- (defthm-glcp-generic-interp-flg
- (defthm glcp-generic-interp-term-correct
- (implies (and (bfr-eval hyp (car env))
- (alistp alist)
- (pseudo-termp x)
- (not (mv-nth 0 (glcp-generic-interp-term
- x alist hyp clk obligs config state)))
- (acl2::interp-defs-alistp obligs)
- (acl2::interp-defs-alistp (glcp-config->overrides config))
- (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses
- (mv-nth 1 (glcp-generic-interp-term
- x alist hyp clk obligs config state)))))
- ;; (glcp-generic-ev-meta-extract-global-facts)
- (glcp-generic-ev-meta-extract-global-facts :state state1)
- (equal (w state1) (w state)))
- (equal (glcp-generic-geval
- (mv-nth 2 (glcp-generic-interp-term
- x alist hyp clk obligs config state))
- env)
- (glcp-generic-ev x (glcp-generic-geval-alist alist env))))
- :flag glcp-generic-interp-term)
-
- (defthm glcp-generic-interp-list-correct
- (implies (and (bfr-eval hyp (car env))
- (not (mv-nth 0 (glcp-generic-interp-list
- x alist hyp clk obligs config state)))
- (acl2::interp-defs-alistp obligs)
- (acl2::interp-defs-alistp (glcp-config->overrides config))
- (alistp alist)
- (pseudo-term-listp x)
- (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses
- (mv-nth 1 (glcp-generic-interp-list
- x alist hyp clk obligs config state)))))
- (glcp-generic-ev-meta-extract-global-facts :state state1)
- (equal (w state1) (w state)))
- (equal (glcp-generic-geval
- (mv-nth 2 (glcp-generic-interp-list
- x alist hyp clk obligs config state))
- env)
- (glcp-generic-ev-lst x (glcp-generic-geval-alist alist env))))
- :flag glcp-generic-interp-list)
- :hints (("goal" ;; :induct (glcp-generic-interp-flg flag x alist hyp clk obligs config state)
- :expand
- ((glcp-generic-interp-term x alist hyp clk obligs config state)
- (glcp-generic-interp-list x alist hyp clk obligs config state)
- (glcp-generic-interp-term nil alist hyp clk obligs config state)
- (glcp-generic-interp-list nil alist hyp clk obligs config state))
- :do-not '(generalize fertilize)
- :do-not-induct t)
- (glcp-generic-ev-constraint-hint clause)
- (and stable-under-simplificationp
- (case-match id
- ((('0 '1) (n . &) . &)
- '(:in-theory
- (enable
- glcp-generic-ev-of-fncall-args)))))
-;; (if stable-under-simplificationp
-;; (let ((state (acl2::f-put-global
-;; 'evbdd-cp-clauses
-;; (cons clause
-;; (and (boundp-global 'evbdd-cp-clauses
-;; state)
-;; (@ evbdd-cp-clauses)))
-;; state)))
-;; (value '(:clause-processor
-;; (acl2::bfr-eval-cp
-;; clause
-;; (list '('t 'nil)
-;; '((hyp-fix . &)
-;; ;; (bfr-or . &)
-;; ;; (bfr-not . &)
-;; ;; (bfr-and . &)
-;; ;; (gtests-unknown . &)
-;; ;; (gtests-nonnil . &)
-;; ;; 'nil 't
-;; )
-;; ;; '((car env))
-;; t)))))
-;; (value nil))
- )))))
-
-(in-theory (disable glcp-generic-interp-term))
-
-
(defun strip-cadrs (x)
(if (atom x)
nil
@@ -1376,24 +126,9 @@
(collect-vars-list (cdr x))))))
-(defun shape-spec-bindingsp (x)
- (declare (xargs :guard t))
- (if (atom x)
- (equal x nil)
- (and (consp (car x))
- (symbolp (caar x))
- (not (keywordp (caar x)))
- (caar x)
- (consp (cdar x))
- (shape-specp (cadar x))
- (shape-spec-bindingsp (cdr x)))))
-(defun gobj-alist-to-param-space (alist p)
- (if (atom alist)
- nil
- (cons (cons (caar alist) (gobj-to-param-space (cdar alist) p))
- (gobj-alist-to-param-space (cdr alist) p))))
+
@@ -1435,26 +170,26 @@
:hints ((acl2::set-reasoning)))
(defthm-collect-vars-flg
- glcp-generic-ev-norm-alist-collect-vars-lemma
+ glcp-generic-geval-ev-norm-alist-collect-vars-lemma
(collect-vars
(implies (and (pseudo-termp x)
(subsetp-equal (collect-vars x) vars))
- (equal (glcp-generic-ev x (norm-alist vars alist))
- (glcp-generic-ev x alist)))
- :name glcp-generic-ev-norm-alist-collect-vars1)
+ (equal (glcp-generic-geval-ev x (norm-alist vars alist))
+ (glcp-generic-geval-ev x alist)))
+ :name glcp-generic-geval-ev-norm-alist-collect-vars1)
(collect-vars-list
(implies (and (pseudo-term-listp x)
(subsetp-equal (collect-vars-list x) vars))
- (equal (glcp-generic-ev-lst x (norm-alist vars alist))
- (glcp-generic-ev-lst x alist)))
- :name glcp-generic-ev-lst-norm-alist-collect-vars-list1)
+ (equal (glcp-generic-geval-ev-lst x (norm-alist vars alist))
+ (glcp-generic-geval-ev-lst x alist)))
+ :name glcp-generic-geval-ev-lst-norm-alist-collect-vars-list1)
:hints (("goal" :induct (collect-vars-flg flag x)
:in-theory (enable subsetp-equal))
("Subgoal *1/3"
- :in-theory (enable glcp-generic-ev-of-fncall-args))))
+ :in-theory (enable glcp-generic-geval-ev-of-fncall-args))))
+
-
(encapsulate nil
(local (defthm member-equal-second-revappend
@@ -1508,8 +243,8 @@
(glcp-generic-geval x env))
:hints (("goal" :use ((:instance glcp-generic-geval-of-gl-cons)
(:instance
- glcp-generic-geval-g-concrete-quote-correct))
- :expand ((gobject-hierarchy-lite x))
+ glcp-generic-geval-g-concrete-quote-correct
+ (b env)))
:in-theory (e/d (gl-cons g-concrete-quote g-keyword-symbolp)
(glcp-generic-geval-of-gl-cons
glcp-generic-geval-g-concrete-quote-correct))))))
@@ -1518,15 +253,15 @@
(implies (alistp x)
(equal (glcp-generic-geval-alist x env)
(pairlis$ (strip-cars x)
- (glcp-generic-geval (gobj-strip-cdrs x) env))))
- :hints(("Goal" :in-theory (enable strip-cars))))
+ (glcp-generic-geval-list (strip-cdrs x) env))))
+ :hints(("Goal" :in-theory (enable strip-cars glcp-generic-geval-alist))))
(defthm strip-cdrs-shape-specs-to-interp-al
(implies (shape-spec-bindingsp x)
- (equal (gobj-strip-cdrs (shape-specs-to-interp-al x))
- (shape-spec-to-gobj (strip-cadrs x))))
+ (equal (strip-cdrs (shape-specs-to-interp-al x))
+ (shape-spec-to-gobj-list (strip-cadrs x))))
:hints(("Goal" :induct (len x)
- :expand ((:free (a b) (shape-spec-to-gobj (cons a b)))))))
+ :expand ((:free (a b) (shape-spec-to-gobj-list (cons a b)))))))
;; (defthm gobject-alistp-gobj-alist-to-param-space
@@ -1534,8 +269,9 @@
;; (gobject-alistp (gobj-alist-to-param-space x p))))
(defthm strip-cars-gobj-alist-to-param-space
- (equal (strip-cars (gobj-alist-to-param-space x p))
- (strip-cars x)))
+ (implies (alistp x)
+ (equal (strip-cars (gobj-alist-to-param-space x p))
+ (strip-cars x))))
(defthm gobj-to-param-space-of-gl-cons
(equal (gobj-to-param-space (gl-cons a b) p)
@@ -1546,17 +282,17 @@
gl-cons tag)
:expand ((:free (a b) (gobj-to-param-space (cons a b) p))))))
- (defthm strip-cdrs-gobj-alist-to-param-space
- (equal (gobj-strip-cdrs (gobj-alist-to-param-space x p))
- (gobj-to-param-space (gobj-strip-cdrs x) p))
- :hints(("Goal" :in-theory (enable strip-cdrs
- gobj-to-param-space
- tag)
- :induct (gobj-alist-to-param-space x p)
- :expand ((:free (a b) (gobj-to-param-space (cons a b) p))))))
+ ;; (defthm strip-cdrs-gobj-alist-to-param-space
+ ;; (equal (gobj-strip-cdrs (gobj-alist-to-param-space x p))
+ ;; (gobj-to-param-space (gobj-strip-cdrs x) p))
+ ;; :hints(("Goal" :in-theory (enable strip-cdrs
+ ;; gobj-to-param-space
+ ;; tag)
+ ;; :induct (gobj-alist-to-param-space x p)
+ ;; :expand ((:free (a b) (gobj-to-param-space (cons a b) p))))))
- (defthm alistp-gobj-alist-to-param-space
- (alistp (gobj-alist-to-param-space x p)))
+ ;; (defthm alistp-gobj-alist-to-param-space
+ ;; (alistp (gobj-alist-to-param-space x p)))
(defthm nonnil-symbol-listp-strip-cars-shape-spec-bindings
@@ -1567,7 +303,8 @@
(defthm shape-spec-listp-strip-cadrs
(implies (shape-spec-bindingsp x)
- (shape-spec-listp (strip-cadrs x))))
+ (shape-spec-listp (strip-cadrs x)))
+ :hints(("Goal" :in-theory (enable shape-spec-listp))))
(defthm shape-specp-strip-cadrs-bindings
(implies (shape-spec-bindingsp x)
@@ -1578,23 +315,9 @@
-(defun quote-if-needed (obj)
- (declare (xargs :mode :logic :guard t))
- (if (or (booleanp obj)
- (keywordp obj)
- (acl2-numberp obj)
- (characterp obj)
- (stringp obj))
- obj
- (list 'quote obj)))
-(defun bindings-quote-if-needed (bindings)
- (declare (xargs :guard (true-list-listp bindings)))
- (if (atom bindings)
- nil
- (cons (list (caar bindings)
- (quote-if-needed (cadar bindings)))
- (bindings-quote-if-needed (cdr bindings)))))
+
+
(defun glcp-make-pretty-bindings (alist)
(if (atom alist)
@@ -1638,211 +361,39 @@
(max (max-list (car x))
(max-list-list (cdr x)))))
-(defund inspec-max-index (x)
- (if (atom x)
- 0
- (pattern-match x
- ((g-concrete &) 0)
- ((g-boolean b) b)
- ((g-number n) (max-list-list n))
- ((g-ite if then else)
- (max (inspec-max-index if)
- (max (inspec-max-index then)
- (inspec-max-index else))))
- ((g-apply & args) (inspec-max-index args))
- ((g-var &) 0)
- (& (max (inspec-max-index (car x))
- (inspec-max-index (cdr x)))))))
+;; (defund inspec-max-index (x)
+;; (if (atom x)
+;; 0
+;; (pattern-match x
+;; ((g-concrete &) 0)
+;; ((g-boolean b) b)
+;; ((g-number n) (max-list-list n))
+;; ((g-ite if then else)
+;; (max (inspec-max-index if)
+;; (max (inspec-max-index then)
+;; (inspec-max-index else))))
+;; ((g-apply & args) (inspec-max-index args))
+;; ((g-var &) 0)
+;; (& (max (inspec-max-index (car x))
+;; (inspec-max-index (cdr x)))))))
-(defun bool-to-bit (x)
- (cond ((eq x t) 1)
- ((eq x nil) 0)
- (t x)))
-(defun nth-list-bits (x lst)
- (if (atom x)
- nil
- (cons (bool-to-bit (nth (car x) lst))
- (nth-list-bits (cdr x) lst))))
-(defun nth-list-list-bits (x lst)
- (if (atom x)
- nil
- (cons (nth-list-bits (car x) lst)
- (nth-list-list-bits (cdr x) lst))))
-;; To-satisfying-assign-spec generates the same satisfying assignment as
-;; to-satisfying-assign given the same lst and bdd, except that when a
-;; variable's value is irrelevant (car and cdr are equal), we put X in the list
-;; instead of T or NIL.
-(defun to-satisfying-assign-spec (lst bdd)
- (declare (xargs :hints (("goal" :in-theory (enable acl2-count)))))
- (cond ((atom bdd) lst)
- ((eq (cdr bdd) nil) (cons t (to-satisfying-assign-spec lst (car bdd))))
- ((eq (car bdd) nil) (cons nil (to-satisfying-assign-spec lst (cdr bdd))))
- ((hqual (car bdd) (cdr bdd))
- (cons 'x (to-satisfying-assign-spec (cdr lst) (car bdd))))
- (t (cons (car lst) (to-satisfying-assign-spec
- (cdr lst)
- (if (car lst) (car bdd) (cdr bdd)))))))
-;; For each index N in an shape spec, this substitutes the Nth value found in
-;; lst. In the number case, it substitutes 1 and 0 for booleans.
-(defund inspec-show-assign-spec (x lst)
- (if (atom x)
- x
- (pattern-match x
- ((g-concrete &) x)
- ((g-boolean b) (g-boolean (nth b lst)))
- ((g-number n) (g-number (nth-list-list-bits n lst)))
- ((g-ite if then else)
- (g-ite (inspec-show-assign-spec if lst)
- (inspec-show-assign-spec then lst)
- (inspec-show-assign-spec else lst)))
- ((g-apply fn args) (g-apply fn (inspec-show-assign-spec args lst)))
- ((g-var &) x)
- (& (cons (inspec-show-assign-spec (car x) lst)
- (inspec-show-assign-spec (cdr x) lst))))))
-
-
-(include-book "centaur/misc/vecs-ints" :dir :system)
-
-
-(defun n-satisfying-assigns-and-specs (n hyp-bdd bdd bound state)
- (if (zp n)
- (value nil)
- (b* (((mv rand state) (acl2::random$ (ash 1 bound) state))
- (lst (acl2::nat-to-v rand bound))
- ;; From when we passed in the unparametrized counterexample BDD:
-;; (assign (to-satisfying-assign lst bdd))
-;; (assign-spec (to-satisfying-assign-spec lst bdd))
- (assign (acl2::unparam-env hyp-bdd (to-satisfying-assign lst bdd)))
- (assign-spec (acl2::unparam-env hyp-bdd (to-satisfying-assign-spec lst bdd)))
- ((er rest) (n-satisfying-assigns-and-specs (1- n) hyp-bdd bdd bound state)))
- (value (cons (list* "generated randomly:" assign assign-spec) rest)))))
-
-(defthm n-satisfying-assigns-does-not-fail
- (not (mv-nth 0 (n-satisfying-assigns-and-specs n hyp-bdd bdd bound state))))
-
-
-(defun vars-onto-alist (vars val al)
- (if (atom vars)
- al
- (if (hons-get (car vars) al)
- (vars-onto-alist (cdr vars) val al)
- (vars-onto-alist (cdr vars) val (hons-acons (car vars) val al)))))
-
-(defun glcp-gen-assignments (ctrex-info alist hyp-bdd n state)
- (if (and (bfr-mode) ;; AIG mode
- (bfr-counterex-mode)) ;; alist counterexample mode
- (b* ((al (acl2::aig-extract-iterated-assigns-alist hyp-bdd 10))
- ;; Careful: al is memoized so we can't steal it.
- (cex-alist (hons-shrink-alist (append al ctrex-info) nil)))
- (value (list (list "counterexample from SAT:"
- (vars-onto-alist
- ;; WRONG:
- ;; Hmm, logically this isn't really well-typed,
- ;; because alist consists of real g-objects whereas
- ;; shape-spec-indices wants shape-specs. But in the
- ;; AIG case, parametrization doesn't do anything, so
- ;; this works. If we were to apply this in cases
- ;; where alist was not generated by parametrizing a
- ;; shape-spec-alist, this would need to be changed.
-
- ;; Actually, parametrization gets rid of any AIG
- ;; variables that are constrained to concrete values.
- ;; So we need to reproduce the parametrized binding
- ;; alist here.
- (shape-spec-indices (strip-cdrs alist)) nil
- cex-alist)))))
- (b* ((bound (inspec-max-index alist))
- ((er assigns) (n-satisfying-assigns-and-specs
- (max 0 (- n 2)) hyp-bdd ctrex-info bound state))
- (nils (acl2::nat-to-v 0 bound))
- (ts (acl2::nat-to-v -1 bound)))
- (value (take n
- (list* (list* "generated by assigning 0/NIL to all possible bits:"
- (acl2::unparam-env
- hyp-bdd
- (to-satisfying-assign nils ctrex-info))
- (acl2::unparam-env
- hyp-bdd
- (to-satisfying-assign-spec nils ctrex-info)))
- (list* "generated by assigning 1/T to all possible bits:"
- (acl2::unparam-env
- hyp-bdd
- (to-satisfying-assign ts ctrex-info))
- (acl2::unparam-env
- hyp-bdd
- (to-satisfying-assign-spec ts ctrex-info)))
- assigns))))))
-
-(defthm glcp-gen-assignments-does-not-fail
- (not (mv-nth 0 (glcp-gen-assignments n hyp-bdd bdd bound state))))
-
-
-(defun glcp-pretty-print-assignments (n ctrexes concl execp state)
- (declare (xargs :stobjs state
- :guard (and (natp n)
- (true-list-listp ctrexes)
- (pseudo-termp concl))))
- (if (atom ctrexes)
- nil
- (b* (((list string assign-alist assign-spec-alist) (car ctrexes))
- (bindings (ec-call (bindings-quote-if-needed assign-alist)))
- (- (if (bfr-mode)
- (cw "Example ~x2, ~@0~%Assignment:~%~x1~%~%" string bindings n)
- (cw "Example ~x3, ~@0~%Template:~%~x1~%Assignment:~%~x2~%~%" string assign-spec-alist
- bindings n)))
- ((unless execp)
- (glcp-pretty-print-assignments (1+ n) (cdr ctrexes) concl execp state))
- (- (cw "Running conclusion:~%"))
- ;; ((acl2::cmp concl-term)
- ;; (acl2::translate-cmp
- ;; concl t t t 'glcp-print-ctrexamples (w state)
- ;; (default-state-vars state)))
-
- ;; assign-alist is actually of the form
- ;; ((var0 val0) (var1 val1)...) --
- ;; change it to ((var0 . val0) (var1 . val1) ...)
- (alist (pairlis$ (acl2::alist-keys assign-alist)
- (acl2::alist-keys (acl2::alist-vals assign-alist))))
- ((mv err val)
- (ec-call (acl2::magic-ev concl alist state t t)))
- ((when err)
- (cw "Failed to execute the counterexample: ~@0~%" err))
- (- (cw "Result: ~x0~%~%" val)))
- (glcp-pretty-print-assignments (1+ n) (cdr ctrexes) concl execp state))))
-
-(defun glcp-print-ctrexamples (ctrexes warn-err type concl execp state)
- (declare (xargs :stobjs state
- :guard (and (true-list-listp ctrexes)
- (pseudo-termp concl))))
- (b* ((- (cw "
-*** SYMBOLIC EXECUTION ~@0 ***: ~@1 found." warn-err type))
- (- (and ctrexes
- (if (and (bfr-mode)
- (bfr-counterex-mode))
- (cw "~%Showing the example produced by SAT.~%~%")
- (cw "
-Showing ~x0 examples. Each example consists of a template and a
-concrete assignment. The template shows a class of examples, and the
-concrete assignment represents a specific example from that
-class:~%~%" (len ctrexes))))))
- (glcp-pretty-print-assignments 1 ctrexes concl execp state)))
;; (defun glcp-counterexample-wormhole (ctrexes warn-err type concl execp)
;; (wormhole
@@ -1870,157 +421,105 @@
(add-macro-alias glcp-error glcp-error-fn)
-(defun glcp-bit-to-obj-ctrexamples (assigns sspec-alist gobj-alist)
- (if (atom assigns)
- nil
- (cons (list (caar assigns)
- (generic-geval gobj-alist (list (cadar assigns)))
- (inspec-show-assign-spec sspec-alist (cddar assigns)))
- (glcp-bit-to-obj-ctrexamples (cdr assigns) sspec-alist gobj-alist))))
-
-(defun glcp-gen-ctrexes (ctrex-info alist hyp-bdd n state)
- (b* (((er assigns) (glcp-gen-assignments ctrex-info alist hyp-bdd n state)))
- (value (glcp-bit-to-obj-ctrexamples assigns alist (shape-spec-to-gobj
- alist)))))
-
-(defthm glcp-gen-ctrexes-does-not-fail
- (not (mv-nth 0 (glcp-gen-ctrexes n hyp-bdd bdd bound state)))
- :hints(("Goal" :in-theory (disable glcp-gen-assignments))))
-
-(in-theory (disable glcp-gen-ctrexes))
-
-(defun glcp-analyze-interp-result (val al hyp-bdd id concl config state)
- (b* (((glcp-config config) config)
- (test (gtests val t))
- (hyp-param (bfr-to-param-space hyp-bdd hyp-bdd))
- (unk (bfr-and hyp-param (gtests-unknown test)))
- (false (bfr-and hyp-param
- (bfr-not (gtests-unknown test))
- (bfr-not (gtests-nonnil test))))
+
+
+
+
+
+
+
+(defun glcp-analyze-interp-result (hyp-bfr concl-bfr constraint al id concl config bvar-db
+ state)
+ (declare (xargs :stobjs (bvar-db state)
+ :verify-guards nil))
+ (b* ((config (glcp-config-update-param hyp-bfr config))
+ (config (glcp-config-update-term concl config))
+ ((glcp-config config) config)
+ (hyp-param (bfr-to-param-space hyp-bfr hyp-bfr))
+ (false (bfr-and hyp-param (bfr-and constraint (bfr-not concl-bfr))))
(state (acl2::f-put-global 'glcp-var-bindings al state))
- (state (acl2::f-put-global 'glcp-counterex false state))
- (state (acl2::f-put-global 'glcp-indeterminate unk state))
+ (state (acl2::f-put-global 'glcp-concl-bfr false state))
((mv false-sat false-succ false-ctrex) (bfr-sat false))
((when (and false-sat false-succ))
- (b* (((er ctrexes) (glcp-gen-ctrexes
- false-ctrex al hyp-bdd config.nexamples state))
- (state (acl2::f-put-global 'glcp-counterex-assignments
- ctrexes state)))
- (prog2$ (glcp-print-ctrexamples
- ctrexes "ERROR" "Counterexamples"
- concl config.exec-ctrex state)
- (if config.abort-ctrex
- (glcp-error
- (acl2::msg "~
-~x0: Counterexamples found in ~@1; aborting~%" config.clause-proc-name id))
- (value (list ''nil))))))
- ;; False was either unsat or the check failed. Either way we check unknown.
- ((mv unk-sat unk-succ unk-ctrex) (bfr-sat unk))
- ((when (and unk-sat unk-succ))
- (b* (((er ctrexes) (glcp-gen-ctrexes
- unk-ctrex al hyp-bdd config.nexamples state))
- (state (acl2::f-put-global 'glcp-indeterminate-assignments
- ctrexes state)))
- (prog2$ (glcp-print-ctrexamples
- ctrexes (if config.abort-unknown "ERROR" "WARNING")
- "Indeterminate results" concl config.exec-ctrex state)
- (if config.abort-unknown
- (glcp-error
- (acl2::msg "~
-~x0: Indeterminate results found in ~@1; aborting~%"
- config.clause-proc-name id))
- (value (list ''nil))
- ;; NOTE: We used to produce the following clause when an
- ;; unknown result was encountered, giving the user the chance
- ;; to prove that the resulting symbolic object actually
- ;; represented something constant-true. But this seems
- ;; impractical, and it requires that the evaluator used to
- ;; prove the clause processor correct recognize geval, which
- ;; causes soundness problems regarding bfr-mode attachment,
- ;; because we're producing a term whose meaning depends on
- ;; the current bfr-mode. A fix might be to create separate
- ;; geval functions for the separate bfr modes and put down
- ;; whichever matches the current bfr mode.
- ;;
- ;; (value `((not (gl-cp-hint 'result))
- ;; (,geval-name ',val env)))
- ))))
- ((when (and false-succ unk-succ))
+ (b* (((mv er & state)
+ (glcp-gen/print-ctrexamples
+ false-ctrex "ERROR" "Counterexamples" config bvar-db state))
+ ((when er) (mv er nil state))
+ ((when config.abort-ctrex)
+ (mv (msg
+ "~x0: Counterexamples found in ~@1; aborting~%"
+ config.clause-proc-name id)
+ nil state)))
+ (value (list ''nil))))
+ ((when false-succ)
;; Both checks succeeded and were UNSAT, so the theorem is proved
;; (modulo side-goals).
(value (list ''t))))
- ;; One or both of the SAT checks failed.
+ ;; The SAT check failed:
(if config.abort-unknown
- (glcp-error
- (acl2::msg "~ ~x0: SAT check failed in ~@1; aborting~%"
- config.clause-proc-name id))
- (value (list ''nil))
- ;; NOTE: See above comment about soundness problems with
- ;; geval/bfr-mode/attachment.
-;; (value `((not (gl-cp-hint 'result))
-;; (,geval-name ',val env)))
- )))
-
-(local
- (encapsulate nil
- (local (defthm equal-of-cons
- (equal (equal (cons a b) c)
- (and (consp c)
- (equal a (car c))
- (equal b (cdr c))))))
- (defthm glcp-analyze-interp-result-irrelevant
- (and (implies (syntaxp (not (and (equal al ''nil)
- (equal concl ''nil)
- (equal st ''nil))))
- (and (equal (mv-nth 0 (glcp-analyze-interp-result
- val al hyp-bdd id concl config st))
- (mv-nth 0 (glcp-analyze-interp-result
- val nil hyp-bdd id nil config nil)))
- (equal (mv-nth 1 (glcp-analyze-interp-result
- val al hyp-bdd id concl config st))
- (mv-nth 1 (glcp-analyze-interp-result
- val nil hyp-bdd id nil config nil)))))
- ;; (implies (syntaxp (not (and (equal al ''nil)
- ;; (equal concl ''nil)
- ;; (equal st ''nil))))
- ;; (equal (mv-nth 1 (glcp-analyze-interp-result
- ;; val al hyp-bdd id concl config st))
- ;; (mv-nth 1 (glcp-analyze-interp-result
- ;; val nil hyp-bdd abort-unknown abort-ctrex nil nil
- ;; geval-name nil nil nil nil))))
- )
- :hints(("Goal" :in-theory '(glcp-analyze-interp-result
- glcp-gen-ctrexes-does-not-fail
- glcp-error))))))
+ (mv
+ (msg "~x0: SAT check failed in ~@1; aborting~%"
+ config.clause-proc-name id)
+ nil state)
+ (value (list ''nil)))))
+
+
+;; (local
+;; (encapsulate nil
+;; (local (defthm equal-of-cons
+;; (equal (equal (cons a b) c)
+;; (and (consp c)
+;; (equal a (car c))
+;; (equal b (cdr c))))))
+;; (defthm glcp-analyze-interp-result-irrelevant
+;; (and (implies (syntaxp (not (and (equal al ''nil)
+;; (equal concl ''nil)
+;; (equal st ''nil))))
+;; (and (equal (mv-nth 0 (glcp-analyze-interp-result
+;; val al hyp-bfr id concl config
+;; bvar-db st))
+;; (mv-nth 0 (glcp-analyze-interp-result
+;; val nil hyp-bfr id concl config nil nil)))
+;; (equal (mv-nth 1 (glcp-analyze-interp-result
+;; val al hyp-bfr id concl config
+;; bvar-db st))
+;; (mv-nth 1 (glcp-analyze-interp-result
+;; val nil hyp-bfr id concl config nil nil)))))
+;; ;; (implies (syntaxp (not (and (equal al ''nil)
+;; ;; (equal concl ''nil)
+;; ;; (equal st ''nil))))
+;; ;; (equal (mv-nth 1 (glcp-analyze-interp-result
+;; ;; val al hyp-bfr id concl config st))
+;; ;; (mv-nth 1 (glcp-analyze-interp-result
+;; ;; val nil hyp-bfr abort-unknown abort-ctrex nil nil
+;; ;; geval-name nil nil nil nil))))
+;; )
+;; :hints(("Goal" :in-theory '(glcp-analyze-interp-result
+;; glcp-gen-ctrexes-does-not-fail
+;; glcp-error))))))
+(local (in-theory (disable glcp-gen/print-ctrexamples)))
(local
(defthm glcp-analyze-interp-result-correct
- (implies (and (not (glcp-generic-geval val (cdr (assoc-equal 'env alist))))
- (bfr-eval (bfr-to-param-space hyp-bdd hyp-bdd)
+ (implies (and (not (bfr-eval val (cadr (assoc-equal 'env alist))))
+ (bfr-eval (bfr-to-param-space hyp-bfr hyp-bfr)
+ (car (cdr (assoc-equal 'env alist))))
+ (bfr-eval constraint
(car (cdr (assoc-equal 'env alist)))))
- (not (glcp-generic-ev
+ (not (glcp-generic-geval-ev
(disjoin
(mv-nth 1 (glcp-analyze-interp-result
- val al hyp-bdd id concl config state)))
+ hyp-bfr val constraint al id concl config bvar-db state)))
alist)))
:hints (("goal" :use
- ((:instance glcp-generic-geval-gtests-nonnil-correct
- (x val) (hyp t)
- (env (cdr (assoc-equal 'env alist))))
- (:instance
- bfr-sat-unsat
- (prop (bfr-and (bfr-to-param-space hyp-bdd hyp-bdd)
- (bfr-not (gtests-unknown (gtests val t)))
- (bfr-not (gtests-nonnil (gtests val t)))))
- (env (cadr (assoc-equal 'env alist))))
- (:instance
+ ((:instance
bfr-sat-unsat
- (prop (bfr-and (bfr-to-param-space hyp-bdd hyp-bdd)
- (gtests-unknown (gtests val t))))
+ (prop (bfr-and (bfr-to-param-space hyp-bfr hyp-bfr)
+ (bfr-and constraint (bfr-not val))))
(env (cadr (assoc-equal 'env alist)))))
:in-theory (e/d (gl-cp-hint)
- (glcp-generic-geval-gtests-nonnil-correct
+ (; glcp-generic-geval-gtests-nonnil-correct
gtests-nonnil-correct
bfr-sat-unsat))
:do-not-induct t)
@@ -2037,56 +536,71 @@
(local
(defthm w-state-of-n-satisfying-assigns-and-specs
(equal (w (mv-nth 2 (n-satisfying-assigns-and-specs
- n hyp-bdd ctrex-info max-index state)))
+ n hyp-bfr ctrex-info max-index state)))
(w state))
:hints(("Goal" :in-theory (enable random$)))))
(local
(defthm w-state-of-glcp-gen-assignments
- (equal (w (mv-nth 2 (glcp-gen-assignments ctrex-info alist hyp-bdd n
+ (equal (w (mv-nth 2 (glcp-gen-assignments ctrex-info alist hyp-bfr n
state)))
(w state))))
+(local (in-theory (disable glcp-gen-assignments)))
+(local (in-theory (disable glcp-bit-to-obj-ctrexamples)))
(local
(defthm w-state-of-glcp-gen-ctrexes
- (equal (w (mv-nth 2 (glcp-gen-ctrexes ctrex-info alist hyp-bdd n
- state)))
+ (equal (w (mv-nth 2 (glcp-gen-ctrexes ctrex-info alist hyp-bfr n
+ bvar-db state)))
(w state))
:hints(("Goal" :in-theory (enable glcp-gen-ctrexes)))))
+(local (in-theory (disable glcp-gen-ctrexes)))
+
+(local (in-theory (disable w put-global)))
+
+;; (local (defthm w-state-of-glcp-pretty-print-assignments
+;; (equal (w (mv-nth 2 (glcp-pretty-print-assignments
+;; n ctrexes concl execp param-bfr bvar-db state)))
+;; (w state))
+;; :hints(("Goal" :in-theory (disable glcp-ctrex-check-bvar-db
+;; bindings-quote-if-needed
+;; acl2::magic-ev
+;; magicer-ev)))))
(local
(defthm w-state-of-glcp-analyze-interp-result
(equal (w (mv-nth 2 (glcp-analyze-interp-result
- val al hyp-bdd id concl config state)))
+ hyp-bfr val constr al id concl config bvar-db state)))
(w state))
- :hints(("Goal" :in-theory (enable glcp-analyze-interp-result)))))
+ :hints(("Goal" :in-theory (enable glcp-analyze-interp-result
+ glcp-gen/print-ctrexamples)))))
(local
(defthm glcp-analyze-interp-result-pseudo-term-listp
(pseudo-term-listp
(mv-nth 1 (glcp-analyze-interp-result
- val al hyp-bdd id concl config state)))))
+ hyp-bfr val constr al id concl config bvar-db state)))))
(in-theory (disable glcp-analyze-interp-result))
-(local
- (progn
- (defun gobj-list-to-param-space (list p)
- (if (atom list)
- nil
- (gl-cons (gobj-to-param-space (car list) p)
- (gobj-list-to-param-space (cdr list) p))))
-
-
- (defthm glcp-generic-geval-alist-gobj-alist-to-param-space
- (equal (glcp-generic-geval-alist
- (gobj-alist-to-param-space alist p)
- env)
- (pairlis$ (strip-cars alist)
- (glcp-generic-geval
- (gobj-to-param-space (gobj-strip-cdrs alist) p)
- env)))
- :hints(("Goal" :in-theory (enable strip-cdrs))))))
+;; (local
+;; (progn
+;; ;; (defun gobj-list-to-param-space (list p)
+;; ;; (if (atom list)
+;; ;; nil
+;; ;; (gl-cons (gobj-to-param-space (car list) p)
+;; ;; (gobj-list-to-param-space (cdr list) p))))
+
+
+;; (defthm glcp-generic-geval-alist-gobj-alist-to-param-space
+;; (equal (glcp-generic-geval-alist
+;; (gobj-alist-to-param-space alist p)
+;; env)
+;; (pairlis$ (strip-cars alist)
+;; (glcp-generic-geval-list
+;; (gobj-list-to-param-space (strip-cdrs alist) p)
+;; env)))
+;; :hints(("Goal" :in-theory (enable strip-cdrs))))))
@@ -2230,51 +744,274 @@
(local
(progn
- (defthm glcp-generic-ev-dumb-negate-lit
- (iff (glcp-generic-ev (dumb-negate-lit lit) a)
- (not (glcp-generic-ev lit a))))
+ (defthm glcp-generic-geval-ev-dumb-negate-lit
+ (iff (glcp-generic-geval-ev (dumb-negate-lit lit) a)
+ (not (glcp-generic-geval-ev lit a))))
- (defthm glcp-generic-ev-list*-macro
- (equal (glcp-generic-ev (list*-macro (append x (list ''nil))) al)
- (glcp-generic-ev-lst x al))
+ (defthm glcp-generic-geval-ev-list*-macro
+ (equal (glcp-generic-geval-ev (list*-macro (append x (list ''nil))) al)
+ (glcp-generic-geval-ev-lst x al))
:hints(("Goal" :in-theory (enable append))))
(defthm pairlis-eval-alist-is-norm-alist
(implies (nonnil-symbol-listp vars)
(equal (pairlis$ vars
- (glcp-generic-ev-lst vars alist))
+ (glcp-generic-geval-ev-lst vars alist))
(norm-alist vars alist)))
:hints(("Goal" :in-theory (enable nonnil-symbol-listp
pairlis$))))
- (defthmd glcp-generic-ev-disjoin-is-or-list-glcp-generic-ev-lst
- (iff (glcp-generic-ev (disjoin lst) env)
- (acl2::or-list (glcp-generic-ev-lst lst env)))
+ (defthmd glcp-generic-geval-ev-disjoin-is-or-list-glcp-generic-geval-ev-lst
+ (iff (glcp-generic-geval-ev (disjoin lst) env)
+ (acl2::or-list (glcp-generic-geval-ev-lst lst env)))
:hints (("goal" :induct (len lst))))
- (defthm glcp-generic-ev-disjoin-norm-alist
+ (defthm glcp-generic-geval-ev-disjoin-norm-alist
(implies (and (pseudo-term-listp clause)
(subsetp-equal (collect-vars-list clause) vars))
- (iff (glcp-generic-ev (disjoin clause) (norm-alist vars alist))
- (glcp-generic-ev (disjoin clause) alist)))
+ (iff (glcp-generic-geval-ev (disjoin clause) (norm-alist vars alist))
+ (glcp-generic-geval-ev (disjoin clause) alist)))
:hints(("Goal" :in-theory (enable
- glcp-generic-ev-disjoin-is-or-list-glcp-generic-ev-lst))))))
+ glcp-generic-geval-ev-disjoin-is-or-list-glcp-generic-geval-ev-lst))))))
+
+
+
+
+(defun shape-spec-bindingsp (x)
+ (declare (xargs :guard t))
+ (if (atom x)
+ (equal x nil)
+ (and (consp (car x))
+ (symbolp (caar x))
+ (not (keywordp (caar x)))
+ (caar x)
+ (consp (cdar x))
+ (shape-specp (cadar x))
+ (shape-spec-bindingsp (cdr x)))))
+
+
+
+
+
+
+
+
+(local (defthm pbfr-depends-on-t-is-bfr-depends-on
+ (equal (pbfr-depends-on k t x)
+ (bfr-depends-on k x))
+ :hints (("goal" :in-theory (enable pbfr-depends-on
+ bfr-depends-on
+ pbfr-semantic-depends-on
+ bfr-from-param-space)))))
+
+(defthm pbfr-vars-bounded-of-bfr-var
+ (implies (<= (+ 1 (nfix v)) (nfix k))
+ (pbfr-vars-bounded k t (bfr-var v)))
+ :hints ((and stable-under-simplificationp
+ `(:expand (,(car (last clause)))))))
+
+
+(defthm pbfr-list-vars-bounded-of-numlist-to-vars
+ (implies (<= (nat-list-max x) (nfix n))
+ (pbfr-list-vars-bounded n t (numlist-to-vars x)))
+ :hints (("goal" :induct (nat-list-max x)
+ :expand ((nat-list-max x)
+ (numlist-to-vars x)))))
+
+;; (defthm pbfr-list-vars-bounded-of-greater
+;; (implies (and (pbfr-list-vars-bounded n p x)
+;; (<= (nfix n) (nfix k)))
+;; (pbfr-list-vars-bounded k p x))
+;; :hints ((and stable-under-simplificationp
+;; `(:expand (,(car (last clause)))))))
+
+
+
+(include-book "symbolic-arithmetic")
+
+(defthm pbfr-list-vars-bounded-of-bfr-logapp-nus
+ (implies (and (pbfr-list-vars-bounded k p x)
+ (pbfr-list-vars-bounded k p y))
+ (pbfr-list-vars-bounded k p (bfr-logapp-nus n x y)))
+ :hints (("goal" :in-theory (enable pbfr-list-vars-bounded-in-terms-of-witness))))
+
+(defthm pbfr-list-vars-bounded-of-break-g-number
+ (implies (and (<= (nat-list-max (car num)) (nfix n))
+ (<= (nat-list-max (cadr num)) (nfix n))
+ (<= (nat-list-max (caddr num)) (nfix n))
+ (<= (nat-list-max (cadddr num)) (nfix n)))
+ (and (pbfr-list-vars-bounded
+ n t (mv-nth 0 (break-g-number (num-spec-to-num-gobj num))))
+ (pbfr-list-vars-bounded
+ n t (mv-nth 1 (break-g-number (num-spec-to-num-gobj num))))
+ (pbfr-list-vars-bounded
+ n t (mv-nth 2 (break-g-number (num-spec-to-num-gobj num))))
+ (pbfr-list-vars-bounded
+ n t (mv-nth 3 (break-g-number (num-spec-to-num-gobj num))))))
+ :hints(("Goal" :in-theory (enable break-g-number num-spec-to-num-gobj))))
+
+(defthm pbfr-list-vars-bounded-of-break-g-number-int
+ (implies (pbfr-list-vars-bounded k p int)
+ (and (pbfr-list-vars-bounded
+ k p (mv-nth 0 (break-g-number (list int))))
+ (pbfr-list-vars-bounded
+ k p (mv-nth 1 (break-g-number (list int))))
+ (pbfr-list-vars-bounded
+ k p (mv-nth 2 (break-g-number (list int))))
+ (pbfr-list-vars-bounded
+ k p (mv-nth 3 (break-g-number (list int))))))
+ :hints(("Goal" :in-theory (enable break-g-number))))
+
+
+
+(defthm-shape-spec-flag
+ (defthm gobj-vars-bounded-of-shape-spec-to-gobj
+ (implies (<= (shape-spec-max-bvar x) (nfix n))
+ (gobj-vars-bounded n t (shape-spec-to-gobj x)))
+ :flag ss)
+ (defthm gobj-vars-bounded-of-shape-spec-to-gobj-list
+ (implies (<= (shape-spec-max-bvar-list x) (nfix n))
+ (gobj-list-vars-bounded n t (shape-spec-to-gobj-list x)))
+ :flag list)
+ :hints (("goal" :do-not '(simplify preprocess)
+ :in-theory (disable shape-spec-max-bvar
+ shape-spec-max-bvar-list
+ shape-spec-to-gobj
+ shape-spec-to-gobj-list
+ nat-list-max))
+ (acl2::just-expand ((shape-spec-to-gobj-list x)
+ (shape-spec-max-bvar-list x)
+ (shape-spec-to-gobj x)
+ (shape-spec-max-bvar x))
+ :mark-only t :last-only t)
+ '(:do-not nil)
+ (and stable-under-simplificationp
+ '(:in-theory (e/d (acl2::expand-marked-meta)
+ (shape-spec-max-bvar
+ shape-spec-max-bvar-list
+ shape-spec-to-gobj
+ shape-spec-to-gobj-list
+ nat-list-max))))))
+
+
+
+
+
+
+
+
+
+(local
+ (progn
+ (defthm bvar-db-fix-env-eval-gobj-list-vars-bounded-unparam-rw
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (gobj-list-vars-bounded min t x)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env)))
+ (equal (glcp-generic-geval-list x (cons (bfr-unparam-env p env-n) var-env))
+ (glcp-generic-geval-list x (cons env var-env)))))
+ :hints (("goal" :induct (len x)
+ :expand ((:free (env) (glcp-generic-geval-list x env))))))
+
+ (defthm bvar-db-fix-env-eval-gobj-list-vars-bounded-unparam-with-no-param
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (gobj-list-vars-bounded min t x)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db t env var-env)))
+ (equal (glcp-generic-geval-list x (cons env-n var-env))
+ (glcp-generic-geval-list x (cons env var-env)))))
+ :hints (("goal" :induct (len x)
+ :expand ((:free (env) (glcp-generic-geval-list x env))))))))
+
+
+
+(defun glcp-cases-wormhole (term id)
+ (wormhole 'glcp-cases-wormhole
+ '(lambda (whs) whs)
+ nil
+ `(prog2$ (let ((id ',id))
+ (declare (ignorable id))
+ ,term)
+ (value :q))
+ :ld-prompt nil
+ :ld-pre-eval-print nil
+ :ld-post-eval-print nil
+ :ld-verbose nil))
+
+(defun doubleton-list-to-alist (x)
+ (if (atom x)
+ nil
+ (cons (cons (caar x) (cadar x))
+ (doubleton-list-to-alist (cdr x)))))
+
+(defun bindings-to-vars-vals (x)
+ (if (atom x)
+ (mv nil nil)
+ (mv-let (vars vals)
+ (bindings-to-vars-vals (cdr x))
+ (if (and (symbolp (caar x))
+ (pseudo-termp (cadar x)))
+ (mv (cons (caar x) vars)
+ (cons (cadar x) vals))
+ (mv vars vals)))))
+
+(defun bindings-to-lambda (bindings term)
+ (mv-let (vars vals)
+ (bindings-to-vars-vals bindings)
+ `((lambda ,vars ,term) . ,vals)))
+
+(defthm bindings-to-vars-vals-wfp
+ (mv-let (vars vals)
+ (bindings-to-vars-vals x)
+ (and (symbol-listp vars)
+ (pseudo-term-listp vals)
+ (true-listp vals)
+ (equal (len vals) (len vars))
+ (not (stringp vars))
+ (not (stringp vals))))
+ :hints(("Goal" :in-theory (disable pseudo-termp))))
+(defthm bindings-to-lambda-pseudo-termp
+ (implies (pseudo-termp term)
+ (pseudo-termp (bindings-to-lambda bindings term)))
+ :hints(("Goal" :in-theory (enable true-listp length pseudo-termp))))
+
+(in-theory (disable bindings-to-lambda))
+
+;; Transforms an alist with elements of the form
+;; (((param1 val1) (param2 val2)) shape-spec)
+;; to the form (parametrized-hyp . shape-spec).
+(defun param-bindings-to-alist (hyp bindings)
+ (if (atom bindings)
+ nil
+ (cons (list* (sublis-into-term
+ hyp (doubleton-list-to-alist (caar bindings)))
+;; (bindings-to-lambda (caar bindings) hyp)
+ (acl2::msg "case: ~x0" (caar bindings))
+ (cadar bindings))
+ (param-bindings-to-alist hyp (cdr bindings)))))
+(local
+ (defthm param-bindings-to-alist-pseudo-term-listp-strip-cars
+ (implies (pseudo-termp hyp)
+ (pseudo-term-listp (strip-cars (param-bindings-to-alist hyp bindings))))))
(make-event
- (sublis *glcp-generic-template-subst* *glcp-run-parametrized-template*))
+ (sublis *glcp-generic-template-subst* *glcp-clause-proc-template*))
(local (progn
; [Removed by Matt K. to handle changes to member, assoc, etc. after ACL2 4.2.]
; (defthm member-eq-is-member-equal
; (equal (member-eq x y) (member-equal x y)))
-;
+;
; (defthm set-difference-eq-is-set-difference-equal
; (equal (set-difference-eq x y) (set-difference-equal x y))
; :hints(("Goal" :in-theory (enable set-difference-equal))))
@@ -2286,7 +1023,7 @@
-(local
+(local
(encapsulate nil
(local (defthm true-listp-when-nat-listp
(implies (nat-listp x)
@@ -2307,6 +1044,24 @@
(append (shape-spec-vars (cadar x))
(shape-spec-bindings-vars (cdr x)))))))
+
+
+(local
+ (progn
+ (defthm assoc-in-glcp-generic-geval-alist
+ (implies (alistp al)
+ (equal (assoc k (glcp-generic-geval-alist al env))
+ (and (assoc k al)
+ (cons k (glcp-generic-geval (cdr (assoc k al)) env))))))
+
+ (defthm assoc-in-shape-specs-to-interp-al
+ (implies (alistp al)
+ (equal (assoc k (shape-specs-to-interp-al al))
+ (and (assoc k al)
+ (cons k (shape-spec-to-gobj (cadr (assoc k al))))))))))
+
+
+
;; (defthm eval-of-shape-spec-to-interp-al-alist
;; (implies (and (shape-spec-bindingsp bindings)
;; (no-duplicatesp (shape-spec-bindings-indices bindings))
@@ -2314,127 +1069,531 @@
;; (equal (glcp-generic-geval-alist
;; (shape-specs-to-interp-al bindings)
;; (shape-spec-to-env (strip-cadrs bindings)
-;; (glcp-generic-ev-lst (strip-cars bindings)
+;; (glcp-generic-geval-ev-lst (strip-cars bindings)
;; alist)))
;; (pairlis$ (strip-cars bindings)
-;; (glcp-generic-ev-lst (strip-cars bindings) alist))))
+;; (glcp-generic-geval-ev-lst (strip-cars bindings) alist))))
;; hie)
;; ((GLCP-GENERIC-GEVAL-ALIST
;; (SHAPE-SPECS-TO-INTERP-AL BINDINGS)
;; (SHAPE-SPEC-TO-ENV (STRIP-CADRS BINDINGS)
-;; (GLCP-GENERIC-EV-LST (STRIP-CARS BINDINGS)
+;; (GLCP-GENERIC-GEVAL-EV-LST (STRIP-CARS BINDINGS)
;; ALIST)))
+(local
+ (defun-nx glcp-generic-run-parametrized-ctrex (alist hyp concl bindings obligs config state)
+ (b* (((glcp-config config) config)
+ (obj (strip-cadrs bindings))
+ (config (change-glcp-config config :shape-spec-alist bindings))
+ (al (shape-specs-to-interp-al bindings))
+ (env-term (shape-spec-list-env-term
+ obj
+ (strip-cars bindings)))
+ (env1 (glcp-generic-geval-ev env-term alist))
+ (env (cons (slice-to-bdd-env (car env1) nil) (cdr env1)))
+ (next-bvar (shape-spec-max-bvar-list
+ (strip-cadrs bindings)))
+ (interp-st (create-interp-st))
+ (interp-st (update-is-obligs obligs interp-st))
+ (interp-st (update-is-constraint t interp-st))
+ (interp-st (update-is-constraint-db
+ (gbc-db-make-fast
+ (table-alist 'gl-bool-constraints (w state)))
+ interp-st)))
+ (glcp-generic-interp-hyp/concl-env
+ env hyp concl al config.concl-clk config interp-st next-bvar state))))
+ ;; ;; (bvar-db nil)
+ ;; ;; (bvar-db1 nil)
+ ;; (bvar-db (init-bvar-db (shape-spec-max-bvar-list
+ ;; (strip-cadrs bindings)) bvar-db))
+ ;; ;; (config1 (glcp-config-update-param t config))
+ ;; ((mv ?er obligs1 hyp-bfr bvar-db state)
+ ;; (glcp-generic-interp-top-level-term hyp al t config.hyp-clk obligs config1 bvar-db state))
+ ;; (env1 (cons (bvar-db-fix-env (next-bvar bvar-db)
+ ;; (base-bvar bvar-db)
+ ;; bvar-db t (car env) (cdr env))
+ ;; (cdr env)))
+ ;; (param-env (genv-param hyp-bfr env1))
+ ;; (param-al (gobj-alist-to-param-space al hyp-bfr))
+ ;; (bvar-db1 (parametrize-bvar-db hyp-bfr bvar-db bvar-db1))
+ ;; (hyp-param (bfr-to-param-space hyp-bfr hyp-bfr))
+ ;; (config2 (glcp-config-update-param hyp-bfr config1))
+ ;; ((mv ?er ?obligs2 ?val bvar-db1 ?state)
+ ;; (glcp-generic-interp-top-level-term concl param-al hyp-param config.concl-clk
+ ;; obligs1 config2 bvar-db1 state))
+ ;; (env2 (cons (bvar-db-fix-env (next-bvar bvar-db1)
+ ;; (next-bvar bvar-db)
+ ;; bvar-db1 hyp-bfr (car param-env) (cdr param-env))
+ ;; (cdr param-env))))
+ ;; `((env1 . ,env1)
+ ;; (env2 . ,env2)
+ ;; (config1 . ,config1)
+ ;; (config2 . ,config2)
+ ;; (bvar-db . ,bvar-db)
+ ;; (bvar-db1 . ,bvar-db1))))
+
+;; (defun-nx glcp-generic-run-parametrized-ctrex (alist hyp concl bindings obligs
+;; config state)
+;; (cdr (assoc 'env2 (glcp-generic-run-parametrized-ctrex-aux alist hyp concl bindings
+;; obligs config state))))
+
+
+
+
+;; (defthm bvar-db-env-ok-of-bvar-db-fix-env-no-param
+;; (implies (and (bvar-db-orderedp t bvar-db)
+;; (<= (nfix min) (nfix m))
+;; (<= (base-bvar$a bvar-db) (nfix m))
+;; (< (nfix m) (nfix n))
+;; (<= (nfix n) (next-bvar$a bvar-db)))
+;; (let* ((bfr-env (bvar-db-fix-env n min bvar-db t bfr-env
+;; var-env)))
+;; (iff (bfr-lookup m bfr-env)
+;; (glcp-generic-geval (get-bvar->term m bvar-db)
+;; (cons bfr-env var-env)))))
+;; :hints (("Goal" :use ((:instance bvar-db-env-ok-of-bvar-db-fix-env-lemma
+;; (p t)))
+;; :do-not-induct t)))
+
+
+
+
+
+;; (defthm glcp-generic-interp-top-level-term-correct-special
+;; (b* (((mv ?erp ?obligs1 ?val ?bvar-db1 ?state1)
+;; (glcp-generic-interp-top-level-term
+;; term alist pathcond clk obligs config bvar-db state))
+;; (bfr-env (bvar-db-fix-env n min bvar-db2 p bfr-env var-env)))
+;; (implies (and (bfr-eval pathcond bfr-env)
+;; (not erp)
+;; (acl2::interp-defs-alistp obligs)
+;; (acl2::interp-defs-alistp (glcp-config->overrides config))
+;; (glcp-generic-geval-ev-theoremp
+;; (conjoin-clauses
+;; (acl2::interp-defs-alist-clauses
+;; obligs1)))
+;; ;; (glcp-generic-geval-ev-meta-extract-global-facts)
+;; (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+;; (glcp-generic-bvar-db-env-ok bvar-db1 config (cons bfr-env var-env))
+;; (equal (w state0) (w state))
+;; (pseudo-termp term)
+;; (alistp alist))
+;; (iff (bfr-eval val bfr-env)
+;; (glcp-generic-geval-ev term (glcp-generic-geval-alist
+;; alist (cons bfr-env var-env))))))
+;; :hints(("Goal" :use ((:instance glcp-generic-interp-top-level-term-correct
+;; (bfr-env (bvar-db-fix-env n min bvar-db2 p bfr-env
+;; var-env))
+;; (env (cons (bvar-db-fix-env n min bvar-db2 p bfr-env
+;; var-env)
+;; var-env))))
+;; :in-theory (disable glcp-generic-interp-top-level-term-correct))))
+
+;; (defthm bfr-vars-bounded-consts
+;; (and (bfr-vars-bounded k t)
+;; (bfr-vars-bounded k nil))
+;; :hints(("Goal" :in-theory (enable bfr-vars-bounded))))
+
+;; (defthm bvar-db-env-ok-of-bvar-db-fix-env-no-param
+;; (implies (and (bvar-db-orderedp t bvar-db)
+;; (equal t (glcp-config->param-bfr config))
+;; (equal n (next-bvar$a bvar-db))
+;; (equal b (base-bvar$a bvar-db)))
+;; (let ((bfr-env (bvar-db-fix-env n b
+;; bvar-db t bfr-env var-env)))
+;; (glcp-generic-bvar-db-env-ok bvar-db config (cons bfr-env var-env))))
+;; :hints (("goal" :use ((:instance bvar-db-env-ok-of-bvar-db-fix-env
+;; (p t)))
+;; :in-theory (disable bvar-db-env-ok-of-bvar-db-fix-env)
+;; :do-not-induct t)))
+
+
+;; (defthm bvar-db-ordered-of-glcp-generic-interp-top-level-special
+;; (b* (((mv ?erp ?obligs1 ?val ?bvar-db1 ?state1)
+;; (glcp-generic-interp-top-level-term
+;; term alist pathcond clk obligs config bvar-db state))
+;; (k (next-bvar$a bvar-db)))
+;; (implies (and (equal t (glcp-config->param-bfr config))
+;; (bvar-db-orderedp t bvar-db)
+;; (gobj-alist-vars-bounded k t alist))
+;; (bvar-db-orderedp t bvar-db1)))
+;; :hints (("goal" :Use ((:instance
+;; bvar-db-ordered-of-glcp-generic-interp-top-level
+;; (p t)))
+;; :in-theory (disable bvar-db-ordered-of-glcp-generic-interp-top-level))))
+
+
+;; ;; (defthm gobj-alist-vars-bounded-of-shape-specs-to-interp-al
+;; ;; (implies (<= (shape-spec-max-bvar-list (strip-cadrs bindings)) (nfix n))
+;; ;; (not (gobj-alist-depends-on n t (shape-specs-to-interp-al
+;; ;; bindings))))
+;; ;; :hints(("Goal" :in-theory (enable shape-specs-to-interp-al))))
+
+(local
+ (defthm gobj-alist-vars-bounded-of-shape-specs-to-interp-al
+ (implies (<= (shape-spec-max-bvar-list (strip-cadrs bindings)) (nfix n))
+ (gobj-alist-vars-bounded n t (shape-specs-to-interp-al bindings)))))
+
+
+
+
+
+;; (defthm bfr-vars-bounded-of-glcp-generic-interp-top-level
+;; (b* (((mv ?erp ?obligs1 ?val ?bvar-db1 ?state1)
+;; (glcp-generic-interp-top-level-term
+;; term alist pathcond clk obligs config bvar-db state)))
+;; (implies (and (<= (next-bvar$a bvar-db1) (nfix k))
+;; (equal t (glcp-config->param-bfr config))
+;; (gobj-alist-vars-bounded k t alist))
+;; (bfr-vars-bounded k val)))
+;; :hints (("goal" :use ((:instance
+;; vars-bounded-of-glcp-generic-interp-top-level
+;; (p t)))
+;; :in-theory (disable vars-bounded-of-glcp-generic-interp-top-level))))
+
+
+
+;; (defthm glcp-generic-run-parametrized-bvar-db-env1-ok
+;; (b* (((mv ?erp ?obligs1 ?val ?bvar-db1 ?state1)
+;; (glcp-generic-interp-top-level-term
+;; term alist pathcond clk obligs config bvar-db state))
+;; (bfr-env (bvar-db-fix-env n min bvar-db2 p bfr-env var-env))
+;; (aux (glcp-generic-run-parametrized-ctrex-aux alist hyp concl bindings
+;; obligs config state)))
+;; (implies (and (bfr-eval pathcond bfr-env)
+;; (not erp)
+;; (acl2::interp-defs-alistp obligs)
+;; (acl2::interp-defs-alistp (glcp-config->overrides config))
+;; (glcp-generic-geval-ev-theoremp
+;; (conjoin-clauses
+;; (acl2::interp-defs-alist-clauses
+;; obligs1)))
+;; ;; (glcp-generic-geval-ev-meta-extract-global-facts)
+;; (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+;; (glcp-generic-bvar-db-env-ok bvar-db1 config (cons bfr-env var-env))
+;; (equal (w state0) (w state))
+;; (pseudo-termp term)
+;; (alistp alist))
+;; (glcp-generic-bvar-db-env-ok
+;; (cdr (assoc 'bvar-db aux))
+;; (cdr (assoc 'config1 aux))
+;; (cdr (assoc 'env1 aux)))))
+;; :hints (("goal" :do-not-induct t)
+;; (and stable-under-simplificationp
+;; `(:expand (,(car (last clause)))))
+;; (and stable-under-simplificationp
+;; (let ((w (acl2::find-call-lst
+;; 'glcp-generic-bvar-db-env-ok-witness
+;; clause)))
+;; `(:clause-processor
+;; (acl2::simple-generalize-cp
+;; clause '((,w . idx)))))))
+;; :otf-flg t)
+
+
+;; (defthm glcp-generic-run-parametrized-bvar-db-env3-ok
+;; (b* (((mv ?erp ?obligs1 ?val ?bvar-db1 ?state1)
+;; (glcp-generic-interp-top-level-term
+;; term alist pathcond clk obligs config bvar-db state))
+;; (bfr-env (bvar-db-fix-env n min bvar-db2 p bfr-env var-env))
+;; (aux (glcp-generic-run-parametrized-ctrex-aux alist hyp concl bindings
+;; obligs config state)))
+;; (implies (and (bfr-eval pathcond bfr-env)
+;; (not erp)
+;; (acl2::interp-defs-alistp obligs)
+;; (acl2::interp-defs-alistp (glcp-config->overrides config))
+;; (glcp-generic-geval-ev-theoremp
+;; (conjoin-clauses
+;; (acl2::interp-defs-alist-clauses
+;; obligs1)))
+;; ;; (glcp-generic-geval-ev-meta-extract-global-facts)
+;; (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+;; (glcp-generic-bvar-db-env-ok bvar-db1 config (cons bfr-env var-env))
+;; (equal (w state0) (w state))
+;; (pseudo-termp term)
+;; (alistp alist))
+;; (glcp-generic-bvar-db-env-ok
+;; (cdr (assoc 'bvar-db1 aux))
+;; (cdr (assoc 'config2 aux))
+;; (cdr (assoc 'env2 aux)))))
+;; :hints (("goal" :do-not-induct t)
+;; (and stable-under-simplificationp
+;; `(:expand (,(car (last clause)))))
+;; (and stable-under-simplificationp
+;; (let ((w (acl2::find-call-lst
+;; 'glcp-generic-bvar-db-env-ok-witness
+;; clause)))
+;; `(:clause-processor
+;; (acl2::simple-generalize-cp
+;; clause '((,w . idx)))))))
+;; :otf-flg t)
+
+;; (defun-nx glcp-generic-run-parametrized-ctrex
+;; (env hyp concl bindings obligs config state)
+;; (b* (((glcp-config config) config)
+;; (al (shape-specs-to-interp-al bindings))
+;; (next-bvar (shape-spec-max-bvar-list (strip-cadrs bindings)))
+;; (config (glcp-config-update-param t config)))
+;; (glcp-generic-interp-hyp/concl-env
+;; env hyp concl al config.concl-clk obligs config next-bvar state)))
+ ;; ((mv er obligs1 hyp-bfr concl-bfr bvar-db bvar-db1 state)
+ ;; (glcp-generic-interp-hyp/concl
+ ;; hyp concl al config.concl-clk obligs config next-bvar bvar-db
+ ;; bvar-db1 state))
+ ;; ((when er)
+ ;; (flush-hons-get-hash-table-link obligs1)
+ ;; (mv er nil state bvar-db bvar-db1))
+ ;; ((mv erp val-clause state)
+ ;; (glcp-analyze-interp-result
+ ;; concl-bfr bindings hyp-bfr id concl config state))
+ ;; ((when erp)
+ ;; (mv erp nil state bvar-db bvar-db1))
+ ;; ((mv erp val state)
+ ;; (value (list val-clause cov-clause obligs1))))
+ ;; (mv erp val state bvar-db bvar-db1))
+
(local
- (progn
+ (defthm glcp-generic-run-parametrized-correct-lemma
+ (b* (((mv erp (list val-clause cov-clause out-obligs) &)
+ (glcp-generic-run-parametrized
+ hyp concl vars bindings id obligs
+ config state))
+ (ctrex-env
+ (glcp-generic-run-parametrized-ctrex
+ alist hyp concl bindings obligs config state)))
+ (implies (and (glcp-generic-geval-ev hyp alist)
+ (not (glcp-generic-geval-ev concl alist))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses out-obligs)))
+ (not erp)
+ (acl2::interp-defs-alistp obligs)
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (pseudo-termp concl)
+ (pseudo-termp hyp)
+ (equal vars (collect-vars concl))
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state1)
+ (equal (w state) (w state1))
+ (glcp-generic-geval-ev (disjoin cov-clause) alist)
+ )
+ (not (glcp-generic-geval-ev
+ (disjoin val-clause)
+ `((env . ,(list ctrex-env)))))))
+ :hints (("goal" :do-not-induct t
+ :in-theory (e/d (gbc-db-empty-implies-gbc-db-vars-bounded)
+ (collect-vars nth update-nth
+ pseudo-termp
+ dumb-negate-lit))))))
+
+
+(local
+ (defthm glcp-generic-run-parametrized-correct
+ (b* (((mv erp (list val-clause cov-clause out-obligs) &)
+ (glcp-generic-run-parametrized
+ hyp concl vars bindings id obligs
+ config state)))
+ (implies (and (glcp-generic-geval-ev hyp alist)
+ (not (glcp-generic-geval-ev concl alist))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses out-obligs)))
+ (not erp)
+ (acl2::interp-defs-alistp obligs)
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (pseudo-termp concl)
+ (pseudo-termp hyp)
+ (equal vars (collect-vars concl))
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state1)
+ (equal (w state) (w state1))
+ (glcp-generic-geval-ev (disjoin cov-clause) alist)
+ )
+ (not (glcp-generic-geval-ev-theoremp
+ (disjoin val-clause)))))
+ :hints (("goal" :do-not-induct t
+ :in-theory (disable collect-vars
+ pseudo-termp
+ dumb-negate-lit
+ glcp-generic-run-parametrized
+ glcp-generic-run-parametrized-ctrex)
+ :use ((:instance glcp-generic-geval-ev-falsify
+ (x (disjoin (car (mv-nth 1 (glcp-generic-run-parametrized
+ hyp concl vars bindings id obligs
+ config state)))))
+ (a `((env . ,(list (glcp-generic-run-parametrized-ctrex
+ alist hyp concl bindings obligs config state)))))))))))
+
+
+
+ ;; :hints (("goal" :do-not-induct
+ ;; t
+ ;; :in-theory
+ ;; (e/d* ()
+ ;; (glcp-generic-geval-alist-gobj-alist-to-param-space
+ ;; glcp-generic-geval-gtests-nonnil-correct
+ ;; glcp-generic-interp-bad-obligs-term
+ ;; ;; shape-spec-listp-impl-shape-spec-to-gobj-list
+ ;; (:rules-of-class :definition :here)
+ ;; (:rules-of-class :type-prescription :here))
+ ;; (gl-cp-hint acl2::clauses-result assoc-equal
+ ;; glcp-generic-run-parametrized not
+ ;; glcp-error
+ ;; acl2::fast-no-duplicatesp
+ ;; acl2::fast-no-duplicatesp-equal))
+ ;; :restrict ((glcp-generic-geval-ev-disjoin-append ((a alist)))))
+ ;; (and stable-under-simplificationp
+ ;; (acl2::bind-as-in-definition
+ ;; (glcp-generic-run-parametrized
+ ;; hyp concl (collect-vars concl) bindings id obligs config state)
+ ;; (cov-clause val-clause hyp-bfr hyp-val)
+ ;; (b* ((binding-env
+ ;; '(let ((slice (glcp-generic-geval-ev
+ ;; (shape-spec-env-term
+ ;; (strip-cadrs bindings)
+ ;; (list*-macro (append (strip-cars
+ ;; bindings) '('nil)))
+ ;; nil)
+ ;; alist)))
+ ;; (cons (slice-to-bdd-env (car slice) nil)
+ ;; (cdr slice))))
+ ;; (param-env `(genv-param ,hyp-bfr ,binding-env)))
+ ;; `(:use
+ ;; ((:instance glcp-generic-geval-ev-falsify
+ ;; (x (disjoin ,cov-clause))
+ ;; (a alist))
+ ;; (:instance glcp-generic-geval-ev-falsify
+ ;; (x (disjoin ,val-clause))
+ ;; (a `((env . ,,param-env))))
+ ;; (:instance glcp-generic-geval-gtests-nonnil-correct
+ ;; (x ,hyp-val)
+ ;; (hyp t)
+ ;; (env ,binding-env)))))))
+ ;; (bfr-reasoning)))
+
+
+(local
+ (encapsulate nil
;; (defthm bfr-p-bfr-to-param-space
;; (implies (and (bfr-p p) (bfr-p x))
;; (bfr-p (bfr-to-param-space p x)))
;; :hints(("Goal" :in-theory (enable bfr-to-param-space bfr-p))))
- (encapsulate nil
- (local (in-theory
- (e/d (gl-cp-hint)
- (shape-specs-to-interp-al
- shape-spec-listp pseudo-term-listp
- pseudo-termp pairlis$
- shape-spec-bindingsp
- dumb-negate-lit
- gtests-nonnil-correct
- no-duplicatesp-equal
- (bfr-to-param-space)
- gobj-alist-to-param-space
- list*-macro binary-append strip-cadrs strip-cars member-equal))))
- (defthm glcp-generic-run-parametrized-correct
- (b* (((mv erp (cons clauses out-obligs) &)
- (glcp-generic-run-parametrized
- hyp concl untrans-concl vars bindings id obligs
- config state)))
- (implies (and (not (glcp-generic-ev concl alist))
- (glcp-generic-ev-theoremp
- (conjoin-clauses
- (acl2::interp-defs-alist-clauses out-obligs)))
- (not erp)
- (glcp-generic-ev hyp alist)
- (acl2::interp-defs-alistp obligs)
- (acl2::interp-defs-alistp (glcp-config->overrides config))
- (pseudo-termp concl)
- (pseudo-termp hyp)
- (equal vars (collect-vars concl))
- (glcp-generic-ev-meta-extract-global-facts :state state1)
- (equal (w state) (w state1)))
- (not (glcp-generic-ev-theoremp (conjoin-clauses clauses)))))
- :hints (("goal" :do-not-induct
- t
- :in-theory
- (e/d* ()
- (glcp-generic-geval-alist-gobj-alist-to-param-space
- glcp-generic-geval-gtests-nonnil-correct
- glcp-generic-interp-term-bad-obligs
- ;; shape-spec-listp-impl-shape-spec-to-gobj-list
- (:rules-of-class :definition :here)
- (:rules-of-class :type-prescription :here))
- (gl-cp-hint acl2::clauses-result assoc-equal
- glcp-generic-run-parametrized not
- glcp-error
- acl2::fast-no-duplicatesp
- acl2::fast-no-duplicatesp-equal))
- :restrict ((glcp-generic-ev-disjoin-append ((a alist)))))
- (and stable-under-simplificationp
- (acl2::bind-as-in-definition
- (glcp-generic-run-parametrized
- hyp concl untrans-concl (collect-vars concl) bindings id obligs config state)
- (cov-clause val-clause hyp-bdd hyp-val)
- (b* ((binding-env '(shape-spec-to-env
- (strip-cadrs bindings)
- (glcp-generic-ev-lst
- (strip-cars bindings)
- alist)))
- (param-env `(genv-param ,hyp-bdd ,binding-env)))
- `(:use
- ((:instance glcp-generic-ev-falsify
- (x (disjoin ,cov-clause))
- (a alist))
- (:instance glcp-generic-ev-falsify
- (x (disjoin ,val-clause))
- (a `((env . ,,param-env))))
- (:instance glcp-generic-geval-gtests-nonnil-correct
- (x ,hyp-val)
- (hyp t)
- (env ,binding-env)))))))
- (bfr-reasoning))))
+ (local (in-theory (disable shape-specs-to-interp-al
+ pseudo-termp pseudo-term-listp
+ shape-spec-bindingsp
+ nth update-nth
+ ; acl2::consp-by-len
+ list*-macro)))
+
+ ;; (encapsulate nil
+ ;; (local (in-theory
+ ;; (e/d (gl-cp-hint)
+ ;; (shape-specs-to-interp-al
+ ;; shape-spec-listp pseudo-term-listp
+ ;; pseudo-termp pairlis$
+ ;; shape-spec-bindingsp
+ ;; dumb-negate-lit
+ ;; gtests-nonnil-correct
+ ;; no-duplicatesp-equal
+ ;; (bfr-to-param-space)
+ ;; gobj-alist-to-param-space
+ ;; list*-macro binary-append strip-cadrs strip-cars member-equal))))
+ ;; (defthm glcp-generic-run-parametrized-correct
+ ;; (b* (((mv erp (cons clauses out-obligs) &)
+ ;; (glcp-generic-run-parametrized
+ ;; hyp concl vars bindings id obligs
+ ;; config state)))
+ ;; (implies (and (not (glcp-generic-geval-ev concl alist))
+ ;; (glcp-generic-geval-ev-theoremp
+ ;; (conjoin-clauses
+ ;; (acl2::interp-defs-alist-clauses out-obligs)))
+ ;; (not erp)
+ ;; (glcp-generic-geval-ev hyp alist)
+ ;; (acl2::interp-defs-alistp obligs)
+ ;; (acl2::interp-defs-alistp (glcp-config->overrides config))
+ ;; (pseudo-termp concl)
+ ;; (pseudo-termp hyp)
+ ;; (equal vars (collect-vars concl))
+ ;; (glcp-generic-geval-ev-meta-extract-global-facts :state state1)
+ ;; (equal (w state) (w state1)))
+ ;; (not (glcp-generic-geval-ev-theoremp (conjoin-clauses clauses)))))
+ ;; :hints (("goal" :do-not-induct
+ ;; t
+ ;; :in-theory
+ ;; (e/d* ()
+ ;; (; glcp-generic-geval-alist-gobj-alist-to-param-space
+ ;; glcp-generic-geval-gtests-nonnil-correct
+ ;; glcp-generic-interp-bad-obligs-term
+ ;; ;; shape-spec-listp-impl-shape-spec-to-gobj-list
+ ;; (:rules-of-class :definition :here)
+ ;; (:rules-of-class :type-prescription :here))
+ ;; (gl-cp-hint acl2::clauses-result assoc-equal
+ ;; glcp-generic-run-parametrized not
+ ;; glcp-error
+ ;; acl2::fast-no-duplicatesp
+ ;; acl2::fast-no-duplicatesp-equal))
+ ;; :restrict ((glcp-generic-geval-ev-disjoin-append ((a alist)))))
+ ;; (and stable-under-simplificationp
+ ;; (acl2::bind-as-in-definition
+ ;; (glcp-generic-run-parametrized
+ ;; hyp concl (collect-vars concl) bindings id obligs config state)
+ ;; (cov-clause val-clause hyp-bfr hyp-val)
+ ;; (b* ((binding-env
+ ;; '(let ((slice (glcp-generic-geval-ev
+ ;; (shape-spec-env-term
+ ;; (strip-cadrs bindings)
+ ;; (list*-macro (append (strip-cars
+ ;; bindings) '('nil)))
+ ;; nil)
+ ;; alist)))
+ ;; (cons (slice-to-bdd-env (car slice) nil)
+ ;; (cdr slice))))
+ ;; (param-env `(genv-param ,hyp-bfr ,binding-env)))
+ ;; `(:use
+ ;; ((:instance glcp-generic-geval-ev-falsify
+ ;; (x (disjoin ,cov-clause))
+ ;; (a alist))
+ ;; (:instance glcp-generic-geval-ev-falsify
+ ;; (x (disjoin ,val-clause))
+ ;; (a `((env . ,,param-env))))
+ ;; (:instance glcp-generic-geval-gtests-nonnil-correct
+ ;; (x ,hyp-val)
+ ;; (hyp t)
+ ;; (env ,binding-env)))))))
+ ;; (bfr-reasoning))))
(defthm glcp-generic-run-parametrized-bad-obligs
- (b* (((mv erp (cons & out-obligs) &)
+ (b* (((mv erp (list & & out-obligs) &)
(glcp-generic-run-parametrized
- hyp concl untrans-concl vars bindings id obligs config state)))
+ hyp concl vars bindings id obligs config state)))
(implies (and (not erp)
- (not (glcp-generic-ev-theoremp
+ (not (glcp-generic-geval-ev-theoremp
(conjoin-clauses
(acl2::interp-defs-alist-clauses obligs)))))
- (not (glcp-generic-ev-theoremp
+ (not (glcp-generic-geval-ev-theoremp
(conjoin-clauses
- (acl2::interp-defs-alist-clauses out-obligs)))))))
+ (acl2::interp-defs-alist-clauses out-obligs))))))
+ :hints(("Goal" :in-theory (disable collect-vars pseudo-termp
+ dumb-negate-lit))))
(defthm glcp-generic-run-parametrized-ok-obligs
- (b* (((mv erp (cons & out-obligs) &)
+ (b* (((mv erp (list & & out-obligs) &)
(glcp-generic-run-parametrized
- hyp concl untrans-concl vars bindings id obligs config state)))
+ hyp concl vars bindings id obligs config state)))
(implies (and (not erp)
- (glcp-generic-ev-theoremp
+ (glcp-generic-geval-ev-theoremp
(conjoin-clauses
(acl2::interp-defs-alist-clauses out-obligs))))
- (glcp-generic-ev-theoremp
+ (glcp-generic-geval-ev-theoremp
(conjoin-clauses
(acl2::interp-defs-alist-clauses obligs))))))
(defthm glcp-generic-run-parametrized-defs-alistp
- (b* (((mv erp (cons & out-obligs) &)
+ (b* (((mv erp (list & & out-obligs) &)
(glcp-generic-run-parametrized
- hyp concl untrans-concl vars bindings id obligs config state)))
+ hyp concl vars bindings id obligs config state)))
(implies (and (acl2::interp-defs-alistp obligs)
(acl2::interp-defs-alistp (glcp-config->overrides config))
(pseudo-termp concl)
@@ -2443,38 +1602,29 @@
(defthm glcp-generic-run-paremetrized-w-state
(equal (w (mv-nth 2 (glcp-generic-run-parametrized
- hyp concl untrans-concl vars bindings id obligs config state)))
+ hyp concl vars bindings id obligs config state)))
(w state)))))
(in-theory (disable glcp-generic-run-parametrized))
-(defun glcp-cases-wormhole (term id)
- (wormhole 'glcp-cases-wormhole
- '(lambda (whs) whs)
- nil
- `(prog2$ (let ((id ',id))
- (declare (ignorable id))
- ,term)
- (value :q))
- :ld-prompt nil
- :ld-pre-eval-print nil
- :ld-post-eval-print nil
- :ld-verbose nil))
-(in-theory (disable glcp-cases-wormhole))
+(in-theory (disable glcp-cases-wormhole))
-(make-event
- (sublis *glcp-generic-template-subst* *glcp-run-cases-template*))
(local
- (progn
+ (encapsulate nil
+ (local (in-theory (disable pseudo-termp
+ ;; acl2::consp-by-len
+ shape-spec-bindingsp
+ nonnil-symbol-listp-pseudo-term-listp)))
+
(defthm glcp-generic-run-cases-interp-defs-alistp
(b* (((mv erp (cons & out-obligs) &)
(glcp-generic-run-cases
- param-alist concl untrans-concl vars obligs config state)))
+ param-alist concl vars obligs config state)))
(implies (and (acl2::interp-defs-alistp obligs)
(acl2::interp-defs-alistp (glcp-config->overrides config))
(pseudo-termp concl)
@@ -2484,19 +1634,19 @@
(defthm glcp-generic-run-cases-ok-w-state
(equal (w (mv-nth 2 (glcp-generic-run-cases
- param-alist concl untrans-concl vars obligs config
+ param-alist concl vars obligs config
state)))
(w state)))
(defthm glcp-generic-run-cases-correct
(b* (((mv erp (cons clauses out-obligs) &)
(glcp-generic-run-cases
- param-alist concl untrans-concl vars obligs config state)))
- (implies (and (glcp-generic-ev-theoremp
+ param-alist concl vars obligs config state)))
+ (implies (and (glcp-generic-geval-ev-theoremp
(conjoin-clauses
(acl2::interp-defs-alist-clauses out-obligs)))
- (not (glcp-generic-ev concl a))
- (glcp-generic-ev (disjoin (strip-cars param-alist))
+ (not (glcp-generic-geval-ev concl a))
+ (glcp-generic-geval-ev (disjoin (strip-cars param-alist))
a)
(not erp)
(acl2::interp-defs-alistp obligs)
@@ -2504,32 +1654,35 @@
(pseudo-termp concl)
(pseudo-term-listp (strip-cars param-alist))
(equal vars (collect-vars concl))
- (glcp-generic-ev-meta-extract-global-facts :state state1)
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state1)
(equal (w state) (w state1)))
- (not (glcp-generic-ev-theoremp (conjoin-clauses clauses))))))
+ (not (glcp-generic-geval-ev-theoremp (conjoin-clauses
+ clauses)))))
+ :hints(("Goal" :in-theory (enable strip-cars
+ glcp-generic-geval-ev-falsify-sufficient))))
(defthm glcp-generic-run-cases-bad-obligs
(b* (((mv erp (cons & out-obligs) &)
(glcp-generic-run-cases
- param-alist concl untrans-concl vars obligs config state)))
+ param-alist concl vars obligs config state)))
(implies (and (not erp)
- (not (glcp-generic-ev-theoremp
+ (not (glcp-generic-geval-ev-theoremp
(conjoin-clauses
(acl2::interp-defs-alist-clauses obligs)))))
- (not (glcp-generic-ev-theoremp
+ (not (glcp-generic-geval-ev-theoremp
(conjoin-clauses
(acl2::interp-defs-alist-clauses out-obligs)))))))
(defthm glcp-generic-run-cases-ok-obligs
(b* (((mv erp (cons & out-obligs) &)
(glcp-generic-run-cases
- param-alist concl untrans-concl vars obligs config state)))
+ param-alist concl vars obligs config state)))
(implies (and (not erp)
- (glcp-generic-ev-theoremp
+ (glcp-generic-geval-ev-theoremp
(conjoin-clauses
(acl2::interp-defs-alist-clauses out-obligs))))
- (glcp-generic-ev-theoremp
+ (glcp-generic-geval-ev-theoremp
(conjoin-clauses
(acl2::interp-defs-alist-clauses obligs))))))))
@@ -2541,73 +1694,15 @@
-(defun doubleton-list-to-alist (x)
- (if (atom x)
- nil
- (cons (cons (caar x) (cadar x))
- (doubleton-list-to-alist (cdr x)))))
-(defun bindings-to-vars-vals (x)
- (if (atom x)
- (mv nil nil)
- (mv-let (vars vals)
- (bindings-to-vars-vals (cdr x))
- (if (and (symbolp (caar x))
- (pseudo-termp (cadar x)))
- (mv (cons (caar x) vars)
- (cons (cadar x) vals))
- (mv vars vals)))))
-
-(defun bindings-to-lambda (bindings term)
- (mv-let (vars vals)
- (bindings-to-vars-vals bindings)
- `((lambda ,vars ,term) . ,vals)))
-(defthm bindings-to-vars-vals-wfp
- (mv-let (vars vals)
- (bindings-to-vars-vals x)
- (and (symbol-listp vars)
- (pseudo-term-listp vals)
- (true-listp vals)
- (equal (len vals) (len vars))
- (not (stringp vars))
- (not (stringp vals)))))
-(defthm bindings-to-lambda-pseudo-termp
- (implies (pseudo-termp term)
- (pseudo-termp (bindings-to-lambda bindings term)))
- :hints(("Goal" :in-theory (enable true-listp length))))
-
-(in-theory (disable bindings-to-lambda))
-
-;; Transforms an alist with elements of the form
-;; (((param1 val1) (param2 val2)) shape-spec)
-;; to the form (parametrized-hyp . shape-spec).
-(defun param-bindings-to-alist (hyp bindings)
- (if (atom bindings)
- nil
- (cons (list* (sublis-into-term
- hyp (doubleton-list-to-alist (caar bindings)))
-;; (bindings-to-lambda (caar bindings) hyp)
- (acl2::msg "case: ~x0" (caar bindings))
- (cadar bindings))
- (param-bindings-to-alist hyp (cdr bindings)))))
-(local
- (defthm param-bindings-to-alist-pseudo-term-listp-strip-cars
- (implies (pseudo-termp hyp)
- (pseudo-term-listp (strip-cars (param-bindings-to-alist hyp bindings))))))
-
-
-
-
-
-(make-event (sublis *glcp-generic-template-subst* *glcp-clause-proc-template*))
(local
(progn
;; What am I doing here?
- (defund glcp-generic-run-parametrized-placeholder (clauses)
- (glcp-generic-ev-theoremp (conjoin-clauses clauses)))
+ (defund glcp-generic-run-parametrized-placeholder (term)
+ (glcp-generic-geval-ev-theoremp term))
(defun check-top-level-bind-free (bindings mfc state)
(declare (ignore state)
@@ -2616,44 +1711,46 @@
bindings))
(defthmd glcp-generic-run-parametrized-correct-rw
- (b* (((mv erp (cons clauses out-obligs) &)
+ (b* (((mv erp (list val-clause cov-clause out-obligs) &)
(glcp-generic-run-parametrized
- hyp concl untrans-concl vars bindings id obligs config st)))
+ hyp concl vars bindings id obligs config st)))
(implies (and (bind-free (check-top-level-bind-free
'((alist . alist)) acl2::mfc state)
(alist))
- (glcp-generic-ev-theoremp
+ (glcp-generic-geval-ev-theoremp
(conjoin-clauses
(acl2::interp-defs-alist-clauses out-obligs)))
(not erp)
- (glcp-generic-ev hyp alist)
+ (glcp-generic-geval-ev hyp alist)
(acl2::interp-defs-alistp obligs)
(acl2::interp-defs-alistp (glcp-config->overrides config))
(pseudo-termp concl)
(pseudo-termp hyp)
(equal vars (collect-vars concl))
- (glcp-generic-ev-meta-extract-global-facts :state state1)
- (equal (w st) (w state1)))
- (iff (glcp-generic-ev-theoremp (conjoin-clauses clauses))
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state1)
+ (equal (w st) (w state1))
+ (glcp-generic-geval-ev-theoremp (disjoin cov-clause)))
+ (iff (glcp-generic-geval-ev-theoremp (disjoin val-clause))
(and (glcp-generic-run-parametrized-placeholder
- clauses)
- (glcp-generic-ev concl alist)))))
+ (disjoin val-clause))
+ (glcp-generic-geval-ev concl alist)))))
:hints(("Goal" :in-theory (enable
- glcp-generic-run-parametrized-placeholder))))
+ glcp-generic-run-parametrized-placeholder
+ glcp-generic-geval-ev-falsify-sufficient))))
(defund glcp-generic-run-cases-placeholder (clauses)
- (glcp-generic-ev-theoremp (conjoin-clauses clauses)))
+ (glcp-generic-geval-ev-theoremp (conjoin-clauses clauses)))
(defthmd glcp-generic-run-cases-correct-rw
(b* (((mv erp (cons clauses out-obligs) &)
(glcp-generic-run-cases
- param-alist concl untrans-concl vars obligs config st)))
+ param-alist concl vars obligs config st)))
(implies (and (bind-free (check-top-level-bind-free
'((alist . alist)) mfc state) (alist))
- (glcp-generic-ev-theoremp
+ (glcp-generic-geval-ev-theoremp
(conjoin-clauses
(acl2::interp-defs-alist-clauses out-obligs)))
- (glcp-generic-ev (disjoin (strip-cars param-alist))
+ (glcp-generic-geval-ev (disjoin (strip-cars param-alist))
a)
(not erp)
(acl2::interp-defs-alistp obligs)
@@ -2661,11 +1758,11 @@
(pseudo-termp concl)
(pseudo-term-listp (strip-cars param-alist))
(equal vars (collect-vars concl))
- (glcp-generic-ev-meta-extract-global-facts :state state1)
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state1)
(equal (w st) (w state1)))
- (iff (glcp-generic-ev-theoremp (conjoin-clauses clauses))
+ (iff (glcp-generic-geval-ev-theoremp (conjoin-clauses clauses))
(and (glcp-generic-run-cases-placeholder clauses)
- (glcp-generic-ev concl a)))))
+ (glcp-generic-geval-ev concl a)))))
:hints(("Goal" :in-theory (enable glcp-generic-run-cases-placeholder))))))
(local
@@ -2677,16 +1774,16 @@
(defthm glcp-generic-correct
(implies (and (pseudo-term-listp clause)
(alistp alist)
- (glcp-generic-ev-meta-extract-global-facts)
- (glcp-generic-ev
+ (glcp-generic-geval-ev-meta-extract-global-facts)
+ (glcp-generic-geval-ev
(conjoin-clauses
(acl2::clauses-result
(glcp-generic clause hints state)))
- (glcp-generic-ev-falsify
+ (glcp-generic-geval-ev-falsify
(conjoin-clauses
(acl2::clauses-result
(glcp-generic clause hints state))))))
- (glcp-generic-ev (disjoin clause) alist))
+ (glcp-generic-geval-ev (disjoin clause) alist))
:hints
(("goal" :do-not-induct
t
@@ -2694,10 +1791,16 @@
(e/d* (glcp-generic-run-cases-correct-rw
glcp-generic-run-parametrized-correct-rw)
(glcp-analyze-interp-result-correct
- glcp-generic-geval-alist-gobj-alist-to-param-space
- glcp-generic-geval-gtests-nonnil-correct
+ ;; glcp-generic-geval-alist-gobj-alist-to-param-space
+ ;; glcp-generic-geval-gtests-nonnil-correct
glcp-generic-run-cases-correct
glcp-generic-run-parametrized-correct
+ pseudo-term-listp-cdr
+ pseudo-termp-car
+ ;; acl2::consp-under-iff-when-true-listp
+ glcp-generic-run-cases-bad-obligs
+ ;; acl2::consp-by-len
+ nfix
;; shape-spec-listp-impl-shape-spec-to-gobj-list
(:rules-of-class :definition :here))
(gl-cp-hint
@@ -2709,19 +1812,19 @@
glcp-generic glcp-error
assoc-equal pseudo-term-listp))
- :restrict ((glcp-generic-ev-disjoin-append ((a alist)))
- (glcp-generic-ev-disjoin-cons ((a alist)))))
+ :restrict ((glcp-generic-geval-ev-disjoin-append ((a alist)))
+ (glcp-generic-geval-ev-disjoin-cons ((a alist)))))
(and stable-under-simplificationp
(acl2::bind-as-in-definition
glcp-generic
(hyp-clause concl-clause params-cov-term hyp)
- `(:use ((:instance glcp-generic-ev-falsify
+ `(:use ((:instance glcp-generic-geval-ev-falsify
(x (disjoin ,hyp-clause))
(a alist))
- (:instance glcp-generic-ev-falsify
+ (:instance glcp-generic-geval-ev-falsify
(x (disjoin ,concl-clause))
(a alist))
- (:instance glcp-generic-ev-falsify
+ (:instance glcp-generic-geval-ev-falsify
(x (disjoin (CONS
(CONS
'NOT
@@ -2743,28 +1846,26 @@
;; produces all the other necessary clauses. We define this by
;; using a mock interp-term function that just returns T and no
;; obligs, and also a mock analyze-term
-(defun glcp-fake-interp-term (x bindings hyp clk obligs config state)
- (declare (ignore x bindings hyp clk config))
- (mv nil obligs t state))
+(defun glcp-fake-interp-hyp/concl (hyp concl bindings clk config interp-st
+ next-bvar bvar-db bvar-db1 state)
+ (declare (ignore hyp concl bindings clk config next-bvar)
+ (xargs :stobjs (interp-st bvar-db bvar-db1 state)))
+ (mv t t bvar-db1 nil interp-st bvar-db state))
(defun glcp-fake-analyze-interp-result
- (val param-al hyp-bdd id concl config state)
- (declare (ignore val param-al hyp-bdd id concl config)
- (xargs :stobjs state))
+ (hyp-bfr val constr param-al id concl config bvar-db state)
+ (declare (ignore val param-al hyp-bfr id concl config bvar-db constr)
+ (xargs :stobjs (bvar-db state)))
(mv nil '('t) state))
(defconst *glcp-side-goals-subst*
- `((interp-term . glcp-fake-interp-term)
+ '((interp-hyp/concl . glcp-fake-interp-hyp/concl)
(run-cases . glcp-side-goals-run-cases)
(run-parametrized . glcp-side-goals-run-parametrized)
(clause-proc . glcp-side-goals-clause-proc1)
(clause-proc-name . 'glcp-side-goals-clause-proc)
(glcp-analyze-interp-result . glcp-fake-analyze-interp-result)))
-(make-event (sublis *glcp-side-goals-subst*
- *glcp-run-parametrized-template*))
-
-(make-event (sublis *glcp-side-goals-subst* *glcp-run-cases-template*))
(make-event (sublis *glcp-side-goals-subst*
*glcp-clause-proc-template*))
@@ -2815,22 +1916,26 @@
;; Looks up a function in the gl-function-info table to see if it has
;; a symbolic counterpart, and executes it if so.
-(defun gl-universal-run-gified (fn actuals hyp clk state)
- (declare (xargs :guard (and (symbolp fn)
- (natp clk))
- :mode :program))
- (b* ((world (w state))
- (al (table-alist 'gl-function-info world))
- (look (assoc-eq fn al))
- ((unless look) (mv nil nil))
- (gfn (cadr look))
- ((mv er res)
- (acl2::magic-ev-fncall gfn (append actuals (list hyp clk))
- state t t))
- ((when er)
- (prog2$ (cw "GL-UNIVERSAL-RUN-GIFIED: error: ~@0~%" er)
- (mv nil nil))))
- (mv t res)))
+;; (defun gl-universal-run-gified (fn actuals pathcond clk config bvar-db state)
+;; (declare (xargs :guard (and (symbolp fn)
+;; (glcp-config-p config)
+;; (natp clk))
+;; :stobjs (bvar-db state)
+;; :mode :program)
+;; (ignorable config bvar-db))
+;; (b* ((world (w state))
+;; (al (table-alist 'gl-function-info world))
+;; (look (assoc-eq fn al))
+;; ((unless look) (mv nil nil))
+;; (gfn (cadr look))
+;; ((mv er res)
+;; (acl2::magic-ev-fncall gfn (append actuals (list pathcond clk config
+;; bvar-db state))
+;; state t t))
+;; ((when er)
+;; (prog2$ (cw "GL-UNIVERSAL-RUN-GIFIED: error: ~@0~%" er)
+;; (mv nil nil))))
+;; (mv t res)))
;; (defun gl-universal-apply-concrete (fn actuals state)
;; (declare (xargs :guard (true-listp actuals)
@@ -2849,402 +1954,183 @@
;; (mv nil nil state))))
;; (mv t val state)))
-(defconst *gl-universal-subst*
- `((run-gified . gl-universal-run-gified)
- (apply-concrete . gl-universal-apply-concrete)
- (interp-term . gl-universal-interp-term)
- (interp-list . gl-universal-interp-list)
- (run-cases . gl-universal-run-cases)
- (run-parametrized . gl-universal-run-parametrized)
- (clause-proc . gl-universal-clause-proc)
- (clause-proc-name . 'gl-universal-clause-proc)))
-
-(program)
+;; (defconst *gl-universal-subst*
+;; '((run-gified . gl-universal-run-gified)
+;; (interp-term . gl-universal-interp-term)
+;; (interp-fncall-ifs . gl-universal-interp-fncall-ifs)
+;; (interp-fncall . gl-universal-interp-fncall)
+;; (interp-if . gl-universal-interp-if)
+;; (finish-or . gl-universal-finish-or)
+;; (finish-if . gl-universal-finish-if)
+;; (simplify-if-test . gl-universal-simplify-if-test)
+;; (rewrite . gl-universal-rewrite)
+;; (rewrite-apply-rules . gl-universal-rewrite-apply-rules)
+;; (rewrite-apply-rule . gl-universal-rewrite-apply-rule)
+;; (relieve-hyps . gl-universal-relieve-hyps)
+;; (relieve-hyp . gl-universal-relieve-hyp)
+;; (interp-list . gl-universal-interp-list)
+;; (interp-top-level-term . gl-universal-interp-top-level-term)
+;; (interp-concl . gl-universal-interp-concl)
+;; (interp-hyp/concl . gl-universal-interp-hyp/concl)
+;; (run-parametrized . gl-universal-run-parametrized)
+;; (run-cases . gl-universal-run-cases)
+;; (clause-proc . gl-universal)
+;; (clause-proc-name . (gl-universal-clause-proc-name))))
-(make-event (sublis *gl-universal-subst* *glcp-interp-template*))
+;; (program)
-(make-event (sublis *gl-universal-subst*
- *glcp-run-parametrized-template*))
+;; (make-event (sublis *gl-universal-subst* *glcp-interp-template*))
+;; (make-event (sublis *gl-universal-subst* *glcp-interp-wrappers-template*))
-(make-event (sublis *gl-universal-subst* *glcp-run-cases-template*))
+;; (make-event (sublis *gl-universal-subst*
+;; *glcp-run-parametrized-template*))
-(make-event (sublis *gl-universal-subst*
- *glcp-clause-proc-template*))
+;; (make-event (sublis *gl-universal-subst* *glcp-run-cases-template*))
-(logic)
+;; (make-event (sublis *gl-universal-subst*
+;; *glcp-clause-proc-template*))
+;; (logic)
-;; To install this as a clause processor, run the following. Note
-;; that this creates a ttag.
-(defmacro allow-gl-universal-clause-processor ()
- '(acl2::define-trusted-clause-processor
- gl-universal-clause-proc
- nil :ttag gl-universal-clause-proc))
+;; ;; To install this as a clause processor, run the following. Note
+;; ;; that this creates a ttag.
+;; (defmacro allow-gl-universal-clause-processor ()
+;; '(acl2::define-trusted-clause-processor
+;; gl-universal-clause-proc
+;; nil :ttag gl-universal-clause-proc))
-;; Symbolic interpreter for translated terms, based on the universal clause
-;; processor defined above. X is the term, ALIST gives a
-;; list of bindings of variables to g-objects, hyp is a BDD.
-(defun gl-interp-term (x alist hyp clk state)
- (declare (xargs :mode :program :stobjs state))
- (b* ((world (w state))
- ((er overrides)
- (preferred-defs-to-overrides
- (table-alist 'preferred-defs world) state))
- ((mv er obligs ans state)
- (gl-universal-interp-term
- x alist hyp clk nil (make-glcp-config :overrides overrides) state))
- ((when er) (mv er nil state))
- (- (flush-hons-get-hash-table-link obligs)))
- (value ans)))
+;; ;; Symbolic interpreter for translated terms, based on the universal clause
+;; ;; processor defined above. X is the term, ALIST gives a
+;; ;; list of bindings of variables to g-objects, hyp is a BDD.
+
+;; (defun gl-interp-term (x alist pathcond clk bvar-db state)
+;; (declare (xargs :mode :program :stobjs (bvar-db state)))
+;; (b* ((world (w state))
+;; ((mv erp overrides state)
+;; (preferred-defs-to-overrides
+;; (table-alist 'preferred-defs world) state))
+;; ((when erp)
+;; (mv erp nil bvar-db state))
+;; ((mv er obligs ans bvar-db state)
+;; (gl-universal-interp-term
+;; x alist pathcond nil clk nil (make-glcp-config :overrides overrides) bvar-db state))
+;; ((when er) (mv er nil bvar-db state))
+;; (- (flush-hons-get-hash-table-link obligs)))
+;; (mv nil ans bvar-db state)))
-;; Translate the given term, then run the interpreter.
-(defmacro gl-interp-raw (x &optional alist (hyp 't) (clk '100000))
- `(acl2::er-let*
- ((trans (acl2::translate ,x :stobjs-out t t 'gl-interp (w state)
- state)))
- (gl-interp-term trans ,alist ,hyp ,clk state)))
+;; ;; Translate the given term, then run the interpreter.
+;; (defmacro gl-interp-raw (x &optional alist (hyp 't) (clk '100000))
+;; `(b* (((mv er trans state)
+;; (acl2::translate ,x t t t 'gl-interp (w state)
+;; state))
+;; ((when er) (mv er nil bvar-db state)))
+;; (gl-interp-term trans ,alist ,hyp ,clk state)))
-(defdoc gl-interp-raw
- ":Doc-section ACL2::GL
-Symbolically interpret a term using GL.~/
-
-Usage:
-~bv[]
- (gl-interp-raw term bindings)
-~ev[]
-
-The above form runs a symbolic interpretation of ~c[term] on the symbolic input
-~c[bindings]. ~c[bindings] should be an association list mapping variables to
-symbolic objects (not to shape specifiers, as in ~il[gl-interp].) Note also
-that bindings is a dotted alist, rather than a doubleton list as in
-~il[gl-interp]: each pair is ~c[(CONS VAR BINDING)], not ~c[(LIST VAR BINDING)].~/~/")
-
-
-(defun gl-parametrize-by-hyp-fn (hyp al state)
- (declare (xargs :mode :program))
- (b* ((al (shape-specs-to-interp-al al))
- ((er hyp-pred) (gl-interp-raw hyp al))
- (hyp-test (gtests hyp-pred t))
- (hyp-bdd (bfr-or (gtests-nonnil hyp-test)
- (gtests-unknown hyp-test))))
- (value (gobj-to-param-space al hyp-bdd))))
-
-(defmacro gl-parametrize-by-hyp (hyp bindings)
- `(gl-parametrize-by-hyp-fn ,hyp ,bindings state))
-
-(defun gl-interp-fn (hyp term al state)
- (declare (xargs :mode :program
- :stobjs state))
- (b* (((er param-al) (gl-parametrize-by-hyp hyp al))
-;; (al (shape-specs-to-interp-al al))
+;; (defun gl-parametrize-by-hyp-fn (hyp al bvar-db state)
+;; (declare (xargs :mode :program))
+;; (b* ((al (shape-specs-to-interp-al al))
;; ((er hyp-pred) (gl-interp-raw hyp al))
;; (hyp-test (gtests hyp-pred t))
-;; (hyp-bdd (q-or (gtests-nonnil hyp-test)
-;; (gtests-unknown hyp-test)))
-;; (param-al (gobj-to-param-space al hyp-bdd))
- ((er res) (gl-interp-raw term param-al)))
- (value (cons param-al res))))
-
-(defmacro gl-interp (term al &key (hyp 't))
- `(gl-interp-fn ',hyp ',term ,al state))
-
-(defdoc gl-interp
- ":Doc-section ACL2::GL
-Symbolically interpret a term using GL, with inputs generated by parametrization.~/
-
-Usage:
-~bv[]
- (gl-interp term bindings :hyp hyp)
-~ev[]
-
-The above form runs a symbolic interpretation of ~c[term] on the symbolic input
-assignment produced by parametrizing ~c[bindings] using ~c[hyp]. The symbolic
-execution run by this form is similar to that run by
-~bv[]
- (def-gl-thm :hyp hyp :concl term :g-bindings bindings).
-~ev[]
-~c[bindings] should be a binding list of the same kind as taken by
-~il[def-gl-thm], that is, a list of elements ~c[(var val)] such that ~c[var]
-is a variable free in ~c[term], and ~c[val] is a shape specifier
-(~l[gl::shape-specs].)
-
-Similar to ~c[def-gl-thm], ~c[term] and ~c[hyp] should be the (unquoted)
-terms of interest, whereas ~c[bindings] should be something that evaluates to
-the binding list (the quotation of that binding list, for example.)~/
-
-In more detail: First, the input bindings are converted to an assignment of
-symbolic inputs to variables. The hyp term is symbolically interpreted using
-this variable assignment, yielding a predicate. The symbolic input assignment is
-parametrized using this predicate to produce a new such assignment whose
-coverage is restricted to the subset satisfying the hyp. The term is then
-symbolically interpreted using this assignment, and the result is returned.
-
-This macro expands to a function call taking state, and its return value is an
-error triple.
+;; (hyp-bfr (bfr-or (gtests-nonnil hyp-test)
+;; (gtests-unknown hyp-test))))
+;; (value (gobj-to-param-space al hyp-bfr))))
-The symbolic interpreter used by ~c[gl-interp] is not one introduced by
-def-gl-clause-processor as usual, but a special one which can call any function
-on concrete values, and any symbolic counterpart function. (Other interpreters
-can call a fixed list of functions on concrete values and a fixed list of
-symbolic counterparts.) However, typically a fixed interpreter is used when
-proving theorems (otherwise a ttag is needed.) This has some
-performance-related consequences:
-
- - ~c[gl-interp] may interpret a term faster than ~c[def-gl-thm]. This
-occurs mainly when some function is run concretely by the universal interpreter
-but is not in the fixed list of functions callable by the fixed interpreter.
-Determine which function is at fault by looking at a backtrace, and then define
-your interpreter so that it can call this function.
-
- - ~c[gl-interp] may interpret a term slower than ~c[def-gl-thm]. The
-universal interpreter uses somewhat more overhead on each function call than
-fixed interpreters do, so when interpreter overhead is a large portion of the
-runtime relative to BDD operations, ~c[gl-interp] may be a constant factor
-slower than a fixed interpreter.
-
-See ~il[gl-interp-raw] for a similar function that does not perform
-parametrization.~/")
+;; (defmacro gl-parametrize-by-hyp (hyp bindings)
+;; `(gl-parametrize-by-hyp-fn ,hyp ,bindings state))
+(table latest-greatest-gl-clause-proc nil *glcp-generic-template-subst* :clear)
+(defun gl-interp-fn (hyp term al config state)
+ (declare (xargs :mode :program :stobjs state))
+ (b* ((gobj-al (shape-specs-to-interp-al al))
+ ((mv erp overrides state)
+ (preferred-defs-to-overrides
+ (table-alist 'preferred-defs (w state)) state))
+ ((when erp) (mv erp nil nil nil state))
+ ((mv erp hyp-trans state)
+ (acl2::translate hyp t t t 'gl-interp (w state)
+ state))
+ ((when erp) (mv erp nil nil nil state))
+ ((mv erp term-trans state)
+ (acl2::translate term t t t 'gl-interp (w state)
+ state))
+ ((when erp) (mv erp nil nil nil state))
+ (config (or config (make-glcp-config :overrides overrides)))
+ (interp-fn (cdr (assoc 'interp-term-under-hyp
+ (table-alist 'latest-greatest-gl-clause-proc
+ (w state)))))
+ (next-bvar (shape-spec-max-bvar-list (strip-cadrs al)))
+ (form `(,interp-fn ',hyp-trans ',term-trans ',gobj-al ',next-bvar ',config
+ interp-st bvar-db bvar-db1 state))
+ ((mv trans-eval-erp (cons ?stobjs-out
+ (list hyp-bfr param-al res-obj interp-erp
+ ;; and some stobj symbols
+ ))
+ state)
+ (acl2::trans-eval form 'gl-interp state t))
+ ((when trans-eval-erp) (mv trans-eval-erp nil nil nil state))
+ ((when interp-erp) (mv interp-erp nil nil nil state)))
+ (mv nil hyp-bfr param-al res-obj state)))
+
+
+(defmacro gl-interp (term al &key (hyp 't) (config 'nil))
+ `(gl-interp-fn ',hyp ',term ,al ',config state))
+
+(defxdoc gl-interp
+ :parents (reference)
+ :short "Symbolically interpret a term using GL, with inputs generated by
+parametrization."
-(defun find-counterexamples-fn (hyp concl al state)
- (declare (xargs :mode :program
- :stobjs state))
- (b* (((er (cons param-al concl-pred))
- (gl-interp-fn hyp concl al state))
- (concl-tests (gtests concl-pred t))
- (neg-concl (bfr-and (bfr-not (gtests-nonnil concl-tests))
- (bfr-not (gtests-unknown concl-tests))))
- (false-al (gobj-to-param-space param-al neg-concl)))
- (value false-al)))
-
-(defmacro find-counterexamples (concl alist &key (hyp 't))
- `(find-counterexamples-fn ,hyp ,concl ,alist state))
-
-
-
-
-
-
-(defun max-max-max-depth (x)
- (if (atom x)
- 0
- (max (acl2::max-max-depth (car x))
- (max-max-max-depth (cdr x)))))
-
-(defund gobj-max-depth (x)
- (if (atom x)
- 0
- (pattern-match x
- ((g-concrete &) 0)
- ((g-boolean b) (max-depth b))
- ((g-number n) (max-max-max-depth n))
- ((g-ite if then else)
- (max (gobj-max-depth if)
- (max (gobj-max-depth then)
- (gobj-max-depth else))))
- ((g-apply & args) (gobj-max-depth args))
- ((g-var &) 0)
- (& (max (gobj-max-depth (car x))
- (gobj-max-depth (cdr x)))))))
-
-
-
-
-(defun n-random-assignments-fn (n bound obj pred evfn state)
- (declare (xargs :stobjs state
- :mode :program))
- (if (eq pred nil)
- (er soft 'n-random-assignments-fn
- "Unsatisfiable predicate for n-random-assignments~%")
- (if (zp n)
- (value nil)
- (b* (((er rest) (n-random-assignments-fn
- (1- n) bound obj pred evfn state))
- ((mv envn state) (acl2::random$ bound state))
- (env (list (to-satisfying-assign (n2v envn) pred))))
- (if evfn
- (b* ((term `(,evfn ',obj ',env))
- ((er (cons & val))
- (acl2::simple-translate-and-eval
- term nil nil
- (acl2::msg "~
-GL evaluation with ~x0 in n-random-assignments-fn" evfn)
- 'n-random-assignments-fn (w state) state t)))
- (value (cons val rest)))
- (value (cons (generic-geval obj env) rest)))))))
-
-(defmacro n-random-assignments (n obj &optional (pred 't) evfn)
- `(n-random-assignments-fn
- ,n
- (expt 2 (gobj-max-depth ,obj))
- ,obj ,pred ,evfn state))
-
-
+ :long "Usage:
+@({
+ (gl-interp term bindings :hyp hyp)
+})
+The above form runs a symbolic interpretation of @('term') on the symbolic input
+assignment produced by parametrizing @('bindings') using @('hyp'). The symbolic
+execution run by this form is similar to that run by
-(defun possibly-true (res)
- (let ((test (gl::gtests res t)))
- (bfr-or (gl::gtests-nonnil test)
- (gl::gtests-unknown test))))
-
-(defun known-true (res)
- (let ((test (gl::gtests res t)))
- (bfr-and (gl::gtests-nonnil test)
- (bfr-not (gl::gtests-unknown test)))))
-
-
-(defun sim-g-thm-fn (hyp concl g-bindings ctrex-info nexamples erp state)
- (declare (xargs :stobjs state :mode :program))
- (b* ((al (shape-specs-to-interp-al g-bindings))
- ((er hyp-pred) (gl-interp-raw hyp al))
- (hyp-possible (possibly-true hyp-pred))
- ((er hyp-possible)
- (if hyp-possible
- (value hyp-possible)
- (er soft 'sim-g-thm-fn "Impossible hyp~%")))
- (hyp-al (gobj-to-param-space al hyp-possible))
- ((er concl-pred) (gl-interp-raw concl hyp-al))
- (concl-definite (known-true concl-pred)))
- (if (eq concl-definite t)
- (value "OK")
- (b* ((ctrex-bdd (bfr-not concl-definite))
- ((er ctrex-info-res) (gl-interp-raw ctrex-info hyp-al))
- ((er ctrexamples)
- (n-random-assignments nexamples (cons hyp-al ctrex-info-res)
- ctrex-bdd)))
- (if erp
- (er soft 'sim-g-thm-fn
- "Counterexamples found: ~x0~%" ctrexamples)
- (value ctrexamples))))))
-
-(defmacro sim-g-thm
- (&key hyp concl g-bindings ctrex-term (nexamples '3) (erp 't))
- `(sim-g-thm-fn ',hyp ',concl ,g-bindings ',ctrex-term ,nexamples ,erp state))
+@({
+ (def-gl-thm :hyp hyp :concl term :g-bindings bindings).
+})
+@('bindings') should be a binding list of the same kind as taken by @(see
+def-gl-thm), that is, a list of elements @('(var val)') such that @('var') is a
+variable free in @('term'), and @('val') is a shape specifier; see @(see
+shape-specs).
+
+Similar to @('def-gl-thm'), @('term') and @('hyp') should be the (unquoted)
+terms of interest, whereas @('bindings') should be something that evaluates to
+the binding list (the quotation of that binding list, for example.)
+In more detail: First, the input bindings are converted to an assignment of
+symbolic inputs to variables. The hyp term is symbolically interpreted using
+this variable assignment, yielding a predicate. The symbolic input assignment
+is parametrized using this predicate to produce a new such assignment whose
+coverage is restricted to the subset satisfying the hyp. The term is then
+symbolically interpreted using this assignment, and the result is returned.
-(defun param-al-to-interp-al (al)
- (if (atom al)
- nil
- (if (consp (car al))
- (cons (cons (caar al) (mk-g-concrete (cadar al)))
- (param-al-to-interp-al (cdr al)))
- (param-al-to-interp-al (cdr al)))))
+This macro expands to a function call taking state and the bvar-db and
+bvar-db1 live stobjs. It returns:
+@({
+ (mv error-message hyp-bfr param-al result bvar-db bvar-db1 state)
+})
+
+The symbolic interpreter used by @('gl-interp') is the latest interpreter
+defined using def-gl-clause-processor (as recorded in the
+gl::latest-greatest-gl-clause-proc table).
")
-(defun sim-param-coverage (param-hyp param-bindings cov-al state)
- (declare (xargs :stobjs state
- :mode :program))
- (if (atom param-bindings)
- (value nil)
- (b* (((er rest) (sim-param-coverage
- param-hyp (cdr param-bindings) cov-al state))
- (curr-al (append (param-al-to-interp-al (caar param-bindings))
- cov-al))
- ((er res) (gl-interp-raw param-hyp curr-al))
- (res-known (known-true res)))
- (value (bfr-or rest res-known)))))
-
-
-(defun sim-param-coverage-ok (hyp param-hyp param-bindings cov-bindings
- nexamples erp state)
- (declare (xargs :stobjs state
- :mode :program))
- (b* ((cov-al (shape-specs-to-interp-al cov-bindings))
- ((er hyp-res) (gl-interp-raw hyp cov-al))
- (hyp-possible (possibly-true hyp-res))
- ((er param-cov) (sim-param-coverage
- param-hyp param-bindings cov-al state))
- (uncov (bfr-and hyp-possible (bfr-not param-cov))))
- (if uncov
- (b* (((er examples)
- (n-random-assignments nexamples cov-al uncov)))
- (if erp
- (er soft 'sim-param-coverage-ok
- "Coverage gap found. Examples: ~x0~%" examples)
- (value examples)))
- (value "OK"))))
-
-(defun gl-interp-on-alists (term alists state)
- (declare (xargs :stobjs state :mode :program))
- (if (atom alists)
- (value nil)
- (b* (((er rest) (gl-interp-on-alists term (cdr alists) state))
- ((er (cons & first))
- (acl2::simple-translate-and-eval
- term (car alists) nil
- "gl-interp-on-alists"
- 'gl-interp-on-alists (w state) state t))
-;; (gl-interp term (car alists))
- )
- (value (cons (cons (car alists) first) rest)))))
-
-(defun sim-params (param-bindings param-hyp concl ctrex-info nexamples
- run-after-cases state)
- (declare (xargs :stobjs state
- :mode :program))
- (if (atom param-bindings)
- (value "OK")
- (b* ((- (cw "Param bindings: ~x0~%" (caar param-bindings)))
- (al (shape-specs-to-interp-al (cadar param-bindings)))
- (al-with-params (append (param-al-to-interp-al (caar param-bindings)) al))
- ((er hyp) (gl-interp-raw param-hyp al-with-params))
- (hyp-possible (possibly-true hyp))
- ((er &)
- (if hyp-possible
- (b* ((param-al (gobj-to-param-space al hyp-possible))
- ((er concl-pred) (gl-interp-raw concl param-al))
- (concl-known (known-true concl-pred)))
- (if (eq concl-known t)
- (value "OK")
- (b* ((ctrex-bdd (bfr-not concl-known))
- ((er ctrex-alists)
- (n-random-assignments
- nexamples param-al ctrex-bdd))
- ((er ctrexamples)
- (gl-interp-on-alists ctrex-info ctrex-alists state)))
- (er soft 'sim-params
- "Counterexamples found at parameters ~x0: ~x1~%"
- (caar param-bindings) ctrexamples))))
- (prog2$ (cw "Note: Param hyp is impossible with settings ~x0~%"
- (caar param-bindings))
- (value "OK"))))
- ((er &)
- (acl2::simple-translate-and-eval
- run-after-cases nil nil
- (acl2::msg "~
-sim-params: ~x0~%" run-after-cases)
- 'sim-params (w state) state t)))
- (sim-params (cdr param-bindings) param-hyp concl ctrex-info nexamples
- run-after-cases state))))
-
-
-(defun sim-param-thm-fn (hyp param-hyp concl cov-bindings param-bindings
- ctrex-info nexamples run-after-cases erp state)
- (declare (xargs :stobjs state
- :mode :program))
- (er-progn
- (sim-param-coverage-ok hyp param-hyp param-bindings cov-bindings
- nexamples erp state)
- (sim-params param-bindings param-hyp concl ctrex-info nexamples
- run-after-cases state)))
-
-(defmacro sim-param-thm
- (&key hyp param-hyp concl cov-bindings param-bindings ctrex-term
- (nexamples '3) run-after-cases (erp 't))
- `(sim-param-thm-fn ',hyp ',param-hyp ',concl ,cov-bindings ,param-bindings
- ',ctrex-term ,nexamples ',run-after-cases ,erp state))
diff -Nru acl2-6.2/books/centaur/gl/gl-generic-interp-defs.lisp acl2-6.3/books/centaur/gl/gl-generic-interp-defs.lisp
--- acl2-6.2/books/centaur/gl/gl-generic-interp-defs.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gl-generic-interp-defs.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,1148 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "GL")
+(include-book "ite-merge")
+(include-book "gtests")
+(include-book "glcp-templates")
+(include-book "shape-spec-defs")
+(include-book "symbolic-arithmetic-fns")
+(include-book "param")
+(include-book "bfr-sat")
+(include-book "glcp-config")
+(include-book "gl-mbe")
+(include-book "split-args")
+(include-book "glcp-unify-defs")
+(include-book "centaur/misc/rewrite-rule" :dir :system)
+(include-book "centaur/misc/beta-reduce-full" :dir :system)
+(include-book "glcp-geval")
+(include-book "constraint-db-deps")
+
+(verify-termination acl2::evisc-tuple)
+(verify-guards acl2::evisc-tuple)
+
+(defun glcp-case-split-report (test then else)
+ (declare (xargs :guard t)
+ (ignore test then else))
+ nil)
+
+
+(defmacro glcp-if (test then else &key report)
+ `(b* ((hyp pathcond)
+ (gtests (gtests ,test hyp))
+ (then-hyp (hf (bfr-or (gtests-unknown gtests)
+ (gtests-nonnil gtests))))
+ (else-hyp (hf (bfr-or (gtests-unknown gtests)
+ (bfr-not (gtests-nonnil gtests)))))
+ (- (and then-hyp else-hyp ,report))
+ ((glcp-er then)
+ (if then-hyp
+ (let ((pathcond (bfr-and hyp then-hyp)))
+ (declare (ignorable pathcond))
+ ,then)
+ (glcp-value nil)))
+ ((glcp-er else)
+ (if else-hyp
+ (let ((pathcond (bfr-and hyp else-hyp)))
+ (declare (ignorable pathcond))
+ ,else)
+ (glcp-value nil)))
+ (merge (gobj-ite-merge (gtests-nonnil gtests) then else
+ (bfr-and (bfr-not (gtests-unknown gtests))
+ hyp))))
+ (if (hf (gtests-unknown gtests))
+ (glcp-value
+ (mk-g-ite (mk-g-boolean (gtests-unknown gtests))
+ (mk-g-ite (gtests-obj gtests) then else)
+ merge))
+ (glcp-value merge))))
+
+
+(defmacro glcp-or (test else)
+ `(b* ((hyp pathcond)
+ (test ,test)
+ (gtests (gtests test hyp))
+ (else-hyp (hf (bfr-or (gtests-unknown gtests)
+ (bfr-not (gtests-nonnil gtests)))))
+ ((glcp-er else)
+ (if else-hyp
+ (let ((pathcond (bfr-and hyp else-hyp)))
+ (declare (ignorable pathcond))
+ ,else)
+ (glcp-value nil)))
+ (merge (gobj-ite-merge (gtests-nonnil gtests) test else
+ (bfr-and (bfr-not (gtests-unknown gtests))
+ hyp))))
+ (if (hf (gtests-unknown gtests))
+ (glcp-value
+ (mk-g-ite (mk-g-boolean (gtests-unknown gtests))
+ (mk-g-ite (gtests-obj gtests) test else)
+ merge))
+ (glcp-value merge))))
+
+
+
+
+(acl2::def-meta-extract glcp-generic-geval-ev glcp-generic-geval-ev-lst)
+
+(encapsulate
+ (((glcp-generic-run-gified * * * * * bvar-db state)
+ => (mv * *)
+ :formals (fn actuals hyp clk config bvar-db state)
+ :guard (and (symbolp fn)
+ (true-listp actuals)
+ (glcp-config-p config)
+ (natp clk)))
+ ;; ((glcp-generic-geval-ev * *) => *)
+ ;; ((glcp-generic-geval-ev-lst * *) => *)
+ ;; ((glcp-generic-geval * *) => *)
+ )
+
+ ;; (local (def-eval-g glcp-generic-geval
+ ;; (if gl-cp-hint shape-spec-obj-in-range return-last use-by-hint equal
+ ;; acl2::typespec-check implies iff not cons gl-aside gl-ignore gl-error)))
+
+ ;; (local (defun glcp-generic-geval (x env)
+ ;; (generic-geval x env)))
+
+ (local (defun glcp-generic-run-gified (fn actuals hyp clk config bvar-db state)
+ (declare (xargs :stobjs (bvar-db state)
+ :guard (and (symbolp fn)
+ (natp clk)))
+ (ignorable fn actuals hyp clk config bvar-db state))
+ (mv nil nil)))
+
+ ;; (local (acl2::defevaluator-fast
+ ;; glcp-generic-ev glcp-generic-ev-lst
+ ;; ((if a b c)
+ ;; (gl-cp-hint x)
+ ;; (shape-spec-obj-in-range a b)
+ ;; (return-last fn arg1 arg2)
+ ;; (use-by-hint x)
+ ;; (equal a b)
+ ;; (acl2::typespec-check ts x)
+ ;; (implies a b)
+ ;; (iff a b)
+ ;; (not x)
+ ;; (cons a b)
+ ;; (gl-aside x)
+ ;; (gl-ignore x)
+ ;; (gl-error x))
+ ;; :namedp t))
+
+ (defthm glcp-generic-run-gified-correct
+ (implies (and (bfr-eval hyp (car env))
+ ;; (gobj-listp actuals)
+ (mv-nth 0 (glcp-generic-run-gified fn actuals hyp
+ clk config bvar-db state)))
+ (equal (glcp-generic-geval
+ (mv-nth 1 (glcp-generic-run-gified
+ fn actuals hyp clk config bvar-db state))
+ env)
+ (glcp-generic-geval-ev
+ (cons fn
+ (acl2::kwote-lst
+ (glcp-generic-geval-list actuals env))) nil))))
+
+ (defthm gobj-depends-on-of-glcp-generic-run-gified
+ (implies (not (gobj-list-depends-on k p actuals))
+ (not (gobj-depends-on k p (mv-nth 1 (glcp-generic-run-gified
+ fn actuals hyp clk config bvar-db state))))))
+
+
+ ;; (defthm true-listp-glcp-generic-run-gified
+ ;; (true-listp (glcp-generic-run-gified fn actuals hyp clk config bvar-db state)))
+
+ ;; (make-event
+ ;; `(progn
+ ;; . ,(acl2::defevaluator-fast-form/defthms-named
+ ;; 'glcp-generic-geval-ev 'glcp-generic-geval-ev-lst
+ ;; '((if a b c)
+ ;; (gl-cp-hint x)
+ ;; (shape-spec-obj-in-range a b)
+ ;; (return-last fn arg1 arg2)
+ ;; (use-by-hint x)
+ ;; (equal a b)
+ ;; (acl2::typespec-check ts x)
+ ;; (implies a b)
+ ;; (iff a b)
+ ;; (not x)
+ ;; (cons a b)
+ ;; (gl-aside x)
+ ;; (gl-ignore x)
+ ;; (gl-error x)))))
+
+ )
+
+(defun general-concrete-listp (x)
+ (declare (xargs :guard t))
+ (if (atom x)
+ (eq x nil)
+ (and (general-concretep (car x))
+ (general-concrete-listp (cdr x)))))
+
+(defun general-concrete-obj-list (x)
+ (declare (xargs :guard (general-concrete-listp x)))
+ (if (atom x)
+ nil
+ (cons (general-concrete-obj (car x))
+ (general-concrete-obj-list (cdr x)))))
+
+
+(mutual-recursion
+ (defun sublis-into-term (x alist)
+ (declare (xargs :guard t))
+ (cond ((null x) nil)
+ ((atom x)
+ (let ((look (hons-assoc-equal x alist)))
+ (if look (acl2::kwote (cdr look)) x)))
+ ((eq (car x) 'quote) x)
+ (t (cons (car x) (sublis-into-list (cdr x) alist)))))
+ (defun sublis-into-list (x alist)
+ (declare (xargs :guard t))
+ (if (atom x)
+ nil
+ (cons (sublis-into-term (car x) alist)
+ (sublis-into-list (cdr x) alist)))))
+
+
+
+(defund gl-aside-wormhole (term alist)
+ (declare (xargs :guard t))
+ (wormhole 'glcp-interp-gl-aside
+ '(lambda (whs) whs)
+ nil
+ `(prog2$ ,(sublis-into-term
+ term alist)
+ (value :q))
+ :ld-prompt nil
+ :ld-pre-eval-print nil
+ :ld-post-eval-print nil
+ :ld-verbose nil))
+
+(defthmd acl2-count-last-cdr-when-cadr-hack
+ (implies (< 1 (len x))
+ (< (acl2-count (car (last x)))
+ (+ 1 (acl2-count (cdr x)))))
+ :rule-classes (:rewrite :linear))
+
+
+
+(acl2::def-b*-binder
+ rewrite-rule
+ #!acl2
+ (cutil::da-patbind-fn 'rewrite-rule
+ #!GL '(rune hyps lhs rhs equiv subclass heuristic-info)
+ args forms rest-expr))
+;; Note: careful with this; variable names that are imported symbols yield
+;; names in the other package. In particular, since we import single-letter
+;; variables from the ACL2 package, use multiletter variables.
+
+;; used for measure
+(defun pos-fix (x)
+ (if (posp x) x 1))
+
+
+(defund glcp-relieve-hyp-synp (hyp bindings state)
+ (declare (xargs :stobjs state
+ :guard (and (consp hyp)
+ (pseudo-termp hyp))))
+ (b* ((args (cdr hyp))
+ ((unless #!acl2 (and
+ ;; check that synp is defined as expected
+ (fn-check-def 'synp state '(vars form term) ''t)
+ ;; check that all three args are quoted
+ (equal (len args) 3)
+ (quote-listp args)))
+ (mv (acl2::msg "Bad synp hyp: ~x0~%" hyp) nil nil))
+ (hyp-form (second (second args)))
+ ((unless (and (consp hyp-form) (eq (car hyp-form) 'syntaxp)))
+ (mv (acl2::msg "Bind-free isn't supported yet: ~x0~%" hyp) nil nil))
+ (form (second ;; unquote
+ (third args)))
+ ((unless (and (pseudo-termp form)
+ (symbol-alistp bindings)))
+ (mv (acl2::msg "ill-formed syntaxp form: ~x0~%" form) nil nil))
+ ((mv err val) (acl2::magic-ev form bindings state t t))
+ ((when err)
+ (mv (acl2::msg "synp error: ~@0~%" (if (eq err t) "error" err)) nil nil)))
+ (mv nil val bindings)))
+
+
+(mutual-recursion
+ (defun gl-term-to-apply-obj (x alist)
+ (declare (xargs :guard (pseudo-termp x)
+ :verify-guards nil))
+ (b* (((when (not x)) nil)
+ ((when (atom x)) (cdr (hons-assoc-equal x alist)))
+ ((when (eq (car x) 'quote)) (g-concrete-quote (cadr x)))
+ (args (gl-termlist-to-apply-obj-list (cdr x) alist))
+ (fn (car x))
+ ((when (consp fn))
+ (b* ((formals (cadr fn))
+ (body (caddr fn)))
+ (gl-term-to-apply-obj body (pairlis$ formals args))))
+ ((when (eq fn 'if))
+ (g-ite (first args) (second args) (third args)))
+ ((when (eq fn 'cons))
+ (gl-cons (first args) (second args))))
+ (g-apply fn args)))
+ (defun gl-termlist-to-apply-obj-list (x alist)
+ (declare (xargs :guard (pseudo-term-listp x)))
+ (if (atom x)
+ nil
+ (cons (gl-term-to-apply-obj (car x) alist)
+ (gl-termlist-to-apply-obj-list (cdr x) alist)))))
+
+(in-theory (disable gl-term-to-apply-obj
+ gl-termlist-to-apply-obj-list))
+
+
+(flag::make-flag gl-term-to-apply-obj-flag gl-term-to-apply-obj)
+
+(defthm-gl-term-to-apply-obj-flag
+ (defthm true-listp-gl-termlist-to-apply-obj-list
+ (true-listp (gl-termlist-to-apply-obj-list x alist))
+ :hints ('(:expand ((gl-termlist-to-apply-obj-list x alist))))
+ :rule-classes :type-prescription
+ :flag gl-termlist-to-apply-obj-list)
+ :skip-others t)
+
+(verify-guards gl-term-to-apply-obj)
+
+;; NOTE. This is provably equal to pseudo-term-listp, but we use it
+;; differently. When an element is a symbol, it stands for an equivalence
+;; relation; otherwise, it is a context "fixing" term.
+(defun contextsp (x)
+ (declare (xargs :guard t))
+ (if (atom x)
+ (eq x nil)
+ (and (or (symbolp (car x))
+ (pseudo-termp (car x)))
+ (contextsp (cdr x)))))
+
+
+;; (defund-nx glcp-generic-eval-context-equivs (contexts x y a)
+;; (b* (((when (atom contexts))
+;; (equal (glcp-generic-geval-ev x a)
+;; (glcp-generic-geval-ev y a)))
+;; (ctx (car contexts))
+;; (ctx-fn (if (symbolp ctx)
+;; ctx
+;; `(lambda (x y)
+;; (equal ,ctx
+;; ((lambda (x) ,ctx) y))))))
+;; (or (glcp-generic-geval-ev (list ctx-fn x y) a)
+;; (glcp-generic-eval-context-equivs (cdr contexts) x y a))))
+
+;; (defun-sk glcp-generic-equiv-under-contexts (contexts x y)
+;; (forall (a)
+;; (glcp-generic-eval-context-equivs contexts x y a))
+;; :rewrite :direct)
+
+
+(defun-sk glcp-generic-equiv-relp (f)
+ (forall (a x y z)
+ (and (booleanp (glcp-generic-geval-ev (list f x y) a))
+ (glcp-generic-geval-ev (list f x x) a)
+ (implies (glcp-generic-geval-ev (list f x y) a)
+ (glcp-generic-geval-ev (list f y x) a))
+ (implies (and (glcp-generic-geval-ev (list f x y) a)
+ (glcp-generic-geval-ev (list f y z) a))
+ (glcp-generic-geval-ev (list f x z) a))))
+ :rewrite :direct)
+
+(in-theory (disable glcp-generic-equiv-relp))
+
+(defun proper-contextsp (contexts)
+ (if (atom contexts)
+ t
+ (and (or (not (symbolp (car contexts)))
+ (glcp-generic-equiv-relp (car contexts)))
+ (proper-contextsp (cdr contexts)))))
+
+(defund-nx glcp-generic-eval-context-equiv (contexts x y)
+ (b* (((when (atom contexts)) (equal x y))
+ (ctx (car contexts))
+ (ctx-fn (if (symbolp ctx)
+ ctx
+ `(lambda (x y)
+ (equal ((lambda (x) ,ctx) x)
+ ((lambda (x) ,ctx) y))))))
+ (or (glcp-generic-geval-ev (list ctx-fn (kwote x) (kwote y)) nil)
+ (glcp-generic-eval-context-equiv (cdr contexts) x y))))
+
+
+(defthmd glcp-generic-eval-context-equiv-commute
+ (implies (and (proper-contextsp contexts)
+ (glcp-generic-eval-context-equiv contexts x y))
+ (glcp-generic-eval-context-equiv contexts y x))
+ :hints (("goal" :induct (glcp-generic-eval-context-equiv contexts x y)
+ :in-theory (enable glcp-generic-eval-context-equiv
+ glcp-generic-geval-ev-of-fncall-args)
+ :expand ((glcp-generic-eval-context-equiv contexts y x)
+ (proper-contextsp contexts)))))
+
+(defun glcp-generic-eval-context-equiv-chain (contexts chain)
+ (declare (xargs :hints(("Goal" :in-theory (enable acl2-count)))))
+ (if (atom (cdr chain))
+ t
+ (and (glcp-generic-eval-context-equiv contexts
+ (car chain)
+ (cadr chain))
+ (glcp-generic-eval-context-equiv-chain contexts (cdr chain)))))
+
+(defun-sk glcp-generic-eval-context-equiv* (contexts x y)
+ (exists chain
+ (and (consp chain)
+ (equal (car chain) x)
+ (equal (car (last chain)) y)
+ (glcp-generic-eval-context-equiv-chain contexts chain))))
+
+(in-theory (disable glcp-generic-eval-context-equiv*))
+
+(defthm glcp-generic-eval-context-equiv*-refl
+ (glcp-generic-eval-context-equiv* contexts x x)
+ :hints (("goal" :use ((:instance glcp-generic-eval-context-equiv*-suff
+ (chain (list x)) (y x))))))
+
+
+
+(defthm glcp-generic-eval-context-equiv*-chain-append
+ (implies (and (glcp-generic-eval-context-equiv-chain contexts c1)
+ (glcp-generic-eval-context-equiv-chain contexts c2)
+ (equal (car (last c1)) (car c2)))
+ (glcp-generic-eval-context-equiv-chain contexts (append c1 (cdr
+ c2))))
+ :hints(("Goal" :in-theory (disable glcp-generic-eval-context-equiv-commute))))
+
+
+(encapsulate nil
+ (local (defthm last-of-append-when-first/last-equal
+ (implies (equal (car b) (car (last a)))
+ (equal (car (last (append a (cdr b))))
+ (car (last b))))))
+
+ (local (defthm car-append-when-consp
+ (implies (consp x)
+ (equal (car (append x y))
+ (car x)))))
+
+ (defthm glcp-generic-eval-context-equiv*-trans
+ (implies (and (glcp-generic-eval-context-equiv* contexts x y)
+ (glcp-generic-eval-context-equiv* contexts y z))
+ (glcp-generic-eval-context-equiv* contexts x z))
+ :hints (("goal" :use ((:instance glcp-generic-eval-context-equiv*-suff
+ (chain (append
+ (glcp-generic-eval-context-equiv*-witness
+ contexts x y)
+ (cdr (glcp-generic-eval-context-equiv*-witness
+ contexts y z))))
+ (y z)))
+ :expand ((glcp-generic-eval-context-equiv* contexts x y)
+ (glcp-generic-eval-context-equiv* contexts y z))))))
+
+
+(encapsulate nil
+
+ (local (defthm chain-of-append-when-last/first-related
+ (implies (and (consp x)
+ (glcp-generic-eval-context-equiv contexts (car (last x))
+ (car y))
+ (glcp-generic-eval-context-equiv-chain contexts x)
+ (glcp-generic-eval-context-equiv-chain contexts y))
+ (glcp-generic-eval-context-equiv-chain contexts (append x
+ y)))))
+
+ (local (defthm last-of-append-when-consp-second
+ (implies (consp y)
+ (equal (last (append x y))
+ (last y)))))
+
+
+ (local (defthm car-last-of-rev
+ (implies (consp x)
+ (equal (car (last (acl2::rev x)))
+ (car x)))
+ :hints(("Goal" :in-theory (enable acl2::rev)))))
+
+ (defthmd glcp-generic-eval-context-equiv-chain-rev
+ (implies (and (proper-contextsp contexts)
+ (glcp-generic-eval-context-equiv-chain contexts chain))
+ (glcp-generic-eval-context-equiv-chain contexts (acl2::rev chain)))
+ :hints(("Goal" :in-theory (e/d (acl2::rev) (proper-contextsp))
+ :induct (acl2::rev chain))
+ (and stable-under-simplificationp
+ '(:expand ((acl2::rev (cdr chain)))
+ :in-theory (e/d (glcp-generic-eval-context-equiv-commute)
+ (acl2::associativity-of-append))))))
+
+ (local (in-theory (enable glcp-generic-eval-context-equiv-chain-rev)))
+
+ (local (defthm consp-rev
+ (equal (consp (acl2::rev x))
+ (consp x))))
+
+ (local (defthm car-append-when-consp
+ (implies (consp x)
+ (equal (car (append x y))
+ (car x)))))
+
+
+ (local (defthm car-rev-when-consp
+ (implies (consp x)
+ (equal (car (acl2::rev x))
+ (car (last x))))
+ :hints(("Goal" :in-theory (enable acl2::rev)))))
+
+ (defthmd glcp-generic-eval-context-equiv*-commute
+ (implies (and (proper-contextsp contexts)
+ (glcp-generic-eval-context-equiv* contexts x y))
+ (glcp-generic-eval-context-equiv* contexts y x))
+ :hints (("goal" :use ((:instance glcp-generic-eval-context-equiv*-suff
+ (chain (acl2::rev
+ (glcp-generic-eval-context-equiv*-witness
+ contexts x y)))
+ (x y) (y x)))
+ :in-theory (disable proper-contextsp)
+ :expand ((glcp-generic-eval-context-equiv* contexts x y))))))
+
+
+(defthm g-ite->test-acl2-count-decr
+ (implies (equal (tag x) :g-ite)
+ (< (acl2-count (g-ite->test x)) (acl2-count x)))
+ :hints(("Goal" :in-theory (enable tag g-ite->test)))
+ :rule-classes :linear)
+
+(defthm g-ite->then-acl2-count-decr
+ (implies (equal (tag x) :g-ite)
+ (< (acl2-count (g-ite->then x)) (acl2-count x)))
+ :hints(("Goal" :in-theory (enable tag g-ite->then)))
+ :rule-classes :linear)
+
+(defthm g-ite->else-acl2-count-decr
+ (implies (equal (tag x) :g-ite)
+ (< (acl2-count (g-ite->else x)) (acl2-count x)))
+ :hints(("Goal" :in-theory (enable tag g-ite->else)))
+ :rule-classes :linear)
+
+
+
+(in-theory (disable glcp-generic-equiv-relp))
+
+(defsection ensure-equiv-relationp
+
+ (acl2::def-unify glcp-generic-geval-ev glcp-generic-geval-ev-alist)
+ (acl2::def-meta-extract glcp-generic-geval-ev glcp-generic-geval-ev-lst)
+
+ (defund search-match-in-conjunction (pat term)
+ (declare (xargs :guard (and (pseudo-termp pat)
+ (pseudo-termp term))))
+ (b* (((mv ok &) (acl2::simple-one-way-unify term pat nil))
+ ((when ok) t)
+ ((when (atom term)) nil)
+ ((unless (and (eq (car term) 'if)
+ (equal (fourth term) ''nil)))
+ nil))
+ (or (search-match-in-conjunction pat (second term))
+ (search-match-in-conjunction pat (third term)))))
+
+ (defthmd glcp-generic-geval-ev-theoremp-of-conjunction
+ (implies (and (equal (car term) 'if)
+ (equal (fourth term) ''nil))
+ (iff (glcp-generic-geval-ev-theoremp term)
+ (and (glcp-generic-geval-ev-theoremp (second term))
+ (glcp-generic-geval-ev-theoremp (third term)))))
+ :hints (("goal" :use ((:instance glcp-generic-geval-ev-falsify
+ (x term) (a (glcp-generic-geval-ev-falsify (second term))))
+ (:instance glcp-generic-geval-ev-falsify
+ (x term) (a (glcp-generic-geval-ev-falsify (third term))))
+ (:instance glcp-generic-geval-ev-falsify
+ (x (second term))
+ (a (glcp-generic-geval-ev-falsify term)))
+ (:instance glcp-generic-geval-ev-falsify
+ (x (third term))
+ (a (glcp-generic-geval-ev-falsify term))))
+ :in-theory (disable pseudo-termp pseudo-term-listp))))
+
+ (local (in-theory (enable glcp-generic-geval-ev-theoremp-of-conjunction)))
+
+ (defthmd search-match-in-conjunction-correct
+ (implies (and (glcp-generic-geval-ev-theoremp term)
+ (pseudo-termp term)
+ (pseudo-termp pat)
+ (search-match-in-conjunction pat term))
+ (glcp-generic-geval-ev pat a))
+ :hints(("Goal" :in-theory (e/d (search-match-in-conjunction)
+ (glcp-generic-geval-ev-alist
+ symbol-listp
+ nonnil-symbol-listp))
+ :induct (search-match-in-conjunction pat term))
+ (and stable-under-simplificationp
+ '(:use ((:instance glcp-generic-geval-ev-falsify
+ (x term)
+ (a (glcp-generic-geval-ev-alist
+ (mv-nth 1 (acl2::simple-one-way-unify term pat nil))
+ a))))))))
+
+ (defund check-equiv-formula (form e)
+ (declare (xargs :guard (and (pseudo-termp form)
+ (symbolp e)
+ (not (eq e 'quote)))))
+ (and (search-match-in-conjunction `(booleanp (,e x y)) form)
+ (search-match-in-conjunction `(,e x x) form)
+ (search-match-in-conjunction `(implies (,e x y) (,e y x)) form)
+ (search-match-in-conjunction `(implies (if (,e x y)
+ (,e y z)
+ 'nil)
+ (,e x z))
+ form)))
+
+ (local (defthm lemma1
+ (implies (and (pseudo-termp form)
+ (glcp-generic-geval-ev-theoremp form)
+ (search-match-in-conjunction `(booleanp (,e x y)) form)
+ (symbolp e)
+ (not (equal e 'quote)))
+ (booleanp (glcp-generic-geval-ev (list e x y) a)))
+ :hints (("goal" :in-theory (e/d (check-equiv-formula
+ glcp-generic-geval-ev-of-fncall-args)
+ (search-match-in-conjunction-correct))
+ :use ((:instance search-match-in-conjunction-correct
+ (term form) (pat `(booleanp (,e x y)))
+ (a `((x . ,(glcp-generic-geval-ev x a))
+ (y . ,(glcp-generic-geval-ev y a))
+ (z . ,(glcp-generic-geval-ev z a))))))))))
+
+ (local (defthm lemma2
+ (implies (and (pseudo-termp form)
+ (glcp-generic-geval-ev-theoremp form)
+ (search-match-in-conjunction `(,e x x) form)
+ (symbolp e)
+ (not (equal e 'quote)))
+ (glcp-generic-geval-ev (list e x x) a))
+ :hints (("goal" :in-theory (e/d (check-equiv-formula
+ glcp-generic-geval-ev-of-fncall-args)
+ (search-match-in-conjunction-correct))
+ :use ((:instance search-match-in-conjunction-correct
+ (term form) (pat `(,e x x))
+ (a `((x . ,(glcp-generic-geval-ev x a))
+ (y . ,(glcp-generic-geval-ev y a))
+ (z . ,(glcp-generic-geval-ev z a))))))))))
+
+ (local (defthm lemma3
+ (implies (and (pseudo-termp form)
+ (glcp-generic-geval-ev-theoremp form)
+ (search-match-in-conjunction
+ `(implies (,e x y) (,e y x)) form)
+ (symbolp e)
+ (not (equal e 'quote))
+ (glcp-generic-geval-ev (list e x y) a))
+ (glcp-generic-geval-ev (list e y x) a))
+ :hints (("goal" :in-theory (e/d (check-equiv-formula
+ glcp-generic-geval-ev-of-fncall-args)
+ (search-match-in-conjunction-correct))
+ :use ((:instance search-match-in-conjunction-correct
+ (term form) (pat `(implies (,e x y) (,e y x)))
+ (a `((x . ,(glcp-generic-geval-ev x a))
+ (y . ,(glcp-generic-geval-ev y a))
+ (z . ,(glcp-generic-geval-ev z a))))))))))
+
+ (local (defthm lemma4
+ (implies (and (pseudo-termp form)
+ (glcp-generic-geval-ev-theoremp form)
+ (search-match-in-conjunction
+ `(implies (if (,e x y) (,e y z) 'nil) (,e x z)) form)
+ (symbolp e)
+ (not (equal e 'quote))
+ (glcp-generic-geval-ev (list e x y) a)
+ (glcp-generic-geval-ev (list e y z) a))
+ (glcp-generic-geval-ev (list e x z) a))
+ :hints (("goal" :in-theory (e/d (check-equiv-formula
+ glcp-generic-geval-ev-of-fncall-args)
+ (search-match-in-conjunction-correct))
+ :use ((:instance search-match-in-conjunction-correct
+ (term form) (pat `(implies (if (,e x y) (,e y z) 'nil) (,e x z)))
+ (a `((x . ,(glcp-generic-geval-ev x a))
+ (y . ,(glcp-generic-geval-ev y a))
+ (z . ,(glcp-generic-geval-ev z a))))))))))
+
+ (defthmd check-equiv-formula-correct
+ (implies (and (check-equiv-formula form e)
+ (glcp-generic-geval-ev-theoremp form)
+ (pseudo-termp form)
+ (symbolp e)
+ (not (eq e 'quote)))
+ (glcp-generic-equiv-relp e))
+ :hints(("Goal" :in-theory '(check-equiv-formula
+ glcp-generic-equiv-relp
+ lemma1 lemma2 lemma3 lemma4))))
+
+ (local (in-theory (enable check-equiv-formula-correct)))
+
+ (local (in-theory (disable w)))
+
+ (defund check-equiv-rule (rune e w)
+ (declare (xargs :guard (and (symbolp e)
+ (not (eq e 'quote))
+ (plist-worldp w))))
+ (b* ((rule (if (symbolp rune)
+ rune
+ (and (symbol-listp rune)
+ (cadr rune))))
+ ((unless rule) nil)
+ (form (acl2::meta-extract-formula-w rule w))
+ ((unless (pseudo-termp form)) nil))
+ (check-equiv-formula form e)))
+
+ (defthmd check-equiv-rule-correct
+ (implies (and (check-equiv-rule rune e w)
+ (glcp-generic-geval-ev-meta-extract-global-facts)
+ (equal w (w state))
+ (symbolp e) (not (eq e 'quote)))
+ (glcp-generic-equiv-relp e))
+ :hints(("Goal" :in-theory (e/d (check-equiv-rule)
+ (pseudo-termp)))))
+
+ (local (in-theory (enable check-equiv-rule-correct)))
+
+
+ (defund congruences-find-equiv-rule (congs e w)
+ (declare (xargs :guard (and (symbolp e)
+ (not (eq e 'quote))
+ (plist-worldp w))))
+ (b* (((when (atom congs)) nil)
+ (cong (car congs))
+ ((unless (and (acl2::weak-congruence-rule-p cong)
+ (eq (acl2::access acl2::congruence-rule
+ cong :equiv)
+ e)))
+ (congruences-find-equiv-rule (cdr congs) e w))
+ (rune (acl2::access acl2::congruence-rule cong :rune)))
+ (or (check-equiv-rule rune e w)
+ (congruences-find-equiv-rule (cdr congs) e w))))
+
+ (defthmd congruences-find-equiv-rule-correct
+ (implies (and (congruences-find-equiv-rule congs e w)
+ (glcp-generic-geval-ev-meta-extract-global-facts)
+ (equal w (w state))
+ (symbolp e) (not (eq e 'quote)))
+ (glcp-generic-equiv-relp e))
+ :hints(("Goal" :in-theory (e/d (congruences-find-equiv-rule)
+ (pseudo-termp
+ acl2::weak-congruence-rule-p
+ default-car)))))
+
+ (local (in-theory (enable congruences-find-equiv-rule-correct)))
+
+ (defund ensure-equiv-relationp (e w)
+ (declare (xargs :guard (and (symbolp e)
+ (plist-worldp w))))
+ (b* (((when (member-eq e '(equal iff))) t)
+ ((when (eq e 'quote)) nil)
+ (coarsenings (getprop e 'acl2::coarsenings nil 'current-acl2-world w))
+ ((unless coarsenings) nil)
+ ;; shortcut: ACL2 always stores e as a coarsening of itself if it's an
+ ;; equivalence relation. In fact, it should only have coarsenings if it
+ ;; is one. But we don't get to assume that in meta-extract so we look
+ ;; for a theorem stating it.
+ (congruences (getprop e 'acl2::congruences nil 'current-acl2-world w))
+ (equal-congs (cdr (hons-assoc-equal 'equal congruences)))
+ (first-arg-congs (and (consp equal-congs) (car equal-congs))))
+ (congruences-find-equiv-rule first-arg-congs e w)))
+
+ (defthmd ensure-equiv-relationp-correct
+ (implies (and (ensure-equiv-relationp e w)
+ (glcp-generic-geval-ev-meta-extract-global-facts)
+ (equal w (w state))
+ (symbolp e))
+ (glcp-generic-equiv-relp e))
+ :hints(("Goal" :in-theory (e/d (ensure-equiv-relationp)
+ (pseudo-termp
+ acl2::weak-congruence-rule-p
+ default-car))
+ :expand ((glcp-generic-equiv-relp 'iff)
+ (glcp-generic-equiv-relp 'equal))))))
+
+
+;; X is a gobj. Returns OK, repl, negp.
+;; OK implies that equiv-term <=> (xor negp (equiv x repl)) of x, where equiv
+;; is an equivalence ok under the contexts.
+(defund check-equiv-replacement (x equiv-term contexts state)
+ (declare (xargs :guard (contextsp contexts)
+ :stobjs state)
+ (ignorable state))
+ ;; BOZO fix these to work with context fixing terms, refinements, etc
+ (b* (((when (hqual x equiv-term))
+ (mv t nil t))
+ ((unless (and (consp equiv-term)
+ (eq (tag equiv-term) :g-apply)))
+ (mv nil nil nil))
+ (equiv (g-apply->fn equiv-term))
+ ((unless (and (symbolp equiv)
+ (not (eq equiv 'quote))
+ (or (eq equiv 'equal)
+ (member-eq equiv contexts))))
+ (mv nil nil nil))
+ (args (g-apply->args equiv-term))
+ ((unless (equal (len args) 2))
+ (mv nil nil nil))
+ ((when (hqual (car args) x))
+ (mv t (cadr args) nil))
+ ((when (hqual (cadr args) x))
+ (mv t (car args) nil)))
+ (mv nil nil nil)))
+
+
+;; (defund check-equiv-replacement-ok (x equiv-term contexts state)
+;; (declare (xargs :guard (contextsp contexts)
+;; :stobjs state)
+;; (ignorable state))
+;; ;; BOZO fix these to work with context fixing terms, refinements, etc
+;; (b* (((unless (and (consp equiv-term)
+;; (eq (tag equiv-term) :g-apply)))
+;; nil)
+;; (equiv (g-apply->fn equiv-term))
+;; ((unless (and (symbolp equiv)
+;; (not (eq equiv 'quote))
+;; (or (eq equiv 'equal)
+;; (member-eq equiv contexts))))
+;; nil)
+;; (args (g-apply->args equiv-term))
+;; ((unless (equal (len args) 2))
+;; nil)
+;; ((when (or (hqual (car args) x)
+;; (hqual (cadr args) x)))
+;; t))
+;; nil))
+
+;; (trace$ (check-equiv-replacement :cond (check-equiv-replacement-ok x equiv-term
+;; contexts
+;; state)
+;; :entry (list 'check-equiv)
+;; :exit (list 'check-equiv x (cadr values))
+;; :evisc-tuple '(nil 5 10 nil)
+;; :hide nil))
+
+
+(defund try-equivalences (x bvars pathcond contexts p bvar-db state)
+ (declare (xargs :guard (and (contextsp contexts)
+ (non-exec (ec-call (bvar-listp bvars bvar-db))))
+ :stobjs (bvar-db state)))
+ (b* (((when (atom bvars)) (mv nil nil))
+ (bvar (car bvars))
+ (equiv-term (get-bvar->term bvar bvar-db))
+ ((mv check-ok repl negp)
+ (check-equiv-replacement x equiv-term contexts state))
+ ((unless check-ok)
+ (try-equivalences x (cdr bvars) pathcond contexts p bvar-db state))
+ ((when negp)
+ (if (false-under-hyp
+ (hyp-fix (bfr-to-param-space p (bfr-var bvar))
+ pathcond)
+ pathcond)
+ (mv t repl)
+ (try-equivalences x (cdr bvars) pathcond contexts p bvar-db state)))
+ ((unless (true-under-hyp
+ (hyp-fix (bfr-to-param-space p (bfr-var bvar))
+ pathcond)
+ pathcond))
+ (try-equivalences x (cdr bvars) pathcond contexts p bvar-db state)))
+ (mv t repl)))
+
+
+
+(defund try-equivalences-loop (x pathcond contexts clk p bvar-db state)
+ (declare (xargs :guard (and (natp clk)
+ (contextsp contexts))
+ :stobjs (bvar-db state)
+ :measure (nfix clk)))
+ (b* (((when (zp clk)) (mv "try-equivalences ran out of clock -- equiv loop?"
+ x))
+ (equivs (get-term->equivs x bvar-db))
+ ((mv ok repl) (try-equivalences x equivs pathcond contexts p bvar-db
+ state))
+ ((when ok)
+ (try-equivalences-loop repl pathcond contexts (1- clk) p bvar-db
+ state)))
+ (mv nil x)))
+
+
+(defund maybe-add-equiv-term (test-obj bvar bvar-db state)
+ (declare (xargs :stobjs (bvar-db state)
+ :guard (and (integerp bvar)
+ (<= (base-bvar bvar-db) bvar)
+ (< bvar (next-bvar bvar-db))))
+ (ignorable state))
+ (b* (;; (equivp (getprop fn 'acl2::coarsenings nil 'current-acl2-world (w state)))
+ ;; ((unless equivp)
+ ;; ;; not an equivalence relation
+ ;; bvar-db)
+ ((unless (consp test-obj))
+ bvar-db)
+
+ ((when (eq (tag test-obj) :g-var))
+ (add-term-equiv test-obj bvar bvar-db))
+
+ ((unless (eq (tag test-obj) :g-apply))
+ bvar-db)
+
+ (fn (g-apply->fn test-obj))
+ (args (g-apply->args test-obj))
+
+ ((unless (and (eq fn 'equal)
+ (equal (len args) 2)))
+ (add-term-equiv test-obj bvar bvar-db))
+ ((list a b) args)
+ ;; The rest is just a heuristic determination of which should rewrite to
+ ;; the other.
+ (a-goodp (or (atom a)
+ (member (tag a) '(:g-number :g-boolean))
+ (general-concretep a)))
+ ((when a-goodp)
+ (add-term-equiv b bvar bvar-db))
+ (b-goodp (or (atom b)
+ (member (tag b) '(:g-number :g-boolean))
+ (general-concretep b)))
+ ((when b-goodp)
+ (add-term-equiv a bvar bvar-db)))
+ bvar-db))
+
+;; (defund glcp-generic-geval-ev-theoremsp (rules)
+;; (if (atom rules)
+;; t
+;; (and (glcp-generic-geval-ev-theoremp (car rules))
+;; (glcp-generic-geval-ev-theoremsp (cdr rules)))))
+
+
+
+;; (defund meta-extract-formulas (names wrld)
+;; (declare (xargs :guard (plist-worldp wrld)))
+;; (b* (((when (atom names)) nil)
+;; (name (car names))
+;; ((unless (symbolp name)) (meta-extract-formulas (cdr names) wrld))
+;; (thm (acl2::meta-extract-formula-w name wrld)))
+;; (cons thm (meta-extract-formulas (cdr names) wrld))))
+
+;; (defthm glcp-generic-geval-ev-theoremsp-of-meta-extract-formulas
+;; (implies (and (glcp-generic-geval-ev-meta-extract-global-facts)
+;; (equal wrld (w state)))
+;; (glcp-generic-geval-ev-theoremsp (meta-extract-formulas names wrld)))
+;; :hints(("Goal" :in-theory (e/d (glcp-generic-geval-ev-theoremsp
+;; meta-extract-formulas)
+;; (w)))))
+
+(defund conjunction-to-list (x)
+ (declare (xargs :guard (pseudo-termp x)))
+ (if (or (atom x)
+ (not (eq (car x) 'if))
+ (not (equal (fourth x) ''nil)))
+ (list x)
+ (cons (second x)
+ (conjunction-to-list (third x)))))
+
+(defthm conjunction-to-list-pseudo-term-listp
+ (implies (pseudo-termp x)
+ (pseudo-term-listp (conjunction-to-list x)))
+ :hints(("Goal" :in-theory (enable conjunction-to-list))))
+
+
+(defsection glcp-branch-merge-formula-to-rule
+
+ (local (defthm pseudo-termp-subterms
+ (implies (and (pseudo-termp x)
+ (consp x)
+ (not (eq (car x) 'quote)))
+ (and (pseudo-termp (cadr x))
+ (pseudo-termp (caddr x))
+ (pseudo-termp (cadddr x))
+ (implies (cdr x)
+ (consp (cdr x)))
+ (implies (cddr x)
+ (consp (cddr x)))
+ (implies (cdddr x)
+ (consp (cdddr x)))))
+ :hints(("Goal" :expand ((pseudo-termp x)
+ (pseudo-term-listp (cdr x))
+ (pseudo-term-listp (cddr x))
+ (pseudo-term-listp (cdddr x)))))))
+
+ (local (in-theory (disable acl2::beta-reduce-full
+ pseudo-termp)))
+
+
+ (defund glcp-branch-merge-formula-to-rule (name wrld)
+ (declare (xargs :guard (and (symbolp name) (plist-worldp wrld))
+ :guard-hints
+ (("goal" :use ((:instance
+ acl2::pseudo-termp-of-beta-reduce-full
+ (x (acl2::meta-extract-formula-w name wrld))))
+ :in-theory (disable acl2::pseudo-termp-of-beta-reduce-full)))))
+ (b* ((thm (acl2::meta-extract-formula-w name wrld))
+ ((unless (pseudo-termp thm)) (mv nil nil))
+ (thm (acl2::beta-reduce-full thm))
+ ((when (atom thm)) (mv nil nil))
+ ((mv hyps concl)
+ (if (eq (car thm) 'implies)
+ (mv (conjunction-to-list (second thm))
+ (third thm))
+ (mv nil thm)))
+ ((when (atom concl)) (mv nil nil))
+ (equiv (car concl))
+ ((unless (and (symbolp equiv)
+ (not (eq equiv 'quote))
+ (getprop equiv 'acl2::coarsenings nil 'current-acl2-world wrld)
+ (eql (len concl) 3)))
+ (mv nil nil)))
+ (mv t (acl2::make-rewrite-rule
+ :rune `(:gl-branch-merge ,name)
+ :nume -1
+ :hyps hyps
+ :equiv equiv
+ :lhs (second concl)
+ :rhs (third concl)
+ :subclass 'acl2::backchain)))))
+
+(defund glcp-branch-merge-formulas-to-rules (names wrld)
+ (declare (xargs :guard (plist-worldp wrld)))
+ (b* (((when (atom names)) nil)
+ ((unless (symbolp (car names)))
+ (glcp-branch-merge-formulas-to-rules (cdr names) wrld))
+ ((mv ok rule) (glcp-branch-merge-formula-to-rule (car names) wrld)))
+ (if ok
+ (cons rule (glcp-branch-merge-formulas-to-rules (cdr names) wrld))
+ (glcp-branch-merge-formulas-to-rules (cdr names) wrld))))
+
+
+(defund glcp-get-branch-merge-rules (fn wrld)
+ (declare (xargs :guard (and (symbolp fn)
+ (plist-worldp wrld))))
+ (b* ((thms (cdr (hons-assoc-equal fn (acl2::table-alist 'gl-branch-merge-rules wrld)))))
+ (glcp-branch-merge-formulas-to-rules thms wrld)))
+
+(memoize 'glcp-get-branch-merge-rules)
+
+(defun weak-rewrite-rule-listp (x)
+ (declare (xargs :guard t))
+ (if (atom x)
+ (eq x nil)
+ (and (acl2::weak-rewrite-rule-p (car x))
+ (weak-rewrite-rule-listp (cdr x)))))
+
+(defund rewrite-rules->runes (x)
+ (declare (xargs :guard (weak-rewrite-rule-listp x)))
+ (if (atom x)
+ nil
+ (cons (acl2::rewrite-rule->rune (car x))
+ (rewrite-rules->runes (cdr x)))))
+
+(defun-inline glcp-if-or-condition (test tbr contexts)
+ (declare (xargs :guard t))
+ (and (hons-equal test tbr)
+ ;; dumb
+ (or (not contexts) (equal contexts '(iff)))))
+
+(defun-inline glcp-or-test-contexts (contexts)
+ (declare (xargs :guard t))
+ (if (equal contexts '(iff))
+ '(iff)
+ nil))
+
+(defund glcp-lift-ifsp (fn flg w)
+ (declare (xargs :guard (and (symbolp fn)
+ (plist-worldp w))))
+ (and flg
+ (not (cdr (hons-assoc-equal fn (table-alist 'gl-if-opaque-fns w))))))
+
+
+
+(defthmd acl2-count-of-car
+ (<= (acl2-count (car x)) (acl2-count x))
+ :rule-classes :linear)
+
+(defthmd acl2-count-of-cdr
+ (<= (acl2-count (cdr x)) (acl2-count x))
+ :rule-classes :linear)
+
+(defthmd acl2-count-of-car-g-apply->args
+ (implies (equal (tag x) :g-apply)
+ (< (acl2-count (car (g-apply->args x))) (acl2-count x)))
+ :hints(("Goal" :in-theory (enable acl2-count-of-car)))
+ :rule-classes :linear)
+
+(defthmd acl2-count-of-cadr-g-apply->args
+ (implies (equal (tag x) :g-apply)
+ (< (acl2-count (cadr (g-apply->args x))) (acl2-count x)))
+ :hints(("Goal" :in-theory (enable acl2-count-of-car
+ acl2-count-of-cdr)))
+ :rule-classes :linear)
+
+;; (local (defthm acl2-count-of-g-apply->args-consp
+;; (implies (consp x)
+;; (< (acl2-count (g-apply->args x)) (acl2-count x)))
+;; :rule-classes :linear))
+
+(encapsulate nil
+ (local (defthm acl2-count-of-g-concrete->obj
+ (implies (equal (tag x) :g-concrete)
+ (< (acl2-count (g-concrete->obj x))
+ (acl2-count x)))
+ :rule-classes :linear))
+ (local (defthm acl2-count-of-car-strong
+ (implies (consp x)
+ (< (acl2-count (car X)) (acl2-count x)))
+ :rule-classes :linear))
+ (local (defthm acl2-count-of-cdr-strong
+ (implies (consp x)
+ (< (acl2-count (cdr X)) (acl2-count x)))
+ :rule-classes :linear))
+
+ (local (defthm acl2-count-of-g-concrete
+ (equal (acl2-count (g-concrete x))
+ (+ 1 (acl2-count x)))
+ :hints(("Goal" :in-theory (enable g-concrete)))))
+
+ (defthmd acl2-count-of-general-consp-car
+ (implies (general-consp x)
+ (< (acl2-count (general-consp-car x))
+ (acl2-count x)))
+ :hints(("Goal" :in-theory (enable mk-g-concrete)))
+ :rule-classes :linear)
+
+ (defthmd acl2-count-of-general-consp-cdr
+ (implies (general-consp x)
+ (< (acl2-count (general-consp-cdr x))
+ (acl2-count x)))
+ :hints(("Goal" :in-theory (enable mk-g-concrete)))
+ :rule-classes :linear))
+
+
+(defconst *glcp-generic-template-subst*
+ (let ((names (cons 'run-gified
+ (remove 'clause-proc *glcp-fnnames*))))
+ (cons '(clause-proc . glcp-generic)
+ (pairlis$ names (glcp-put-name-each 'glcp-generic names)))))
+
+(make-event
+ (sublis *glcp-generic-template-subst*
+ *glcp-interp-template*))
+
+
+
diff -Nru acl2-6.2/books/centaur/gl/gl-generic-interp.lisp acl2-6.3/books/centaur/gl/gl-generic-interp.lisp
--- acl2-6.2/books/centaur/gl/gl-generic-interp.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gl-generic-interp.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,5095 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "GL")
+(include-book "gl-generic-interp-defs")
+(include-book "misc/untranslate-patterns" :dir :system)
+(include-book "clause-processors/use-by-hint" :dir :system)
+(include-book "clause-processors/decomp-hint" :dir :system)
+(include-book "centaur/misc/interp-function-lookup" :dir :system)
+(include-book "var-bounds")
+(local (include-book "data-structures/no-duplicates" :dir :system))
+(local (include-book "general-object-thms"))
+(local (include-book "tools/with-quoted-forms" :dir :system))
+(local (include-book "hyp-fix-logic"))
+(local (include-book "std/lists/acl2-count" :dir :system))
+(local (include-book "clause-processors/find-matching" :dir :system))
+(local (include-book "clause-processors/just-expand" :dir :system))
+(local (include-book "arithmetic/top-with-meta" :dir :system))
+(local (in-theory (disable* sets::double-containment w)))
+(include-book "constraint-db-deps")
+(include-book "clause-processors/find-subterms" :dir :system)
+(include-book "glcp-unify-thms")
+(include-book "glcp-geval-thms")
+(flag::make-flag sublis-into-term-flg sublis-into-term)
+
+;; (defthm assoc-equal-nonnil-of-append
+;; (implies x
+;; (equal (assoc-equal x (append a b))
+;; (or (assoc-equal x a)
+;; (assoc-equal x b))))
+;; :hints(("Goal" :in-theory (enable append assoc-equal))))
+
+;; (defthm-sublis-into-term-flg
+;; sublis-into-term-correct-lemma
+;; (sublis-into-term
+;; (implies (pseudo-termp x)
+;; (equal (glcp-generic-geval-ev (sublis-into-term x subst) alist)
+;; (glcp-generic-geval-ev x (append subst alist))))
+;; :name sublis-into-term-correct)
+;; (sublis-into-list
+;; (implies (pseudo-term-listp x)
+;; (equal (glcp-generic-geval-ev-lst (sublis-into-list x subst) alist)
+;; (glcp-generic-geval-ev-lst x (append subst alist))))
+;; :name sublis-into-list-correct)
+;; :hints (("goal" :induct (sublis-into-term-flg flag x alist))
+;; (and stable-under-simplificationp
+;; '(:in-theory (enable glcp-generic-geval-ev-constraint-0)))))
+
+(progn
+ (defthm len-sublis-into-list
+ (implies (pseudo-term-listp x)
+ (equal (length (sublis-into-list x subst))
+ (length x)))
+ :hints (("goal" :induct (len x)
+ :in-theory (enable length))))
+
+ (defthm-sublis-into-term-flg
+ sublis-into-term-pseudo-term-lemma
+ (sublis-into-term
+ (implies (pseudo-termp x)
+ (pseudo-termp (sublis-into-term x subst)))
+ :name pseudo-termp-sublis-into-term)
+ (sublis-into-list
+ (implies (pseudo-term-listp x)
+ (pseudo-term-listp (sublis-into-list x subst)))
+ :name pseudo-term-listp-sublis-into-list)
+ :hints (("goal" :induct (sublis-into-term-flg flag x alist)
+ :expand ((pseudo-termp x)
+ (:free (args) (pseudo-termp (cons (car x)
+ args))))))))
+
+
+
+
+(set-state-ok t)
+
+
+
+
+;; (defun univ-run-gified-guard-wrapper (fn actuals hyp clk state)
+;; (declare (xargs :guard (and (symbolp fn)
+;; (gobject-listp actuals)
+;; (bfr-p hyp)
+;; (natp clk))
+;; :stobjs state))
+;; (ec-call (univ-run-gified fn actuals hyp clk state)))
+
+;; (defun glcp-generic-apply-concrete-guard-wrapper
+;; (fn actuals state)
+;; (declare (xargs :guard (true-listp actuals)
+;; :stobjs state))
+;; (ec-call (glcp-generic-apply-concrete fn actuals state)))
+
+
+(local
+ (progn
+ ;; (defun-nx glcp-generic-geval-lst (x env)
+ ;; (if (atom x)
+ ;; nil
+ ;; (cons (glcp-generic-geval (car x) env)
+ ;; (glcp-generic-geval-lst (cdr x) env))))
+
+ ;; (defthmd glcp-generic-geval-of-gobj-list
+ ;; (implies (gobj-listp x)
+ ;; (equal (glcp-generic-geval x env)
+ ;; (glcp-generic-geval-lst x env)))
+ ;; :hints
+ ;; (("goal" :induct (gobject-listp x)
+ ;; :in-theory (enable gobject-listp-impl-gobjectp
+ ;; glcp-generic-geval-of-gobject-car
+ ;; gobject-listp))))
+
+
+
+
+
+
+ (defthm nonnil-symbol-listp-impl-eqlable-listp
+ (implies (nonnil-symbol-listp x)
+ (eqlable-listp x))
+ :hints(("Goal" :in-theory (enable nonnil-symbol-listp))))
+
+
+
+
+ ;; (defthm univ-run-gified-wrapper-unwrap
+ ;; (equal (univ-run-gified-guard-wrapper fn actuals hyp clk state)
+ ;; (univ-run-gified fn actuals hyp clk state)))
+
+
+
+
+ ;; (defthm glcp-generic-apply-concrete-wrapper-unwrap
+ ;; (equal (glcp-generic-apply-concrete-guard-wrapper fn actuals state)
+ ;; (glcp-generic-apply-concrete fn actuals state)))
+
+ ;; (in-theory (disable univ-run-gified-guard-wrapper
+ ;; ;; glcp-generic-apply-concrete-guard-wrapper
+ ;; ))
+ ))
+
+
+
+
+
+
+
+
+
+;; (defun gobject-vals-alistp (x)
+;; (declare (Xargs :guard t))
+;; (if (atom x)
+;; (equal x nil)
+;; (and (or (atom (car x))
+;; (gobjectp (cdar x)))
+;; (gobject-vals-alistp (cdr x)))))
+
+
+;; (defthm lookup-in-gobject-vals-alistp
+;; (implies (gobject-vals-alistp x)
+;; (gobjectp (cdr (hons-assoc-equal k x)))))
+
+;; (defthm gobject-vals-alistp-pairlis$
+;; (implies (gobject-listp vals)
+;; (gobject-vals-alistp (pairlis$ keys vals)))
+;; :hints(("Goal" :in-theory (enable gobject-listp
+;; pairlis$))))
+
+
+
+
+(local (in-theory (disable* general-concretep-def acl2-count
+; sets::double-containment
+ integer-abs
+; sets::nonempty-means-set
+ equal-of-booleans-rewrite
+ put-global
+ acl2::true-list-listp-forward-to-true-listp-assoc-equal)))
+
+
+
+
+;; (defthmd gobject-listp-true-listp
+;; (implies (gobject-listp x)
+;; (true-listp x))
+;; :hints(("Goal" :in-theory (enable gobject-listp)))
+;; :rule-classes (:rewrite :forward-chaining))
+
+;; (defthm glcp-generic-geval-of-gobj-list
+;; (implies (and (gobj-listp x)
+;; (consp x))
+;; (equal (glcp-generic-geval x env)
+;; (cons (glcp-generic-geval (car x) env)
+;; (glcp-generic-geval (cdr x) env))))
+;; :hints(("Goal" :use ((:instance glcp-generic-geval-of-gl-cons
+;; (x (car x)) (y (cdr x))))
+;; :in-theory (enable gl-cons gobj-listp))))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;; (defsection rune
+;; (definlined rune->thmname (rune)
+;; (declare (xargs :guard (symbol-listp rune)))
+;; (mbe :logic (and (symbol-listp rune) (cadr rune))
+;; :exec (cadr rune)))
+
+;; (local (in-theory (enable rune->thmname)))
+
+;; (defthm symbolp-of-rune->thmname
+;; (symbolp (rune->thmname rune))))
+
+
+
+(defsection glcp-relieve-hyp-synp
+ (local (in-theory (enable glcp-relieve-hyp-synp)))
+
+ (defthm glcp-relieve-hyp-synp-bindings
+ (b* (((mv ?erp ?successp ?bindings1)
+ (glcp-relieve-hyp-synp hyp bindings state)))
+ (equal bindings1
+ (and (not erp) bindings))))
+
+ (defthm glcp-relieve-hyp-synp-correct
+ (b* (((mv ?erp ?successp ?bindings1)
+ (glcp-relieve-hyp-synp hyp bindings st)))
+ (implies (and successp
+ (consp hyp)
+ (eq (car hyp) 'synp)
+ (glcp-generic-geval-ev-meta-extract-global-facts)
+ (equal (w state) (w st)))
+ (glcp-generic-geval-ev hyp (glcp-generic-geval-alist bindings env))))))
+
+
+
+(defsection gl-term-to-apply-obj
+ (local (defthm assoc-is-hons-assoc
+ (implies k
+ (equal (assoc k alist)
+ (hons-assoc-equal k alist)))))
+
+ (local (defthm glcp-generic-geval-of-car-of-gl-cons
+ (equal (glcp-generic-geval (car (gl-cons x y)) env)
+ (glcp-generic-geval x env))
+ :hints(("Goal" :in-theory (enable gl-cons glcp-generic-geval)))))
+
+ (defthm cdr-of-gl-cons
+ (equal (cdr (gl-cons x y)) y)
+ :hints(("Goal" :in-theory (enable gl-cons))))
+
+
+ (defthm-gl-term-to-apply-obj-flag
+ (defthm gobj-listp-of-gl-termlist-to-apply-obj-list
+ (true-listp (gl-termlist-to-apply-obj-list x alist))
+ :hints ('(:expand ((gl-termlist-to-apply-obj-list x alist))))
+ :flag gl-termlist-to-apply-obj-list)
+ :skip-others t)
+
+ (defthm-gl-term-to-apply-obj-flag
+ (defthm gl-term-to-apply-obj-correct
+ (implies (pseudo-termp x)
+ (equal (glcp-generic-geval (gl-term-to-apply-obj x alist) env)
+ (glcp-generic-geval-ev x (glcp-generic-geval-alist alist env))))
+ :hints ('(:expand ((gl-term-to-apply-obj nil alist)
+ (gl-term-to-apply-obj x alist)))
+ (and stable-under-simplificationp
+ '(:in-theory (e/d (glcp-generic-geval-ev-of-fncall-args)
+ ((g-ite)))))
+ (and stable-under-simplificationp
+ '(:expand ((gl-termlist-to-apply-obj-list (cdr x) alist)
+ (gl-termlist-to-apply-obj-list (cddr x) alist)
+ (gl-termlist-to-apply-obj-list (cdddr x) alist)
+ (gl-termlist-to-apply-obj-list (cddddr x) alist)
+ (gl-termlist-to-apply-obj-list nil alist)
+ (:free (x y z)
+ (:with glcp-generic-geval
+ (glcp-generic-geval (g-ite x y z) env)))))))
+ :flag gl-term-to-apply-obj)
+ (defthm gl-termlist-to-apply-obj-list-correct
+ (implies (pseudo-term-listp x)
+ (equal (glcp-generic-geval-list (gl-termlist-to-apply-obj-list x alist) env)
+ (glcp-generic-geval-ev-lst x (glcp-generic-geval-alist alist env))))
+ :hints ('(:expand ((gl-termlist-to-apply-obj-list x alist)
+ (gl-termlist-to-apply-obj-list nil alist))))
+ :flag gl-termlist-to-apply-obj-list))
+
+ (defthm-gl-term-to-apply-obj-flag
+ (defthm gobj-depends-on-of-gl-term-to-apply-obj
+ (implies (not (gobj-alist-depends-on k p alist))
+ (not (gobj-depends-on k p (gl-term-to-apply-obj x alist))))
+ :hints ('(:expand ((gl-term-to-apply-obj nil alist)
+ (gl-term-to-apply-obj x alist))))
+ :flag gl-term-to-apply-obj)
+ (defthm gobj-depends-on-of-gl-term-to-apply-obj-list
+ (implies (not (gobj-alist-depends-on k p alist))
+ (not (gobj-list-depends-on k p (gl-termlist-to-apply-obj-list x alist))))
+ :hints ('(:expand ((gl-termlist-to-apply-obj-list nil alist)
+ (gl-termlist-to-apply-obj-list x alist))))
+ :flag gl-termlist-to-apply-obj-list)))
+
+
+(make-event
+ `(in-theory (disable . ,(glcp-put-name-each 'glcp-generic
+ (event-form-collect-fn-names
+ *glcp-interp-template*)))))
+
+(local (in-theory (disable acl2::weak-rewrite-rule-p)))
+
+(with-output :off (prove event)
+ (flag::make-flag glcp-generic-interp-flg
+ glcp-generic-interp-term
+ :flag-mapping
+ ((glcp-generic-interp-test . test)
+ (glcp-generic-interp-term . term)
+ (glcp-generic-interp-fncall-ifs . fncall-ifs)
+ (glcp-generic-maybe-interp-fncall-ifs . maybe-fncall-ifs)
+ (glcp-generic-interp-term-equivs . equivs)
+ (glcp-generic-interp-if/or . if/or)
+ (glcp-generic-maybe-interp . maybe)
+ (glcp-generic-interp-if . if)
+ (glcp-generic-interp-or . or)
+ (glcp-generic-merge-branches . merge)
+ (glcp-generic-merge-branch-subterms . merge-sub)
+ (glcp-generic-merge-branch-subterm-lists . merge-list)
+ (glcp-generic-interp-fncall . fncall)
+ (glcp-generic-simplify-if-test . test-simp)
+ (glcp-generic-simplify-if-test-fncall . test-simp-fncall)
+ (glcp-generic-add-bvar-constraints . constraints)
+ (glcp-generic-add-bvar-constraint-substs . constraint-substs)
+ (glcp-generic-rewrite . rewrite)
+ (glcp-generic-rewrite-apply-rules . rules)
+ (glcp-generic-rewrite-apply-rule . rule)
+ (glcp-generic-relieve-hyps . hyps)
+ (glcp-generic-relieve-hyp . hyp)
+ (glcp-generic-interp-list . list))
+ :formals-subst ((state . st))
+ :hints (("goal" :in-theory
+ (e/d (acl2-count
+ acl2-count-of-car-g-apply->args
+ acl2-count-of-cadr-g-apply->args
+ acl2-count-last-cdr-when-cadr-hack
+ acl2-count-of-general-consp-car
+ acl2-count-of-general-consp-cdr)
+ (last))))))
+
+(local
+ (defthm assoc-in-add-pair
+ (implies (not (equal k1 k2))
+ (equal (assoc k1 (add-pair k2 v a))
+ (assoc k1 a)))))
+
+
+(defthm w-of-put-global
+ (implies (not (eq var 'current-acl2-world))
+ (equal (w (put-global var val state))
+ (w state)))
+ :hints(("Goal" :in-theory (enable w put-global add-pair))))
+
+(local (in-theory (disable w)))
+
+
+
+(defun def-glcp-interp-thm-body (binder basename kws flag)
+ (declare (xargs :mode :program))
+ (b* ((fn-kws (cdr (assoc flag (cadr (assoc-keyword :special kws)))))
+ (body (or (cadr (assoc-keyword :body fn-kws))
+ (cadr (assoc-keyword :body kws))))
+ (hyps (or (cadr (assoc-keyword :hyps fn-kws))
+ (cadr (assoc-keyword :hyps kws))))
+ (add-hyps (cadr (assoc-keyword :add-hyps fn-kws)))
+ (add-concls (append (cadr (assoc-keyword :add-concls kws))
+ (cadr (assoc-keyword :add-concls fn-kws))))
+ (add-bindings (cadr (assoc-keyword :add-bindings kws)))
+ (skip (cadr (assoc-keyword :skip fn-kws)))
+ (full-hyps (if hyps
+ (if add-hyps `(and ,hyps ,add-hyps) hyps)
+ add-hyps))
+ (concl (if body
+ `(and ,body . ,add-concls)
+ `(and . ,add-concls)))
+ (full-body (if full-hyps
+ `(implies ,full-hyps
+ ,concl)
+ concl)))
+ `(defthm ,(or (cadr (assoc-keyword :name fn-kws))
+ (intern-in-package-of-symbol
+ (concatenate 'string (symbol-name basename) "-" (symbol-name flag))
+ basename))
+ (b* (,binder
+ . ,add-bindings)
+ ,full-body)
+ :hints (,@(let* ((fn-expand-look (assoc-keyword :expand-call fn-kws))
+ (expand (if fn-expand-look
+ (cadr fn-expand-look)
+ (cadr (assoc-keyword :expand-calls kws)))))
+ (and expand
+ `((acl2::just-expand (,(cadr binder))
+ :last-only t
+ :mark-only ,(eq expand :mark-only))
+ . ,(and (not (or (cadr (assoc-keyword :do-not-undo kws))
+ (cadr (assoc-keyword :do-not-undo fn-kws))))
+ '('(:do-not nil))))))
+ ,@(cadr (assoc-keyword :hints fn-kws)))
+ :rule-classes ,(or (cadr (assoc-keyword :rule-classes fn-kws))
+ (cadr (assoc-keyword :rule-classes kws))
+ :rewrite)
+ :skip ,skip
+ :flag ,flag)))
+
+(defconst *glcp-ind-inputs*
+ (subst 'st 'state *glcp-common-inputs*))
+(defconst *glcp-ind-retvals*
+ '(?erp ?interp-st1 ?bvar-db1 ?state1))
+
+(defconst *glcp-generic-interp-signatures*
+ ;; flag call returns
+ `((test
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-interp-test x alist intro-bvars . ,*glcp-ind-inputs*))
+ (term
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-interp-term x alist contexts . ,*glcp-ind-inputs*))
+ (equivs
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-interp-term-equivs x alist contexts . ,*glcp-ind-inputs*))
+ (fncall-ifs
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-interp-fncall-ifs fn actuals x contexts . ,*glcp-ind-inputs*))
+ (maybe-fncall-ifs
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-maybe-interp-fncall-ifs fn actuals x contexts branchcond . ,*glcp-ind-inputs*))
+ (fncall
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-interp-fncall fn actuals x contexts . ,*glcp-ind-inputs*))
+ (if/or
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-interp-if/or test tbr fbr alist contexts . ,*glcp-ind-inputs*))
+ (maybe
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-maybe-interp x alist contexts branchcond . ,*glcp-ind-inputs*))
+ (if
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-interp-if test tbr fbr alist contexts . ,*glcp-ind-inputs*))
+ (or
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-interp-or test fbr alist contexts . ,*glcp-ind-inputs*))
+ (merge
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-merge-branches test-bfr then else switchedp contexts . ,*glcp-ind-inputs*))
+ (merge-sub
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-merge-branch-subterms test-bfr then else . ,*glcp-ind-inputs*))
+ (merge-list
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-merge-branch-subterm-lists test-bfr then else . ,*glcp-ind-inputs*))
+ (test-simp
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-simplify-if-test test-obj intro-bvars . ,*glcp-ind-inputs*))
+ (test-simp-fncall
+ (mv ?val . ,*glcp-ind-retvals*)
+ (glcp-generic-simplify-if-test-fncall fn args intro-bvars . ,*glcp-ind-inputs*))
+ (constraints
+ (mv . ,*glcp-ind-retvals*)
+ (glcp-generic-add-bvar-constraints lit . ,*glcp-ind-inputs*))
+ (constraint-substs
+ (mv . ,*glcp-ind-retvals*)
+ (glcp-generic-add-bvar-constraint-substs substs . ,*glcp-ind-inputs*))
+ (rewrite
+ (mv ?successp ?term ?bindings . ,*glcp-ind-retvals*)
+ (glcp-generic-rewrite fn actuals rwtype contexts . ,*glcp-ind-inputs*))
+ (rules
+ (mv ?successp ?term ?bindings . ,*glcp-ind-retvals*)
+ (glcp-generic-rewrite-apply-rules
+ fn-rewrites rules fn actuals contexts . ,*glcp-ind-inputs*))
+ (rule
+ (mv ?successp ?term ?bindings . ,*glcp-ind-retvals*)
+ (glcp-generic-rewrite-apply-rule
+ rule fn actuals contexts . ,*glcp-ind-inputs*))
+ (hyps
+ (mv ?successp ?bindings1 . ,*glcp-ind-retvals*)
+ (glcp-generic-relieve-hyps
+ rune hyps bindings . ,*glcp-ind-inputs*))
+ (hyp
+ (mv ?successp ?bindings1 . ,*glcp-ind-retvals*)
+ (glcp-generic-relieve-hyp
+ rune hyp bindings . ,*glcp-ind-inputs*))
+ (list
+ (mv ?vals . ,*glcp-ind-retvals*)
+ (glcp-generic-interp-list x alist . ,*glcp-ind-inputs*))))
+
+
+(defun interp-thm-body-calls (list basename keys)
+ (declare (xargs :mode :program))
+ (if (atom list)
+ nil
+ (cons (def-glcp-interp-thm-body
+ (cdar list) basename keys (caar list))
+ (interp-thm-body-calls (cdr list) basename keys))))
+
+
+
+(defun def-glcp-interp-thm-fn (basename keys)
+ (declare (xargs :mode :program))
+ `(with-output :off (prove) ;; induction scheme too big to print
+ (defthm-glcp-generic-interp-flg
+ ,@(interp-thm-body-calls *glcp-generic-interp-signatures* basename keys)
+ :hints (,@(and (cadr (assoc-keyword :expand-calls keys))
+ `(("Goal" :do-not '(simplify preprocess))))
+ ,@(cadr (assoc-keyword :hints keys)))
+ :no-induction-hint ,(cadr (assoc-keyword :no-induction-hint keys)))))
+
+(defmacro def-glcp-interp-thm (basename &rest keys)
+ (def-glcp-interp-thm-fn basename keys))
+
+
+
+
+
+
+
+(def-glcp-interp-thm glcp-generic-interp-w-state-preserved
+ :body (equal (w state1) (w st))
+ :expand-calls t)
+
+
+
+(local
+ (with-output :off (prove)
+ (defthm-glcp-generic-interp-flg
+ (defthm alistp-glcp-generic-rewrite
+ (b* (((mv ?successp ?term ?bindings ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-rewrite fn actuals rwtype contexts pathcond clk config interp-st bvar-db st)))
+ (alistp bindings))
+ :hints ('(:expand ((glcp-generic-rewrite fn actuals rwtype contexts pathcond clk config interp-st
+ bvar-db st))))
+ :flag rewrite)
+ (defthm alistp-glcp-generic-apply-rules
+ (b* (((mv ?successp ?term ?bindings ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-rewrite-apply-rules
+ fn-rewrites rules fn actuals contexts pathcond clk config interp-st bvar-db st)))
+ (alistp bindings))
+ :hints ('(:expand ((glcp-generic-rewrite-apply-rules
+ fn-rewrites rules fn actuals contexts pathcond clk config interp-st bvar-db st))))
+ :flag rules)
+ (defthm alistp-glcp-generic-apply-rule
+ (b* (((mv ?successp ?term ?bindings ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-rewrite-apply-rule
+ rule fn actuals contexts pathcond clk config interp-st bvar-db st)))
+ (alistp bindings))
+ :hints ('(:expand ((:free (fn)
+ (glcp-generic-rewrite-apply-rule
+ rule fn actuals contexts pathcond clk config interp-st bvar-db st)))))
+ :flag rule)
+ (defthm alistp-glcp-generic-relieve-hyps
+ (b* (((mv ?successp ?bindings1 ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-relieve-hyps
+ rune hyps bindings pathcond clk config interp-st bvar-db st)))
+ (equal bindings1
+ (if erp nil bindings)))
+ :hints ('(:expand ((glcp-generic-relieve-hyps
+ rune hyps bindings pathcond clk config interp-st bvar-db st))))
+ :flag hyps)
+ (defthm alistp-glcp-generic-relieve-hyp
+ (b* (((mv ?successp ?bindings1 ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-relieve-hyp
+ rune hyp bindings pathcond clk config interp-st bvar-db st)))
+ (equal bindings1
+ (if erp nil bindings)))
+ :hints ('(:expand ((glcp-generic-relieve-hyp
+ rune hyp bindings pathcond clk config interp-st bvar-db st))))
+ :flag hyp)
+ :skip-others t)))
+
+
+ ;; (defthm-glcp-generic-interp-flg
+ ;; (defthm gobjectp-glcp-generic-interp-term
+ ;; (implies (and (glcp-generic-geval-ev-meta-extract-global-facts)
+ ;; (equal (w st) (w state))
+ ;; (sym-counterparts-ok (w st))
+ ;; (bfr-p hyp)
+ ;; (not (mv-nth 0 (glcp-generic-interp-term
+ ;; x alist pathcond clk obligs config st))))
+ ;; (gobjectp (mv-nth 2 (glcp-generic-interp-term
+ ;; x alist pathcond clk obligs config st))))
+ ;; :flag glcp-generic-interp-term)
+
+ ;; (defthm gobject-listp-glcp-generic-interp-list
+ ;; (implies (and (glcp-generic-geval-ev-meta-extract-global-facts)
+ ;; (equal (w st) (w state))
+ ;; (sym-counterparts-ok (w st))
+ ;; (bfr-p hyp)
+ ;; (not (mv-nth 0 (glcp-generic-interp-list
+ ;; x alist pathcond clk obligs config st))))
+ ;; (gobject-listp (mv-nth 2 (glcp-generic-interp-list
+ ;; x alist pathcond clk obligs config st))))
+ ;; :flag glcp-generic-interp-list)
+ ;; :hints (("goal" :induct (glcp-generic-interp-flg flag x alist pathcond clk obligs config st)
+ ;; :expand ((glcp-generic-interp-term x alist pathcond clk obligs config st)
+ ;; (glcp-generic-interp-list x alist pathcond clk obligs config st)
+ ;; (glcp-generic-interp-term nil alist pathcond clk obligs config st)
+ ;; (glcp-generic-interp-list nil alist pathcond clk obligs config st)
+ ;; (gobject-listp nil)
+ ;; (:free (a b) (gobject-listp (cons a b))))
+ ;; :in-theory (e/d** ( ;; gobjectp-gobj-ite-merge
+ ;; ;; gobjectp-cons
+ ;; ;; gtests-wfp
+ ;; ;; bfr-p-of-bfr-and
+ ;; ;; bfr-p-of-bfr-not
+ ;; ;; bfr-p-of-bfr-or
+ ;; ;; hyp-fix-bfr-p
+ ;; ;; (gobjectp)
+ ;; gobjectp-g-apply
+ ;; gobjectp-gobj-fix
+ ;; gtests-wfp
+ ;; gobjectp-cons
+ ;; bfr-p-bfr-binary-and
+ ;; bfr-p-bfr-not
+ ;; bfr-p-bfr-binary-or
+ ;; gobjectp-mk-g-concrete
+ ;; gobjectp-g-concrete-quote
+ ;; hyp-fix-bfr-p
+ ;; glcp-generic-interp-list-w-state-preserved
+ ;; glcp-generic-interp-term-w-state-preserved
+ ;; gl-aside gl-ignore gl-error-is-nil
+ ;; gobjectp-of-atomic-constants
+ ;; gobjectp-gobj-ite-merge
+ ;; gobjectp-mk-g-ite
+ ;; gobjectp-mk-g-boolean
+ ;; car-cons cdr-cons (bfr-p)
+ ;; glcp-interp-error
+ ;; glcp-generic-interp-flg-equivalences
+ ;; (:induction glcp-generic-interp-flg)
+ ;; booleanp-compound-recognizer
+ ;; bfr-p-bfr-binary-or
+ ;; gobjectp-mk-g-boolean
+ ;; (g-keyword-symbolp)))
+ ;; :do-not-induct t)))
+
+
+
+(local
+ (defsection glcp-generic-geval-thms
+ (local (in-theory (disable glcp-generic-geval-alt-def)))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-gobj-ite-merge-correct
+ gobj-ite-merge-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-apply-agrees-with-glcp-generic-geval-ev)
+ (glcp-generic-geval-apply))
+ :expand ((:with glcp-generic-geval (glcp-generic-geval x env))
+ (glcp-generic-geval-list x env)))))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-gtests-nonnil-correct
+ gtests-nonnil-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+ (in-theory (disable glcp-generic-geval-gtests-nonnil-correct))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-gtests-obj-correct
+ gtests-obj-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-gl-args-split-ite-correct
+ gl-args-split-ite-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-gl-fncall-maybe-split-correct
+ gl-fncall-maybe-split-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-gl-cons-maybe-split-correct
+ gl-cons-maybe-split-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))))
+
+(local (in-theory (enable glcp-generic-geval-gtests-nonnil-correct)))
+
+
+
+
+(progn
+
+ (defthm pseudo-termp-car
+ (implies (pseudo-term-listp x)
+ (pseudo-termp (car x))))
+
+ (defthm pseudo-term-listp-cdr
+ (implies (pseudo-term-listp x)
+ (pseudo-term-listp (cdr x))))
+
+ (defthm pseudo-term-listp-cdr-pseudo-term
+ (implies (and (pseudo-termp x)
+ (consp x)
+ (not (equal (car x) 'quote)))
+ (pseudo-term-listp (cdr x))))
+
+ (defthm pseudo-termp-symbolp-car-x
+ (implies (and (pseudo-termp x)
+ (not (consp (car x))))
+ (symbolp (car x))))
+
+ (defthm pseudo-termp-lambda-body
+ (implies (and (pseudo-termp x)
+ (consp (car x)))
+ (pseudo-termp (caddar x))))
+
+ (defthm pseudo-termp-car-last-of-pseudo-term-listp
+ (implies (pseudo-term-listp x)
+ (pseudo-termp (car (last x))))
+ :hints(("Goal" :in-theory (enable last))))
+
+ (defthm pseudo-termp-car-last
+ (implies (and (pseudo-termp x)
+ (< 1 (len x))
+ (not (equal (car x) 'quote)))
+ (pseudo-termp (car (last x))))
+ :hints(("Goal" :expand ((pseudo-termp x))))))
+
+
+
+(encapsulate nil
+ (local (in-theory (disable
+ sets::sets-are-true-lists
+ pseudo-term-listp
+ (:t hyp-fix)
+ (:t acl2::interp-defs-alistp)
+ (:t pseudo-termp)
+ (:t glcp-generic-interp-term)
+ (:t glcp-generic-interp-term-equivs)
+ (:t glcp-generic-interp-test)
+ (:t glcp-generic-interp-if/or)
+ (:t glcp-generic-interp-if)
+ (:t glcp-generic-interp-or)
+ (:t glcp-generic-merge-branches)
+ (:t glcp-generic-merge-branch-subterms)
+ (:t glcp-generic-merge-branch-subterm-lists)
+ (:t gtests)
+ (:t pseudo-term-listp)
+ (:t general-concrete-listp)
+ (:t len)
+ (:t glcp-generic-rewrite)
+ (:t glcp-generic-interp-list)
+ (:t acl2::interp-function-lookup)
+ (:t glcp-generic-simplify-if-test)
+ (:t glcp-generic-simplify-if-test-fncall)
+ acl2::cancel_times-equal-correct
+ acl2::cancel_plus-equal-correct
+ fgetprop
+ len
+ nth update-nth
+ default-car default-cdr
+ true-listp-update-nth
+ no-duplicatesp-equal
+ member-equal
+ hons-assoc-equal
+ acl2::weak-rewrite-rule-p
+ general-concrete-listp
+ general-concrete-obj-list
+ not
+ true-listp
+ hyp-fix-of-hyp-fixedp
+ pseudo-termp)))
+ (def-glcp-interp-thm glcp-generic-interp-obligs-okp
+ :hyps (and (acl2::interp-defs-alistp (nth *is-obligs* interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config)))
+ :body (acl2::interp-defs-alistp (nth *is-obligs* interp-st1))
+ :special
+ ((test :add-hyps (pseudo-termp x))
+ (term :add-hyps (pseudo-termp x))
+ (equivs :add-hyps (pseudo-termp x))
+ (if/or :add-hyps (and (pseudo-termp test)
+ (pseudo-termp tbr)
+ (pseudo-termp fbr)))
+ (maybe :add-hyps (pseudo-termp x))
+ (if :add-hyps (and (pseudo-termp test)
+ (pseudo-termp tbr)
+ (pseudo-termp fbr)))
+ (or :add-hyps (and (pseudo-termp test)
+ (pseudo-termp fbr)))
+ (list :add-hyps (pseudo-term-listp x))
+ (hyp :add-hyps (pseudo-termp hyp))
+ (hyps :add-hyps (pseudo-term-listp hyps))
+ (fncall-ifs :add-hyps (and (symbolp fn)
+ (not (eq fn 'quote))))
+ (maybe-fncall-ifs :add-hyps (and (symbolp fn)
+ (not (eq fn 'quote))))
+ (fncall :add-hyps (and (symbolp fn)
+ (not (eq fn 'quote))))
+ (rewrite :body (implies (and (symbolp fn)
+ (not (eq fn 'quote)))
+ (and (acl2::interp-defs-alistp (nth *is-obligs* interp-st1))
+ (pseudo-termp term))))
+ (rules :body (implies (and (symbolp fn)
+ (not (eq fn 'quote)))
+ (and (acl2::interp-defs-alistp (nth *is-obligs* interp-st1))
+ (pseudo-termp term))))
+ (rule :body (implies (and (symbolp fn)
+ (not (eq fn 'quote)))
+ (and (acl2::interp-defs-alistp (nth *is-obligs* interp-st1))
+ (pseudo-termp term)))))
+ :expand-calls t))
+
+
+
+
+(local
+ (with-output :off (prove)
+ (defthm-glcp-generic-interp-flg
+ (defthm true-listp-glcp-generic-interp-list
+ (true-listp (mv-nth 0 (glcp-generic-interp-list
+ x alist pathcond clk config interp-st bvar-db st)))
+ :hints('(:expand (glcp-generic-interp-list
+ x alist pathcond clk config interp-st bvar-db st)
+ :in-theory (enable gl-cons)))
+ :rule-classes :type-prescription
+ :flag list)
+ :skip-others t)))
+
+
+(local (include-book "system/f-put-global" :dir :system))
+(local (in-theory (disable state-p1-forward)))
+
+(encapsulate nil
+ (local (in-theory (disable* pseudo-termp
+ symbol-listp
+ hyp-fix-of-hyp-fixedp
+ state-p-implies-and-forward-to-state-p1
+ len nth update-nth
+ default-car default-cdr
+ (:rules-of-class :type-prescription :here))))
+ (def-glcp-interp-thm glcp-generic-interp-state-p1-preserved
+ :body (implies (state-p1 st)
+ (state-p1 state1))
+
+ :expand-calls t))
+
+
+(local
+ (defthm true-listp-gl-cons
+ (equal (true-listp (gl-cons x y))
+ (true-listp y))
+ :hints(("Goal" :in-theory (enable gl-cons)))))
+
+
+
+
+
+(local
+ (defthm consp-last
+ (equal (consp (last x))
+ (consp x))))
+
+
+
+(set-ignore-ok t)
+
+(defthm plist-worldp-of-w-state
+ (implies (state-p1 state)
+ (plist-worldp (w state)))
+ :hints(("Goal" :in-theory (e/d (state-p1 get-global w)
+ (all-boundp)))))
+
+;; (defun get-guard-verification-theorem (name state)
+;; (declare (xargs :mode :program
+;; :stobjs state))
+;; (b* ((wrld (w state))
+;; (ctx 'get-guard-verification-theorem)
+;; ((er names) (acl2::chk-acceptable-verify-guards
+;; name ctx wrld state))
+;; (ens (acl2::ens state))
+;; ((mv clauses & state)
+;; (acl2::guard-obligation-clauses
+;; names nil ens wrld state))
+;; (term (acl2::termify-clause-set clauses)))
+;; (value term)))
+
+
+;; (local (defthm symbol-listp-implies-true-listp
+;; (implies (symbol-listp x)
+;; (true-listp x))
+;; :rule-classes :forward-chaining))
+
+(local (defthm nonnil-symbol-listp-true-listp
+ (implies (nonnil-symbol-listp x)
+ (true-listp x))))
+
+;; (local (defthm gobj-listp-impl-true-listp
+;; (implies (gobj-listp x)
+;; (true-listp x))
+;; :hints(("Goal" :in-theory (enable gobj-listp)))
+;; :rule-classes :compound-recognizer))
+
+(local (defthm pseudo-termp-impl-symbol-listp-lambda-formals
+ (implies (and (pseudo-termp x)
+ (consp (car x)))
+ (symbol-listp (cadar x)))
+ :hints(("Goal" :expand ((pseudo-termp x))))))
+
+
+(local (defthm symbol-listp-impl-eqlable-listp
+ (implies (symbol-listp x)
+ (eqlable-listp x))))
+
+(local (defthm symbol-listp-impl-true-listp
+ (implies (symbol-listp x)
+ (true-listp x))))
+
+(local (defthm pseudo-termp-impl-len-lambda-formals
+ (implies (and (pseudo-termp x)
+ (consp (car x)))
+ (equal (equal (len (cadar x)) (len (cdr x)))
+ t))
+ :hints(("Goal" :expand ((pseudo-termp x))))))
+
+
+(local
+ (with-output :off (prove)
+ (progn
+ (defthm len-gl-cons
+ (equal (len (gl-cons x y))
+ (+ 1 (len y)))
+ :hints(("Goal" :in-theory (enable gl-cons))))
+
+ (defthm-glcp-generic-interp-flg
+ (defthm len-of-glcp-generic-interp-list
+ (mv-let (res erp)
+ (glcp-generic-interp-list
+ x alist pathcond clk config interp-st bvar-db st)
+ (implies (not erp)
+ (equal (len res)
+ (len x))))
+ :hints ('(:expand ((glcp-generic-interp-list
+ x alist pathcond clk config interp-st bvar-db st))))
+ :flag list)
+ :skip-others t))))
+
+(local (defthmd contextsp-implies-true-listp
+ (implies (contextsp x)
+ (true-listp x))
+ :rule-classes :forward-chaining))
+
+
+
+(defsection glcp-branch-merge-formula-to-rule
+
+ (defthm conjunction-to-list-correct
+ (iff (glcp-generic-geval-ev (conjoin (conjunction-to-list x)) a)
+ (glcp-generic-geval-ev x a))
+ :hints(("Goal" :in-theory (enable conjunction-to-list))))
+
+ (local (in-theory (disable acl2::beta-reduce-full
+ pseudo-termp)))
+
+ (local (in-theory (enable glcp-branch-merge-formula-to-rule)))
+
+ (defthm glcp-branch-merge-formula-to-rule-wfp
+ (b* (((mv ok rule)
+ (glcp-branch-merge-formula-to-rule name wrld)))
+ (implies ok
+ (acl2::weak-rewrite-rule-p rule)))
+ :hints(("Goal" :in-theory (disable acl2::weak-rewrite-rule-p))))
+
+ (local (defthmd beta-reduce-full-correct-for-glcp-generic-geval-ev
+ (implies (pseudo-termp x)
+ (equal (glcp-generic-geval-ev (acl2::beta-reduce-full x) a)
+ (glcp-generic-geval-ev x a)))
+ :hints (("goal" :use ((:instance
+ (:functional-instance
+ acl2::beta-reduce-full-correct
+ (acl2::beta-eval glcp-generic-geval-ev)
+ (acl2::beta-eval-list
+ glcp-generic-geval-ev-lst))))
+ :in-theory (enable glcp-generic-geval-ev-of-fncall-args)))))
+
+
+ (defthmd rewrite-rule-term-alt-def
+ (equal (acl2::rewrite-rule-term x)
+ (if (eq (acl2::rewrite-rule->subclass x) 'acl2::meta)
+ ''t
+ `(implies ,(conjoin (acl2::rewrite-rule->hyps x))
+ (,(acl2::rewrite-rule->equiv x)
+ ,(acl2::rewrite-rule->lhs x)
+ ,(acl2::rewrite-rule->rhs x)))))
+ :hints(("Goal" :in-theory (enable acl2::rewrite-rule->subclass
+ acl2::rewrite-rule->hyps
+ acl2::rewrite-rule->equiv
+ acl2::rewrite-rule->lhs
+ acl2::rewrite-rule->rhs))))
+
+ (local (in-theory (disable acl2::rewrite-rule-term)))
+
+ ; (local (include-book "arithmetic/top-with-meta" :dir :system))
+
+ (local (defthm equal-of-len
+ (implies (syntaxp (quotep n))
+ (equal (equal (len x) n)
+ (and (natp n)
+ (if (equal n 0)
+ (atom x)
+ (and (consp x)
+ (equal (len (cdr x)) (1- n)))))))))
+
+
+
+ (defthm glcp-branch-merge-formula-to-rule-correct
+ (b* (((mv ok rule)
+ (glcp-branch-merge-formula-to-rule name wrld)))
+ (implies (and (glcp-generic-geval-ev-meta-extract-global-facts)
+ (equal wrld (w state))
+ ok)
+ (glcp-generic-geval-ev-theoremp (acl2::rewrite-rule-term rule))))
+ :hints (("goal" :use ((:instance glcp-generic-geval-ev-falsify
+ (x (acl2::meta-extract-formula-w name wrld))
+ (a (glcp-generic-geval-ev-falsify
+ (acl2::rewrite-rule-term
+ (mv-nth 1 (glcp-branch-merge-formula-to-rule
+ name wrld))))))
+ (:instance
+ beta-reduce-full-correct-for-glcp-generic-geval-ev
+ (x (acl2::meta-extract-formula-w name wrld))
+ (a (glcp-generic-geval-ev-falsify
+ (acl2::rewrite-rule-term
+ (mv-nth 1 (glcp-branch-merge-formula-to-rule
+ name wrld)))))))
+ :expand ((glcp-branch-merge-formula-to-rule name wrld))
+ :in-theory (e/d (glcp-generic-geval-ev-of-fncall-args
+ rewrite-rule-term-alt-def)
+ (equal-of-booleans-rewrite
+ default-car default-cdr
+ sets::double-containment
+ len kwote-lst
+ w))))))
+
+
+
+(defun good-rewrite-rulesp (rules)
+ (if (atom rules)
+ t
+ (and (glcp-generic-geval-ev-theoremp (acl2::rewrite-rule-term (car rules)))
+ (good-rewrite-rulesp (cdr rules)))))
+
+(defsection glcp-branch-merge-formulas-to-rules
+
+ (local (in-theory (enable glcp-branch-merge-formulas-to-rules)))
+
+ (defthm good-rewrite-rulesp-of-glcp-branch-merge-formulas-to-rules
+ (implies (and (glcp-generic-geval-ev-meta-extract-global-facts)
+ (equal wrld (w state)))
+ (good-rewrite-rulesp
+ (glcp-branch-merge-formulas-to-rules names wrld)))
+ :hints(("Goal" :in-theory (e/d (good-rewrite-rulesp)
+ (acl2::rewrite-rule-term
+ rewrite-rule-term-alt-def)))))
+
+ (defthm weak-rewrite-rule-listp-of-glcp-branch-merge-formulas-to-rules
+ (weak-rewrite-rule-listp
+ (glcp-branch-merge-formulas-to-rules names wrld))))
+
+(defsection good-rewrite-rulesp-of-get-lemmas
+ (local (defthmd good-rewrite-rulesp-of-get-lemmas1
+ (implies (and (glcp-generic-geval-ev-meta-extract-global-facts)
+ (subsetp rules (getprop fn 'acl2::lemmas nil
+ 'current-acl2-world (w state))))
+ (good-rewrite-rulesp rules))
+ :hints(("Goal" :in-theory (e/d (subsetp-equal
+ good-rewrite-rulesp)
+ (acl2::rewrite-rule-term
+ rewrite-rule-term-alt-def
+ w))))))
+ (defthm good-rewrite-rulesp-of-get-lemmas
+ (implies (and (glcp-generic-geval-ev-meta-extract-global-facts)
+ (equal wrld (w state)))
+ (good-rewrite-rulesp
+ (getprop fn 'acl2::lemmas nil
+ 'current-acl2-world (w state))))
+ :hints (("goal" :use ((:instance good-rewrite-rulesp-of-get-lemmas1
+ (rules
+ (getprop fn 'acl2::lemmas nil
+ 'current-acl2-world (w state)))))))))
+
+
+
+
+(defthm good-rewrite-rules-of-glcp-get-branch-merge-rules
+ (implies (and (glcp-generic-geval-ev-meta-extract-global-facts)
+ (equal wrld (w state)))
+ (good-rewrite-rulesp (glcp-get-branch-merge-rules fn wrld)))
+ :hints(("Goal" :in-theory (enable glcp-get-branch-merge-rules))))
+
+(defthm weak-rewrite-rule-listp-of-glcp-get-branch-merge-rules
+ (weak-rewrite-rule-listp
+ (glcp-get-branch-merge-rules fn wrld))
+ :hints(("Goal" :in-theory (enable glcp-get-branch-merge-rules))))
+
+
+(encapsulate nil
+ (local (defthm len-0
+ (equal (equal (len x) 0)
+ (not (consp x)))))
+
+ (make-event
+ (b* (((er &) (in-theory nil))
+ ((er thm) (get-guard-verification-theorem 'glcp-generic-interp-term state)))
+ (value
+ `(with-output :off (prove)
+ (defthm glcp-generic-interp-guards-ok
+ ,thm
+ :hints (("goal" :in-theory
+ (e/d* (pseudo-termp-car-last-of-pseudo-term-listp
+ gl-aside gl-ignore gl-error-is-nil
+ contextsp-implies-true-listp)
+ (glcp-generic-interp-term
+ glcp-generic-interp-list
+ acl2::weak-rewrite-rule-p
+ consp-assoc-equal
+ pseudo-term-listp
+ w
+ nth update-nth
+ contextsp
+ nonnil-symbol-listp
+ true-listp symbol-listp
+ not no-duplicatesp-equal
+ fgetprop plist-worldp
+ hons-assoc-equal
+; bfr-and-is-bfr-and
+; bfr-not-is-bfr-not
+; bfr-p-is-bfr-p
+ assoc table-alist
+ general-concrete-listp
+ general-concretep-def
+ state-p-implies-and-forward-to-state-p1
+ (:rules-of-class :forward-chaining :here)
+ (:rules-of-class :type-prescription :here)
+ (force))
+ ((:type-prescription glcp-generic-interp-term)
+ (:type-prescription glcp-generic-interp-list)
+ (:type-prescription acl2::interp-function-lookup)
+ (:type-prescription general-concrete-obj-list)
+ (:type-prescription hons-assoc-equal)
+ (:t type-of-get-term->bvar$a)))
+ :do-not-induct t))
+ :rule-classes nil))))))
+
+
+
+(local (defthm car-last-when-length-4
+ (implies (equal (len x) 4)
+ (equal (car (last x))
+ (cadddr x)))
+ :hints(("Goal" :in-theory (enable len last)))))
+
+(local
+ (progn
+ (include-book "tools/def-functional-instance" :dir :system)
+
+ (acl2::def-functional-instance
+ glcp-generic-interp-function-lookup-correct
+ acl2::interp-function-lookup-correct
+ ((acl2::ifl-ev glcp-generic-geval-ev)
+ (acl2::ifl-ev-lst glcp-generic-geval-ev-lst)
+ (acl2::ifl-ev-falsify glcp-generic-geval-ev-falsify)
+ (acl2::ifl-ev-meta-extract-global-badguy
+ glcp-generic-geval-ev-meta-extract-global-badguy))
+ :hints ((and stable-under-simplificationp
+ '(:use (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-ev-falsify
+ glcp-generic-geval-ev-meta-extract-global-badguy)))))
+
+ (acl2::def-functional-instance
+ glcp-generic-interp-function-lookup-theoremp-defs-history
+ acl2::interp-function-lookup-theoremp-defs-history
+ ((acl2::ifl-ev glcp-generic-geval-ev)
+ (acl2::ifl-ev-lst glcp-generic-geval-ev-lst)
+ (acl2::ifl-ev-falsify glcp-generic-geval-ev-falsify)))
+
+
+
+ (defthm glcp-generic-interp-function-lookup-theoremp-defs-history-rev
+ (b* (((mv erp & & out-defs)
+ (acl2::interp-function-lookup fn in-defs overrides world)))
+ (implies (and (not (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses in-defs))))
+ (not erp))
+ (not (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses out-defs)))))))
+
+ ;; (defthm glcp-generic-interp-function-lookup-theoremp-defs-history-fwd
+ ;; (b* (((mv erp & & out-defs)
+ ;; (acl2::interp-function-lookup fn in-defs overrides world)))
+ ;; (implies (and (glcp-generic-geval-ev-theoremp
+ ;; (conjoin-clauses
+ ;; (acl2::interp-defs-alist-clauses out-defs)))
+ ;; (not erp))
+ ;; (glcp-generic-geval-ev-theoremp
+ ;; (conjoin-clauses
+ ;; (acl2::interp-defs-alist-clauses in-defs)))))
+ ;; :rule-classes :forward-chaining)
+
+ ))
+
+(local (in-theory (disable acl2::interp-defs-alist-clauses)))
+
+(encapsulate nil
+ (local (in-theory (disable* (:rules-of-class :type-prescription :here)
+ pseudo-termp
+ len nth update-nth default-car default-cdr
+ fgetprop
+ glcp-generic-geval-ev-conjoin-clauses-atom
+ hons-assoc-equal
+ glcp-generic-geval-ev-rules
+ glcp-generic-interp-function-lookup-theoremp-defs-history
+ pseudo-termp-car)))
+
+ (defun find-bad-obligs-lit (clause)
+ (declare (xargs :mode :program))
+ (if (atom clause)
+ nil
+ (b* (((mv ok &) (acl2::simple-one-way-unify
+ '(GLCP-GENERIC-GEVAL-EV
+ (CONJOIN-CLAUSES (ACL2::INTERP-DEFS-ALIST-CLAUSES OBLIGS))
+ (GLCP-GENERIC-GEVAL-EV-FALSIFY
+ (CONJOIN-CLAUSES (ACL2::INTERP-DEFS-ALIST-CLAUSES OBLIGS))))
+ (car clause)
+ nil))
+ ((when ok) t))
+ (find-bad-obligs-lit (cdr clause)))))
+
+ (defun bad-obligs-syntaxp (mfc state)
+ (declare (xargs :mode :program :stobjs state))
+ (or (acl2::mfc-ancestors mfc)
+ (car (acl2::mfc-current-literal mfc state))))
+ ;; (and negp
+ ;; (case-match lit
+ ;; (('glcp-generic-geval-ev
+ ;; ('conjoin-clauses
+ ;; ('acl2::interp-defs-alist-clauses . &))
+ ;; ('glcp-generic-geval-ev-falsify . &))
+ ;; t)))))
+
+ (defund interp-defs-ok (obligs)
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses obligs))))
+
+ (local (in-theory (enable interp-defs-ok)))
+
+ (def-glcp-interp-thm glcp-generic-interp-bad-obligs
+ ;; :hyps (and ;; (syntaxp ((lambda (mfc state)
+ ;; ;; (find-bad-obligs-lit (mfc-clause mfc)))
+ ;; ;; mfc state))
+ ;;
+ :hyps ;; (and (syntaxp (bad-obligs-syntaxp mfc state))
+ (not (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (nth *is-obligs* interp-st)))))
+ :body (not (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (nth *is-obligs*
+ interp-st1)))))
+ ; (and (interp-defs-ok (nth *is-obligs* interp-st1))
+ ;; (glcp-generic-geval-ev-theoremp
+ ;; (conjoin-clauses
+ ;; (acl2::interp-defs-alist-clauses (nth *is-obligs*
+ ;; interp-st)))))
+;; :rule-classes :forward-chaining
+ :expand-calls t)
+
+ ;; (defthm glcp-generic-interp-function-lookup-theoremp-defs-history-rev
+ ;; (B* (((MV ERP & & OUT-DEFS)
+ ;; (ACL2::INTERP-FUNCTION-LOOKUP FN IN-DEFS OVERRIDES WORLD)))
+ ;; (implies (not erp)
+ ;; (iff (glcp-generic-geval-ev-theoremp
+ ;; (conjoin-clauses
+ ;; (acl2::interp-defs-alist-clauses out-defs)))
+ ;; (and (interp-defs-ok out-defs)
+ ;; (glcp-generic-geval-ev-theoremp
+ ;; (conjoin-clauses
+ ;; (acl2::interp-defs-alist-clauses in-defs))))))))
+)
+
+
+
+
+
+
+
+
+
+
+
+
+
+(progn
+ (local (in-theory (disable nth update-nth)))
+ ;; (defthm glcp-generic-interp-term-ok-obligs
+ ;; (implies (and (not (glcp-generic-geval-ev-theoremp
+ ;; (conjoin-clauses
+ ;; (acl2::interp-defs-alist-clauses (nth *is-obligs* interp-st)))))
+ ;; (glcp-generic-geval-ev-theoremp
+ ;; (conjoin-clauses
+ ;; (acl2::interp-defs-alist-clauses
+ ;; (nth *is-obligs*
+ ;; (mv-nth 2 (glcp-generic-interp-term
+ ;; x alist contexts pathcond clk config interp-st bvar-db st)))))))
+ ;; (mv-nth 1 (glcp-generic-interp-term
+ ;; x alist contexts pathcond clk config interp-st bvar-db
+ ;; st)))
+ ;; :hints (("goal" :use glcp-generic-interp-bad-obligs-term)))
+
+
+
+
+
+ ;; (defthm glcp-generic-obligs-okp-final-implies-start
+ ;; (implies (and (glcp-generic-geval-ev-theoremp
+ ;; (conjoin-clauses
+ ;; (acl2::interp-defs-alist-clauses
+ ;; (nth *is-obligs*
+ ;; (mv-nth 2 (glcp-generic-interp-term-equivs
+ ;; x alist pathcond contexts clk config interp-st bvar-db state))))))
+ ;; (not (mv-nth 1 (glcp-generic-interp-term-equivs
+ ;; x alist pathcond contexts clk config interp-st bvar-db state))))
+ ;; (glcp-generic-geval-ev-theoremp
+ ;; (conjoin-clauses
+ ;; (acl2::interp-defs-alist-clauses
+ ;; (nth *is-obligs* interp-st)))))
+ ;; :rule-classes :forward-chaining)
+
+ (defthm glcp-generic-obligs-okp-final-implies-start
+ (implies (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (nth *is-obligs*
+ (mv-nth 2 (glcp-generic-interp-term-equivs
+ x alist contexts pathcond clk config
+ (update-nth *is-obligs* obligs interp-st)
+ bvar-db st))))))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses obligs))))
+ :hints (("goal" :use ((:instance glcp-generic-interp-bad-obligs-equivs
+ (interp-st (update-nth *is-obligs* obligs interp-st))))))
+ :rule-classes :forward-chaining)
+
+
+ (defthm assoc-eq-glcp-generic-geval-alist
+ (implies (alistp alist)
+ (equal (cdr (assoc-eq x (glcp-generic-geval-alist alist env)))
+ (glcp-generic-geval (cdr (hons-assoc-equal x alist))
+ env)))
+ :hints(("Goal" :in-theory (enable glcp-generic-geval-alist
+ hons-assoc-equal))))
+
+
+ (defthm glcp-generic-geval-lst-general-concrete-obj-list
+ (implies (general-concrete-listp x)
+ (equal (glcp-generic-geval-list x env)
+ (general-concrete-obj-list x)))
+ :hints(("Goal" :in-theory (e/d (gobj-listp) ()))))
+
+
+ (defthm glcp-generic-geval-ev-nil
+ (equal (glcp-generic-geval-ev nil a) nil))
+
+
+ (defthm glcp-generic-geval-ev-meta-extract-rewrite-rule
+ (implies (and (glcp-generic-geval-ev-theoremp (acl2::rewrite-rule-term rule))
+ (not (equal (acl2::rewrite-rule->subclass rule) 'acl2::meta))
+ (glcp-generic-geval-ev (conjoin (acl2::rewrite-rule->hyps
+ rule))
+ a)
+ (equal (acl2::rewrite-rule->equiv rule) 'equal))
+ (equal (glcp-generic-geval-ev
+ (acl2::rewrite-rule->rhs rule) a)
+ (glcp-generic-geval-ev
+ (acl2::rewrite-rule->lhs rule) a)))
+ :hints (("goal" :use ((:instance glcp-generic-geval-ev-falsify
+ (x (acl2::rewrite-rule-term rule))))
+ :in-theory (enable acl2::rewrite-rule->rhs
+ acl2::rewrite-rule->lhs
+ acl2::rewrite-rule->hyps
+ acl2::rewrite-rule->equiv
+ acl2::rewrite-rule->subclass)))))
+
+;; (defthm glcp-generic-rewrite-apply-rule-correct
+;; (let* ((lhs (acl2::rewrite-rule->lhs rule))
+;; (fn (car lhs))
+;; (args (cdr lhs))
+;; (unify-subst (glcp-generic-geval-alist
+;; (mv-nth 1 (glcp-unify-term/gobj-list
+;; args actuals nil))
+;; env)))
+;; (implies (and (symbolp fn)
+;; (not (eq fn 'quote))
+;; (member rule (getprop fn 'acl2::lemmas nil 'current-acl2-world (w state)))
+;; (glcp-generic-geval-ev
+;; (conjoin (acl2::rewrite-rule->hyps rule))
+;; unify-subst)
+;; (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+;; (equal (w state0) (w state)))
+;; (equal (glcp-generic-geval-ev
+;; (acl2::rewrite-rule->rhs rule)
+;; unify-subst)
+;; (glcp-generic-geval-ev
+;; (cons fn (kwote-lst (glcp-generic-geval actuals env)))
+;; nil))))
+;; :hints (("goal"
+
+
+
+(local (defthm true-listp-cdr-when-pseudo-termp
+ (implies (pseudo-termp x)
+ (true-listp (cdr x)))
+ :rule-classes :forward-chaining))
+
+(progn
+ (encapsulate nil
+ (local (bfr-reasoning-mode t))
+ (local (acl2::set-bdd-patterns '((hyp-fix . &) 't 'nil)))
+ (defthm bfr-eval-gtests-unknown
+ (implies (and (not (hf (gtests-unknown (gtests test hyp))))
+ (bfr-eval hyp env))
+ (not (bfr-eval (gtests-unknown (gtests test hyp)) env))))
+
+ (defthm bfr-eval-gtests-unknown-or
+ (implies (and (not (hf (bfr-or (gtests-unknown (gtests test hyp)) other)))
+ (bfr-eval hyp env))
+ (not (bfr-eval (gtests-unknown (gtests test hyp)) env))))
+
+
+ (defthm geval-of-interp-res-hyp-fix-unknown-false
+ (implies (and (not (glcp-generic-geval interp-res env))
+ (bfr-eval hyp (car env)))
+ (hyp-fix (bfr-or
+ (gtests-unknown (gtests interp-res hyp))
+ (bfr-not
+ (gtests-nonnil (gtests interp-res hyp))))
+ hyp)))
+
+ (defthm geval-of-interp-res-hyp-fix-unknown-true
+ (implies (and (glcp-generic-geval interp-res env)
+ (bfr-eval hyp (car env)))
+ (hyp-fix (bfr-or
+ (gtests-unknown (gtests interp-res hyp))
+ (gtests-nonnil (gtests interp-res hyp)))
+ hyp)))
+
+ (defthm gtests-nonnil-or-not
+ (implies
+ (and
+ (bfr-eval hyp (car env))
+ (not
+ (hyp-fix
+ (bfr-or
+ (gtests-unknown (gtests test hyp))
+ (gtests-nonnil (gtests test hyp)))
+ hyp)))
+ (hyp-fix
+ (bfr-or
+ (gtests-unknown (gtests test hyp))
+ (bfr-not (gtests-nonnil (gtests test hyp))))
+ hyp)))
+
+ (defthmd gtests-known-and-true
+ (implies (and (bfr-eval hyp (car env))
+ (equal (gtests-unknown (gtests gobj hyp)) nil)
+ (equal (glcp-generic-geval gobj env) nil))
+ (not (equal (gtests-nonnil (gtests gobj hyp)) t)))
+ :hints (("goal" :use ((:instance
+ geval-of-interp-res-hyp-fix-unknown-false
+ (interp-res gobj)))
+ :in-theory (e/d (hyp-fix)
+ (geval-of-interp-res-hyp-fix-unknown-false))))))
+
+
+ (defthm len-kwote-lst
+ (equal (len (kwote-lst x))
+ (len x)))
+
+ (defthm glcp-generic-geval-ev-lst-kwote-lst
+ (equal (glcp-generic-geval-ev-lst (kwote-lst args) a)
+ (acl2::list-fix args)))
+
+ (defcong acl2::list-equiv equal (pairlis$ x y) 2)
+
+ (defthm glcp-generic-interp-function-lookup-correct-special
+ (mv-let (erp body formals out-defs)
+ (acl2::interp-function-lookup fn in-defs overrides (w state))
+ (implies (and (not erp)
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses out-defs)))
+ (acl2::interp-defs-alistp in-defs)
+ (acl2::interp-defs-alistp overrides)
+ (equal (len formals) (len actuals))
+ (not (eq fn 'quote))
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state1)
+ (equal (w state) (w state1)))
+ (equal (glcp-generic-geval-ev body (pairlis$ formals actuals))
+ (glcp-generic-geval-ev (cons fn (kwote-lst actuals))
+ nil))))
+ :hints (("goal" :use ((:instance
+ glcp-generic-interp-function-lookup-correct
+ (acl2::actuals (kwote-lst actuals))
+ (acl2::overrides overrides)
+ (acl2::fn fn)
+ (a nil)
+ (state state1)
+ (acl2::in-defs in-defs)))
+ :in-theory (enable interp-defs-ok))))
+
+ (defthm glcp-generic-geval-ev-magic-ev-fncall-special
+ (b* (((mv erp val)
+ (acl2::magic-ev-fncall f args st t nil)))
+ (implies (and (glcp-generic-geval-ev-meta-extract-global-facts)
+ (equal (w st) (w state))
+ (not erp))
+ (equal val
+ (glcp-generic-geval-ev (cons f (kwote-lst args)) nil))))
+ :hints(("Goal" :in-theory (enable glcp-generic-geval-ev-meta-extract-fncall))))
+
+ (in-theory (disable glcp-generic-geval-ev-meta-extract-fncall)))
+
+
+(defun-sk glcp-generic-bvar-db-env-ok (bvar-db p bound env)
+ (forall n
+ (implies (and (<= (base-bvar$a bvar-db) (nfix n))
+ (< (nfix n) bound)
+ (< (nfix n) (next-bvar$a bvar-db)))
+ (iff (bfr-lookup
+ n (bfr-unparam-env p (car env)))
+ (glcp-generic-geval (get-bvar->term$a n bvar-db) env))))
+ :rewrite :direct)
+
+
+;; (defthm bfr-lookup-when-glcp-generic-bvar-db-env-ok
+;; (implies (and (glcp-generic-bvar-db-env-ok bvar-db config env)
+;; (<= (base-bvar bvar-db) (nfix n))
+;; (< (nfix n) (next-bvar bvar-db)))
+;; (iff (bfr-lookup n
+;; (bfr-unparam-env (glcp-config->param-bfr config) (car env)))
+;; (glcp-generic-geval (get-bvar->term$a n bvar-db) env)))
+;; :hints (("goal" :use ((:instance glcp-generic-bvar-db-env-ok-necc
+;; (x (get-bvar->term$a n bvar-db))))
+;; :in-theory (disable glcp-generic-bvar-db-env-ok-necc
+;; bfr-to-param-space))))
+
+(in-theory (disable glcp-generic-bvar-db-env-ok))
+
+(defthm glcp-generic-bvar-db-env-ok-of-add-term-bvar
+ (implies (<= bound (next-bvar$a bvar-db))
+ (equal (glcp-generic-bvar-db-env-ok (add-term-bvar$a x bvar-db)
+ p bound env)
+ (glcp-generic-bvar-db-env-ok bvar-db p bound env)))
+ :hints (("goal" :cases ((glcp-generic-bvar-db-env-ok (add-term-bvar$a x bvar-db)
+ p bound env)))
+ (and stable-under-simplificationp
+ (if (eq (caar clause) 'not)
+ `(:expand (,(car (last clause))))
+ `(:expand (,(car clause)))))))
+
+(defthm glcp-generic-bvar-db-env-ok-of-add-term-equiv
+ (equal (glcp-generic-bvar-db-env-ok (add-term-equiv x n bvar-db)
+ p bound env)
+ (glcp-generic-bvar-db-env-ok bvar-db p bound env))
+ :hints (("goal" :cases ((glcp-generic-bvar-db-env-ok (add-term-equiv x n bvar-db)
+ p bound env)))
+ (and stable-under-simplificationp
+ (if (eq (caar clause) 'not)
+ `(:expand (,(car (last clause))))
+ `(:expand (,(car clause)))))))
+
+(defthm glcp-generic-bvar-db-env-ok-of-add-term-bvar-next
+ (implies (not (glcp-generic-bvar-db-env-ok bvar-db p (next-bvar$a bvar-db) env))
+ (not (glcp-generic-bvar-db-env-ok (add-term-bvar$a x bvar-db)
+ p (+ 1 (next-bvar$a bvar-db)) env)))
+ :hints (("goal" :expand ((glcp-generic-bvar-db-env-ok bvar-db p (next-bvar$a bvar-db) env)))))
+
+;; (defthm glcp-generic-bvar-db-env-ok-of-add-term-bvar
+;; (implies (not (glcp-generic-bvar-db-env-ok bvar-db p bound env))
+;; (not (glcp-generic-bvar-db-env-ok (add-term-bvar$a x bvar-db)
+;; p bound env)))
+;; :hints (("goal" :use ((:instance glcp-generic-bvar-db-env-ok-necc
+;; (bvar-db (add-term-bvar$a x bvar-db))
+;; (n (glcp-generic-bvar-db-env-ok-witness
+;; bvar-db p bound env))))
+;; :expand ((glcp-generic-bvar-db-env-ok bvar-db p bound env))
+;; :in-theory (disable glcp-generic-bvar-db-env-ok-necc))))
+
+(defthm glcp-generic-bvar-db-env-ok-bound-decr
+ (implies (and (glcp-generic-bvar-db-env-ok bvar-db p bound1 env)
+ (<= bound bound1))
+ (glcp-generic-bvar-db-env-ok bvar-db p bound env))
+ :hints (("goal" :expand ((glcp-generic-bvar-db-env-ok bvar-db p bound env)))))
+
+(encapsulate nil
+ (local (in-theory (disable* (:rules-of-class :type-prescription :here)
+ pseudo-termp
+ len
+ ; acl2::nfix-when-natp
+ no-duplicatesp-equal
+ fgetprop
+ general-concrete-listp
+ member-equal
+ hons-assoc-equal pairlis$ last
+ pseudo-term-listp
+ symbol-listp
+ pseudo-termp-symbolp-car-x
+ ; glcp-generic-interp-term-ok-obligs
+ hyp-fix-of-hyp-fixedp
+ nfix
+ default-<-2
+ default-<-1
+ default-car default-cdr
+ ;; rationalp-implies-acl2-numberp
+ ;; acl2::cancel_plus-lessp-correct
+ general-concrete-obj-list
+ ; acl2::nfix-when-not-natp
+ acl2::cancel_times-equal-correct
+ acl2::cancel_plus-equal-correct)))
+
+ (defthm base-bvar-of-maybe-add-equiv-term
+ (equal (base-bvar$a (maybe-add-equiv-term test-obj bvar bvar-db state))
+ (base-bvar$a bvar-db))
+ :hints(("Goal" :in-theory (enable maybe-add-equiv-term))))
+
+ (defthm next-bvar-of-maybe-add-equiv-term
+ (equal (next-bvar$a (maybe-add-equiv-term test-obj bvar bvar-db state))
+ (next-bvar$a bvar-db))
+ :hints(("Goal" :in-theory (enable maybe-add-equiv-term))))
+
+ (defthm get-term->bvar-of-maybe-add-equiv-term
+ (equal (get-term->bvar$a x (maybe-add-equiv-term test-obj bvar bvar-db state))
+ (get-term->bvar$a x bvar-db))
+ :hints(("Goal" :in-theory (enable maybe-add-equiv-term))))
+
+ (defthm get-bvar->term-of-maybe-add-equiv-term
+ (equal (get-bvar->term$a x (maybe-add-equiv-term test-obj bvar bvar-db state))
+ (get-bvar->term$a x bvar-db))
+ :hints(("Goal" :in-theory (enable maybe-add-equiv-term))))
+
+ (def-glcp-interp-thm glcp-generic-interp-base-bvar-preserved
+ :body (equal (base-bvar$a bvar-db1) (base-bvar$a bvar-db))
+ :expand-calls t)
+
+ (def-glcp-interp-thm glcp-generic-interp-next-bvar-incr
+ :body (>= (next-bvar$a bvar-db1) (next-bvar$a bvar-db))
+ :rule-classes :linear
+ :expand-calls t)
+
+ (def-glcp-interp-thm glcp-generic-interp-get-bvar->term-preserved
+ :body (implies (and (<= (base-bvar$a bvar-db) (nfix n))
+ (< (nfix n) (next-bvar$a bvar-db)))
+ (equal (get-bvar->term$a n bvar-db1)
+ (get-bvar->term$a n bvar-db)))
+ :expand-calls t)
+
+ (def-glcp-interp-thm glcp-generic-interp-get-term->bvar-preserved
+ :body (implies (get-term->bvar$a n bvar-db)
+ (equal (get-term->bvar$a n bvar-db1)
+ (get-term->bvar$a n bvar-db)))
+ :expand-calls t))
+
+(encapsulate nil
+ (local (in-theory (disable* pseudo-termp pseudo-term-listp
+ pseudo-termp-car
+ default-<-2 default-<-1 fgetprop
+ len
+ hons-assoc-equal
+ (:rules-of-class :type-prescription :here))))
+
+ (defthm glcp-generic-interp-bvar-db-env-ok-of-maybe-add-equiv-term
+ (equal (glcp-generic-bvar-db-env-ok
+ (maybe-add-equiv-term test-obj bvar bvar-db state)
+ p bound env)
+ (glcp-generic-bvar-db-env-ok bvar-db p bound env))
+ :hints(("Goal" :in-theory (enable maybe-add-equiv-term))))
+
+ (local (deflabel pre-env-ok-preserved))
+
+ (def-glcp-interp-thm glcp-generic-interp-bvar-db-env-ok-preserved
+ :hyps (<= bound (next-bvar$a bvar-db))
+ :body (equal (glcp-generic-bvar-db-env-ok bvar-db1 p bound env)
+ (glcp-generic-bvar-db-env-ok bvar-db p bound env))
+ :expand-calls t)
+
+ (def-ruleset! env-ok-preserved-rules
+ (set-difference-theories
+ (current-theory :here)
+ (current-theory 'pre-env-ok-preserved)))
+
+ (local (deflabel pre-env-ok-special))
+
+ (def-glcp-interp-thm glcp-generic-interp-bvar-db-preserved-special
+ :hyps (and ;; (syntaxp ((lambda (mfc state)
+ ;; (assoc 'glcp-generic-bvar-db-env-ok
+ ;; (mfc-clause mfc)))
+ ;; mfc state))
+ (not (glcp-generic-bvar-db-env-ok bvar-db p (next-bvar$a bvar-db) env)))
+ :body (not (glcp-generic-bvar-db-env-ok bvar-db1 p (next-bvar$a bvar-db1) env))
+ :expand-calls t)
+
+ (def-ruleset! env-ok-special-rules
+ (set-difference-theories
+ (current-theory :here)
+ (current-theory 'pre-env-ok-special)))
+
+ (in-theory (disable* env-ok-preserved-rules
+ env-ok-special-rules)))
+
+(local (in-theory (disable bfr-to-param-space)))
+
+
+(encapsulate nil
+ (defthm glcp-generic-eval-context-equiv-nil
+ (equal (glcp-generic-eval-context-equiv
+ nil a b)
+ (equal a b))
+ :hints(("Goal" :in-theory (enable glcp-generic-eval-context-equiv))))
+
+ (defthm glcp-generic-eval-context-equiv-refl
+ (glcp-generic-eval-context-equiv
+ equivs a a)
+ :hints(("Goal" :in-theory (enable glcp-generic-eval-context-equiv))))
+
+ (local (defthm glcp-generic-eval-context-equiv-chain-nil
+ (implies (and (glcp-generic-eval-context-equiv-chain
+ nil x)
+ (equal (car x) a)
+ (equal (car (last x)) b))
+ (equal (equal a b) t))
+ :hints(("Goal" :in-theory (enable glcp-generic-eval-context-equiv-chain)))))
+
+ (defthm glcp-generic-eval-context-equiv*-nil
+ (equal (glcp-generic-eval-context-equiv* nil a b)
+ (equal a b))
+ :hints (("goal" :use ((:instance glcp-generic-eval-context-equiv*-suff
+ (x a) (y b) (chain (list a)) (contexts nil)))
+ :in-theory (disable glcp-generic-eval-context-equiv*-suff)
+ :expand ((glcp-generic-eval-context-equiv* nil a b))))))
+
+(defsection iff*
+ (defund iff* (x y)
+ (iff x y))
+ (defequiv iff* :hints(("Goal" :in-theory (enable iff*))))
+ (defrefinement iff iff* :hints(("Goal" :in-theory (enable iff*))))
+ (defrefinement iff* iff :hints(("Goal" :in-theory (enable iff*))))
+
+ (defthm iff*-of-nonnils
+ (implies (and x y)
+ (equal (iff* x y) t))
+ :hints(("Goal" :in-theory (enable iff*)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+(encapsulate nil
+ (defthm glcp-generic-eval-context-equiv-iff
+ (equal (glcp-generic-eval-context-equiv
+ '(iff) a b)
+ (iff* a b))
+ :hints(("Goal" :in-theory (enable glcp-generic-eval-context-equiv))))
+
+ (local (defthmd glcp-generic-eval-context-equiv-chain-iff
+ (implies (and (glcp-generic-eval-context-equiv-chain
+ '(iff) x)
+ (equal (car x) a)
+ (equal (car (last x)) b))
+ (equal (iff* a b) t))
+ :hints(("Goal" :in-theory (enable glcp-generic-eval-context-equiv-chain)))))
+
+ (defthm glcp-generic-eval-context-equiv*-iff
+ (equal (glcp-generic-eval-context-equiv* '(iff) a b)
+ (iff* a b))
+ :hints (("goal" :use ((:instance glcp-generic-eval-context-equiv*-suff
+ (x a) (y b) (chain (list a b)) (contexts '(iff)))
+ (:instance glcp-generic-eval-context-equiv-chain-iff
+ (x (glcp-generic-eval-context-equiv*-witness
+ '(iff) a b))))
+ :in-theory (disable glcp-generic-eval-context-equiv*-suff)
+ :expand ((glcp-generic-eval-context-equiv* '(iff) a b)
+ (glcp-generic-eval-context-equiv* '(iff) a nil)
+ (glcp-generic-eval-context-equiv* '(iff) nil b))))))
+
+
+
+
+
+
+
+(defthm glcp-generic-eval-context-equiv-of-rewrites
+ (implies (and (glcp-generic-geval-ev-theoremp (acl2::rewrite-rule-term rule))
+ (not (equal (acl2::rewrite-rule->subclass rule) 'acl2::meta))
+ (glcp-generic-geval-ev (conjoin (acl2::rewrite-rule->hyps
+ rule))
+ a)
+ (proper-contextsp contexts)
+ (symbolp (acl2::rewrite-rule->equiv rule))
+ (not (eq (acl2::rewrite-rule->equiv rule) 'quote))
+ (member (acl2::rewrite-rule->equiv rule) contexts)
+ (equal lhs (glcp-generic-geval-ev
+ (acl2::rewrite-rule->lhs rule) a)))
+ (glcp-generic-eval-context-equiv
+ contexts
+ (glcp-generic-geval-ev
+ (acl2::rewrite-rule->rhs rule) a)
+ lhs))
+ :hints (("goal" :induct (len contexts)
+ :in-theory (disable acl2::rewrite-rule-term)
+ :expand ((:free (a b) (glcp-generic-eval-context-equiv contexts a
+ b))))
+ (and stable-under-simplificationp
+ '(:use ((:instance glcp-generic-geval-ev-falsify
+ (x (acl2::rewrite-rule-term rule))))
+ :in-theory (e/d ( ;; acl2::rewrite-rule->rhs
+ ;; acl2::rewrite-rule->lhs
+ ;; acl2::rewrite-rule->hyps
+ ;; acl2::rewrite-rule->equiv
+ ;; acl2::rewrite-rule->subclass
+ rewrite-rule-term-alt-def
+ glcp-generic-geval-ev-of-fncall-args)
+ (acl2::rewrite-rule-term))))))
+
+(encapsulate nil
+ (defthmd glcp-generic-eval-context-equiv*-when-equiv
+ (implies (glcp-generic-eval-context-equiv contexts x y)
+ (glcp-generic-eval-context-equiv* contexts x y))
+ :hints (("goal" :use ((:instance glcp-generic-eval-context-equiv*-suff
+ (chain (list x y))))
+ :in-theory (disable glcp-generic-eval-context-equiv*-suff))))
+
+ (local (in-theory (enable glcp-generic-eval-context-equiv*-when-equiv)))
+
+ (defthm glcp-generic-eval-context-equiv*-of-rewrites
+ (implies (and (glcp-generic-geval-ev-theoremp (acl2::rewrite-rule-term rule))
+ (not (equal (acl2::rewrite-rule->subclass rule) 'acl2::meta))
+ (glcp-generic-geval-ev (conjoin (acl2::rewrite-rule->hyps
+ rule))
+ a)
+ (proper-contextsp contexts)
+ (symbolp (acl2::rewrite-rule->equiv rule))
+ (not (eq (acl2::rewrite-rule->equiv rule) 'quote))
+ (member (acl2::rewrite-rule->equiv rule) contexts)
+ (equal lhs (glcp-generic-geval-ev
+ (acl2::rewrite-rule->lhs rule) a)))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval-ev
+ (acl2::rewrite-rule->rhs rule) a)
+ lhs))))
+
+
+(defsection bvar-db-depends-on
+ (defund-nx bvar-db-depends-on (k p n bvar-db)
+ (declare (xargs :measure (nfix n)))
+ (if (<= (nfix n) (base-bvar bvar-db))
+ nil
+ (or (gobj-depends-on k p (get-bvar->term (1- (nfix n)) bvar-db))
+ (bvar-db-depends-on k p (1- (nfix n)) bvar-db))))
+
+ (local (in-theory (enable bvar-db-depends-on)))
+ (local (include-book "centaur/misc/arith-equivs" :dir :system))
+
+ (defthm gobj-depends-on-of-get-bvar->term
+ (implies (and (<= (base-bvar bvar-db) (nfix m))
+ (not (bvar-db-depends-on k p n bvar-db))
+ (< (nfix m) (next-bvar bvar-db))
+ (< (nfix m) (nfix n)))
+ (not (gobj-depends-on k p (get-bvar->term$a m bvar-db))))))
+
+(defsection check-equiv-replacement
+
+ (local (in-theory (enable check-equiv-replacement)))
+
+ (local (defthmd context-equiv-term-when-member-equivs
+ (implies (and (glcp-generic-geval-ev (list equiv (kwote x) (kwote y)) a)
+ (symbolp equiv)
+ (not (eq equiv 'quote))
+ (member equiv contexts))
+ (glcp-generic-eval-context-equiv contexts x y))
+ :hints(("Goal" :in-theory (enable member
+ glcp-generic-eval-context-equiv
+ glcp-generic-geval-ev-of-fncall-args)))))
+
+ (local (Defthm equal-of-len
+ (implies (syntaxp (quotep y))
+ (equal (equal (len x) y)
+ (if (zp y)
+ (and (equal y 0)
+ (atom x))
+ (and (consp x)
+ (equal (len (cdr x)) (1- y))))))))
+
+ (local (include-book "arithmetic/top-with-meta" :dir :system))
+
+
+ (local (defthm check-equiv-replacement-correct1
+ (b* (((mv ok replacement negp)
+ (check-equiv-replacement x equiv-term contexts state)))
+ (implies (and (proper-contextsp contexts)
+ ok
+ (xor negp (glcp-generic-geval equiv-term env)))
+ (glcp-generic-eval-context-equiv
+ contexts
+ (glcp-generic-geval replacement env)
+ (glcp-generic-geval x env))))
+ :hints (("goal" :expand ((:with glcp-generic-geval
+ (glcp-generic-geval equiv-term env)))
+ :in-theory (enable glcp-generic-geval-list
+ glcp-generic-eval-context-equiv-commute)
+ :use ((:instance context-equiv-term-when-member-equivs
+ (equiv (g-apply->fn equiv-term))
+ (x (glcp-generic-geval (car (g-apply->args equiv-term)) env))
+ (y (glcp-generic-geval (cadr (g-apply->args equiv-term)) env))
+ (a nil)))))))
+
+ (defthmd glcp-generic-eval-context-equiv*-when-equiv
+ (implies (glcp-generic-eval-context-equiv contexts x y)
+ (glcp-generic-eval-context-equiv* contexts x y))
+ :hints (("goal" :use ((:instance glcp-generic-eval-context-equiv*-suff
+ (chain (list x y))))
+ :in-theory (disable glcp-generic-eval-context-equiv*-suff))))
+
+ (defthm check-equiv-replacement-correct
+ (b* (((mv ok replacement negp) (check-equiv-replacement x equiv-term contexts state)))
+ (implies (and (proper-contextsp contexts)
+ ok
+ (xor negp (glcp-generic-geval equiv-term env)))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval replacement env)
+ (glcp-generic-geval x env))))
+ :hints (("goal"
+ :in-theory (e/d (glcp-generic-eval-context-equiv*-when-equiv)
+ (check-equiv-replacement)))))
+
+ (defthm check-equiv-replacement-depends-on
+ (b* (((mv ok replacement) (check-equiv-replacement x equiv-term contexts state)))
+ (implies (and ok
+ (not (gobj-depends-on k p equiv-term)))
+ (not (gobj-depends-on k p replacement))))))
+
+
+(defsection try-equivalences
+ (local (in-theory (enable try-equivalences)))
+
+ (defthm try-equivalences-correct
+ (b* (((mv ok repl) (try-equivalences x bvars pathcond contexts p bvar-db state)))
+ (implies (and (bfr-eval pathcond (car env))
+ (glcp-generic-bvar-db-env-ok bvar-db p (next-bvar$a bvar-db) env)
+ ok
+ (bvar-listp bvars bvar-db)
+ (proper-contextsp contexts))
+ (glcp-generic-eval-context-equiv* contexts
+ (glcp-generic-geval repl env)
+ (glcp-generic-geval x env))))
+ :hints (("goal" :induct (try-equivalences x bvars pathcond contexts p bvar-db state)
+ :expand ((bvar-listp$a bvars bvar-db)))
+ (and stable-under-simplificationp
+ '(:use ((:instance true-under-hyp-point
+ (x (hyp-fix
+ (bfr-to-param-space
+ p (bfr-var (car bvars)))
+ pathcond))
+ (hyp pathcond)
+ (v (car env)))
+ (:instance false-under-hyp-point
+ (x (hyp-fix
+ (bfr-to-param-space
+ p (bfr-var (car bvars)))
+ pathcond))
+ (hyp pathcond)
+ (v (car env))))))))
+
+ (defthm try-equivalences-depends-on
+ (b* (((mv ok repl) (try-equivalences x bvars pathcond contexts pp bvar-db state)))
+ (implies (and ok
+ (bvar-listp bvars bvar-db)
+ (not (bvar-db-depends-on k p (next-bvar$a bvar-db) bvar-db)))
+ (not (gobj-depends-on k p repl))))
+ :hints (("goal" :induct (try-equivalences x bvars pathcond contexts pp bvar-db state)
+ :expand ((bvar-listp bvars bvar-db))))))
+
+(defsection try-equivalences-loop
+ (local (in-theory (enable try-equivalences-loop)))
+
+ (defthm try-equivalences-loop-correct
+ (b* (((mv ?er repl)
+ (try-equivalences-loop x pathcond contexts clk p bvar-db state)))
+ (implies (and (bfr-eval pathcond (car env))
+ (glcp-generic-bvar-db-env-ok bvar-db p (next-bvar$a bvar-db) env)
+ (proper-contextsp contexts))
+ (glcp-generic-eval-context-equiv* contexts
+ (glcp-generic-geval repl env)
+ (glcp-generic-geval x env))))
+ :hints (("goal" :induct (try-equivalences-loop x pathcond contexts clk p bvar-db state))
+ (and stable-under-simplificationp
+ '(:use ((:instance try-equivalences-correct
+ (bvars (get-term->equivs x bvar-db))))
+ :in-theory (disable try-equivalences-correct)))))
+
+ (defthm try-equivalences-loop-depends-on
+ (b* (((mv ?er repl) (try-equivalences-loop x pathcond contexts clk pp bvar-db state)))
+ (implies (and (not (gobj-depends-on k p x))
+ (not (bvar-db-depends-on k p (next-bvar$a bvar-db) bvar-db)))
+ (not (gobj-depends-on k p repl)))))
+
+ (defthm try-equivalences-loop-special
+ (b* (((mv ?er repl)
+ (try-equivalences-loop x pathcond contexts clk p bvar-db state)))
+ (implies (and (bfr-eval pathcond (car env))
+ (glcp-generic-bvar-db-env-ok bvar-db p (next-bvar$a bvar-db) env)
+ (proper-contextsp contexts)
+ (glcp-generic-eval-context-equiv*
+ contexts (glcp-generic-geval x env) y))
+ (glcp-generic-eval-context-equiv* contexts
+ (glcp-generic-geval repl env)
+ y)))
+ :hints(("Goal" :in-theory (e/d (glcp-generic-eval-context-equiv*-trans)
+ (try-equivalences-loop-correct))
+ :use try-equivalences-loop-correct
+ :do-not-induct t))))
+
+(defsection glcp-or-test-contexts
+ (defthmd glcp-context-equiv-of-glcp-or-test-contexts
+ (equal (glcp-generic-eval-context-equiv*
+ (glcp-or-test-contexts contexts) x y)
+ (and (hide (glcp-generic-eval-context-equiv*
+ (glcp-or-test-contexts contexts) x y))
+ (iff* x y)
+ (glcp-generic-eval-context-equiv*
+ contexts x y)))
+ :hints (("goal" :expand ((:free (x) (hide x))))))
+
+ (defthm proper-contextsp-of-glcp-or-test-contexts
+ (proper-contextsp (glcp-or-test-contexts contexts))
+ :hints(("Goal" :in-theory (e/d (glcp-generic-equiv-relp)
+ ((proper-contextsp))))))
+
+ (defthm contextsp-of-glcp-or-test-contexts
+ (contextsp (glcp-or-test-contexts contexts))))
+
+
+
+
+(defun id-on-the-way-to (id dest-id)
+ (and
+ ;; same induction step
+ (equal (car id) (car dest-id))
+ ;; case splits
+ (acl2::prefixp (cadr id) (cadr dest-id))))
+
+
+(defsection glcp-interp-accs-ok
+
+ (defund-nx glcp-interp-accs-ok (interp-st bvar-db config env)
+ (and (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (is-obligs interp-st))))
+ (glcp-generic-bvar-db-env-ok
+ bvar-db (glcp-config->param-bfr config)
+ (next-bvar bvar-db) env)))
+
+ (local (in-theory (enable glcp-interp-accs-ok)))
+
+ (def-glcp-interp-thm glcp-generic-interp-accs-ok
+ :hyps (not (glcp-interp-accs-ok interp-st bvar-db config env))
+ :body (not (glcp-interp-accs-ok interp-st1 bvar-db1 config env))
+ :hints(("Goal" :in-theory (enable* env-ok-special-rules)))
+ :no-induction-hint t)
+
+ (defthm glcp-interp-accs-ok-of-maybe-add-equiv-term
+ (equal (glcp-interp-accs-ok
+ interp-st
+ (maybe-add-equiv-term test-obj bvar bvar-db state) config env)
+ (glcp-interp-accs-ok interp-st bvar-db config env))
+ :hints(("Goal" :in-theory (enable maybe-add-equiv-term))))
+
+ (defthm glcp-interp-accs-ok-implies
+ (implies (glcp-interp-accs-ok interp-st bvar-db config env)
+ (and (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (nth *is-obligs* interp-st))))
+ (glcp-generic-bvar-db-env-ok
+ bvar-db (glcp-config->param-bfr config)
+ (next-bvar$a bvar-db) env))))
+
+ (defthm glcp-interp-accs-ok-of-add-term-bvar
+ (implies (not (glcp-interp-accs-ok interp-st bvar-db config env))
+ (not (glcp-interp-accs-ok interp-st (add-term-bvar$a x bvar-db)
+ config env))))
+
+ (defthm glcp-interp-accs-ok-env-ok-necc
+ (implies (and (glcp-interp-accs-ok interp-st bvar-db config env)
+ (<= (base-bvar$a bvar-db) (nfix n))
+ (< (nfix n) (next-bvar$a bvar-db)))
+ (iff (bfr-lookup
+ n (bfr-unparam-env (glcp-config->param-bfr config) (car env)))
+ (glcp-generic-geval (get-bvar->term$a n bvar-db) env))))
+
+ (defthm glcp-interp-accs-ok-interp-function-lookup
+ (b* (((mv erp & & out-defs)
+ (acl2::interp-function-lookup fn (nth *is-obligs* interp-st) overrides world)))
+ (implies (and (not (glcp-interp-accs-ok interp-st bvar-db config env))
+ (not erp))
+ (not (glcp-interp-accs-ok
+ (update-nth *is-obligs* out-defs interp-st)
+ bvar-db config env)))))
+
+ (defthm glcp-interp-accs-ok-interp-function-lookup-correct
+ (mv-let (erp body formals out-defs)
+ (acl2::interp-function-lookup fn (nth *is-obligs* interp-st) overrides (w state))
+ (implies (and (glcp-interp-accs-ok
+ (update-nth *is-obligs* out-defs interp-st)
+ bvar-db config env)
+ (not erp)
+ (acl2::interp-defs-alistp (nth *is-obligs* interp-st))
+ (acl2::interp-defs-alistp overrides)
+ (equal (len formals) (len actuals))
+ (not (eq fn 'quote))
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state1)
+ (equal (w state) (w state1)))
+ (equal (glcp-generic-geval-ev body (pairlis$ formals actuals))
+ (glcp-generic-geval-ev (cons fn (kwote-lst actuals))
+ nil)))))
+
+ (defthm glcp-interp-accs-ok-final-implies-start
+ (b* (((mv & & interp-st1 bvar-db1 &)
+ (glcp-generic-interp-term-equivs
+ x alist contexts pathcond clk config
+ interp-st bvar-db st)))
+ (implies (glcp-interp-accs-ok interp-st1 bvar-db1 confing env)
+ (glcp-interp-accs-ok interp-st bvar-db confing env)))
+ :hints(("Goal" :in-theory (enable* env-ok-special-rules)))
+ :rule-classes :forward-chaining))
+
+
+
+
+(local (include-book "centaur/misc/arith-equivs" :dir :system))
+(local (include-book "clause-processors/constant-prop" :dir :System))
+
+(defsection bvar-in-range
+ (defund bvar-in-range (k bvar-db)
+ (declare (Xargs :stobjs bvar-db))
+ (and (<= (base-bvar bvar-db) (nfix k))
+ (< (nfix k) (next-bvar bvar-db))))
+
+ (local (in-theory (enable bvar-in-range)))
+
+
+ (defthm maybe-add-equiv-term-bvar-in-range-preserved
+ (implies (bvar-in-range k bvar-db)
+ (bvar-in-range k (maybe-add-equiv-term
+ term bvar bvar-db state))))
+
+ (defthm maybe-add-equiv-term-bvar-in-range-preserved-fwd
+ (implies (not (bvar-in-range k (maybe-add-equiv-term
+ term bvar bvar-db state)))
+ (not (bvar-in-range k bvar-db)))
+ :rule-classes :forward-chaining)
+
+ (defthm add-term-bvar-bvar-in-range-preserved
+ (implies (bvar-in-range k bvar-db)
+ (bvar-in-range k (add-term-bvar$a term bvar-db))))
+
+ (defthm not-in-range-implies-not-equal-get-term->bvar
+ (implies (not (bvar-in-range k bvar-db))
+ (not (equal (nfix k) (get-term->bvar$a term bvar-db))))
+ :hints (("goal" :cases ((get-term->bvar$a term bvar-db)))))
+
+ (defun find-good-add-term-bvar$a-term (bvar-db calls)
+ (if (atom calls)
+ nil
+ (b* ((bdb1 (caddr (car calls)))
+ (add-term-call (acl2::find-call 'add-term-bvar$a bdb1)))
+ (if (and add-term-call
+ (equal bvar-db (caddr add-term-call)))
+ `((bvar-db1 . ,bdb1))
+ (find-good-add-term-bvar$a-term bvar-db (cdr calls))))))
+
+ (defun find-add-term-bvar$a-term (bvar-db mfc state)
+ (declare (xargs :mode :program :stobjs state)
+ (ignorable state))
+ (b* ((calls (acl2::find-calls-lst 'bvar-in-range (mfc-clause mfc))))
+ (find-good-add-term-bvar$a-term bvar-db calls)))
+
+ (defthm not-in-range-implies-not-equal-next-bvar$a-bind-free
+ (implies (and (bind-free (find-add-term-bvar$a-term bvar-db mfc state) (bvar-db1))
+ (not (bvar-in-range k bvar-db1))
+ (equal (base-bvar bvar-db) (base-bvar bvar-db1))
+ (< (next-bvar bvar-db) (next-bvar bvar-db1)))
+ (not (equal (nfix k) (next-bvar$a bvar-db))))
+ :hints (("goal" :cases ((get-term->bvar$a term bvar-db)))))
+
+
+
+ (local (in-theory (disable bvar-in-range)))
+
+ (local (in-theory (disable pseudo-termp
+ pseudo-term-listp
+ len
+ fgetprop
+ last
+ no-duplicatesp-equal
+ symbol-listp
+ general-concrete-obj-list
+ member-equal
+ default-car default-cdr
+ hons-assoc-equal)))
+
+ (def-glcp-interp-thm bvar-in-range-preserved
+ :body (implies (bvar-in-range k bvar-db)
+ (bvar-in-range k bvar-db1))
+ :expand-calls t))
+
+
+(encapsulate nil
+
+ (local (defthm gobj-alist-depends-on-nil
+ (not (gobj-alist-depends-on k p nil))))
+
+ (local (in-theory (disable pseudo-termp
+ pseudo-termp-symbolp-car-x
+ gbc-process-new-lit
+ gbc-db-emptyp-implies-no-dependencies
+ tag-when-atom
+; glcp-generic-interp-term-ok-obligs
+ (:t hyp-fix) (:t hyp-fixedp)
+ hyp-fix-of-hyp-fixedp
+ acl2::nfix-when-not-natp
+ acl2::natp-when-integerp
+ acl2::natp-rw
+ default-cdr
+ acl2::natp-when-gte-0
+ default-<-1
+ default-<-2
+ not len
+ pbfr-depends-on-t
+ acl2::cancel_plus-lessp-correct
+ acl2::cancel_plus-equal-correct
+ rationalp-implies-acl2-numberp
+ gobj-depends-on
+ glcp-or-test-contexts
+ gobj-alist-depends-on
+ acl2::cancel_times-equal-correct
+ acl2::cancel_plus-equal-correct)))
+
+
+ (local (defthm bvar-db-depends-on-of-add-term-bvar-preserved
+ (implies (and (not (bvar-db-depends-on k p n bvar-db))
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (not (bvar-db-depends-on k p n (add-term-bvar$a gobj bvar-db))))
+ :hints(("Goal" :in-theory (enable bvar-db-depends-on)))))
+
+ (local (defthm bvar-db-depends-on-of-add-term-bvar
+ (implies (and (not (bvar-db-depends-on k p (next-bvar$a bvar-db)
+ bvar-db))
+ (not (gobj-depends-on k p gobj)))
+ (not (bvar-db-depends-on k p (+ 1 (next-bvar$a bvar-db))
+ (add-term-bvar$a
+ gobj bvar-db))))
+ :hints(("Goal" :expand ((bvar-db-depends-on k p (+ 1 (next-bvar$a bvar-db))
+ (add-term-bvar$a
+ gobj bvar-db)))))))
+
+ (defthm bvar-db-depends-on-of-add-term-equiv
+ (equal (bvar-db-depends-on k p n (add-term-equiv x z bvar-db))
+ (bvar-db-depends-on k p n bvar-db))
+ :hints(("Goal" :in-theory (enable bvar-db-depends-on))))
+
+ (defthm bvar-db-depends-on-of-maybe-add-equiv-term
+ (equal (bvar-db-depends-on k p n (maybe-add-equiv-term test-obj bvar bvar-db state))
+ (bvar-db-depends-on k p n bvar-db))
+ :hints(("Goal" :in-theory (enable maybe-add-equiv-term))))
+
+ (local (in-theory (disable* (:rules-of-class :type-prescription :here))))
+ (local (in-theory (enable (:t type-of-get-term->bvar$a)
+ (:t type-of-next-bvar$a))))
+
+ (set-case-split-limitations '(2 100000))
+ (local (in-theory (disable gobj-list-depends-on
+ BFR-VARS-BOUNDED-NECC
+ gobj-vars-bounded-implies-not-depends-on
+ glcp-generic-interp-get-term->bvar-preserved-rewrite
+ fgetprop
+ len hons-assoc-equal
+ bfr-eval-booleanp
+ no-duplicatesp-equal
+ general-concrete-obj-list
+ pbfr-vars-bounded-necc)))
+
+ (def-glcp-interp-thm dependencies-of-glcp-generic-interp
+ :hyps (and ;; (not erp)
+ (not (bvar-in-range k bvar-db1))
+ (not (bfr-depends-on k p))
+ (bfr-eval p env)
+ (equal p (glcp-config->param-bfr config))
+ (not (bvar-db-depends-on k p (next-bvar$a bvar-db) bvar-db))
+ (not (gbc-db-depends-on k p (nth *is-constraint-db* interp-st))))
+ :add-bindings ((nn (next-bvar$a bvar-db1)))
+ :add-concls ((not (gbc-db-depends-on k p (nth *is-constraint-db* interp-st1)))
+ (implies (not (pbfr-depends-on k p (nth *is-constraint* interp-st)))
+ (not (pbfr-depends-on k p (nth *is-constraint*
+ interp-st1))))
+ (not (bvar-db-depends-on k p nn bvar-db1)))
+ :special
+ ((test :add-hyps (not (gobj-alist-depends-on k p alist))
+ :body (not (pbfr-depends-on k p val)))
+ (equivs :add-hyps (not (gobj-alist-depends-on k p alist))
+ :body (not (gobj-depends-on k p val)))
+ (term :add-hyps (not (gobj-alist-depends-on k p alist))
+ :body (not (gobj-depends-on k p val)))
+ (if/or :add-hyps (not (gobj-alist-depends-on k p alist))
+ :body (not (gobj-depends-on k p val)))
+ (maybe :add-hyps (not (gobj-alist-depends-on k p alist))
+ :body (not (gobj-depends-on k p val)))
+ (if :add-hyps (not (gobj-alist-depends-on k p alist))
+ :body (not (gobj-depends-on k p val)))
+ (or :add-hyps (not (gobj-alist-depends-on k p alist))
+ :body (not (gobj-depends-on k p val)))
+ (merge :add-hyps (and (not (pbfr-depends-on k p test-bfr))
+ (not (gobj-depends-on k p then))
+ (not (gobj-depends-on k p else)))
+ :body (not (gobj-depends-on k p val)))
+ (merge-sub :add-hyps (and (not (pbfr-depends-on k p test-bfr))
+ (not (gobj-depends-on k p then))
+ (not (gobj-depends-on k p else)))
+ :body (not (gobj-depends-on k p val)))
+ (merge-list :add-hyps (and (not (pbfr-depends-on k p test-bfr))
+ (not (gobj-list-depends-on k p then))
+ (not (gobj-list-depends-on k p else))
+ (equal (len then) (len else)))
+ :body (not (gobj-list-depends-on k p val))
+ :hints ('(:in-theory (enable len))))
+ (test-simp :add-hyps (not (gobj-depends-on k p test-obj))
+ :body (not (pbfr-depends-on k p val)))
+ (constraints :add-hyps (not (gobj-depends-on k p lit)))
+ (constraint-substs :add-hyps (not (gobj-alist-list-depends-on
+ k p (alist-vals substs)))
+ :hints('(:in-theory (enable
+ gobj-alist-list-depends-on
+ alist-vals))))
+ (test-simp-fncall :add-hyps (not (gobj-list-depends-on k p args))
+ :body (not (pbfr-depends-on k p val)))
+ (fncall-ifs :add-hyps (not (gobj-list-depends-on k p actuals))
+ :body (not (gobj-depends-on k p val)))
+ (maybe-fncall-ifs :add-hyps (not (gobj-list-depends-on k p actuals))
+ :body (not (gobj-depends-on k p val)))
+ (fncall :add-hyps (not (gobj-list-depends-on k p actuals))
+ :body (not (gobj-depends-on k p val))
+ :hints ('(:in-theory (enable glcp-generic-geval-ev-of-fncall-args))))
+ (rewrite :add-hyps (not (gobj-list-depends-on k p actuals))
+ :body (not (gobj-alist-depends-on k p bindings)))
+ (rules :add-hyps (not (gobj-list-depends-on k p actuals))
+ :body (not (gobj-alist-depends-on k p bindings)))
+ (rule :add-hyps (not (gobj-list-depends-on k p actuals))
+ :body (not (gobj-alist-depends-on k p bindings)))
+ (hyps :add-hyps (not (gobj-alist-depends-on k p bindings)))
+ (hyp :add-hyps (not (gobj-alist-depends-on k p bindings)))
+ (list :add-hyps (not (gobj-alist-depends-on k p alist))
+ :body (not (gobj-list-depends-on k p vals))))
+ :expand-calls t
+ :hints (;;'(:error t)
+ ;; (case-match id
+ ;; (('(0 1) '(29) . &)
+ ;; (prog2$ (cw "empty~%")
+ ;; (let ((state (f-put-global 'goals nil state)))
+ ;; (value nil))))
+ ;; (('(0 1) ('29 &) . &)
+ ;; (prog2$ (cw "cons~%")
+ ;; (let ((state (f-put-global 'goals (cons clause (@ goals))
+ ;; state)))
+ ;; (value nil))))
+ ;; (& (value nil)))
+ (let ((lit (car clause)))
+ (case-match lit
+ (('not ('acl2::flag-is . &) . &)
+ '(:computed-hint-replacement
+ ('(:expand :lambdas))
+ :clause-processor acl2::constant-prop-cp))))
+ (and stable-under-simplificationp
+ '(; :in-theory (enable acl2::expand-marked-meta)
+ :do-not-induct t
+ :do-not '(generalize)))
+ ;; (and (id-on-the-way-to id '((0 1) (29 93 95 41) . 0))
+ ;; (cw "~x0~%" (acl2::prettyify-clause clause nil (w state)))
+ ;; )
+ )))
+
+
+
+
+
+
+
+
+
+
+(defsection bvar-db-vars-bounded
+ (defund-nx bvar-db-vars-bounded (k p n bvar-db)
+ (declare (xargs :measure (nfix n)))
+ (if (<= (nfix n) (base-bvar bvar-db))
+ t
+ (and (gobj-vars-bounded k p (get-bvar->term (1- (nfix n)) bvar-db))
+ (bvar-db-vars-bounded k p (1- (nfix n)) bvar-db))))
+
+ (local (in-theory (enable bvar-db-vars-bounded)))
+
+ (defthm gobj-vars-bounded-of-get-bvar->term
+ (implies (and (<= (base-bvar bvar-db) (nfix m))
+ (bvar-db-vars-bounded k p n bvar-db)
+ (< (nfix m) (next-bvar bvar-db))
+ (< (nfix m) (nfix n)))
+ (gobj-vars-bounded k p (get-bvar->term$a m bvar-db))))
+
+ (defund-nx bvar-db-vars-bounded-witness (k p n bvar-db)
+ (declare (xargs :measure (nfix n)))
+ (if (<= (nfix n) (base-bvar bvar-db))
+ nil
+ (or (gobj-vars-bounded-witness k p (get-bvar->term (1- (nfix n)) bvar-db))
+ (bvar-db-vars-bounded-witness k p (1- (nfix n)) bvar-db))))
+
+ (defthm bvar-db-vars-bounded-witness-under-iff
+ (iff (bvar-db-vars-bounded-witness k p n bvar-db)
+ (not (bvar-db-vars-bounded k p n bvar-db)))
+ :hints(("Goal" :in-theory (enable bvar-db-vars-bounded-witness))))
+
+ (defthmd bvar-db-vars-bounded-in-terms-of-witness
+ (implies (acl2::rewriting-positive-literal
+ `(bvar-db-vars-bounded ,k ,p ,n ,bvar-db))
+ (equal (bvar-db-vars-bounded k p n bvar-db)
+ (let ((m (bvar-db-vars-bounded-witness k p n bvar-db)))
+ (or (< (nfix m) (nfix k))
+ (not (bvar-db-depends-on m p n bvar-db))))))
+ :hints(("Goal" :in-theory (enable bvar-db-vars-bounded-witness
+ bvar-db-depends-on
+ gobj-vars-bounded-in-terms-of-witness))))
+
+ (defthm bvar-db-depends-on-when-vars-bounded
+ (implies (and (bvar-db-vars-bounded k p n bvar-db)
+ (<= (nfix k) (nfix m)))
+ (not (bvar-db-depends-on m p n bvar-db)))
+ :hints(("Goal" :in-theory (enable bvar-db-vars-bounded
+ bvar-db-depends-on))))
+
+ (defthm bvar-db-vars-bounded-of-add-term-bvar-preserved
+ (implies (and (bvar-db-vars-bounded k p n bvar-db)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (bvar-db-vars-bounded k p n (add-term-bvar$a gobj bvar-db)))
+ :hints(("Goal" :in-theory (enable bvar-db-vars-bounded))))
+
+ (defthmd bvar-db-vars-bounded-incr
+ (implies (and (bvar-db-vars-bounded k p n bvar-db)
+ (<= (nfix k) (nfix m)))
+ (bvar-db-vars-bounded m p n bvar-db))
+ :hints(("Goal" :in-theory (enable bvar-db-vars-bounded-in-terms-of-witness))))
+
+ (defthm bvar-db-vars-bounded-of-add-term-bvar
+ (implies (and (bvar-db-vars-bounded k p (next-bvar$a bvar-db)
+ bvar-db)
+ (gobj-vars-bounded j p gobj)
+ (<= (nfix k) (nfix m))
+ (<= (nfix j) (nfix m)))
+ (bvar-db-vars-bounded m p (+ 1 (next-bvar$a bvar-db))
+ (add-term-bvar$a
+ gobj bvar-db)))
+ :hints(("Goal" :expand ((bvar-db-vars-bounded k p (+ 1 (next-bvar$a bvar-db))
+ (add-term-bvar$a
+ gobj bvar-db)))
+ :in-theory (enable bvar-db-vars-bounded-incr)))))
+
+
+
+
+
+(encapsulate nil
+ (local (in-theory (disable ;; glcp-generic-interp-term-ok-obligs
+ (:type-prescription hyp-fix)
+ hyp-fix-of-hyp-fixedp
+ pseudo-termp
+ pseudo-term-listp
+ acl2::interp-defs-alist-clauses
+ general-concrete-listp
+ general-concrete-obj-list
+ acl2::weak-rewrite-rule-p
+ acl2::eval-bdd
+ hons-assoc-equal
+ proper-contextsp
+ (proper-contextsp)
+ kwote-lst)))
+
+ ;; this isn't an induction, it's just based on the dependencies theorem
+ (def-glcp-interp-thm vars-bounded-of-glcp-generic-interp
+ :hyps (and ;; (not erp)
+ (<= (next-bvar$a bvar-db1) (nfix k))
+ (bfr-vars-bounded k p)
+ (bfr-eval p env)
+ (bvar-db-vars-bounded k p (next-bvar$a bvar-db) bvar-db)
+ (equal nn (next-bvar$a bvar-db1))
+ (equal p (glcp-config->param-bfr config))
+ (gbc-db-vars-bounded k p (nth *is-constraint-db* interp-st)))
+ :add-concls ((implies (pbfr-vars-bounded k p (nth *is-constraint* interp-st))
+ (pbfr-vars-bounded k p (nth *is-constraint* interp-st1)))
+ (bvar-db-vars-bounded k p nn bvar-db1)
+ (gbc-db-vars-bounded k p (nth *is-constraint-db* interp-st1)))
+ :special
+ ((test :add-hyps (gobj-alist-vars-bounded k p alist)
+ :body (pbfr-vars-bounded k p val))
+ (equivs :add-hyps (gobj-alist-vars-bounded k p alist)
+ :body (gobj-vars-bounded k p val))
+ (term :add-hyps (gobj-alist-vars-bounded k p alist)
+ :body (gobj-vars-bounded k p val))
+ (if/or :add-hyps (gobj-alist-vars-bounded k p alist)
+ :body (gobj-vars-bounded k p val))
+ (maybe :add-hyps (gobj-alist-vars-bounded k p alist)
+ :body (gobj-vars-bounded k p val))
+ (if :add-hyps (gobj-alist-vars-bounded k p alist)
+ :body (gobj-vars-bounded k p val))
+ (or :add-hyps (gobj-alist-vars-bounded k p alist)
+ :body (gobj-vars-bounded k p val))
+ (merge :add-hyps (and (pbfr-vars-bounded k p test-bfr)
+ (gobj-vars-bounded k p then)
+ (gobj-vars-bounded k p else))
+ :body (gobj-vars-bounded k p val))
+ (merge-sub :add-hyps (and (pbfr-vars-bounded k p test-bfr)
+ (gobj-vars-bounded k p then)
+ (gobj-vars-bounded k p else))
+ :body (gobj-vars-bounded k p val))
+ (merge-list :add-hyps (and (pbfr-vars-bounded k p test-bfr)
+ (gobj-list-vars-bounded k p then)
+ (gobj-list-vars-bounded k p else)
+ (equal (len then) (len else)))
+ :body (gobj-list-vars-bounded k p val))
+ (test-simp :add-hyps (gobj-vars-bounded k p test-obj)
+ :body (pbfr-vars-bounded k p val))
+
+ (test-simp-fncall :add-hyps (gobj-list-vars-bounded k p args)
+ :body (pbfr-vars-bounded k p val))
+ (constraints :add-hyps (gobj-vars-bounded k p lit))
+ (constraint-substs :add-hyps (gobj-alist-list-vars-bounded
+ k p (alist-vals substs)))
+ (fncall-ifs :add-hyps (gobj-list-vars-bounded k p actuals)
+ :body (gobj-vars-bounded k p val))
+
+ (maybe-fncall-ifs :add-hyps (gobj-list-vars-bounded k p actuals)
+ :body (gobj-vars-bounded k p val))
+
+ (fncall :add-hyps (gobj-list-vars-bounded k p actuals)
+ :body (gobj-vars-bounded k p val))
+ (rewrite :add-hyps (gobj-list-vars-bounded k p actuals)
+ :body (gobj-alist-vars-bounded k p bindings))
+ (rules :add-hyps (gobj-list-vars-bounded k p actuals)
+ :body (gobj-alist-vars-bounded k p bindings))
+ (rule :add-hyps (gobj-list-vars-bounded k p actuals)
+ :body (gobj-alist-vars-bounded k p bindings))
+ (hyps :add-hyps (gobj-alist-vars-bounded k p bindings)
+ :body (bvar-db-vars-bounded k p nn bvar-db1))
+ (hyp :add-hyps (gobj-alist-vars-bounded k p bindings)
+ :body (bvar-db-vars-bounded k p nn bvar-db1))
+ (list :add-hyps (gobj-alist-vars-bounded k p alist)
+ :body (gobj-list-vars-bounded k p vals)))
+ :hints (("goal" :in-theory (enable bvar-db-vars-bounded-in-terms-of-witness
+ gobj-vars-bounded-in-terms-of-witness
+ gobj-list-vars-bounded-in-terms-of-witness
+ gobj-alist-vars-bounded-in-terms-of-witness
+ gbc-db-vars-bounded-in-terms-of-witness
+ bvar-in-range))
+ (and stable-under-simplificationp
+ (member (caar (last clause)) '(pbfr-vars-bounded))
+ `(:expand (,(car (last clause))))))
+ :no-induction-hint t))
+
+
+
+(defthm gobj-alist-vars-bounded-of-glcp-unify-term/gobj-list
+ (implies (and (gobj-list-vars-bounded k p actuals)
+ (gobj-alist-vars-bounded k p alist))
+ (gobj-alist-vars-bounded
+ k p (mv-nth 1 (glcp-unify-term/gobj-list pat actuals alist))))
+ :hints (("goal" :in-theory (enable gobj-alist-vars-bounded-in-terms-of-witness))))
+
+
+
+
+(defthm gobj-list-vars-bounded-of-gl-args-split-ite
+ (b* (((mv ?has-if test then else)
+ (gl-args-split-ite args)))
+ (implies (gobj-list-vars-bounded k p args)
+ (and (gobj-vars-bounded k p test)
+ (gobj-list-vars-bounded k p then)
+ (gobj-list-vars-bounded k p else))))
+ :hints (("goal" :in-theory (enable gobj-vars-bounded-in-terms-of-witness
+ gobj-list-vars-bounded-in-terms-of-witness
+ gobj-alist-vars-bounded-in-terms-of-witness))))
+
+
+(encapsulate nil
+ (local (in-theory (disable pseudo-termp
+ pseudo-termp-symbolp-car-x
+ ;;glcp-generic-interp-term-ok-obligs
+ (:t hyp-fix) (:t hyp-fixedp)
+ hyp-fix-of-hyp-fixedp
+ acl2::nfix-when-not-natp
+ pbfr-vars-bounded-t
+ gbc-process-new-lit
+ glcp-or-test-contexts
+ acl2::cancel_times-equal-correct
+ acl2::cancel_plus-equal-correct)))
+
+ (defthm bvar-db-orderedp-implies-vars-bounded
+ (implies (and (bvar-db-orderedp p bvar-db)
+ (<= (next-bvar$a bvar-db) (nfix n))
+ (<= (nfix m) (next-bvar$a bvar-db)))
+ (bvar-db-vars-bounded n p m bvar-db))
+ :hints(("Goal" :in-theory (enable bvar-db-vars-bounded))))
+
+ (defthm pbfr-vars-bounded-of-bfr-not
+ (implies (pbfr-vars-bounded k p x)
+ (pbfr-vars-bounded k p (bfr-not x)))
+ :hints (("goal" :expand ((pbfr-vars-bounded k p (bfr-not x))))))
+
+ (local (defthmd gobj-vars-bounded-when-gobject-hierarchy-lite
+ (implies (gobject-hierarchy-lite x)
+ (gobj-vars-bounded k p x))
+ :hints(("Goal" :in-theory (enable gobject-hierarchy-lite
+ gobj-vars-bounded)))))
+
+ (local (in-theory (disable len default-car default-cdr bfr-eval-booleanp
+ fgetprop hons-assoc-equal)))
+
+ (defthm gobj-vars-bounded-of-general-consp-car
+ (implies (and (gobj-vars-bounded k p x)
+ (general-consp x))
+ (gobj-vars-bounded k p (general-consp-car x)))
+ :hints(("Goal" :in-theory (enable general-consp general-consp-car
+ mk-g-concrete
+ concrete-gobjectp
+ gobj-vars-bounded-when-gobject-hierarchy-lite))))
+
+ (defthm gobj-vars-bounded-of-general-consp-cdr
+ (implies (and (gobj-vars-bounded k p x)
+ (general-consp x))
+ (gobj-vars-bounded k p (general-consp-cdr x)))
+ :hints(("Goal" :in-theory (enable general-consp general-consp-cdr
+ mk-g-concrete
+ concrete-gobjectp
+ gobj-vars-bounded-when-gobject-hierarchy-lite))))
+
+ ;; (defthm bvar-db-orderedp-of-update-term-equiv
+ ;; (implies (bvar-db-orderedp p bvar-db)
+ ;; (bvar-db-orderedp p (add-term-equiv x n bvar-db)))
+ ;; :hints(("Goal" :in-theory (enable add-term-equiv))))
+
+ ;; (defthm bvar-db-orderedp-of-add-term-equiv
+ ;; (implies (bvar-db-orderedp p bvar-db)
+ ;; (bvar-db-orderedp p (add-term-equiv x n bvar-db)))
+ ;; :hints(("Goal" :in-theory (enable add-term-equiv))))
+
+ (defthm bvar-db-orderedp-of-maybe-add-equiv-term
+ (implies (bvar-db-orderedp p bvar-db)
+ (bvar-db-orderedp p (maybe-add-equiv-term x n bvar-db state)))
+ :hints(("Goal" :in-theory (enable maybe-add-equiv-term
+ add-term-equiv))
+ (and stable-under-simplificationp
+ `(:expand (,(car (last clause)))))))
+
+ (defthm bvar-db-orderedp-of-add-term->bvar
+ (implies (and (bvar-db-orderedp p bvar-db)
+ (gobj-vars-bounded (next-bvar$a bvar-db) p gobj))
+ (bvar-db-orderedp p (add-term-bvar$a gobj bvar-db)))
+ :hints((and stable-under-simplificationp
+ `(:expand (,(car (last clause)))))))
+
+
+ (def-glcp-interp-thm bvar-db-ordered-of-glcp-generic-interp
+ :body (implies (and ;; (not erp)
+ (bfr-vars-bounded k p)
+ (bfr-eval p env)
+ (bvar-db-orderedp p bvar-db)
+ (bvar-db-vars-bounded k p k bvar-db)
+ (equal p (glcp-config->param-bfr config))
+ (gbc-db-vars-bounded k p (nth *is-constraint-db* interp-st)))
+ (bvar-db-orderedp p bvar-db1))
+ :add-bindings ((k (next-bvar$a bvar-db)))
+ :special
+ ((test :add-hyps (gobj-alist-vars-bounded k p alist))
+ (equivs :add-hyps (gobj-alist-vars-bounded k p alist))
+ (term :add-hyps (gobj-alist-vars-bounded k p alist))
+ (if/or :add-hyps (gobj-alist-vars-bounded k p alist))
+ (maybe :add-hyps (gobj-alist-vars-bounded k p alist))
+ (if :add-hyps (gobj-alist-vars-bounded k p alist))
+ (or :add-hyps (gobj-alist-vars-bounded k p alist))
+ (merge :add-hyps (and (pbfr-vars-bounded k p test-bfr)
+ (gobj-vars-bounded k p then)
+ (gobj-vars-bounded k p else)))
+ (merge-sub :add-hyps (and (pbfr-vars-bounded k p test-bfr)
+ (gobj-vars-bounded k p then)
+ (gobj-vars-bounded k p else)))
+ (merge-list :add-hyps (and (pbfr-vars-bounded k p test-bfr)
+ (gobj-list-vars-bounded k p then)
+ (gobj-list-vars-bounded k p else)
+ (equal (len then) (len else)))
+ :hints ('(:in-theory (enable len))))
+ (finish-if :add-hyps (and (pbfr-vars-bounded k p test-bfr)
+ (gobj-alist-vars-bounded k p alist)))
+
+ (finish-or :add-hyps (and (pbfr-vars-bounded k p test-bfr)
+ (gobj-vars-bounded k p then-obj)
+ (gobj-alist-vars-bounded k p alist)))
+
+ (test-simp :add-hyps (gobj-vars-bounded k p test-obj)
+ :hints ((and stable-under-simplificationp
+ '(:use ((:instance gobj-vars-bounded-when-g-var
+ (x test-obj) (k 0)
+ (p (glcp-config->param-bfr config))))
+ :in-theory (disable
+ gobj-vars-bounded-when-g-var)))))
+ (test-simp-fncall :add-hyps (gobj-list-vars-bounded k p args))
+ (constraints :add-hyps (gobj-vars-bounded k p lit))
+ (constraint-substs :add-hyps (gobj-alist-list-vars-bounded
+ k p (alist-vals substs))
+ :hints ((and stable-under-simplificationp
+ '(:expand ((alist-vals substs))
+ :in-theory (enable gobj-alist-list-vars-bounded)))))
+ (fncall-ifs :add-hyps (gobj-list-vars-bounded k p actuals))
+ (maybe-fncall-ifs :add-hyps (gobj-list-vars-bounded k p actuals))
+
+ (fncall :add-hyps (gobj-list-vars-bounded k p actuals)
+ :hints ('(:in-theory (enable glcp-generic-geval-ev-of-fncall-args))))
+ (rewrite :add-hyps (gobj-list-vars-bounded k p actuals))
+ (rules :add-hyps (gobj-list-vars-bounded k p actuals))
+ (rule :add-hyps (gobj-list-vars-bounded k p actuals))
+ (hyps :add-hyps (gobj-alist-vars-bounded k p bindings))
+ (hyp :add-hyps (gobj-alist-vars-bounded k p bindings))
+ (list :add-hyps (gobj-alist-vars-bounded k p alist)))
+ :expand-calls t
+ :hints (;; (let ((lit (car clause)))
+ ;; (case-match lit
+ ;; (('not ('acl2::flag-is . &) . &)
+ ;; '(;; :computed-hint-replacement
+ ;; ;; ('(:expand :lambdas))
+ ;; :clause-processor acl2::constant-prop-cp))))
+ (and stable-under-simplificationp
+ `(,@(and (eq (caar (last clause)) 'bvar-db-orderedp)
+ `(:expand (,(car (last clause)))))
+ :in-theory (enable bvar-db-vars-bounded-incr)
+ :do-not-induct t)))))
+
+
+(encapsulate nil
+ (local (in-theory (disable ;;glcp-generic-interp-term-ok-obligs
+ (:type-prescription hyp-fix)
+ hyp-fix-of-hyp-fixedp
+ pseudo-termp
+ gbc-process-new-lit
+ glcp-or-test-contexts
+ glcp-generic-geval-general-concrete-obj-correct
+ pseudo-term-listp
+ acl2::interp-defs-alist-clauses
+ general-concrete-listp
+ general-concrete-obj-list
+ acl2::weak-rewrite-rule-p
+ acl2::eval-bdd
+ hons-assoc-equal
+ proper-contextsp
+ (proper-contextsp)
+ kwote-lst)))
+
+ (local (defthm proper-contextsp-of-iff
+ (proper-contextsp '(iff))
+ :hints(("Goal" :in-theory (enable proper-contextsp
+ glcp-generic-equiv-relp)))))
+ (local (defthm proper-contextsp-nil
+ (proper-contextsp nil)
+ :hints(("Goal" :in-theory (enable proper-contextsp
+ glcp-generic-equiv-relp)))))
+
+ (local (defthmd equal-len
+ (implies (syntaxp (quotep y))
+ (Equal (equal (len x) y)
+ (if (zp y)
+ (and (equal y 0) (atom x))
+ (and (consp x)
+ (equal (len (cdr x)) (1- y))))))))
+
+ (local (in-theory (disable* glcp-generic-geval-ev-rules len default-car
+ default-cdr
+ alistp
+ no-duplicatesp-equal
+ member-equal
+ last nonnil-symbol-listp
+ fgetprop pairlis$ subsetp-equal
+ (:rules-of-class :type-prescription :here))))
+
+ (local (in-theory (enable (:t type-of-next-bvar$a)
+ (:t type-of-base-bvar$a)
+ (:t type-of-get-term->bvar$a))))
+
+ (local (defthm len-general-concrete-obj-list
+ (equal (len (general-concrete-obj-list x))
+ (len x))
+ :hints(("Goal" :in-theory (enable general-concrete-obj-list len)))))
+
+ (local (defthmd glcp-generic-geval-of-consp
+ (implies (and (NOT (EQUAL (TAG X) :G-BOOLEAN))
+ (NOT (EQUAL (TAG X) :G-NUMBER))
+ (NOT (EQUAL (TAG X) :G-CONCRETE))
+ (NOT (EQUAL (TAG X) :G-VAR))
+ (NOT (EQUAL (TAG X) :G-ITE))
+ (NOT (EQUAL (TAG X) :G-APPLY))
+ (consp x))
+ (equal (glcp-generic-geval x env)
+ (cons (glcp-generic-geval (car x) env)
+ (glcp-generic-geval (cdr x) env))))
+ :hints(("Goal" :in-theory (enable g-keyword-symbolp)))))
+
+
+ (local (defthmd glcp-generic-geval-g-ite-p
+ (implies (equal (tag x) :g-ite)
+ (equal (glcp-generic-geval x env)
+ (if (glcp-generic-geval (g-ite->test x) env)
+ (glcp-generic-geval (g-ite->then x) env)
+ (glcp-generic-geval (g-ite->else x) env))))
+ :hints(("Goal" :in-theory (enable glcp-generic-geval)))))
+
+ (local (defthmd bfr-eval-test-when-false
+ (implies (and (not (hyp-fix x pathcond))
+ (bfr-eval pathcond (car env)))
+ (not (bfr-eval x (car env))))
+ :hints ((bfr-reasoning))))
+
+ (local (defthmd bfr-eval-test-when-true
+ (implies (and (not (hyp-fix (bfr-not x) pathcond))
+ (bfr-eval pathcond (car env)))
+ (bfr-eval x (car env)))
+ :hints ((bfr-reasoning))))
+
+ (local (defthmd bfr-eval-when-not-bfr-not
+ (implies (not (bfr-not x))
+ (bfr-eval x (car env)))
+ :hints ((bfr-reasoning))))
+
+ (local (defthmd hyp-fix-bfr-not
+ (implies (and (not (hyp-fix x pathcond))
+ (bfr-eval pathcond (car env)))
+ (hyp-fix (bfr-not x) pathcond))
+ :hints (("goal" :use (bfr-eval-test-when-true
+ bfr-eval-test-when-false)))))
+
+ (local (Defthmd car-kwote-lst
+ (implies (>= (len x) 1)
+ (equal (car (kwote-lst x))
+ (list 'quote (car x))))
+ :hints(("Goal" :in-theory (enable kwote-lst len)))))
+
+ (local (Defthmd cadr-kwote-lst
+ (implies (>= (len x) 2)
+ (equal (cadr (kwote-lst x))
+ (list 'quote (cadr x))))
+ :hints(("Goal" :in-theory (enable kwote-lst len)))))
+
+ (local (Defthmd car-glcp-generic-geval-list
+ (implies (>= (len x) 1)
+ (equal (car (glcp-generic-geval-list x env))
+ (glcp-generic-geval (car x) env)))
+ :hints(("Goal" :in-theory (enable glcp-generic-geval-list len)))))
+
+ (local (Defthmd cadr-glcp-generic-geval-list
+ (implies (>= (len x) 2)
+ (equal (cadr (glcp-generic-geval-list x env))
+ (glcp-generic-geval (cadr x) env)))
+ :hints(("Goal" :in-theory (enable glcp-generic-geval-list len)))))
+
+ (local (defthmd glcp-generic-geval-of-g-boolean
+ (equal (glcp-generic-geval (g-boolean x) env)
+ (bfr-eval x (car env)))
+ :hints(("Goal" :in-theory (enable glcp-generic-geval)))))
+
+ (local (defthm len-0
+ (equal (equal (len x) 0)
+ (not (consp x)))
+ :hints(("Goal" :in-theory (enable len)))))
+
+ (local (defthm if-test-fncall-when-quote
+ (mv-nth 1 (glcp-generic-simplify-if-test-fncall
+ 'quote args intro-bvars pathcond clk config interp-st
+ bvar-db st))
+ :hints (("goal" :expand
+ ((glcp-generic-simplify-if-test-fncall
+ 'quote args intro-bvars pathcond clk config interp-st
+ bvar-db st))))))
+
+ (local (in-theory (disable
+ GLCP-GENERIC-INTERP-FUNCTION-LOOKUP-THEOREMP-DEFS-HISTORY
+ glcp-generic-geval-ev-conjoin-clauses-atom
+ acl2::cancel_times-equal-correct
+ acl2::cancel_plus-equal-correct
+ contextsp not iff tag-when-atom proper-contextsp
+ mv-nth-cons-meta
+ bfr-eval-booleanp
+ glcp-if-or-condition
+ acl2::rewrite-rule-term
+ rewrite-rule-term-alt-def
+ len hons-assoc-equal
+ acl2::alistp-when-hons-duplicity-alist-p
+ acl2::alistp-when-esc-alist-p
+ glcp-generic-eval-context-equiv*-suff
+;glcp-if-test-contexts
+ glcp-generic-interp-bvar-db-env-ok-preserved-term
+ glcp-generic-interp-bvar-db-env-ok-preserved-maybe
+ glcp-generic-interp-bvar-db-env-ok-preserved-equivs
+ glcp-generic-interp-bvar-db-env-ok-preserved-merge
+ glcp-generic-interp-bvar-db-env-ok-preserved-test-simp
+ glcp-generic-interp-bvar-db-env-ok-preserved-test-simp-fncall
+; glcp-generic-interp-bvar-db-env-ok-preserved-fncall-ifs
+ glcp-generic-interp-bvar-db-env-ok-preserved-rewrite
+ glcp-generic-interp-bvar-db-env-ok-preserved-if/or
+ glcp-generic-interp-bvar-db-env-ok-preserved-if
+ glcp-generic-interp-bvar-db-env-ok-preserved-or
+ glcp-generic-bvar-db-env-ok-bound-decr
+ glcp-or-test-contexts)))
+
+ (local (in-theory (enable* env-ok-special-rules)))
+
+
+ (local (in-theory (disable iff)))
+
+ (defthm if*-cases
+ (and (implies x
+ (equal (if* x y z) y))
+ (implies (not x)
+ (equal (if* x y z) z))))
+
+ (local (in-theory (disable if*)))
+
+ (defthm glcp-interp-accs-ok-of-update-constraint
+ (equal (glcp-interp-accs-ok (update-nth *is-constraint* c interp-st)
+ bvar-db config env)
+ (glcp-interp-accs-ok interp-st bvar-db config env))
+ :hints(("Goal" :in-theory (enable glcp-interp-accs-ok))))
+
+ (defthm glcp-interp-accs-ok-of-update-constraint-db
+ (equal (glcp-interp-accs-ok (update-nth *is-constraint-db* cdb interp-st)
+ bvar-db config env)
+ (glcp-interp-accs-ok interp-st bvar-db config env))
+ :hints(("Goal" :in-theory (enable glcp-interp-accs-ok))))
+
+ (def-glcp-interp-thm glcp-generic-interp-correct
+ :hyps (and (bfr-eval (nth *is-constraint* interp-st) (car env))
+ (acl2::interp-defs-alistp (nth *is-obligs* interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ ;; (glcp-generic-geval-ev-theoremp
+ ;; (conjoin-clauses
+ ;; (acl2::interp-defs-alist-clauses
+ ;; (nth *is-obligs* interp-st1))))
+ ;; (glcp-generic-geval-ev-meta-extract-global-facts)
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+ ;; (glcp-generic-bvar-db-env-ok
+ ;; bvar-db1 (glcp-config->param-bfr config)
+ ;; (next-bvar$a bvar-db1) env)
+ (glcp-interp-accs-ok interp-st1 bvar-db1 config env)
+ (equal (w state0) (w st)))
+ :add-concls ((bfr-eval (nth *is-constraint* interp-st1) (car env)))
+ :special
+ ((test :add-hyps (and (pseudo-termp x)
+ (alistp alist))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (iff* (bfr-eval val (car env))
+ (glcp-generic-geval-ev x (glcp-generic-geval-alist
+ alist env)))))
+
+ (equivs :add-hyps (and (pseudo-termp x)
+ (alistp alist)
+ (proper-contextsp contexts)
+ (contextsp contexts))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval val env)
+ (glcp-generic-geval-ev x (glcp-generic-geval-alist
+ alist env)))))
+ (term :add-hyps (and (pseudo-termp x)
+ (alistp alist)
+ (proper-contextsp contexts)
+ (contextsp contexts))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval val env)
+ (glcp-generic-geval-ev x (glcp-generic-geval-alist
+ alist env))))
+ :hints ((and stable-under-simplificationp
+ '(:in-theory (enable
+ glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-ev-of-return-last-call
+ glcp-generic-geval-ev-of-if-call
+ glcp-generic-geval-ev-of-gl-ignore-call
+ glcp-generic-geval-ev-of-gl-aside-call
+ glcp-generic-geval-ev-of-lambda
+ glcp-generic-geval-ev-of-variable
+ glcp-generic-geval-ev-of-quote
+ equal-len
+ acl2::expand-marked-meta)))))
+ (if/or :add-hyps (and (pseudo-termp tbr)
+ (pseudo-termp fbr)
+ (pseudo-termp test)
+ (alistp alist)
+ (proper-contextsp contexts)
+ (contextsp contexts))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval val env)
+ (if (glcp-generic-geval-ev test (glcp-generic-geval-alist
+ alist env))
+ (glcp-generic-geval-ev tbr (glcp-generic-geval-alist
+ alist env))
+ (glcp-generic-geval-ev fbr (glcp-generic-geval-alist
+ alist env))))))
+
+
+ (maybe :add-hyps (and (pseudo-termp x)
+ (alistp alist)
+ (proper-contextsp contexts)
+ (contextsp contexts))
+ :body (implies (and (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (bfr-eval branchcond (car env)))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval val env)
+ (glcp-generic-geval-ev x (glcp-generic-geval-alist
+ alist env))))
+ :hints((and stable-under-simplificationp
+ '(:in-theory (enable bfr-eval-test-when-false)))))
+
+ (if :add-hyps (and (pseudo-termp tbr)
+ (pseudo-termp fbr)
+ (pseudo-termp test)
+ (alistp alist)
+ (proper-contextsp contexts)
+ (contextsp contexts))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval val env)
+ (if* (glcp-generic-geval-ev test (glcp-generic-geval-alist
+ alist env))
+ (glcp-generic-geval-ev tbr (glcp-generic-geval-alist
+ alist env))
+ (glcp-generic-geval-ev fbr (glcp-generic-geval-alist
+ alist env)))))
+ :hints ((prog2$ (cw "IF case~%")
+ '(:no-op t))))
+
+ (or :add-hyps (and (pseudo-termp fbr)
+ (pseudo-termp test)
+ (alistp alist)
+ (proper-contextsp contexts)
+ (contextsp contexts))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval val env)
+ (if* (glcp-generic-geval-ev test (glcp-generic-geval-alist
+ alist env))
+ (glcp-generic-geval-ev test (glcp-generic-geval-alist
+ alist env))
+ (glcp-generic-geval-ev fbr (glcp-generic-geval-alist
+ alist env)))))
+ :hints ('(:in-theory (enable glcp-context-equiv-of-glcp-or-test-contexts))))
+
+ (merge :add-hyps (and (proper-contextsp contexts)
+ (contextsp contexts))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval val env)
+ (if (bfr-eval test-bfr (car env))
+ (glcp-generic-geval then env)
+ (glcp-generic-geval else env))))
+ :hints ((and stable-under-simplificationp
+ '(:in-theory (enable glcp-generic-geval-ev-of-if-call
+ glcp-generic-geval-of-g-boolean
+ glcp-generic-geval-ev-of-quote
+ kwote-lst)))))
+
+ (merge-sub :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (equal (glcp-generic-geval val env)
+ (if (bfr-eval test-bfr (car env))
+ (glcp-generic-geval then env)
+ (glcp-generic-geval else env))))
+ :hints ((and stable-under-simplificationp
+ '(:in-theory (enable glcp-generic-geval-g-apply-p)))))
+
+ (merge-list :add-hyps (equal (len then) (len else))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (equal (glcp-generic-geval-list val env)
+ (if (bfr-eval test-bfr (car env))
+ (glcp-generic-geval-list then env)
+ (glcp-generic-geval-list else env))))
+ :hints('(:in-theory (enable len))))
+
+ (test-simp :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (iff* (bfr-eval val (car env))
+ (glcp-generic-geval test-obj env)))
+ :hints ((and stable-under-simplificationp
+ '(:expand ((:with glcp-generic-geval (glcp-generic-geval test-obj env)))
+ :in-theory (enable ;; glcp-generic-geval-of-consp
+ ;; glcp-generic-geval-g-apply-p
+ ;; glcp-generic-geval-g-ite-p
+ bfr-eval-test-when-true
+ bfr-eval-when-not-bfr-not
+ bfr-eval-test-when-false
+ glcp-generic-geval-ev-of-gl-force-check-call
+ glcp-generic-geval-ev-of-gl-force-check-strong-call
+ glcp-generic-geval-ev-of-gl-force-true-call
+ glcp-generic-geval-ev-of-gl-force-false-call
+ glcp-generic-geval-ev-of-equal-call
+ glcp-generic-geval-ev-of-not-call
+ car-glcp-generic-geval-list
+ cadr-glcp-generic-geval-list
+ car-kwote-lst
+ cadr-kwote-lst
+ glcp-generic-geval-ev-of-quote
+ hyp-fix-bfr-not
+ acl2::expand-marked-meta)))))
+
+ (test-simp-fncall
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (iff* (bfr-eval val (car env))
+ (glcp-generic-geval-ev
+ (cons fn
+ (kwote-lst (glcp-generic-geval-list args env)))
+ nil)))
+ :hints ((and stable-under-simplificationp
+ '(:expand ((:with glcp-generic-geval (glcp-generic-geval test-obj env)))
+ :in-theory (enable ;; glcp-generic-geval-of-consp
+ ;; glcp-generic-geval-g-apply-p
+ ;; glcp-generic-geval-g-ite-p
+ bfr-eval-test-when-true
+ bfr-eval-when-not-bfr-not
+ bfr-eval-test-when-false
+ glcp-generic-geval-ev-of-gl-force-check-call
+ glcp-generic-geval-ev-of-gl-force-check-strong-call
+ glcp-generic-geval-ev-of-gl-force-true-call
+ glcp-generic-geval-ev-of-gl-force-false-call
+ glcp-generic-geval-ev-of-equal-call
+ glcp-generic-geval-ev-of-not-call
+ car-glcp-generic-geval-list
+ cadr-glcp-generic-geval-list
+ car-kwote-lst
+ cadr-kwote-lst
+ glcp-generic-geval-ev-of-quote
+ hyp-fix-bfr-not
+ acl2::expand-marked-meta)))))
+ (constraints)
+ (constraint-substs)
+
+ (fncall-ifs :add-hyps (and (symbolp fn)
+ (not (eq fn 'quote))
+ (proper-contextsp contexts)
+ (contextsp contexts))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval val env)
+ (glcp-generic-geval-ev
+ (cons fn (kwote-lst (glcp-generic-geval-list actuals env)))
+ nil))))
+ (maybe-fncall-ifs :add-hyps (and (symbolp fn)
+ (not (eq fn 'quote))
+ (proper-contextsp contexts)
+ (contextsp contexts))
+ :body (implies (and (bfr-eval branchcond (car env))
+ (and (not erp)
+ (bfr-eval pathcond (car env))))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval val env)
+ (glcp-generic-geval-ev
+ (cons fn (kwote-lst (glcp-generic-geval-list actuals env)))
+ nil)))
+ :hints('(:in-theory (enable bfr-eval-test-when-false))))
+
+ (fncall :add-hyps (and (symbolp fn)
+ (not (eq fn 'quote))
+ (proper-contextsp contexts)
+ (contextsp contexts))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval val env)
+ (glcp-generic-geval-ev
+ (cons fn (kwote-lst (glcp-generic-geval-list actuals env)))
+ nil)))
+ :hints ('(:in-theory (enable glcp-generic-geval-ev-of-fncall-args))))
+ (rewrite :add-hyps (and (symbolp fn)
+ (not (eq fn 'quote))
+ (contextsp contexts)
+ (proper-contextsp contexts))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (implies successp
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval-ev term
+ (glcp-generic-geval-alist
+ bindings env))
+ (glcp-generic-geval-ev
+ (cons fn (kwote-lst (glcp-generic-geval-list
+ actuals env)))
+ nil)))))
+ (rules :add-hyps (and (symbolp fn)
+ (not (eq fn 'quote))
+ (good-rewrite-rulesp fn-rewrites)
+ (contextsp contexts)
+ (proper-contextsp contexts))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (implies successp
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval-ev term
+ (glcp-generic-geval-alist
+ bindings env))
+ (glcp-generic-geval-ev
+ (cons fn (kwote-lst (glcp-generic-geval-list
+ actuals env)))
+ nil)))))
+ (rule :add-hyps (and (symbolp fn)
+ (not (eq fn 'quote))
+ (glcp-generic-geval-ev-theoremp
+ (acl2::rewrite-rule-term rule))
+ (contextsp contexts)
+ (proper-contextsp contexts))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (implies successp
+ (glcp-generic-eval-context-equiv*
+ contexts
+ (glcp-generic-geval-ev term
+ (glcp-generic-geval-alist
+ bindings env))
+ (glcp-generic-geval-ev
+ (cons fn (kwote-lst (glcp-generic-geval-list
+ actuals env)))
+ nil))))
+ :hints((and stable-under-simplificationp
+ '(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ acl2::expand-marked-meta))))))
+ (hyps :add-hyps (and (pseudo-term-listp hyps)
+ (alistp bindings))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (implies successp
+ (glcp-generic-geval-ev
+ (conjoin hyps)
+ (glcp-generic-geval-alist bindings env)))))
+ (hyp :add-hyps (and (pseudo-termp hyp)
+ (alistp bindings))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (implies successp
+ (glcp-generic-geval-ev
+ hyp (glcp-generic-geval-alist bindings env))))
+ :hints ((and stable-under-simplificationp
+ '(:in-theory (e/d* (gtests-known-and-true))))))
+ (list :add-hyps (and (pseudo-term-listp x)
+ (alistp alist))
+ :body (implies (and (not erp)
+ (bfr-eval pathcond (car env)))
+ (equal (glcp-generic-geval-list vals env)
+ (glcp-generic-geval-ev-lst
+ x (glcp-generic-geval-alist alist
+ env))))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-lst-of-cons
+ glcp-generic-geval-ev-lst-of-atom))))))
+ :expand-calls t
+ :hints (;; '(:error t)
+ (let ((lit (car clause)))
+ (case-match lit
+ (('not ('acl2::flag-is . &) . &)
+ '(;; :computed-hint-replacement
+ ;; ('(:expand :lambdas))
+ :clause-processor acl2::constant-prop-cp))))
+ (and stable-under-simplificationp
+ '(; :in-theory (enable acl2::expand-marked-meta)
+ :do-not-induct t
+ :do-not '(generalize)))
+ ;; (and (equal id '((0 1) (49) . 0))
+ ;; (prog2$ (accumulated-persistence t)
+ ;; nil))
+ ;; (and (equal id '((0 1) (48) . 0))
+ ;; (prog2$ (show-accumulated-persistence)
+ ;; nil))
+ ;; (and (id-on-the-way-to id '((0 1) (64 2) . 0))
+ ;; '(:error t)
+ ;; ;; (cw "~x0~%" (acl2::prettyify-clause clause nil (w state)))
+ ;; )
+ )))
+
+
+
+ ;; (forall x
+ ;; (implies (get-term->bvar$a x bvar-db)
+ ;; (iff (bfr-lookup
+ ;; (get-term->bvar$a x bvar-db)
+ ;; (bfr-unparam-env (glcp-config->param-bfr config) (car env)))
+ ;; (glcp-generic-geval x env))))
+
+
+(defun bvar-db-fix-env (n min bvar-db p bfr-env var-env)
+ (declare (xargs :stobjs bvar-db
+ :measure (nfix n)
+ :guard (and (integerp n)
+ (integerp min)
+ (<= (base-bvar bvar-db) min)
+ (<= min n)
+ (<= n (next-bvar bvar-db)))))
+ (b* ((n (lnfix n))
+ (min (lnfix min))
+ ((when (mbe :logic (or (<= n (base-bvar bvar-db))
+ (<= n min))
+ :exec (int= n min))) bfr-env)
+ (n (1- n))
+ (bfr-env (bvar-db-fix-env n min bvar-db p bfr-env var-env))
+ (term (get-bvar->term n bvar-db))
+ (val (glcp-generic-geval term (cons bfr-env var-env))))
+ (bfr-param-env p
+ (bfr-set-var n val (bfr-unparam-env p bfr-env)))))
+
+(defthm bvar-db-fix-env-eval-p-lemma
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (bfr-eval p (bfr-unparam-env p (bvar-db-fix-env n min bvar-db p
+ (bfr-param-env p env)
+ var-env)))))
+
+
+;; (defthm bfr-list->s-of-set-non-dep-bounded
+;; (implies (and (pbfr-list-vars-bounded n p x)
+;; (<= (nfix n) (nfix k))
+;; (bfr-eval p env)
+;; (bfr-eval p (bfr-set-var k v env)))
+;; (equal (bfr-list->s x (bfr-param-env p (bfr-set-var k v env)))
+;; (bfr-list->s x (bfr-param-env p env)))))
+;; :hints(("Goal" :in-theory (enable pbfr-list-depends-on))))
+
+
+
+
+(defthm bfr-list->s-of-param-unparam-param-env
+ (implies (bfr-eval p env)
+ (equal (bfr-list->s x (bfr-param-env
+ p (bfr-unparam-env
+ p (bfr-param-env p env))))
+ (bfr-list->s x (bfr-param-env p env))))
+ :hints(("Goal" :in-theory (enable bfr-list->s))))
+
+(defthm bfr-list->u-of-param-unparam-param-env
+ (implies (bfr-eval p env)
+ (equal (bfr-list->u x (bfr-param-env
+ p (bfr-unparam-env
+ p (bfr-param-env p env))))
+ (bfr-list->u x (bfr-param-env p env))))
+ :hints(("Goal" :in-theory (enable bfr-list->u))))
+
+(defthm-gobj-flag
+ (defthm glcp-generic-geval-of-param-unparam-param-env
+ (implies (bfr-eval p env)
+ (equal (glcp-generic-geval x (cons (bfr-param-env
+ p (bfr-unparam-env
+ p (bfr-param-env p env)))
+ var-env))
+ (glcp-generic-geval x (cons (bfr-param-env p env)
+ var-env))))
+ :hints ('(:expand ((:free (env) (:with glcp-generic-geval (glcp-generic-geval x env))))))
+ :flag gobj)
+ (defthm glcp-generic-geval-list-of-param-unparam-param-env
+ (implies (bfr-eval p env)
+ (equal (glcp-generic-geval-list x (cons (bfr-param-env
+ p (bfr-unparam-env
+ p (bfr-param-env p env)))
+ var-env))
+ (glcp-generic-geval-list x (cons (bfr-param-env p env)
+ var-env))))
+ :hints ('(:expand ((:free (env) (glcp-generic-geval-list x env)))))
+ :flag list))
+
+
+(defthm bfr-list->s-of-unparam-param-env
+ (implies (bfr-eval p env)
+ (equal (bfr-list->s x (bfr-unparam-env
+ p (bfr-param-env p env)))
+ (bfr-list->s x env)))
+ :hints(("Goal" :in-theory (enable bfr-list->s))))
+
+(defthm bfr-list->u-of-unparam-param-env
+ (implies (bfr-eval p env)
+ (equal (bfr-list->u x (bfr-unparam-env
+ p (bfr-param-env p env)))
+ (bfr-list->u x env)))
+ :hints(("Goal" :in-theory (enable bfr-list->u))))
+
+
+(defthm-gobj-flag
+ (defthm glcp-generic-geval-of-unparam-param-env
+ (implies (bfr-eval p env)
+ (equal (glcp-generic-geval x (cons (bfr-unparam-env
+ p (bfr-param-env p env))
+ var-env))
+ (glcp-generic-geval x (cons env var-env))))
+ :hints ('(:expand ((:free (env) (:with glcp-generic-geval (glcp-generic-geval x env))))))
+ :flag gobj)
+ (defthm glcp-generic-geval-list-of-unparam-param-env
+ (implies (bfr-eval p env)
+ (equal (glcp-generic-geval-list x (cons (bfr-unparam-env
+ p (bfr-param-env p env))
+ var-env))
+ (glcp-generic-geval-list x (cons env var-env))))
+ :hints ('(:expand ((:free (env) (glcp-generic-geval-list x env)))))
+ :flag list))
+
+(defthm glcp-generic-geval-param-unparam-fix-env
+ (implies (and (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (equal (glcp-generic-geval x (cons (bfr-param-env
+ p (bfr-unparam-env
+ p (bvar-db-fix-env
+ n min bvar-db p (bfr-param-env p env)
+ var-env)))
+ var-env2))
+ (glcp-generic-geval x (cons (bvar-db-fix-env
+ n min bvar-db p (bfr-param-env p env)
+ var-env)
+ var-env2))))
+ :hints (("goal" :expand ((bvar-db-fix-env
+ n min bvar-db p (bfr-param-env p env)
+ var-env))
+ :do-not-induct t)))
+
+(defthm bfr-eval-param-unparam-fix-env
+ (implies (and (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (equal (bfr-eval x (bfr-param-env
+ p (bfr-unparam-env
+ p (bvar-db-fix-env
+ n min bvar-db p (bfr-param-env p env)
+ var-env))))
+ (bfr-eval x (bvar-db-fix-env
+ n min bvar-db p (bfr-param-env p env)
+ var-env))))
+ :hints (("goal" :expand ((bvar-db-fix-env
+ n min bvar-db p (bfr-param-env p env)
+ var-env))
+ :do-not-induct t)))
+
+
+(acl2::def-functional-instance
+ glcp-generic-geval-of-set-var-when-gobj-vars-bounded
+ generic-geval-of-set-var-when-gobj-vars-bounded
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-apply-agrees-with-glcp-generic-geval-ev)
+ (glcp-generic-geval-apply))
+ :expand ((:with glcp-generic-geval (glcp-generic-geval x env))))))
+
+(acl2::def-functional-instance
+ glcp-generic-geval-list-of-set-var-when-gobj-vars-bounded
+ generic-geval-list-of-set-var-when-gobj-vars-bounded
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-apply-agrees-with-glcp-generic-geval-ev)
+ (glcp-generic-geval-apply))
+ :expand ((:with glcp-generic-geval (glcp-generic-geval x env))))))
+
+(defthm bvar-db-fix-env-eval-gobj-vars-bounded-lemma
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (gobj-vars-bounded m p gobj)
+ (< (nfix m) (nfix n))
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env))
+ (env-m (bvar-db-fix-env m min bvar-db p (bfr-param-env p env)
+ var-env)))
+ (equal (glcp-generic-geval gobj (cons env-n var-env))
+ (glcp-generic-geval gobj (cons env-m var-env)))))
+ :hints (("goal" :induct (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env))
+ (and stable-under-simplificationp
+ '(:expand ((bvar-db-fix-env m min bvar-db p (bfr-param-env p env) var-env))))))
+
+
+(defthm bvar-db-fix-env-eval-bfr-vars-bounded-lemma
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (pbfr-vars-bounded m p x)
+ (< (nfix m) (nfix n))
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env))
+ (env-m (bvar-db-fix-env m min bvar-db p (bfr-param-env p env)
+ var-env)))
+ (equal (bfr-eval x env-n)
+ (bfr-eval x env-m))))
+ :hints (("goal" :induct (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env))
+ (and stable-under-simplificationp
+ '(:expand ((bvar-db-fix-env m min bvar-db p (bfr-param-env p env) var-env))))))
+
+(defthm bvar-db-fix-env-eval-bfr-vars-bounded-lemma-rw
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (pbfr-vars-bounded min p x)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env)))
+ (equal (bfr-eval x env-n)
+ (bfr-eval x (bfr-param-env p env)))))
+ :hints (("goal" :use ((:instance bvar-db-fix-env-eval-bfr-vars-bounded-lemma
+ (m min)))
+ :in-theory (disable bvar-db-fix-env-eval-bfr-vars-bounded-lemma)
+ :expand ((bvar-db-fix-env min min bvar-db p (bfr-param-env p env)
+ var-env)))))
+
+
+
+;; (defthm bvar-db-env-ok-of-bvar-db-fix-env-lemma
+;; (implies (and (bvar-db-orderedp p bvar-db)
+;; (bfr-eval p bfr-env)
+;; (bfr-vars-bounded min p)
+;; (<= (nfix min) (nfix m))
+;; (<= (base-bvar$a bvar-db) (nfix m))
+;; (< (nfix m) (nfix n))
+;; (<= (nfix n) (next-bvar$a bvar-db)))
+;; (let* ((bfr-env (bvar-db-fix-env n min bvar-db p
+;; (bfr-param-env p bfr-env)
+;; var-env)))
+;; (iff (bfr-lookup m (bfr-unparam-env p bfr-env))
+;; (glcp-generic-geval (get-bvar->term m bvar-db)
+;; (cons bfr-env var-env)))))
+;; :hints (("goal" :induct (bvar-db-fix-env n min bvar-db p
+;; (bfr-param-env p bfr-env)
+;; var-env))
+;; (and stable-under-simplificationp
+;; '(:use ((:instance bvar-db-orderedp-necc
+;; (n (nfix m)))
+;; (:instance bvar-db-orderedp-necc
+;; (n m)))
+;; :in-theory (disable bvar-db-orderedp-necc)))))
+
+(defthm bvar-db-env-ok-of-bvar-db-fix-env-lemma
+ (implies (and (bvar-db-orderedp p bvar-db)
+ (bfr-eval p bfr-env)
+ (bfr-vars-bounded min p)
+ (<= (base-bvar$a bvar-db) (nfix m))
+ (< (nfix m) (nfix n))
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((bfr-env1 (bvar-db-fix-env n min bvar-db p
+ (bfr-param-env p bfr-env)
+ var-env)))
+ (iff (bfr-lookup m (bfr-unparam-env p bfr-env1))
+ (if (<= (nfix min) (nfix m))
+ (glcp-generic-geval (get-bvar->term m bvar-db)
+ (cons bfr-env1 var-env))
+ (bfr-lookup m bfr-env)))))
+ :hints (("goal" :induct (bvar-db-fix-env n min bvar-db p
+ (bfr-param-env p bfr-env)
+ var-env))
+ (and stable-under-simplificationp
+ '(:use ((:instance bvar-db-orderedp-necc
+ (n (nfix m)))
+ (:instance bvar-db-orderedp-necc
+ (n m)))
+ :in-theory (disable bvar-db-orderedp-necc
+ gobj-vars-bounded-of-get-bvar->term-when-bvar-db-orderedp)))))
+
+
+(defthm bvar-db-env-ok-of-bvar-db-fix-env
+ (implies (and (bvar-db-orderedp p bvar-db)
+ (bfr-eval p bfr-env)
+ (bfr-vars-bounded (base-bvar$a bvar-db) p)
+ (<= (nfix n) (next-bvar$a bvar-db))
+ (<= nn (nfix n))
+ (equal b (base-bvar$a bvar-db)))
+ (let ((bfr-env (bvar-db-fix-env n b
+ bvar-db p
+ (bfr-param-env p bfr-env) var-env)))
+ (glcp-generic-bvar-db-env-ok bvar-db p nn (cons bfr-env var-env))))
+ :hints ((and stable-under-simplificationp
+ `(:expand (,(car (last clause)))))))
+
+
+
+
+
+
+(defthm bvar-db-env-ok-of-bvar-db-fix-env2
+ (implies (and (bvar-db-orderedp p bvar-db)
+ (bfr-eval p bfr-env)
+ (bfr-vars-bounded min p)
+ (<= (nfix n) (next-bvar$a bvar-db))
+ (<= nn (nfix n))
+ (<= (base-bvar$a bvar-db) (nfix n))
+ (glcp-generic-bvar-db-env-ok bvar-db p min
+ (cons (bfr-param-env p bfr-env)
+ var-env)))
+ (let ((bfr-env (bvar-db-fix-env n min
+ bvar-db p
+ (bfr-param-env p bfr-env) var-env)))
+ (glcp-generic-bvar-db-env-ok bvar-db p nn (cons bfr-env var-env))))
+ :hints ((and stable-under-simplificationp
+ (let* ((lit (car (last clause)))
+ (witness (cons 'glcp-generic-bvar-db-env-ok-witness (cdr lit))))
+ (prog2$ (cw "witness: ~x0~%" witness)
+ `(:computed-hint-replacement
+ ('(:use ((:instance glcp-generic-bvar-db-env-ok-necc
+ (n ,witness)
+ (env (cons (bfr-param-env p bfr-env) var-env))
+ (bound min))
+ (:instance bvar-db-fix-env-eval-gobj-vars-bounded-lemma
+ (gobj (GET-BVAR->TERM$A ,witness BVAR-DB))
+ (m min) (env bfr-env)))
+ :expand ((BVAR-DB-FIX-ENV MIN
+ MIN BVAR-DB P (BFR-PARAM-ENV P BFR-ENV)
+ VAR-ENV))
+ :in-theory (disable glcp-generic-bvar-db-env-ok-necc
+ bvar-db-fix-env-eval-gobj-vars-bounded-lemma)))
+ :expand (,lit)
+ :do-not-induct t))))))
+
+
+
+
+
+(defthm bvar-db-fix-env-eval-bfr-vars-bounded-unparam
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (pbfr-vars-bounded m t x)
+ (< (nfix m) (nfix n))
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env))
+ (env-m (bvar-db-fix-env m min bvar-db p (bfr-param-env p env)
+ var-env)))
+ (equal (bfr-eval x (bfr-unparam-env p env-n))
+ (bfr-eval x (bfr-unparam-env p env-m)))))
+ :hints (("goal" :use ((:instance bvar-db-fix-env-eval-bfr-vars-bounded-lemma
+ (x (bfr-to-param-space p x))))
+ :in-theory (disable bvar-db-fix-env-eval-bfr-vars-bounded-lemma)
+ :do-not-induct t)))
+
+(defthm bvar-db-fix-env-eval-bfr-vars-bounded-unparam-rw
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (pbfr-vars-bounded min t x)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env)))
+ (equal (bfr-eval x (bfr-unparam-env p env-n))
+ (bfr-eval x env))))
+ :hints (("goal" :use ((:instance bvar-db-fix-env-eval-bfr-vars-bounded-unparam
+ (m min)))
+ :in-theory (disable bvar-db-fix-env-eval-bfr-vars-bounded-unparam)
+ :expand ((BVAR-DB-FIX-ENV MIN MIN BVAR-DB P (BFR-PARAM-ENV P ENV)
+ VAR-ENV))
+ :do-not-induct t)))
+
+(defthm bvar-db-fix-env-eval-bfr-vars-bounded-unparam-with-no-param
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (pbfr-vars-bounded min t x)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db t env var-env)))
+ (equal (bfr-eval x env-n)
+ (bfr-eval x env))))
+ :hints (("goal" :use ((:instance bvar-db-fix-env-eval-bfr-vars-bounded-unparam-rw
+ (p t)))
+ :expand ((bfr-vars-bounded min t))
+ :in-theory (disable bvar-db-fix-env-eval-bfr-vars-bounded-unparam-rw)
+ :do-not-induct t)))
+
+
+
+(include-book "param")
+
+
+
+
+
+
+
+
+
+
+
+
+
+(acl2::def-functional-instance
+ glcp-generic-geval-gobj-to-param-space-correct-with-unparam-env
+ gobj-to-param-space-correct-with-unparam-env
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-apply-agrees-with-glcp-generic-geval-ev)
+ (glcp-generic-geval-apply))
+ :expand ((:with glcp-generic-geval (glcp-generic-geval x env))))))
+
+(acl2::def-functional-instance
+ glcp-generic-geval-gobj-list-to-param-space-correct-with-unparam-env
+ gobj-list-to-param-space-correct-with-unparam-env
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-apply-agrees-with-glcp-generic-geval-ev)
+ (glcp-generic-geval-apply))
+ :expand ((:with glcp-generic-geval (glcp-generic-geval x env))))))
+
+
+
+
+
+
+
+(defthm bvar-db-fix-env-eval-gobj-vars-bounded-unparam
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (gobj-vars-bounded m t gobj)
+ (< (nfix m) (nfix n))
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env))
+ (env-m (bvar-db-fix-env m min bvar-db p (bfr-param-env p env)
+ var-env)))
+ (equal (glcp-generic-geval gobj (cons (bfr-unparam-env p env-n) var-env))
+ (glcp-generic-geval gobj (cons (bfr-unparam-env p env-m) var-env)))))
+ :hints (("goal" :use ((:instance bvar-db-fix-env-eval-gobj-vars-bounded-lemma
+ (gobj (gobj-to-param-space gobj p))))
+ :in-theory (e/d (genv-unparam)
+ (bvar-db-fix-env-eval-gobj-vars-bounded-lemma))
+ :do-not-induct t)))
+
+(defthm bvar-db-fix-env-eval-gobj-vars-bounded-unparam-rw
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (gobj-vars-bounded min t x)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env)))
+ (equal (glcp-generic-geval x (cons (bfr-unparam-env p env-n) var-env))
+ (glcp-generic-geval x (cons env var-env)))))
+ :hints (("goal" :use ((:instance bvar-db-fix-env-eval-gobj-vars-bounded-unparam
+ (gobj x) (m min)))
+ :in-theory (disable bvar-db-fix-env-eval-gobj-vars-bounded-unparam)
+ :expand ((BVAR-DB-FIX-ENV MIN MIN BVAR-DB P (BFR-PARAM-ENV P ENV)
+ VAR-ENV))
+ :do-not-induct t)))
+
+(defthm bvar-db-fix-env-eval-gobj-vars-bounded-unparam-with-no-param
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (gobj-vars-bounded min t x)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db t env var-env)))
+ (equal (glcp-generic-geval x (cons env-n var-env))
+ (glcp-generic-geval x (cons env var-env)))))
+ :hints (("goal" :use ((:instance bvar-db-fix-env-eval-gobj-vars-bounded-unparam-rw
+ (p t)))
+ :expand ((bfr-vars-bounded min t))
+ :in-theory (disable bvar-db-fix-env-eval-gobj-vars-bounded-unparam-rw)
+ :do-not-induct t)))
+
+
+
+
+(defthm bvar-db-env-ok-of-bvar-db-fix-env2-no-param
+ (implies (and (bvar-db-orderedp t bvar-db)
+ (<= (nfix n) (next-bvar$a bvar-db))
+ (<= nn (nfix n))
+ (<= (base-bvar$a bvar-db) (nfix n))
+ (glcp-generic-bvar-db-env-ok bvar-db t min
+ (cons bfr-env var-env)))
+ (let ((bfr-env (bvar-db-fix-env n min
+ bvar-db t bfr-env var-env)))
+ (glcp-generic-bvar-db-env-ok bvar-db t nn (cons bfr-env var-env))))
+ :hints (("Goal" :use ((:instance bvar-db-env-ok-of-bvar-db-fix-env2
+ (p t)))
+ :in-theory (disable bvar-db-env-ok-of-bvar-db-fix-env2))))
+
+
+
+
+
+
+;; What's really going to happen?
+
+;; We're going to simulate the hyps under P=t. This may add some variables to
+;; the bvar-db. We get some expression H for the hyps. We translate the
+;; bvar-db to the param space of H. Then we simulate the conclusion in the
+;; param space of H. We get some expression C for the conclusion. We try to
+;; prove C. If we prove it, we have shown there is no env that is consistent
+;; with the bvar-db, satisfies (the self-parameterization of) H, and does not satisfy C.
+
+;; Now assume we have a counterexample to the original hyp => concl. We want
+;; to construct an env from this that contradicts our proof.
+
+
+
+
+;; (defund glcp-generic-interp-top-level-term
+;; (term alist pathcond clk config interp-st bvar-db state)
+;; (declare (xargs :guard (and (pseudo-termp term)
+;; (natp clk)
+;; (acl2::interp-defs-alistp obligs)
+;; (glcp-config-p config)
+;; (acl2::interp-defs-alistp (glcp-config->overrides config)))
+;; :stobjs (bvar-db state)
+;; :verify-guards nil))
+;; (b* (((glcp-er res-obj)
+;; (glcp-generic-interp-term
+;; term alist pathcond '(iff) clk config interp-st bvar-db state)))
+;; (glcp-generic-simplify-if-test res-obj pathcond clk config interp-st bvar-db
+;; state)))
+
+(defthm glcp-generic-equiv-relp-of-iff
+ (glcp-generic-equiv-relp 'iff)
+ :hints (("goal" :expand ((glcp-generic-equiv-relp 'iff)))))
+
+
+
+
+
+
+(defsection glcp-generic-interp-top-level-term
+ (local (in-theory (enable glcp-generic-interp-top-level-term)))
+
+ (defthm glcp-generic-interp-top-level-term-correct
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (bind-free
+ (if (and (consp bfr-env)
+ (eq (car bfr-env) 'bvar-db-fix-env))
+ `((env . (cons ,bfr-env ,(nth 6 bfr-env))))
+ `((free-var . free-var))))
+ (bfr-eval pathcond bfr-env)
+ (bfr-eval (is-constraint interp-st) bfr-env)
+ (not erp)
+ (acl2::interp-defs-alistp (is-obligs interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (is-obligs interp-st1))))
+ ;; (glcp-generic-geval-ev-meta-extract-global-facts)
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+ (equal p (glcp-config->param-bfr config))
+ (glcp-generic-bvar-db-env-ok
+ bvar-db1 p (next-bvar$a bvar-db1) env)
+ (equal bfr-env (car env))
+ (equal (w state0) (w state))
+ (pseudo-termp term)
+ (alistp alist))
+ (iff (bfr-eval val bfr-env)
+ (glcp-generic-geval-ev term (glcp-generic-geval-alist
+ alist env)))))
+ :hints(("Goal" :in-theory (e/d (glcp-interp-accs-ok)
+ (glcp-generic-interp-correct-term))
+ :use ((:instance glcp-generic-interp-correct-term
+ (x term) (contexts '(iff)) (st state)
+ (config (glcp-config-update-term term config)))))))
+
+ (defthm glcp-generic-interp-top-level-term-preserves-constraint
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (bind-free
+ (if (and (consp bfr-env)
+ (eq (car bfr-env) 'bvar-db-fix-env))
+ `((env . (cons ,bfr-env ,(nth 6 bfr-env))))
+ `((free-var . free-var))))
+ (bfr-eval (is-constraint interp-st) bfr-env)
+ (acl2::interp-defs-alistp (is-obligs interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (is-obligs interp-st1))))
+ ;; (glcp-generic-geval-ev-meta-extract-global-facts)
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+ (equal p (glcp-config->param-bfr config))
+ (glcp-generic-bvar-db-env-ok
+ bvar-db1 p (next-bvar$a bvar-db1) env)
+ (equal bfr-env (car env))
+ (equal (w state0) (w state))
+ (pseudo-termp term)
+ (alistp alist))
+ (bfr-eval (nth *is-constraint* interp-st1) bfr-env)))
+ :hints(("Goal" :in-theory (e/d (glcp-interp-accs-ok)
+ (glcp-generic-interp-correct-term))
+ :use ((:instance glcp-generic-interp-correct-term
+ (x term) (contexts '(iff)) (st state)
+ (config (glcp-config-update-term term config)))))))
+
+
+ (defthm w-state-preserved-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (equal (w state1) (w state))))
+
+ (defthm interp-defs-alistp-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (acl2::interp-defs-alistp (is-obligs interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (pseudo-termp term)
+ (not erp))
+ (acl2::interp-defs-alistp (nth *is-obligs* interp-st1)))))
+
+ (defthm state-p1-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (state-p1 state)
+ (state-p1 state1))))
+
+ (defthm bad-obligs-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (not (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (is-obligs interp-st)))))
+ (not erp))
+ (not (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (nth *is-obligs* interp-st1))))))))
+
+ (defthm forward-obligs-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (nth *is-obligs* interp-st1))))
+ (not erp))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (nth *is-obligs* interp-st))))))
+ :rule-classes :forward-chaining)
+
+ (defthm bvar-db-env-ok-preserved-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (<= bound (next-bvar$a bvar-db))
+ (equal p (glcp-config->param-bfr config)))
+ (equal (glcp-generic-bvar-db-env-ok bvar-db1 p bound env)
+ (glcp-generic-bvar-db-env-ok bvar-db p bound env))))
+ :hints(("Goal" :in-theory (enable glcp-generic-interp-bvar-db-env-ok-preserved-test))))
+
+ (defthm bvar-db-env-ok-next-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (not (glcp-generic-bvar-db-env-ok
+ bvar-db p (next-bvar$a bvar-db) env))
+ (equal p (glcp-config->param-bfr config)))
+ (not (glcp-generic-bvar-db-env-ok
+ bvar-db1 p (next-bvar$a bvar-db1) env))))
+ :hints(("Goal" :in-theory (enable glcp-generic-interp-bvar-db-preserved-special-test))))
+
+ (defthm base-bvar-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (equal (base-bvar$a bvar-db1) (base-bvar$a bvar-db))))
+
+ (defthm next-bvar-incr-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (>= (next-bvar$a bvar-db1) (next-bvar$a bvar-db)))
+ :rule-classes :linear)
+
+ (defthm get-bvar->term-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (<= (base-bvar$a bvar-db) (nfix n))
+ (< (nfix n) (next-bvar$a bvar-db)))
+ (equal (get-bvar->term$a n bvar-db1)
+ (get-bvar->term$a n bvar-db)))))
+
+ (defthm get-term->bvar-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (get-term->bvar$a x bvar-db)
+ (equal (get-term->bvar$a x bvar-db1)
+ (get-term->bvar$a x bvar-db)))))
+
+
+ (defthm vars-bounded-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (<= (next-bvar$a bvar-db1) (nfix k))
+ (gbc-db-vars-bounded k p (nth *is-constraint-db* interp-st))
+ (bfr-vars-bounded k p)
+ (bfr-eval p env)
+ (bvar-db-orderedp p bvar-db)
+ (equal p (glcp-config->param-bfr config))
+ (gobj-alist-vars-bounded k p alist))
+ (and (pbfr-vars-bounded k p val)
+ (gbc-db-vars-bounded k p (nth *is-constraint-db* interp-st1))))))
+
+ (defthm constraint-vars-bounded-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (<= (next-bvar$a bvar-db1) (nfix k))
+ (gbc-db-vars-bounded k p (nth *is-constraint-db* interp-st))
+ (bfr-vars-bounded k p)
+ (bfr-eval p env)
+ (bvar-db-orderedp p bvar-db)
+ (equal p (glcp-config->param-bfr config))
+ (gobj-alist-vars-bounded k p alist)
+ (pbfr-vars-bounded k p (nth *is-constraint* interp-st)))
+ (pbfr-vars-bounded k p (nth *is-constraint* interp-st1)))))
+
+ (defthm bfr-vars-bounded-of-glcp-generic-interp-top-level-no-param
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (<= (next-bvar$a bvar-db1) (nfix k))
+ (equal t (glcp-config->param-bfr config))
+ (gbc-db-vars-bounded k t (nth *is-constraint-db* interp-st))
+ (bvar-db-orderedp t bvar-db)
+ (gobj-alist-vars-bounded k t alist))
+ (bfr-vars-bounded k val)))
+ :hints (("Goal" :use ((:instance vars-bounded-of-glcp-generic-interp-top-level
+ (p t)))
+ :in-theory (disable vars-bounded-of-glcp-generic-interp-top-level))))
+
+ (defthm bvar-db-ordered-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state))
+ (k (next-bvar$a bvar-db)))
+ (implies (and (equal p (glcp-config->param-bfr config))
+ (gbc-db-vars-bounded k p (nth *is-constraint-db* interp-st))
+ (bfr-vars-bounded k p)
+ (bfr-eval p env)
+ (bvar-db-orderedp p bvar-db)
+ (gobj-alist-vars-bounded k p alist))
+ (bvar-db-orderedp p bvar-db1))))
+
+
+ (defthm fix-env-correct-of-glcp-generic-interp-top-level-no-param
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state))
+ (bfr-env1 (bvar-db-fix-env (next-bvar$a bvar-db1)
+ next-of-bvar-db
+ bvar-db1 t bfr-env var-env)))
+ (implies (and (equal t (glcp-config->param-bfr config))
+ (equal next-of-bvar-db (next-bvar$a bvar-db))
+ (gbc-db-vars-bounded
+ (next-bvar$a bvar-db) t (nth *is-constraint-db* interp-st))
+ (bvar-db-orderedp t bvar-db)
+ (gobj-alist-vars-bounded (next-bvar$a bvar-db) t alist)
+ (glcp-generic-bvar-db-env-ok
+ bvar-db t (next-bvar$a bvar-db) (cons bfr-env var-env)))
+ (glcp-generic-bvar-db-env-ok
+ bvar-db1 t (next-bvar$a bvar-db1) (cons bfr-env1 var-env))))
+ :hints(("Goal" :in-theory (disable glcp-generic-interp-top-level-term
+ bfr-eval-consts bfr-eval-booleanp)
+ :use ((:theorem (bfr-eval t env))))
+ (and stable-under-simplificationp
+ '(:in-theory (enable bfr-eval-consts)))))
+
+ (defthm fix-env-correct-of-glcp-generic-interp-top-level
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state))
+ (bfr-env1 (bvar-db-fix-env (next-bvar$a bvar-db1)
+ next-of-bvar-db
+ bvar-db1 p
+ (bfr-param-env p bfr-env)
+ var-env)))
+ (implies (and (equal p (glcp-config->param-bfr config))
+ (equal next-of-bvar-db (next-bvar$a bvar-db))
+ (bfr-vars-bounded (next-bvar$a bvar-db) p)
+ (bfr-eval p bfr-env)
+ (bvar-db-orderedp p bvar-db)
+ (gbc-db-vars-bounded
+ (next-bvar$a bvar-db) p (nth *is-constraint-db* interp-st))
+ (gobj-alist-vars-bounded (next-bvar$a bvar-db) p alist)
+ (glcp-generic-bvar-db-env-ok
+ bvar-db p (next-bvar$a bvar-db)
+ (cons (bfr-param-env p bfr-env) var-env)))
+ (glcp-generic-bvar-db-env-ok
+ bvar-db1 p (next-bvar$a bvar-db1) (cons bfr-env1 var-env))))
+ :hints(("Goal" :in-theory (disable glcp-generic-interp-top-level-term)))))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+(defthm glcp-generic-geval-alist-of-gobj-alist-to-param-space
+ (equal (glcp-generic-geval-alist (gobj-alist-to-param-space alist pathcond) env)
+ (glcp-generic-geval-alist
+ alist (genv-unparam pathcond env)))
+ :hints (("goal" :induct (gobj-alist-to-param-space alist pathcond)
+ :in-theory (enable glcp-generic-geval-alist))))
+
+(defthm glcp-generic-geval-alist-of-unparam-param-env
+ (implies (bfr-eval p env)
+ (equal (glcp-generic-geval-alist x (cons (bfr-unparam-env
+ p (bfr-param-env p env))
+ var-env))
+ (glcp-generic-geval-alist x (cons env var-env))))
+ :hints(("Goal" :in-theory (enable glcp-generic-geval-alist))))
+
+
+
+
+
+(encapsulate nil
+ (local (defthm bfr-lookup-to-param-space-with-unparam-env-rev
+ (implies (syntaxp (not (and (consp env)
+ (eq (car env) 'bfr-param-env))))
+ (equal (bfr-lookup n (bfr-unparam-env p env))
+ (bfr-eval (bfr-to-param-space p (bfr-var n)) env)))))
+
+ (local (defthm bfr-eval-to-param-space-with-unparam-env-rev
+ (implies (syntaxp (not (and (consp env)
+ (eq (car env) 'bfr-param-env))))
+ (equal (bfr-eval x (bfr-unparam-env p env))
+ (bfr-eval (bfr-to-param-space p x) env)))))
+ (local (in-theory (disable bfr-eval-to-param-space-with-unparam-env)))
+
+ (defthm bvar-db-env-ok-of-unparam-param
+ (implies (bfr-eval pathcond bfr-env)
+ (equal (glcp-generic-bvar-db-env-ok
+ bvar-db p bound (cons (bfr-unparam-env pathcond (bfr-param-env pathcond bfr-env))
+ var-env))
+ (glcp-generic-bvar-db-env-ok
+ bvar-db p bound (cons bfr-env var-env))))
+ :hints (("goal" :cases ((glcp-generic-bvar-db-env-ok
+ bvar-db p bound (cons bfr-env var-env))))
+ (and stable-under-simplificationp
+ (if (eq (caar clause) 'not)
+ `(:expand (,(car (last clause)))
+ :use ((:instance glcp-generic-bvar-db-env-ok-necc
+ (env (cons bfr-env
+ var-env))
+ (n (glcp-generic-bvar-db-env-ok-witness
+ bvar-db p bound (cons (bfr-unparam-env pathcond
+ (bfr-param-env pathcond bfr-env))
+ var-env)))))
+ :in-theory (disable glcp-generic-bvar-db-env-ok-necc))
+ `(:expand (,(car clause))
+ :use ((:instance glcp-generic-bvar-db-env-ok-necc
+ (env (cons (bfr-unparam-env pathcond
+ (bfr-param-env pathcond bfr-env))
+ var-env))
+ (n (glcp-generic-bvar-db-env-ok-witness
+ bvar-db p bound (cons bfr-env var-env)))))
+ :in-theory (disable glcp-generic-bvar-db-env-ok-necc)))))))
+
+
+
+
+(defsection parametrize-bvar-db
+ (local (in-theory (enable parametrize-bvar-db parametrize-bvar-db-aux)))
+ (local (include-book "arithmetic/top-with-meta" :dir :system))
+ (defthm get-bvar->term-of-parametrize-bvar-db-aux
+ (implies (and (<= (base-bvar$a bvar-db1) (nfix m))
+ (< (nfix m) (+ (next-bvar$a bvar-db1)
+ (- (next-bvar$a bvar-db) (nfix n)))))
+ (equal (get-bvar->term$a m (parametrize-bvar-db-aux n p bvar-db bvar-db1))
+ (if (<= (next-bvar$a bvar-db1) (nfix m))
+ (gobj-to-param-space
+ (get-bvar->term$a (+ (- (nfix m) (next-bvar$a bvar-db1))
+ (nfix n))
+ bvar-db)
+ p)
+ (get-bvar->term$a m bvar-db1)))))
+
+ (defthm base-bvar-of-parametrize-bvar-db-aux
+ (equal (base-bvar$a (parametrize-bvar-db-aux n p bvar-db bvar-db1))
+ (base-bvar$a bvar-db1)))
+
+ (defthm next-bvar-of-parametrize-bvar-db-aux
+ (equal (next-bvar$a (parametrize-bvar-db-aux n p bvar-db bvar-db1))
+ (+ (nfix (- (next-bvar$a bvar-db) (nfix n))) (next-bvar$a bvar-db1))))
+
+
+ (defthm normalize-parametrize-bvar-db
+ (implies (syntaxp (not (equal bvar-db1 ''nil)))
+ (equal (parametrize-bvar-db p bvar-db bvar-db1)
+ (parametrize-bvar-db p bvar-db nil))))
+
+ (defthm base-bvar-of-parametrize-bvar-db
+ (equal (base-bvar$a (parametrize-bvar-db p bvar-db bvar-db1))
+ (base-bvar$a bvar-db)))
+
+ (defthm next-bvar-of-parametrize-bvar-db
+ (equal (next-bvar$a (parametrize-bvar-db p bvar-db bvar-db1))
+ (next-bvar$a bvar-db)))
+
+ (defthm get-bvar->term-of-parametrize-bvar-db
+ (implies (and (<= (base-bvar$a bvar-db) (nfix n))
+ (< (nfix n) (next-bvar$a bvar-db)))
+ (equal (get-bvar->term$a n (parametrize-bvar-db p bvar-db bvar-db1))
+ (gobj-to-param-space
+ (get-bvar->term$a n bvar-db) p))))
+
+ (defthm bvar-db-orderedp-of-parametrize-bvar-db
+ (implies (bvar-db-orderedp t bvar-db)
+ (bvar-db-orderedp p (parametrize-bvar-db p bvar-db bvar-db1)))
+ :hints (("goal" :expand ((bvar-db-orderedp p (parametrize-bvar-db p bvar-db nil)))
+ :in-theory (disable parametrize-bvar-db))))
+
+ (defthm glcp-generic-bvar-db-env-ok-of-parametrize-bvar-db
+ (equal (glcp-generic-bvar-db-env-ok
+ (parametrize-bvar-db p bvar-db bvar-db1)
+ p bound env)
+ (glcp-generic-bvar-db-env-ok
+ bvar-db t bound
+ (cons (bfr-unparam-env p (car env)) (cdr env))))
+ :hints (("goal" :cases ((glcp-generic-bvar-db-env-ok
+ bvar-db t bound
+ (cons (bfr-unparam-env p (car env)) (cdr env)))))
+ (and stable-under-simplificationp
+ (let* ((lit (if (eq (caar clause) 'not)
+ (car (last clause))
+ (car clause)))
+ (other (if (eq (caar clause) 'not)
+ (cadar clause)
+ (cadar (last clause))))
+ (witness (cons 'glcp-generic-bvar-db-env-ok-witness
+ (cdr lit))))
+ `(:expand (,lit)
+ :in-theory (enable genv-unparam)
+ :use ((:instance glcp-generic-bvar-db-env-ok-necc
+ (n ,witness)
+ (p ,(third other))
+ (env ,(nth 4 other))))))))))
+
+
+
+;; ;; bvar-db1 is the real bvar-db from the hyp, bvar-db is initially empty
+;; (defund glcp-generic-interp-concl
+;; (term alist pathcond clk config interp-st bvar-db1 bvar-db state)
+;; (declare (xargs :guard (and (pseudo-termp term)
+;; (natp clk)
+;; (acl2::interp-defs-alistp obligs)
+;; (glcp-config-p config)
+;; (acl2::interp-defs-alistp (glcp-config->overrides config)))
+;; :stobjs (bvar-db bvar-db1 state)
+;; :verify-guards nil))
+;; (b* ((al (gobj-alist-to-param-space alist pathcond))
+;; (bvar-db (init-bvar-db (base-bvar bvar-db1) bvar-db))
+;; (bvar-db (parametrize-bvar-db pathcond bvar-db1 bvar-db))
+;; (config (glcp-config-update-param pathcond config))
+;; (pathcond1 (bfr-to-param-space pathcond pathcond)))
+;; (glcp-generic-interp-top-level-term
+;; term al pathcond1 clk config interp-st bvar-db state)))
+
+
+(defsection glcp-generic-interp-concl
+ (local (in-theory (enable glcp-generic-interp-concl)))
+ (local (set-default-hints '('(:do-not-induct t))))
+
+ (defthm glcp-generic-interp-concl-norm
+ (implies (syntaxp (not (equal bvar-db ''nil)))
+ (equal (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 nil state))))
+
+ (defthm glcp-generic-interp-concl-correct
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (and (bind-free
+ (if (and (consp bfr-env)
+ (eq (car bfr-env) 'bvar-db-fix-env))
+ `((env . (cons ,bfr-env ,(nth 6 bfr-env))))
+ `((free-var . free-var))))
+ (bfr-eval pathcond (bfr-unparam-env pathcond bfr-env))
+ (bfr-eval (is-constraint interp-st) (bfr-unparam-env pathcond bfr-env))
+ (not erp)
+ (acl2::interp-defs-alistp (is-obligs interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (is-obligs interp-st1))))
+ ;; (glcp-generic-geval-ev-meta-extract-global-facts)
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+ (glcp-generic-bvar-db-env-ok
+ bvar-db2 pathcond (next-bvar$a bvar-db2)
+ env)
+ (consp env)
+ (equal (car env) bfr-env)
+ (equal (w state0) (w state))
+ (pseudo-termp term)
+ (alistp alist))
+ (iff (bfr-eval val bfr-env)
+ (glcp-generic-geval-ev
+ term (glcp-generic-geval-alist
+ alist
+ (cons (bfr-unparam-env pathcond (car env))
+ (cdr env)))))))
+ :hints(("Goal" :in-theory (enable genv-unparam)
+ :do-not-induct t))
+ :otf-flg t)
+
+ (defthm glcp-generic-interp-concl-constraint-preserved
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (and (bind-free
+ (if (and (consp bfr-env)
+ (eq (car bfr-env) 'bvar-db-fix-env))
+ `((env . (cons ,bfr-env ,(nth 6 bfr-env))))
+ `((free-var . free-var))))
+ (bfr-eval (is-constraint interp-st) (bfr-unparam-env pathcond bfr-env))
+ (acl2::interp-defs-alistp (is-obligs interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (is-obligs interp-st1))))
+ ;; (glcp-generic-geval-ev-meta-extract-global-facts)
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+ (glcp-generic-bvar-db-env-ok
+ bvar-db2 pathcond (next-bvar$a bvar-db2)
+ env)
+ (consp env)
+ (equal (car env) bfr-env)
+ (equal (w state0) (w state))
+ (pseudo-termp term)
+ (alistp alist))
+ (bfr-eval (nth *is-constraint* interp-st1) bfr-env)))
+ :hints(("Goal" :in-theory (enable genv-unparam)
+ :do-not-induct t))
+ :otf-flg t)
+
+ (defthm w-state-preserved-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (equal (w state1) (w state))))
+
+ (defthm interp-defs-alistp-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (and (acl2::interp-defs-alistp (nth *is-obligs* interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (pseudo-termp term)
+ (not erp))
+ (acl2::interp-defs-alistp (nth *is-obligs* interp-st1)))))
+
+ (defthm state-p1-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (state-p1 state)
+ (state-p1 state1))))
+
+ (defthm bad-obligs-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (and (not (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (nth *is-obligs* interp-st)))))
+ (not erp))
+ (not (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (nth *is-obligs* interp-st1))))))))
+
+ (defthm forward-obligs-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (and (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (nth *is-obligs* interp-st1))))
+ (not erp))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (nth *is-obligs* interp-st))))))
+ :rule-classes :forward-chaining)
+
+ (defthm bvar-db-env-ok-preserved-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (and (<= bound (next-bvar$a bvar-db1))
+ (bfr-eval pathcond (car env))
+ (glcp-generic-bvar-db-env-ok bvar-db1 t bound
+ (cons (bfr-unparam-env pathcond (car env))
+ (cdr env))))
+ (glcp-generic-bvar-db-env-ok bvar-db2 pathcond bound env))))
+
+ (defthm bvar-db-env-ok-next-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (and (not (glcp-generic-bvar-db-env-ok
+ (parametrize-bvar-db pathcond bvar-db1 nil)
+ pathcond (next-bvar$a bvar-db1)
+ env)))
+ (not (glcp-generic-bvar-db-env-ok
+ bvar-db2 pathcond (next-bvar$a bvar-db2) env)))))
+
+ (defthm bvar-db-env-ok-next-of-glcp-generic-interp-concl-forward
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (glcp-generic-bvar-db-env-ok
+ bvar-db2 pathcond (next-bvar$a bvar-db2) env)
+ (glcp-generic-bvar-db-env-ok
+ bvar-db1
+ t (next-bvar$a bvar-db1)
+ (cons (bfr-unparam-env pathcond (car env))
+ (cdr env)))))
+ :rule-classes :forward-chaining)
+
+ (defthm base-bvar-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (equal (base-bvar$a bvar-db2) (base-bvar$a bvar-db1))))
+
+ (defthm next-bvar-incr-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (>= (next-bvar$a bvar-db2) (next-bvar$a bvar-db1)))
+ :rule-classes :linear)
+
+ (defthm get-bvar->term-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (and (<= (base-bvar$a bvar-db1) (nfix n))
+ (< (nfix n) (next-bvar$a bvar-db1)))
+ (equal (get-bvar->term$a n bvar-db2)
+ (gobj-to-param-space (get-bvar->term$a n bvar-db1)
+ pathcond)))))
+
+ ;; (defthm get-term->bvar-of-glcp-generic-interp-concl
+ ;; (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ ;; (glcp-generic-interp-concl
+ ;; term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ ;; (implies (get-term->bvar$a x bvar-db)
+ ;; (equal (get-term->bvar$a x bvar-db1)
+ ;; (get-term->bvar$a x bvar-db)))))
+
+
+ (defthm vars-bounded-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (and (<= (next-bvar$a bvar-db2) (nfix k))
+ (bfr-vars-bounded k pathcond)
+ (bfr-eval pathcond env)
+ (bvar-db-orderedp t bvar-db1)
+ (gbc-db-vars-bounded k t (nth *is-constraint-db* interp-st))
+ (gobj-alist-vars-bounded k t alist))
+ (and (pbfr-vars-bounded k pathcond val)
+ (gbc-db-vars-bounded k pathcond (nth *is-constraint-db* interp-st1))))))
+
+ (defthm constraint-vars-bounded-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state)))
+ (implies (and (<= (next-bvar$a bvar-db2) (nfix k))
+ (bfr-vars-bounded k pathcond)
+ (bfr-eval pathcond env)
+ (bvar-db-orderedp t bvar-db1)
+ (gbc-db-vars-bounded k t (nth *is-constraint-db* interp-st))
+ (gobj-alist-vars-bounded k t alist)
+ (pbfr-vars-bounded k t (nth *is-constraint* interp-st)))
+ (pbfr-vars-bounded k pathcond (nth *is-constraint* interp-st1)))))
+
+ (defthm bvar-db-ordered-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state))
+ (k (next-bvar$a bvar-db1)))
+ (implies (and (bfr-vars-bounded k pathcond)
+ (bfr-eval pathcond env)
+ (bvar-db-orderedp t bvar-db1)
+ (gbc-db-vars-bounded k t (nth *is-constraint-db* interp-st))
+ (gobj-alist-vars-bounded k t alist))
+ (bvar-db-orderedp pathcond bvar-db2))))
+
+
+ ;; (defthm fix-env-correct-of-glcp-generic-interp-concl-no-param
+ ;; (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ ;; (glcp-generic-interp-concl
+ ;; term alist pathcond clk config interp-st bvar-db1 bvar-db state))
+ ;; (bfr-env1 (bvar-db-fix-env (next-bvar$a bvar-db1)
+ ;; (next-bvar$a bvar-db)
+ ;; bvar-db1 t bfr-env var-env)))
+ ;; (implies (and (equal t (glcp-config->param-bfr config))
+ ;; (bvar-db-orderedp t bvar-db)
+ ;; (gobj-alist-vars-bounded (next-bvar$a bvar-db) t alist)
+ ;; (glcp-generic-bvar-db-env-ok
+ ;; bvar-db t (next-bvar$a bvar-db) (cons bfr-env var-env)))
+ ;; (glcp-generic-bvar-db-env-ok
+ ;; bvar-db1 t (next-bvar$a bvar-db1) (cons bfr-env1 var-env))))
+ ;; :hints(("Goal" :in-theory (disable glcp-generic-interp-concl
+ ;; bfr-eval-consts bfr-eval-booleanp)
+ ;; :use ((:theorem (bfr-eval t env))))
+ ;; (and stable-under-simplificationp
+ ;; '(:in-theory (enable bfr-eval-consts)))))
+
+ (defthm fix-env-correct-of-glcp-generic-interp-concl
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db2 ?state1)
+ (glcp-generic-interp-concl
+ term alist pathcond clk config interp-st bvar-db1 bvar-db state))
+ (bfr-env1 (bvar-db-fix-env (next-bvar$a bvar-db2)
+ (next-bvar$a bvar-db1)
+ bvar-db2 pathcond
+ (bfr-param-env pathcond bfr-env)
+ var-env)))
+ (implies (and (bfr-vars-bounded (next-bvar$a bvar-db1) pathcond)
+ (bfr-eval pathcond bfr-env)
+ (bvar-db-orderedp t bvar-db1)
+ (gobj-alist-vars-bounded (next-bvar$a bvar-db1) t alist)
+ (glcp-generic-bvar-db-env-ok
+ bvar-db1 t (next-bvar$a bvar-db1)
+ (cons bfr-env var-env))
+ (gbc-db-vars-bounded (next-bvar$a bvar-db1) t (nth *is-constraint-db* interp-st)))
+ (glcp-generic-bvar-db-env-ok
+ bvar-db2 pathcond (next-bvar$a bvar-db2) (cons bfr-env1 var-env))))
+ :hints (("goal" :do-not-induct t))))
+
+
+
+
+
+
+
+
+
+
+
+(defthm bvar-db-fix-env-eval-gobj-alist-vars-bounded-no-param
+ (implies (and (gobj-alist-vars-bounded min t x)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let ((env-n (bvar-db-fix-env
+ n min bvar-db t env var-env)))
+ (equal (glcp-generic-geval-alist x (cons env-n var-env))
+ (glcp-generic-geval-alist x (cons env var-env)))))
+ :hints(("Goal" :in-theory (enable glcp-generic-geval-alist))))
+
+
+(defthm bvar-db-fix-env-eval-gobj-alist-vars-bounded-unparam-rw
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (gobj-alist-vars-bounded min t x)
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env)))
+ (equal (glcp-generic-geval-alist x (cons (bfr-unparam-env p env-n) var-env))
+ (glcp-generic-geval-alist x (cons env var-env)))))
+ :hints(("Goal" :in-theory (enable glcp-generic-geval-alist))))
+
+
+(defthm bvar-db-fix-env-eval-gobj-vars-bounded-param-rw
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (gobj-vars-bounded min p gobj)
+ (< (nfix min) (nfix n))
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env)))
+ (equal (glcp-generic-geval gobj (cons env-n var-env))
+ (glcp-generic-geval gobj (cons (bfr-param-env p env) var-env)))))
+ :hints (("goal" :use ((:instance bvar-db-fix-env-eval-gobj-vars-bounded-lemma
+ (m min)))
+ :expand ((bvar-db-fix-env min min bvar-db p (bfr-param-env p env)
+ var-env))
+ :in-theory (disable bvar-db-fix-env-eval-gobj-vars-bounded-lemma))))
+
+(defthm bvar-db-fix-env-eval-gobj-alist-vars-bounded-param-rw
+ (implies (and ; (bvar-db-orderedp p bvar-db)
+ (bfr-eval p env)
+ (bfr-vars-bounded min p)
+ (gobj-alist-vars-bounded min p x)
+ (< (nfix min) (nfix n))
+ (<= (nfix n) (next-bvar$a bvar-db)))
+ (let* ((env-n (bvar-db-fix-env n min bvar-db p (bfr-param-env p env)
+ var-env)))
+ (equal (glcp-generic-geval-alist x (cons env-n var-env))
+ (glcp-generic-geval-alist x (cons (bfr-param-env p env) var-env)))))
+ :hints(("Goal" :in-theory (enable glcp-generic-geval-alist))))
+
+
+
+(defthm bvar-db-env-ok-of-init-bvar-db
+ (glcp-generic-bvar-db-env-ok (init-bvar-db$a base bvar-db) p bound env)
+ :hints(("Goal" :in-theory (enable glcp-generic-bvar-db-env-ok))))
+
+
+
+;; (defund glcp-generic-interp-hyp/concl
+;; (hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)
+;; (declare (xargs :guard (and (pseudo-termp hyp)
+;; (pseudo-termp concl)
+;; (natp clk)
+;; (acl2::interp-defs-alistp obligs)
+;; (glcp-config-p config)
+;; (acl2::interp-defs-alistp (glcp-config->overrides config)))
+;; :stobjs (bvar-db bvar-db1 state)
+;; :verify-guards nil))
+;; (b* ((bvar-db (init-bvar-db next-bvar bvar-db))
+;; (bvar-db1 (init-bvar-db next-bvar bvar-db1))
+;; (config (glcp-config-update-param t config))
+;; ((mv er obligs hyp-bfr bvar-db state)
+;; (glcp-generic-interp-top-level-term
+;; hyp alist t clk config interp-st bvar-db state))
+;; ((when er)
+;; (mv er obligs hyp-bfr nil bvar-db bvar-db1 state))
+;; ((when (not hyp-bfr))
+;; (mv "Hypothesis is not satisfiable"
+;; obligs hyp-bfr nil bvar-db bvar-db1 state))
+;; ((mv er obligs concl-bfr bvar-db1 state)
+;; (glcp-generic-interp-concl
+;; concl alist hyp-bfr clk config interp-st bvar-db bvar-db1 state)))
+;; (mv er obligs hyp-bfr concl-bfr bvar-db bvar-db1 state)))
+
+(defund-nx glcp-generic-interp-hyp/concl-env
+ (env hyp concl alist clk config interp-st next-bvar state)
+ (b* ((bvar-db (init-bvar-db next-bvar nil))
+ (bvar-db1 (init-bvar-db next-bvar nil))
+ (config (glcp-config-update-param t config))
+ ((mv hyp-bfr ?er ?interp-st bvar-db1 state)
+ (glcp-generic-interp-top-level-term
+ hyp alist t clk config interp-st bvar-db1 state))
+ (bfr-env1 (bvar-db-fix-env (next-bvar bvar-db1)
+ next-bvar bvar-db1 t
+ (car env) (cdr env)))
+ ((unless (glcp-generic-geval-ev
+ hyp (glcp-generic-geval-alist alist env)))
+ bfr-env1)
+ ((mv ?concl-bfr ?er ?obligs bvar-db state)
+ (glcp-generic-interp-concl
+ concl alist hyp-bfr clk config interp-st bvar-db1 nil state)))
+ (bvar-db-fix-env (next-bvar bvar-db)
+ (next-bvar bvar-db1)
+ bvar-db hyp-bfr
+ (bfr-param-env hyp-bfr bfr-env1)
+ (cdr env))))
+
+
+
+(defsection glcp-generic-interp-hyp/concl
+ (local (in-theory (enable glcp-generic-interp-hyp/concl
+ glcp-generic-interp-hyp/concl-env)))
+
+ (defthm glcp-generic-interp-hyp/concl-norm
+ (implies (syntaxp (not (and (equal bvar-db ''nil)
+ (equal bvar-db1 ''nil))))
+ (equal (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar nil nil state))))
+
+ (defthm glcp-generic-interp-hyp/concl-correct
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (implies (and (not erp)
+ (bfr-eval (nth *is-constraint* interp-st)
+ (bfr-unparam-env hyp-bfr bfr-env))
+ (acl2::interp-defs-alistp (nth *is-obligs* interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (nth *is-obligs* interp-st1))))
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+ (glcp-generic-bvar-db-env-ok
+ concl-bvar-db hyp-bfr (next-bvar$a concl-bvar-db) env)
+ (consp env)
+ (equal bfr-env (car env))
+ (equal (w state0) (w state))
+ (pseudo-termp hyp)
+ (pseudo-termp concl)
+ (alistp alist))
+ (and (iff (bfr-eval hyp-bfr (bfr-unparam-env hyp-bfr bfr-env))
+ (glcp-generic-geval-ev
+ hyp
+ (glcp-generic-geval-alist
+ alist (cons (bfr-unparam-env hyp-bfr (car env))
+ (cdr env)))))
+ (implies (bfr-eval hyp-bfr (bfr-unparam-env hyp-bfr bfr-env))
+ (iff (bfr-eval concl-bfr bfr-env)
+ (glcp-generic-geval-ev
+ concl
+ (glcp-generic-geval-alist
+ alist (cons (bfr-unparam-env hyp-bfr (car env))
+ (cdr env)))))))))
+ :hints(("Goal" :in-theory (e/d (genv-unparam))
+ :do-not-induct t)))
+
+ (defthm w-state-preserved-of-glcp-generic-interp-hyp/concl
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (equal (w state1) (w state))))
+
+ (defthm interp-defs-alistp-of-glcp-generic-interp-hyp/concl
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (implies (and (acl2::interp-defs-alistp (nth *is-obligs* interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (pseudo-termp hyp)
+ (pseudo-termp concl)
+ (not erp))
+ (acl2::interp-defs-alistp (nth *is-obligs* interp-st1)))))
+
+ (defthm state-p1-of-glcp-generic-interp-hyp/concl
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (implies (state-p1 state)
+ (state-p1 state1))))
+
+ (defthm bad-obligs-of-glcp-generic-interp-hyp/concl
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (implies (and (not (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (nth *is-obligs* interp-st)))))
+ (not erp))
+ (not (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (nth *is-obligs* interp-st1))))))))
+
+ (defthm forward-obligs-of-glcp-generic-interp-hyp/concl
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (implies (and (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (nth *is-obligs* interp-st1))))
+ (not erp))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses (nth *is-obligs* interp-st))))))
+ :rule-classes :forward-chaining)
+
+ ;; (defthm bvar-db-env-ok-preserved-of-glcp-generic-interp-hyp/concl
+ ;; (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ ;; (glcp-generic-interp-hyp/concl
+ ;; hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ ;; (implies (and (<= bound (next-bvar$a bvar-db))
+ ;; (equal p (glcp-config->param-bfr config)))
+ ;; (equal (glcp-generic-bvar-db-env-ok bvar-db1 p bound env)
+ ;; (glcp-generic-bvar-db-env-ok bvar-db p bound env)))))
+
+ ;; (defthm bvar-db-env-ok-next-of-glcp-generic-interp-hyp/concl
+ ;; (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ ;; (glcp-generic-interp-hyp/concl
+ ;; hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ ;; (implies (and (not (glcp-generic-bvar-db-env-ok
+ ;; bvar-db p (next-bvar$a bvar-db) env))
+ ;; (equal p (glcp-config->param-bfr config)))
+ ;; (not (glcp-generic-bvar-db-env-ok
+ ;; bvar-db1 p (next-bvar$a bvar-db1) env)))))
+
+ (defthm base-bvar-of-glcp-generic-interp-hyp/concl
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (and (equal (base-bvar$a hyp-bvar-db) (nfix next-bvar))
+ (equal (base-bvar$a concl-bvar-db) (nfix next-bvar)))))
+
+ (defthm next-bvar-incr-of-glcp-generic-interp-hyp/concl-hyp
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (>= (next-bvar$a hyp-bvar-db) (nfix next-bvar)))
+ :rule-classes :linear)
+
+ (defthm next-bvar-incr-of-glcp-generic-interp-hyp/concl-concl
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (>= (next-bvar$a concl-bvar-db) (nfix next-bvar)))
+ :rule-classes :linear)
+
+ (defthm get-bvar->term-of-glcp-generic-interp-hyp/concl
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (implies (and (<= (base-bvar$a hyp-bvar-db) (nfix n))
+ (< (nfix n) (next-bvar$a hyp-bvar-db))
+ (not erp))
+ (equal (get-bvar->term$a n concl-bvar-db)
+ (gobj-to-param-space (get-bvar->term$a n hyp-bvar-db)
+ hyp-bfr)))))
+
+ ;; (defthm get-term->bvar-of-glcp-generic-interp-hyp/concl
+ ;; (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ ;; (glcp-generic-interp-hyp/concl
+ ;; hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ ;; (implies (get-term->bvar$a x bvar-db)
+ ;; (equal (get-term->bvar$a x bvar-db1)
+ ;; (get-term->bvar$a x bvar-db)))))
+
+
+ (defthm vars-bounded-of-glcp-generic-interp-hyp/concl-hyp
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (implies (and (<= (next-bvar$a hyp-bvar-db) (nfix k))
+ (gobj-alist-vars-bounded k t alist)
+ (gbc-db-vars-bounded k t (nth *is-constraint-db* interp-st)))
+ (pbfr-vars-bounded k t hyp-bfr)))
+ :hints (("goal" :use ((:instance bfr-eval-consts))
+ :in-theory (disable bfr-eval-consts bfr-eval-booleanp))))
+
+ (defthm vars-bounded-of-glcp-generic-interp-hyp/concl-concl
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (implies (and (<= (next-bvar$a concl-bvar-db) (nfix k))
+ (bfr-eval hyp-bfr env)
+ (gobj-alist-vars-bounded next-bvar t alist)
+ (gbc-db-vars-bounded next-bvar t (nth *is-constraint-db* interp-st)))
+ (pbfr-vars-bounded k hyp-bfr concl-bfr)))
+ :hints (("goal" :use ((:instance bfr-eval-consts))
+ :in-theory (disable bfr-eval-consts bfr-eval-booleanp))))
+
+ (defthm constraint-vars-bounded-of-glcp-generic-interp-hyp/concl
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (implies (and (<= (next-bvar$a concl-bvar-db) (nfix k))
+ (not erp)
+ (bfr-eval hyp-bfr env)
+ (gobj-alist-vars-bounded next-bvar t alist)
+ (pbfr-vars-bounded next-bvar t (nth *is-constraint* interp-st))
+ (gbc-db-vars-bounded next-bvar t (nth *is-constraint-db* interp-st)))
+ (pbfr-vars-bounded k hyp-bfr (nth *is-constraint* interp-st1))))
+ :hints (("goal" :use ((:instance bfr-eval-consts))
+ :in-theory (disable bfr-eval-consts bfr-eval-booleanp))))
+
+ (defthm bvar-db-ordered-of-glcp-generic-interp-hyp/concl-hyp
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (implies (and (gobj-alist-vars-bounded next-bvar t alist)
+ (gbc-db-vars-bounded next-bvar t (nth *is-constraint-db* interp-st)))
+ (bvar-db-orderedp t hyp-bvar-db)))
+ :hints (("goal" :use ((:instance bfr-eval-consts))
+ :in-theory (disable bfr-eval-consts bfr-eval-booleanp))))
+
+ (defthm bvar-db-ordered-of-glcp-generic-interp-hyp/concl-concl
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)))
+ (implies (and (gobj-alist-vars-bounded next-bvar t alist)
+ (gbc-db-vars-bounded next-bvar t (nth *is-constraint-db* interp-st))
+ (bfr-eval hyp-bfr henv))
+ (bvar-db-orderedp hyp-bfr concl-bvar-db)))
+ :hints (("goal" :use ((:instance bfr-eval-consts))
+ :in-theory (disable bfr-eval-consts bfr-eval-booleanp))))
+
+ (local (defthm glcp-generic-interp-top-level-term-correct-bind
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (bind-free
+ `((env . (cons ,bfr-env (cdr env)))))
+ (bfr-eval pathcond bfr-env)
+ (bfr-eval (is-constraint interp-st) bfr-env)
+ (not erp)
+ (acl2::interp-defs-alistp (is-obligs interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (is-obligs interp-st1))))
+ ;; (glcp-generic-geval-ev-meta-extract-global-facts)
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+ (equal p (glcp-config->param-bfr config))
+ (glcp-generic-bvar-db-env-ok
+ bvar-db1 p (next-bvar$a bvar-db1) env)
+ (equal bfr-env (car env))
+ (equal (w state0) (w state))
+ (pseudo-termp term)
+ (alistp alist))
+ (iff (bfr-eval val bfr-env)
+ (glcp-generic-geval-ev term (glcp-generic-geval-alist
+ alist env)))))
+ :hints(("Goal" :in-theory (e/d ()
+ (glcp-generic-interp-top-level-term))
+ :use ((:instance glcp-generic-interp-correct-term
+ (x term) (contexts '(iff))))))))
+
+ (local (defthm glcp-generic-interp-top-level-term-preserves-constraint-bind
+ (b* (((mv ?val ?erp ?interp-st1 ?bvar-db1 ?state1)
+ (glcp-generic-interp-top-level-term
+ term alist pathcond clk config interp-st bvar-db state)))
+ (implies (and (bind-free
+ `((env . (cons ,bfr-env (cdr env)))))
+ (bfr-eval (is-constraint interp-st) bfr-env)
+ (acl2::interp-defs-alistp (is-obligs interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (is-obligs interp-st1))))
+ ;; (glcp-generic-geval-ev-meta-extract-global-facts)
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+ (equal p (glcp-config->param-bfr config))
+ (glcp-generic-bvar-db-env-ok
+ bvar-db1 p (next-bvar$a bvar-db1) env)
+ (equal bfr-env (car env))
+ (equal (w state0) (w state))
+ (pseudo-termp term)
+ (alistp alist))
+ (bfr-eval (nth *is-constraint* interp-st1) bfr-env)))
+ :hints (("goal" :use
+ glcp-generic-interp-top-level-term-preserves-constraint
+ :in-theory (disable glcp-generic-interp-top-level-term-preserves-constraint)))))
+
+ (defthm glcp-generic-interp-hyp/concl-env-correct
+ (b* (((mv ?hyp-bfr ?concl-bfr ?concl-bvar-db ?erp ?interp-st1 ?hyp-bvar-db ?state1)
+ (glcp-generic-interp-hyp/concl
+ hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state))
+ (fixed-env
+ (glcp-generic-interp-hyp/concl-env
+ env hyp concl alist clk config interp-st next-bvar state)))
+ (implies (and (not erp)
+ (acl2::interp-defs-alistp (nth *is-obligs* interp-st))
+ (acl2::interp-defs-alistp (glcp-config->overrides config))
+ (glcp-generic-geval-ev-theoremp
+ (conjoin-clauses
+ (acl2::interp-defs-alist-clauses
+ (nth *is-obligs* interp-st1))))
+ (bfr-eval (nth *is-constraint* interp-st) (car env))
+ (pbfr-vars-bounded next-bvar t (nth *is-constraint* interp-st))
+ (glcp-generic-geval-ev-meta-extract-global-facts :state state0)
+ (equal (w state0) (w state))
+ (pseudo-termp hyp)
+ (pseudo-termp concl)
+ (alistp alist)
+ (consp env)
+ (natp next-bvar)
+ (gobj-alist-vars-bounded next-bvar t alist)
+ (gbc-db-vars-bounded next-bvar t (nth *is-constraint-db* interp-st))
+ (glcp-generic-geval-ev
+ hyp (glcp-generic-geval-alist alist env))
+ (not (glcp-generic-geval-ev
+ concl (glcp-generic-geval-alist alist env))))
+ (and (bfr-eval hyp-bfr (bfr-unparam-env hyp-bfr fixed-env))
+ (not (bfr-eval concl-bfr fixed-env))
+ (bfr-eval (nth *is-constraint* interp-st1) fixed-env) )))
+ :hints (("goal" :use ((:instance bfr-eval-consts)
+ (:instance bfr-eval-consts (env (car env))))
+ :in-theory (disable bfr-eval-consts bfr-eval-booleanp)
+ :do-not-induct t))))
diff -Nru acl2-6.2/books/centaur/gl/gl-mbe.lisp acl2-6.3/books/centaur/gl/gl-mbe.lisp
--- acl2-6.2/books/centaur/gl/gl-mbe.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gl-mbe.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,41 +1,82 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
+(include-book "xdoc/top" :dir :system)
-(include-book "centaur/gl/gl-doc-string" :dir :system)
+(defsection gl-mbe
+ :parents (reference)
+ :short "Assert that a particular symbolic object is equivalent to a second
+form, and use the second in place of the first."
+ :long "@(call gl-mbe) is defined to simply check whether its two arguments
+SPEC and IMPL are equal, throwing an error if not, and return SPEC.
-(defun gl-mbe (spec impl)
- ":doc-section ACL2::GL
-Assert that a particular symbolic object is equivalent to a second form, and
-use the second in place of the first.~/
-
-GL-MBE is defined to simply check whether its two arguments SPEC and IMPL are
-equal, throwing an error if not, and return SPEC.
-
-However, when GL-MBE is symbolically executed, the equality of the two
+However, when GL-MBE is symbolically executed, the equality of the two
arguments is checked symbolically. If it can be proved that they are always
-equal, then IMPL is returned instead of SPEC, otherwise an error is produced.~/
+equal, then IMPL is returned instead of SPEC, otherwise an error is produced.
-This is most useful when symbolically executing in AIG mode. For example,
+This is most useful when symbolically executing in AIG mode. For example,
suppose that through a series of shifting operations, the symbolic
representation of some numeric operand X is expanded to thousands of bits.
However, the user knows that only the bottom 25 bits may be non-zero. Then the
following form may speed up the rest of the computation involving X by cutting
-off all the upper bits, which are known to be zero:
-~bv[]
+off all the upper bits, which are known to be zero:
+
+@({
(let ((x (gl-mbe x (logand (1- (ash 1 25)) x))))
...)
-~ev[]
+})
-Here GL-MBE tries to prove that X and the LOGAND expression are equivalent,
+Here GL-MBE tries to prove that X and the LOGAND expression are equivalent,
that is, their symbolic representations evaluate to the same concrete values
under all environments. If this can be proved, X is bound to the LOGAND
result, which cuts off the upper bits of X, improving symbolic execution
performance. However, because logically GL-MBE just returns X, the meaning of
-the specification is unaffected.~/
-"
+the specification is unaffected.
"
+
+ (defun gl-mbe (spec impl other-info)
+ (declare (xargs :guard t)
+ (ignore other-info))
+ (prog2$ (or (equal spec impl)
+ (er hard? 'gl-mbe "GL-MBE assertion failed: ~x0 not equal to ~x1~%"
+ spec impl))
+ spec)))
+
+(defun gl-force-check (x)
+ (declare (xargs :guard t))
+ x)
+
+(defun gl-force-true (x)
+ (declare (xargs :guard t))
+ x)
+
+(defun gl-force-false (x)
(declare (xargs :guard t))
- (prog2$ (or (equal spec impl)
- (er hard? 'gl-mbe "GL-MBE assertion failed: ~x0 not equal to ~x1~%"
- spec impl))
- spec))
+ x)
+
+(defun gl-force-check-strong (x)
+ (declare (xargs :guard t))
+ x)
+
+(table gl-uninterpreted-functions 'gl-force-check-strong t)
+(table gl-uninterpreted-functions 'gl-force-check t)
+(table gl-uninterpreted-functions 'gl-force-true t)
+(table gl-uninterpreted-functions 'gl-force-false t)
diff -Nru acl2-6.2/books/centaur/gl/gl-misc-defs.lisp acl2-6.3/books/centaur/gl/gl-misc-defs.lisp
--- acl2-6.2/books/centaur/gl/gl-misc-defs.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gl-misc-defs.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,4 +1,22 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "ACL2")
@@ -151,7 +169,7 @@
()
(local (include-book "arithmetic-3/floor-mod/floor-mod" :dir :system))
(local (in-theory (enable nonnegative-integer-quotient)))
-
+
(defthmd nonnegative-integer-quotient-for-gl
(equal (nonnegative-integer-quotient i j)
(floor (nfix i) (nfix j)))))
diff -Nru acl2-6.2/books/centaur/gl/gl-misc-doc.lisp acl2-6.3/books/centaur/gl/gl-misc-doc.lisp
--- acl2-6.2/books/centaur/gl/gl-misc-doc.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gl-misc-doc.lisp 1970-01-01 00:00:00.000000000 +0000
@@ -1,327 +0,0 @@
-
-(in-package "GL")
-
-(include-book "gl-doc-string")
-
-(defdoc symbolic-objects ":Doc-section ACL2::GL
-Format of symbolic objects in ~il[GL].~/
-
-Symbolic objects represent functions from the set of environments
- (described below) to the set of ACL2 objects. The value of an object
-at an environment is given by an evaluator function. Symbolic objects
-are recursively structured and have a number of constructors. We
-first briefly describe evaluators (and why there can be more than
-one), then the structure of environment objects, and then the symbolic
-object constructors.~/
-
-a. Evaluators
-
-A symbolic object evaluator is a function with the interface
-~bv[]
- (EV symbolic-object environment) => value.
-~ev[]
-
-There may be several evaluators defined. The differences between
-evaluators have to do with the G-APPLY symbolic object type, which
-represents a function applied to symbolic arguments. In order to
-evaluate such an object, the evaluator must be defined such that it
-recognizes the particular function symbol used in the G-APPLY object.
-An evaluator may not evaluate a symbolic object containing a G-APPLY
-construct with an unrecognized function symbol. One evaluator, named
-EVAL-G-BASE, is initially defined in the GL library, and recognizes
-function symbols of the predefined primitives included with the
-library. When new symbolic functions are created using the
-MAKE-G-WORLD event, a new evaluator is created that recognizes each of
-the functions for which symbolic counterparts exist, both newly
-created and preexisting.
-
-b. Environments
-
-The basic components of symbolic objects are data structures
-containing UBDDs, which represent Boolean functions of Boolean
-variables, and G-VAR constructs, which represent unconstrained
-variables. To evaluate a symbolic object, each of these needs to be
-evaluated to a constant. We evaluate UBDDs to Booleans by choosing to
-take either the true or false branch at each decision level; this
-series of choices is described by a list of Booleans. We evaluate
-unconstrained variables by looking them up by name in a list of
-bindings. Therefore an environment is a pair containing a list of
-Booleans used for evaluating UBDDs, and an association list containing
-pairings of variable names and objects, used for evaluating G-VAR
-constructs.
-
-c. Symbolic Object Representation
-
-There are eight basic constructions of symbolic objects, some of which
-may recursively contain other symbolic objects. We now describe each
-such construction and its evaluation.
-
-Representation: (:G-BOOLEAN . bdd)
-Constructor: (G-BOOLEAN bdd)
-Takes the values T and NIL. The evaluation of a G-BOOLEAN object is
-simply the evaluation of using the list of Booleans in the
-environment.
-
-Representation: (:G-NUMBER . list-of-lists-of-bdds)
-Constructor: (G-NUMBER list-of-lists-of-bdds)
-Evaluates to a (complex rational) number.
-should be a list containing four or fewer lists of UBDDs, which
-represent (in order):
- - the numerator of the real part (two's-complement, default 0)
- - the denominator of the real part (unsigned, default 1)
- - the numerator of the imaginary part (two's-complement, default 0)
- - the denominator of the imaginary part (unsigned, default 1).
-It is most common to represent an integer, for which only the first
-list need be included. In both the two's-complement and unsigned
-representations, the bits are ordered from least to most significant,
-with the last bit in the two's complement representation giving the
-sign. Two's complement lists may be sign-extended by repeating the
-final bit, and unsigned lists may be zero-extended by appending NILs
-after the final bit.
-
-Representation (:G-CONCRETE . object)
-Constructor: (G-CONCRETE object)
-Evaluates to . While most ACL2 objects evaluate to themselves
-anyway, this construct is useful for representing symbolic objects or
-objects structured similarly to symbolic objects. For example,
- (:G-CONCRETE . (:G-BOOLEAN . (T . NIL))) evaluates to
- (:G-BOOLEAN . (T . NIL)), whereas
- (:G-BOOLEAN . (T . NIL)) evaluates to either T or NIL.
-
-Representation: (:G-VAR . name)
-Constructor: (G-VAR . name)
- may be any object. Evaluates to the object bound to in
-the environment.
-
-Representation: (:G-ITE test then . else)
-Constructor: (G-ITE test then else)
-Each of , , and must be symbolic objects. If
- evaluates to a nonnil value, then this object evaluates to the
-evaluation of ; otherwise this evaluates to the evaluation of
-.
-
-Representation: (:G-APPLY fn . arglist)
-Constructor: (G-APPLY fnsym arglist)
- should be a symbol and should be a symbolic object. If
-the evaluator recognizes and evaluates to , a
-true-list of length equal to the arity of the function , then this
-object evaluates to the application of to . Otherwise, the
-evaluation is undefined; more specifically, it is provably equal to
- (APPLY-STUB ), where APPLY-STUB is an undefined stub
-function.
-
-Representation: atom
-Every atom evaluates to itself. However, the keyword symbols
-:G-BOOLEAN, :G-NUMBER, :G-CONCRETE, :G-VAR, :G-ITE, and :G-APPLY are
-not themselves well-formed symbolic objects.
-
-Representation: (car . cdr)
-A cons of two symbolic objects evaluates to the cons of their
-evaluations. Note that since the keyword symbols that distinguish
-symbolic object constructions are not themselves well-formed symbolic
-objects, this construction is unambiguous.
-
-
-d. Miscellaneous notes about symbolic objects and evaluation
-
- - Any function from finitely many Boolean values to the universe of
-ACL2 objects can be expressed using only the G-ITE, G-BOOLEAN, and
-G-CONCRETE forms.
-
- - Most ACL2 objects are themselves well-formed symbolic objects which
-evaluate to themselves. The exceptions are ones which contain the
-special keyword symbolis :G-BOOLEAN, :G-NUMBER, :G-CONCRETE, :G-VAR,
-:G-ITE, and :G-APPLY. These atoms (and out of all atoms, only these)
-are not well-formed symbolic objects. Since a cons of any two
-well-formed symbolic objects is itself a well-formed symbolic objects,
-only objects containing these atoms may be non-well-formed.
-
- - The function that checks well-formedness of symbolic objects is
-GOBJECTP, and the initial evaluator function is GL::EVAL-G-BASE. It
-may be useful to read the definitions of these functions for reference
-in case the above symbolic object documentation is unclear.
-
-~/")
-
-
-(defdoc debugging-indeterminate-results
- ":Doc-section ACL2::GL
-Debugging indeterminate results in symbolic executions~/
-
-GL includes two types of symbolic object, G-APPLY and G-VAR, whose symbolic
-truth values can't be syntactically determined. When the result of
-symbolically executing the conclusion of a conjecture contains one of these
-objects, usually the proof will then fail, since GL can't determine that the
-result is never NIL.
-
-Usually, however, G-VAR forms are not used, and G-APPLY forms are unwelcome if
-they appear at all; they typically result in a symbolic execution failure of
-some sort. The following are a few common situations in which G-APPLY forms
-are generated:
-
- * The stack depth limit, or \"clock\", was exhausted.
-
- * An unsupported primitive was called. For example, as of November 2010 we
-do not yet support UNARY-/.
-
- * A primitive was called on an unsupported type of symbolic object. For
-example, the symbolic counterparts for most arithmetic primitives will produce
-a G-APPLY object if an input seems like it might represent a non-integer
-rational. Since symbolic operations on rationals are absurdly expensive, we
-simply don't implement them for the most part.
-~/
-
-In order to determine why a G-APPLY form is being created, we suggest using the
-following TRACE$ form:
-
-~bv[]
- (trace$ (gl::g-apply :entry (prog2$ (cw \"Note: G-APPLY called.~~%\")
- (break$))
- :exit nil))
-~ev[]
-
-Then when GL::G-APPLY is called in order to create the form, ~c[(BREAK$)] will
-be called. Usually this will allow you to look at the backtrace and determine
-in what context the first G-APPLY object is being created.
-
-Usually, the culprit is one of the last two bullets above. Sometimes these
-problems may be worked around by choosing a slightly different implementation
-or by performing symbolic execution using an alternate definition of some
-function (see ~il[GL::ALTERNATE-DEFINITIONS]). If the clock was to blame, then
-most likely the initial clock is set too low; use the ~c[HYP-CLK] or
-~c[CONCL-CLK] keyword arguments to ~c[DEF-GL-THM] and ~c[DEF-GL-PARAM-THM] to
-set this.~/ ")
-
-
-(defdoc alternate-definitions
- ":Doc-section ACL2::GL
-Specifying alternative definitions to be used for symbolic execution~/
-
-Sometimes the definition of some function is ill-suited for automatic methods
-of symbolic execution. For example, ~c[(EVENP X)] is defined as
-~bv[]
- (integerp (* x (/ 2)))
-~ev[]
-and because currently multiplication by a non-integer is not supported in GL,
-this yields a G-APPLY form in most cases.
-
-In this case and several others, one may instead provide an alternate
-definition for the function in question and use that as the basis for GL
-symbolic execution.
-
-In the case of EVENP, the following theorem works as an alternate definition:
-
-~bv[]
- (defthm evenp-is-logbitp
- (equal (evenp x)
- (or (not (acl2-numberp x))
- (and (integerp x)
- (equal (logbitp 0 x) nil))))
- :rule-classes nil)
-~ev[]
-
-After proving this theorem, the following form sets this alternate definition
-as the one GL will use when symbolically interpreting EVENP:
-
-~bv[]
- (gl::set-preferred-def evenp evenp-is-logbitp)
-~ev[]
-
-This form produces one or more table events; ~l[TABLE].
-~/~/")
-
-(defdoc coverage-proofs
- ":Doc-Section ACL2::GL
-Proving the coverage obligation in GL-based proofs~/
-
-In order to prove a theorem using GL, one must show that the symbolic
-objects chosen to represent the inputs are sufficiently general to
-cover the entire set of interest. See ~il[GL::SHAPE-SPECS] for a more
-in-depth discussion. The ~il[DEF-GL-THM] and ~il[DEF-GL-PARAM-THM]
-events as well as the ~il[GL-HINT] hints all provide some degree
-of automation for coverage proofs; often this is enough to satisfy the
-coverage obligation without further user interaction. Here we discuss
-how to debug coverage proofs that do not succeed.~/
-
-First, it is probably important to be able to re-run a coverage proof
-easily without also re-running the associated symbolic execution,
-which may be quite time-consuming. To do this, in either the
-~il[DEF-GL-THM] or ~il[DEF-GL-PARAM-THM] forms, add the keyword
-argument ~c[:TEST-SIDE-GOALS T]. This form will then try to prove the
-coverage obligation in exactly the manner it would do during the real
-proof, but it will not attempt to prove the theorem itself, and will
-not record a new ACL2 theorem even if the proof is successful.
-
-During proof output, GL prints a message \"Now proving coverage\" when
-it begins the coverage proof. The initial goal of a coverage proof
-will also have a hypothesis ~c[(GL::GL-CP-HINT 'GL::COVERAGE)]; this
-hypothesis is logically meaningless, but a useful indicator of the
-beginning of a coverage proof.
-
-When GL's usual set of heuristics is used, a coverage proof proceeds
-as follows. The initial goal is as follows:
-
-~bv[]
- (implies
- (gl::shape-spec-obj-in-range
-
- ))
-~ev[]
-
-The coverage heuristics proceed by repeatedly opening up the
-~c[GL::SHAPE-SPEC-OBJ-IN-RANGE] function. This effectively splits the
-proof into cases for each component of each variable; for example, if
-one variable's shape specifier binding is a cons of two :G-NUMBER
-forms, then its CAR and CDR will be considered separately.
-Eventually, this results in several subgoals, each with conjunction of
-requirements for some component of some input.
-
-During this process of opening the ~c[GL::SHAPE-SPEC-OBJ-IN-RANGE]
-conclusion, the coverage heuristics also examine and manipulate the
-hypotheses. When the conclusion is focused on a certain input
-variable or component of that variable, and some hypothesis does not
-mention that variable, that hypothesis will be dropped so as to speed
-up the proof. If a hypothesis does mention that variable, it may be
-expanded (if it is not a primitive) so as to try and gain more
-information about that variable. This is a useful heuristic because
-often the hypotheses consist of a conjunction of predicates about
-different input variables or components of input variables, and some
-of these predicates are often themselves defined as conjunctions of
-predicates about subcomponents.
-
-However, sometimes this expansion goes too far. In many cases, some
-conjuncts from the hypothesis have nothing to do with the coverage
-obligation. In these cases, the ~c[:DO-NOT-EXPAND] keyword argument
-to ~c[DEF-GL-THM] and ~c[DEF-GL-PARAM-THM] may be used. This argument
-should evaluate to a list of function symbols; the coverage heuristic
-is then prohibited from expanding any of these functions.
-
-For efficiency, the set of rules used in coverage proofs is very
-restricted. Because of this, you may see in the proof output a goal
-which should be obvious, but is not proven because the necessary
-rule is not included. The keyword argument ~c[:COV-THEORY-ADD] may be
-used to enable certain additional rules that are not included. The
-set of rules that is used is defined in the ruleset
-~c[GL::SHAPE-SPEC-OBJ-IN-RANGE-OPEN], which can be listed using
-~bv[]
- (get-ruleset 'gl::shape-spec-obj-in-range-open (w state)).
-~ev[]
-
-The default heuristics for coverage proofs may not always be useful.
-Therefore, the user may also supplement or replace the coverage
-heuristics with arbitrary computed hints. The keyword argument
-~c[:COV-HINTS] gives a list of computed hint forms which, according to
-the value of the keyword argument ~c[:COV-HINTS-POSITION], either
-replaces or supplements the default hints. ~c[:COV-HINTS-POSITION]
-may be either ~c[:REPLACE], in which case the defaults are not used at
-all; ~c[:FIRST], in which case the user-provided ~c[:COV-HINTS] are
-tried first and the defaults afterward, or the default, ~c[:LAST], in
-which case the default coverage heuristic is tried before the
-user-provided hints.
-
-One thing to keep in mind when replacing or supplementing the default
-heuristics with your own computed hints is that subgoal names will be
-different between a ~c[:TEST-SIDE-GOALS] and an actual attempt at
-proving the theorem. Therefore, it is best not to write computed
-hints that depend on the ~c[ID] variable.
-~/")
diff -Nru acl2-6.2/books/centaur/gl/gl-ttags.acl2 acl2-6.3/books/centaur/gl/gl-ttags.acl2
--- acl2-6.2/books/centaur/gl/gl-ttags.acl2 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gl-ttags.acl2 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,22 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(set-waterfall-parallelism nil)
diff -Nru acl2-6.2/books/centaur/gl/gl-ttags.lisp acl2-6.3/books/centaur/gl/gl-ttags.lisp
--- acl2-6.2/books/centaur/gl/gl-ttags.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gl-ttags.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,22 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
@@ -7,5 +26,4 @@
(include-book "bfr-aig-bddify")
(include-book "bfr-satlink")
-(def-gl-clause-processor glcp-ttags)
-
+(def-gl-clause-processor glcp-ttags :output nil)
diff -Nru acl2-6.2/books/centaur/gl/gl-util.lisp acl2-6.3/books/centaur/gl/gl-util.lisp
--- acl2-6.2/books/centaur/gl/gl-util.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gl-util.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,7 +1,24 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "tools/flag" :dir :system)
(include-book "tools/bstar" :dir :system)
@@ -203,7 +220,7 @@
`(,(gl-fnsym fn) ,@args))
(defmacro glc (fn &rest args)
- `(,(gl-fnsym fn) ,@args t 1000000))
+ `(,(gl-fnsym fn) ,@args hyp clk config bvar-db state))
@@ -230,5 +247,5 @@
g-var g-var-p g-var->name))))
-
+
diff -Nru acl2-6.2/books/centaur/gl/gl.lisp acl2-6.3/books/centaur/gl/gl.lisp
--- acl2-6.2/books/centaur/gl/gl.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gl.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,9 +1,25 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-
-
+(include-book "g-logapp")
(include-book "g-ash")
(include-book "g-binary-+")
(include-book "g-cons")
@@ -37,7 +53,6 @@
(include-book "gl-generic-clause-proc")
(include-book "def-gl-clause-proc")
(include-book "gify-thms")
-(include-book "gl-misc-doc")
(include-book "auto-bindings")
;;; Matt K., 2/22/13: Sol Swords suggested commenting out the following
;;; include-book form, in order to avoid dependence on ttag :COUNT-BRANCHES-TO
@@ -45,6 +60,9 @@
; (include-book "bfr-aig-bddify")
(include-book "g-gl-mbe")
+(include-book "doc")
+(include-book "tutorial")
+
(local (include-book "general-object-thms"))
(local (include-book "eval-g-base-help"))
@@ -55,6 +73,7 @@
(defmacro def-g-simple (name body)
`(progn (def-g-fn ,name ,body)
(verify-g-guards ,name)
+ (def-gobj-dependency-thm ,name)
(def-g-correct-thm ,name eval-g-base)))
;; complex-rationalp is an odd bird since it doesn't have a definition
@@ -63,58 +82,106 @@
(def-g-simple complex-rationalp
`(glr equal
nil
- (glr equal 0 (glr imagpart x hyp clk) hyp clk)
- hyp clk))
+ (glr equal 0 (glr imagpart x hyp clk config bvar-db state) hyp clk config bvar-db state)
+ hyp clk config bvar-db state))
(def-g-simple acl2::boolfix
`(g-if x t nil))
(def-g-simple implies
- `(g-or (glr not p hyp clk)
- (glr acl2::boolfix q hyp clk)))
+ `(g-or (glr not p hyp clk config bvar-db state)
+ (glr acl2::boolfix q hyp clk config bvar-db state)))
(def-g-simple eq
- `(glr equal x y hyp clk))
+ `(glr equal x y hyp clk config bvar-db state))
(def-g-simple eql
- `(glr equal x y hyp clk))
+ `(glr equal x y hyp clk config bvar-db state))
(def-g-simple =
- `(glr equal x y hyp clk))
+ `(glr equal x y hyp clk config bvar-db state))
(def-g-simple /=
-`(glr not (glr equal x y hyp clk) hyp clk))
+`(glr not (glr equal x y hyp clk config bvar-db state) hyp clk config bvar-db state))
(def-g-simple null
- `(glr equal x nil hyp clk))
+ `(glr equal x nil hyp clk config bvar-db state))
(def-g-simple atom
- `(glr not (glr consp x hyp clk) hyp clk))
+ `(glr not (glr consp x hyp clk config bvar-db state) hyp clk config bvar-db state))
(def-g-simple endp
- `(glr not (glr consp x hyp clk) hyp clk))
+ `(glr not (glr consp x hyp clk config bvar-db state) hyp clk config bvar-db state))
(def-g-simple zerop
- `(glr equal x 0 hyp clk))
+ `(glr equal x 0 hyp clk config bvar-db state))
(def-g-simple plusp
- `(glr < 0 x hyp clk))
+ `(glr < 0 x hyp clk config bvar-db state))
(def-g-simple minusp
- `(glr < x 0 hyp clk))
+ `(glr < x 0 hyp clk config bvar-db state))
(def-g-simple listp
- `(g-or (glr consp x hyp clk)
- (glr equal x nil hyp clk)))
+ `(g-or (glr consp x hyp clk config bvar-db state)
+ (glr equal x nil hyp clk config bvar-db state)))
; Obsolete, now that prog2$ is defined in terms of return-last:
; (def-g-simple prog2$
; 'y)
+(def-g-fn hons-assoc-equal
+ `(if (zp clk)
+ (g-apply 'hons-assoc-equal (list acl2::key acl2::alist))
+ (g-if (glc atom acl2::alist)
+ nil
+ (let ((car (glc car acl2::alist)))
+ (g-if (g-if (glc consp car)
+ (glc equal acl2::key (glc car car))
+ nil)
+ car
+ (let ((clk (1- clk)))
+ (glc hons-assoc-equal acl2::key (glc cdr acl2::alist)))))))
+ :measure (nfix clk))
+
+(verify-g-guards hons-assoc-equal)
+
+(local (include-book "tools/trivial-ancestors-check" :dir :system))
+(local (acl2::use-trivial-ancestors-check))
+
+(local (include-book "centaur/misc/beta-reduce-full" :dir :system))
+
+;; Note: In the gobj dependency theorem for hons-assoc-equal, there are some
+;; HIDEs in the induction hyp that need to match HIDEs created by the rewriter,
+;; but they seem to sometimes differ in the order of the bindings. So we beta
+;; reduce all HIDE terms with the rule below.
+(local (defthm beta-reduce-hides
+ #!acl2 (implies (pseudo-termp x)
+ (equal (beta-eval x a)
+ (beta-eval (beta-reduce-full x) a)))
+ :rule-classes ((:meta :trigger-fns (hide)))))
+
+(def-gobj-dependency-thm hons-assoc-equal
+ :hints `(("goal" :in-theory (e/d ((:i ,gfn))
+ ((:d ,gfn)))
+ :induct ,gcall
+ :expand (,gcall))))
+
+(def-g-correct-thm hons-assoc-equal eval-g-base
+ :hints `(("goal" :in-theory (e/d ((:i ,gfn))
+ ((:d ,gfn)))
+ :induct ,gcall
+ :expand (,gcall
+ (:free (a b) (eval-g-base-list (cons a b) env))
+ (eval-g-base-list nil env)
+ (hons-assoc-equal (eval-g-base acl2::key env)
+ (eval-g-base acl2::alist env))))))
+
+;; (make-g-world (hons-assoc-equal) geval-basis)
+
-(make-g-world (hons-assoc-equal) geval-basis)
(defun canonical-general-concretep (x)
(declare (xargs :guard t
@@ -184,6 +251,40 @@
obj)
(hons-g-concrete obj)))))
+;; (local (defthm general-concrete-obj-of-car-when-tag
+;; (implies (and (syntaxp (quotep key))
+;; (not (equal (tag x) :g-concrete))
+;; (not (equal (tag x) :g-boolean))
+;; (not (equal (tag x) :g-number))
+;; (not (equal (tag x) :g-ite))
+;; (not (equal (tag x) :g-apply))
+;; (not (equal (tag x) :g-var))
+;; (g-keyword-symbolp key))
+;; (not (equal (general-concrete-obj (car x)) key)))
+;; :hints(("Goal" :in-theory (enable g-keyword-symbolp tag)
+;; :expand ((general-concrete-obj (car x)))))))
+
+;; (local (defthm gobj-depends-on-of-general-concrete-obj
+;; (implies (and (not (gobj-depends-on k p x))
+;; (general-concretep x))
+;; (not (gobj-depends-on k p (general-concrete-obj x))))
+;; :hints(("Goal" :in-theory (enable general-concretep
+;; general-concrete-obj
+;; concrete-gobjectp
+;; gobject-hierarchy-lite)
+;; :induct t
+;; :expand ((:free (a b)
+;; (gobj-depends-on k p (cons a b))))))))
+
+
+(defthm gobj-depends-on-of-canonicalize-general-concrete
+ (implies (and (not (gobj-depends-on k p x))
+ (general-concretep x))
+ (not (gobj-depends-on k p (canonicalize-general-concrete x))))
+ :hints(("Goal" :in-theory (enable canonicalize-general-concrete
+ gobj-depends-on-when-concrete-gobjectp))))
+
+
(local
(progn
(defthm canonicalize-general-concretep-correct
@@ -232,25 +333,25 @@
(local
(progn
- (in-theory (enable geval-basis))
- (eval-g-prove-f-i geval-basis-f-i
- geval-basis generic-geval)
+ (in-theory (e/d (eval-g-base)))
+ (eval-g-prove-f-i eval-g-base-f-i
+ eval-g-base generic-geval)
(eval-g-functional-instance
canonical-eval-canonical-general-concretep
- geval-basis generic-geval)
+ eval-g-base generic-geval)
(eval-g-functional-instance
canonicalize-general-concretep-correct
- geval-basis generic-geval)
+ eval-g-base generic-geval)
(eval-g-functional-instance
generic-geval-cons
- geval-basis generic-geval)
+ eval-g-base generic-geval)
(eval-g-functional-instance
general-concrete-obj-correct
- geval-basis generic-geval)
+ eval-g-base generic-geval)
;; (defthmd not-keyword-symbolp-car-impl
;; (implies (not (g-keyword-symbolp (car x)))
@@ -269,32 +370,33 @@
(defthm ev-hons-assoc-equal-when-concrete-key-alistp
(implies (and (concrete-key-alistp al)
(canonical-general-concretep key))
- (equal (geval-basis
+ (equal (eval-g-base
(hons-assoc-equal key al)
env)
- (hons-assoc-equal (geval-basis key env)
- (geval-basis al env))))
+ (hons-assoc-equal (eval-g-base key env)
+ (eval-g-base al env))))
:hints (("goal" :in-theory
(e/d (; gobjectp-car-impl-not-g-types
; canonical-general-concretep-impl-gobjectp
- gl-thm::canonical-eval-canonical-general-concretep-for-geval-basis
+ gl-thm::canonical-eval-canonical-general-concretep-for-eval-g-base
; not-keyword-symbolp-car-impl
hons-assoc-equal)
(canonical-general-concretep
general-concretep-def
concrete-gobjectp-def
- geval-basis
+ eval-g-base
bfr-sat-bdd-unsat
(:d hons-assoc-equal)
- ;; gl-thm::general-concrete-obj-correct-gobj-fix-for-geval-basis
+ ;; gl-thm::general-concrete-obj-correct-gobj-fix-for-eval-g-base
))
:induct (hons-assoc-equal key al)
:expand ((:free (key) (hons-assoc-equal key al))))
(and stable-under-simplificationp
'(:expand
- ((geval-basis al env)
- (geval-basis (car al) env))
+ ((:with eval-g-base (eval-g-base al env))
+ (:with eval-g-base (eval-g-base (car al) env))
+ (:free (key a b) (hons-assoc-equal key (cons a b))))
;; :in-theory
;; (enable tag g-concrete-p g-concrete->obj)
))))))
@@ -311,7 +413,6 @@
(verify-g-guards hons-acons)
-
;; (def-gobjectp-thm hons-acons
;; :hints `(("goal" :in-theory
;; (enable canonical-general-concretep-impl-gobjectp))))
@@ -330,7 +431,9 @@
;;(local (in-theory (enable canonical-general-concretep-impl-gobjectp)))
-(def-g-correct-thm hons-acons geval-basis)
+(def-gobj-dependency-thm hons-acons)
+
+(def-g-correct-thm hons-acons eval-g-base)
;; Jared: changed hons-get-fn-do-hopy to hons-get for new hons
@@ -342,21 +445,24 @@
(verify-g-guards hons-get)
+(def-gobj-dependency-thm hons-get)
+
+
(local
(progn
(eval-g-functional-instance
canonicalize-general-concretep-correct
- geval-basis generic-geval)
+ eval-g-base generic-geval)
(eval-g-functional-instance
generic-geval-of-g-concrete-p
- geval-basis generic-geval)
+ eval-g-base generic-geval)
(eval-g-functional-instance
eval-concrete-gobjectp
- geval-basis generic-geval)))
+ eval-g-base generic-geval)))
-(def-g-correct-thm hons-get geval-basis)
+(def-g-correct-thm hons-get eval-g-base)
; Jared Note: removed hons-get-fn-do-not-hopy since it's no longer part
@@ -375,7 +481,7 @@
;; (def-gobjectp-thm hons-get-fn-do-not-hopy)
;; (verify-g-guards hons-get-fn-do-not-hopy)
-;; (def-g-correct-thm hons-get-fn-do-not-hopy geval-basis)
+;; (def-g-correct-thm hons-get-fn-do-not-hopy eval-g-base)
; Jared: changing flush-hons-get-hash-table-link to fast-alist-free
@@ -383,7 +489,8 @@
`(fast-alist-free acl2::alist))
(verify-g-guards fast-alist-free)
-(def-g-correct-thm fast-alist-free geval-basis)
+(def-gobj-dependency-thm fast-alist-free)
+(def-g-correct-thm fast-alist-free eval-g-base)
@@ -391,31 +498,78 @@
`(flush-hons-get-hash-table-link acl2::alist))
(verify-g-guards flush-hons-get-hash-table-link)
-(def-g-correct-thm flush-hons-get-hash-table-link geval-basis)
-
+(def-gobj-dependency-thm flush-hons-get-hash-table-link)
+(def-g-correct-thm flush-hons-get-hash-table-link eval-g-base)
+(acl2::defevaluator-fast cl-ev cl-ev-lst ((if a b c)) :namedp t)
-(def-gl-clause-processor glcp
- '(string-append expt))
-
-(defmacro gl-bdd-mode ()
- ":Doc-section ACL2::GL
-Use BDD-based symbolic simulation in GL.~/
-This macro produces an event which sets the GL reasoning mode to use uBDDs,
-This is the default, relatively stable form of GL symbolic simulation.~/~/"
- '(progn (acl2::defattach bfr-mode bfr-bdd)
- (acl2::defattach bfr-counterex-mode bfr-counterex-bdd)
- (acl2::defattach
- (bfr-sat bfr-sat-bdd)
- :hints (("goal" :in-theory '(bfr-sat-bdd-unsat))
- (and stable-under-simplificationp
- '(:in-theory (enable bfr-sat-bdd)))))))
+(defun dumb-clausify (x)
+ (declare (xargs :guard (pseudo-termp x)))
+ (cond ((atom x) (list (list x)))
+ ((equal x ''t) nil)
+ ((and (eq (car x) 'if)
+ (equal (fourth x) ''nil))
+ (append (dumb-clausify (second x))
+ (dumb-clausify (third x))))
+ (t (list (list x)))))
+
+(acl2::def-join-thms cl-ev)
+
+(defthm dumb-clausify-correct
+ (iff (cl-ev (conjoin-clauses (dumb-clausify x)) a)
+ (cl-ev x a)))
+
+(defun dumb-clausify-cp (x)
+ (declare (xargs :guard (pseudo-term-listp x)))
+ (if (or (atom x)
+ (consp (cdr x)))
+ (list x)
+ (dumb-clausify (car x))))
+
+(defthm dumb-clausify-cp-correct
+ (implies (and (pseudo-term-listp x)
+ (alistp a)
+ (cl-ev (conjoin-clauses (dumb-clausify-cp x)) a))
+ (cl-ev (disjoin x) a))
+ :rule-classes :clause-processor)
+
+
+(def-gl-clause-processor glcp :output nil)
+
+
+(defsection gl-bdd-mode
+ :parents (modes reference)
+ :short "Use BDD-based symbolic simulation in GL."
+ :long "This macro produces an event which sets the GL reasoning mode to
+use @(see acl2::ubdds). This is the default form of GL symbolic
+simulation.
"
+
+ (defmacro gl-bdd-mode ()
+ '(progn (acl2::defattach bfr-mode bfr-bdd)
+ (acl2::defattach bfr-counterex-mode bfr-counterex-bdd)
+ (acl2::defattach
+ (bfr-sat bfr-sat-bdd)
+ :hints (("goal" :in-theory '(bfr-sat-bdd-unsat))
+ (and stable-under-simplificationp
+ '(:in-theory (enable bfr-sat-bdd))))))))
;; Default to BDD mode.
(gl-bdd-mode)
+(defsection g-int
+ :parents (shape-specs)
+ :short "Create a g-binding for an integer."
+ :long "This is a low-level way to create a custom shape specifier for a
+signed integer. You might generally prefer higher-level tools like @(see
+auto-bindings).
"
+
+ (defun g-int (start by n)
+ (g-number (list (numlist start by n)))))
+
+;; Fix for unsigned-byte-p's recursive definition in ihs books
+(table structural-decomp-defs 'unsigned-byte-p 'unsigned-byte-p)
@@ -468,3 +622,4 @@
0
(acl2::evisc-tuple 3 6 nil nil))
(break$)))))
+
diff -Nru acl2-6.2/books/centaur/gl/glcp-config.lisp acl2-6.3/books/centaur/gl/glcp-config.lisp
--- acl2-6.2/books/centaur/gl/glcp-config.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/glcp-config.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,88 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "GL")
+(include-book "shape-spec-defs")
+
+(cutil::defaggregate glcp-config
+ ((abort-unknown booleanp :default t)
+ (abort-ctrex booleanp :default t)
+ (exec-ctrex booleanp :default t)
+ (abort-vacuous booleanp :default t)
+ (nexamples natp :rule-classes :type-prescription :default 3)
+ (hyp-clk natp :rule-classes :type-prescription :default 1000000)
+ (concl-clk natp :rule-classes :type-prescription :default 1000000)
+ (clause-proc-name symbolp :rule-classes :type-prescription)
+ (overrides) ;; acl2::interp-defs-alistp but might be too expensive to check
+ ;; the guards in clause processors
+ (param-bfr :default t)
+ top-level-term
+ (shape-spec-alist shape-spec-bindingsp)
+ run-before
+ run-after
+ case-split-override
+ (split-conses booleanp :default nil)
+ (split-fncalls booleanp :default nil)
+ (lift-ifsp booleanp :default nil)
+ )
+ :tag :glcp-config)
+
+
+(defund-inline glcp-config-update-param (p config)
+ (declare (xargs :guard (glcp-config-p config)))
+ (change-glcp-config config :param-bfr p))
+
+(defthm param-bfr-of-glcp-config-update-param
+ (equal (glcp-config->param-bfr (glcp-config-update-param p config))
+ p)
+ :hints(("Goal" :in-theory (enable glcp-config-update-param))))
+
+(defthm glcp-config->overrides-of-glcp-config-update-param
+ (equal (glcp-config->overrides (glcp-config-update-param p config))
+ (glcp-config->overrides config))
+ :hints(("Goal" :in-theory (enable glcp-config-update-param))))
+
+(defthm glcp-config->top-level-term-of-glcp-config-update-param
+ (equal (glcp-config->top-level-term (glcp-config-update-param p config))
+ (glcp-config->top-level-term config))
+ :hints(("Goal" :in-theory (enable glcp-config-update-param))))
+
+
+
+(defund-inline glcp-config-update-term (term config)
+ (declare (xargs :guard (glcp-config-p config)))
+ (change-glcp-config config :top-level-term term))
+
+(defthm param-bfr-of-glcp-config-update-term
+ (equal (glcp-config->param-bfr (glcp-config-update-term term config))
+ (glcp-config->param-bfr config))
+ :hints(("Goal" :in-theory (enable glcp-config-update-term))))
+
+(defthm glcp-config->overrides-of-glcp-config-update-term
+ (equal (glcp-config->overrides (glcp-config-update-term term config))
+ (glcp-config->overrides config))
+ :hints(("Goal" :in-theory (enable glcp-config-update-term))))
+
+(defthm glcp-config->top-level-term-of-glcp-config-update-term
+ (equal (glcp-config->top-level-term (glcp-config-update-term term config))
+ term)
+ :hints(("Goal" :in-theory (enable glcp-config-update-term))))
+
+
diff -Nru acl2-6.2/books/centaur/gl/glcp-geval-thms.lisp acl2-6.3/books/centaur/gl/glcp-geval-thms.lisp
--- acl2-6.2/books/centaur/gl/glcp-geval-thms.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/glcp-geval-thms.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,199 @@
+
+(in-package "GL")
+
+(include-book "glcp-geval")
+(include-book "gtype-thms")
+(include-book "general-object-thms")
+
+(local
+ (defthmd gl-eval-of-atom
+ (implies (atom x)
+ (equal (generic-geval x env) x))
+ :hints (("goal" :in-theory (enable tag)
+ :expand ((generic-geval x env))))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+
+(defsection glcp-generic-geval
+
+ (local (in-theory (enable glcp-generic-geval)))
+
+ (defthm glcp-generic-geval-atom
+ (implies (atom x)
+ (equal (glcp-generic-geval x env) x))
+ :hints(("Goal" :in-theory (enable gl-eval-of-atom)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-mk-g-boolean-correct
+ mk-g-boolean-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-apply-agrees-with-glcp-generic-geval-ev)
+ (glcp-generic-geval-apply))
+ :expand ((glcp-generic-geval x env)
+ (glcp-generic-geval-list x env)))))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-cons
+ generic-geval-cons
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-apply-agrees-with-glcp-generic-geval-ev)
+ (glcp-generic-geval-apply))
+ :expand ((glcp-generic-geval x env)
+ (glcp-generic-geval-list x env)))))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-g-apply-p
+ generic-geval-g-apply-p
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list))
+ :hints ('(:in-theory (e/d* (glcp-generic-geval-ev-of-fncall-args
+ glcp-generic-geval-apply-agrees-with-glcp-generic-geval-ev)
+ (glcp-generic-geval-apply))
+ :expand ((glcp-generic-geval x env)
+ (glcp-generic-geval-list x env)))))
+
+ (in-theory (disable glcp-generic-geval-g-apply-p))
+
+
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-mk-g-ite-correct
+ mk-g-ite-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-mk-g-concrete-correct
+ mk-g-concrete-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-g-concrete-quote-correct
+ g-concrete-quote-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-general-concrete-obj-correct
+ general-concrete-obj-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-of-gl-cons
+ generic-geval-gl-cons
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-g-apply
+ generic-geval-g-apply
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-alt-def
+ generic-geval-alt-def
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list))
+ ;; :do-not-induct
+ ;; t
+ ;; :expand ((glcp-generic-geval x env))))
+ :rule-classes ((:definition :clique (glcp-generic-geval))))
+
+ (in-theory (disable glcp-generic-geval-alt-def))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-general-consp-car-correct
+ general-consp-car-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-general-consp-cdr-correct
+ general-consp-cdr-correct
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list)))
+
+ (acl2::def-functional-instance
+ glcp-generic-geval-consp-general-consp
+ consp-general-consp
+ ((generic-geval-ev glcp-generic-geval-ev)
+ (generic-geval-ev-lst glcp-generic-geval-ev-lst)
+ (generic-geval glcp-generic-geval)
+ (generic-geval-list glcp-generic-geval-list))))
+
+
+
+
+
+(defsection glcp-generic-geval-list
+
+ (local (in-theory (enable glcp-generic-geval-list)))
+
+ (defthm glcp-generic-geval-list-of-cons
+ (equal (glcp-generic-geval-list (cons a b) env)
+ (cons (glcp-generic-geval a env)
+ (glcp-generic-geval-list b env))))
+
+ (defthm glcp-generic-geval-list-of-atom
+ (implies (not (consp x))
+ (equal (glcp-generic-geval-list x env) nil))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ ;; (defthm glcp-generic-geval-when-gobj-list
+ ;; (implies (gobj-listp x)
+ ;; (equal (glcp-generic-geval x env)
+ ;; (glcp-generic-geval-list x env)))
+ ;; :hints (("goal" :induct (gobj-listp x)
+ ;; :in-theory (enable gobj-listp))
+ ;; '(:use ((:instance glcp-generic-geval-of-gl-cons
+ ;; (x (car x)) (y (cdr x))))
+ ;; :in-theory (enable gl-cons gobj-listp))))
+
+ (defthm glcp-generic-geval-list-of-gl-cons
+ (equal (glcp-generic-geval-list (gl-cons x y) env)
+ (cons (glcp-generic-geval x env)
+ (glcp-generic-geval-list y env)))
+ :hints(("Goal" :in-theory (e/d (gl-cons) (glcp-generic-geval-alt-def
+ glcp-generic-geval-general-concrete-obj-correct))
+ :expand ((:with glcp-generic-geval (glcp-generic-geval x env))
+ (:with glcp-generic-geval (glcp-generic-geval (g-concrete
+ x)
+ env))))))
+
+
+ (defthm len-of-glcp-generic-geval-list
+ (equal (len (glcp-generic-geval-list x env))
+ (len x))))
diff -Nru acl2-6.2/books/centaur/gl/glcp-geval.lisp acl2-6.3/books/centaur/gl/glcp-geval.lisp
--- acl2-6.2/books/centaur/gl/glcp-geval.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/glcp-geval.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,104 @@
+
+
+(in-package "GL")
+(include-book "generic-geval")
+(include-book "symbolic-arithmetic-fns")
+(include-book "shape-spec-defs")
+(include-book "gl-mbe")
+
+(defun gl-hide (x)
+ (declare (xargs :guard t))
+ x)
+
+(defun gl-cp-hint (x)
+ (declare (ignore x))
+ t)
+
+(in-theory (disable gl-cp-hint (:type-prescription gl-cp-hint) (gl-cp-hint)))
+
+(def-eval-g glcp-generic-geval
+ (
+ ;; used in shape specs
+ logapp int-set-sign maybe-integer
+ cons car cdr consp if not equal nth len iff
+ shape-spec-slice-to-env
+ ss-append-envs
+ shape-spec-obj-in-range-iff
+ shape-spec-obj-in-range
+ shape-spec-env-slice
+ shape-spec-iff-env-slice
+
+ if gl-cp-hint shape-spec-obj-in-range return-last use-by-hint equal
+ acl2::typespec-check implies iff not cons gl-aside gl-ignore gl-error gl-hide
+ BINARY-*
+ BINARY-+
+ PKG-WITNESS
+; UNARY-/
+ UNARY--
+ COMPLEX-RATIONALP
+; BAD-ATOM<=
+ ACL2-NUMBERP
+ SYMBOL-PACKAGE-NAME
+ INTERN-IN-PACKAGE-OF-SYMBOL
+ CODE-CHAR
+; DENOMINATOR
+ CDR
+; COMPLEX
+ CAR
+ CONSP
+ SYMBOL-NAME
+ CHAR-CODE
+ IMAGPART
+ SYMBOLP
+ REALPART
+; NUMERATOR
+ EQUAL
+ STRINGP
+ RATIONALP
+ CONS
+ INTEGERP
+ CHARACTERP
+ <
+ COERCE
+ booleanp
+ logbitp
+ binary-logand
+ binary-logior
+ lognot
+ ash
+ integer-length
+ floor
+ mod
+ truncate
+ rem
+ acl2::boolfix
+
+ ;; these are from the constant *expandable-boot-strap-non-rec-fns*.
+ NOT IMPLIES
+ EQ ATOM EQL = /= NULL ENDP ZEROP ;; SYNP
+ PLUSP MINUSP LISTP ;; RETURN-LAST causes guard violation
+ ;; FORCE CASE-SPLIT
+ ;; DOUBLE-REWRITE
+
+ ;; used for shape specs
+ acl2::logapp int-set-sign maybe-integer
+
+ ;; force checks
+ gl-force-check gl-force-check-strong gl-force-false gl-force-true
+ ))
+
+(in-theory (disable glcp-generic-geval))
+
+
+
+
+(defund glcp-generic-geval-alist (al env)
+ (declare (xargs :guard (consp env)))
+ (if (atom al)
+ nil
+ (if (consp (car al))
+ (cons (cons (caar al)
+ (glcp-generic-geval (cdar al)
+ env))
+ (glcp-generic-geval-alist (cdr al) env))
+ (glcp-generic-geval-alist (cdr al) env))))
diff -Nru acl2-6.2/books/centaur/gl/glcp-templates.lisp acl2-6.3/books/centaur/gl/glcp-templates.lisp
--- acl2-6.2/books/centaur/gl/glcp-templates.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/glcp-templates.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,346 +1,1152 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
+(include-book "gl-util")
-(include-book "tools/flag" :dir :system)
+(defstobj interp-st
+ is-obligs ;; interp-defs-alistp
+ is-constraint ;; bfr
+ is-constraint-db ;; constraint database
+ )
+
+(defconst *glcp-common-inputs*
+ '(pathcond clk config interp-st bvar-db state))
+
+(defconst *glcp-common-guards*
+ '((acl2::interp-defs-alistp (is-obligs interp-st))
+ (glcp-config-p config)
+ (acl2::interp-defs-alistp (glcp-config->overrides config))))
+
+(defconst *glcp-stobjs* '(interp-st bvar-db state))
+
+(defconst *glcp-common-retvals* '(er interp-st bvar-db state))
+
+(defmacro glcp-value (&rest results)
+ `(mv ,@results nil ,@(cdr *glcp-common-retvals*)))
+
+
+(defun glcp-interp-error-trace (msg)
+ (declare (ignore msg)
+ (xargs :guard t))
+ nil)
+
+(defmacro break-on-glcp-error (flg)
+ (if flg
+ '(trace$ (glcp-interp-error-trace
+ :entry (progn$
+ (cw "GLCP interpreter error:~%~@0~%" msg)
+ (break$))))
+ '(untrace$ glcp-interp-error-trace)))
+
+
+(defmacro glcp-interp-abort (msg &key (nvals '1))
+ `(mv ,@(make-list-ac nvals nil nil)
+ ,msg ,@(cdr *glcp-common-retvals*)))
+
+(defmacro glcp-interp-error (msg &key (nvals '1))
+ (declare (xargs :guard t))
+ `(progn$ (glcp-interp-error-trace ,msg)
+ (glcp-interp-abort ,msg :nvals ,nvals)))
+
+
+(defmacro patbind-glcp-er (args bindings expr)
+ (b* ((nvalsp (member :nvals args))
+ (nvals (or (cadr nvalsp) 1))
+ (args (take (- (len args) (len nvalsp)) args)))
+ `(b* (((mv ,@args patbind-glcp-er-error ,@(cdr *glcp-common-retvals*))
+ ,(car bindings))
+ ((when patbind-glcp-er-error)
+ (glcp-interp-abort patbind-glcp-er-error :nvals ,nvals)))
+ (check-vars-not-free
+ (patbind-glcp-er-error) ,expr))))
+
+(defmacro cpathcond ()
+ '(bfr-and pathcond (is-constraint interp-st)))
+
+
+(defun glcp-put-name-each (name lst)
+ (if (atom lst)
+ nil
+ (cons (incat name (symbol-name name) "-" (symbol-name (car lst)))
+ (glcp-put-name-each name (cdr lst)))))
+
+(mutual-recursion
+ (defun event-forms-collect-fn-names (x)
+ (if (atom x)
+ nil
+ (append (event-form-collect-fn-names (car x))
+ (event-forms-collect-fn-names (cdr x)))))
+ (defun event-form-collect-fn-names (x)
+ (case (car x)
+ ((defun defund) (list (cadr x)))
+ ((mutual-recursion progn)
+ (event-forms-collect-fn-names (cdr x))))))
(defconst *glcp-interp-template*
- '(mutual-recursion
- (defun interp-term (x alist hyp clk obligs config state)
- (declare (xargs :measure (make-ord 1 (1+ (nfix clk)) (acl2-count x))
- :hints (("goal" :in-theory
- (e/d**
- ((:rules-of-class :executable-counterpart :here)
- acl2-count len make-ord nfix o-finp o-first-coeff
- fix o-first-expt o-p o-rst o< car-cons cdr-cons
- commutativity-of-+ ; fold-constants-in-plus
- nfix unicity-of-0 null atom eq
- acl2-count-last-cdr-when-cadr-hack
- car-cdr-elim natp-compound-recognizer
- acl2::zp-compound-recognizer
- acl2::posp-compound-recognizer
- (:type-prescription acl2-count)))))
- :verify-guards nil
- :guard (and (natp clk)
- (pseudo-termp x)
- (acl2::interp-defs-alistp obligs)
- (glcp-config-p config)
- (acl2::interp-defs-alistp
- (glcp-config->overrides config)))
- :stobjs state))
- (cond ((zp clk)
- (glcp-interp-error "The clock ran out.~%"))
-
- ((null x) (glcp-value nil))
-
- ;; X is a variable; look it up in the alist; the result must be a
- ;; g-object because of the gobject-vals-alistp guard.
- ((symbolp x)
- (glcp-value (cdr (hons-assoc-equal x alist))))
-
- ((atom x)
- (glcp-interp-error
- (acl2::msg "GLCP: The unquoted atom ~x0 is not a term~%"
- x)))
-
- ;; X is a quoted (concrete) object. g-concrete-quote creates a
- ;; constant-valued symbolic object. We used to call mk-g-concrete
- ;; here but that scans through the whole cons tree which can be
- ;; expensive. G-concrete-quote just wraps a g-concrete around the
- ;; object unless it's a non-g-keyword atom.
- ((eq (car x) 'quote) (glcp-value (g-concrete-quote
- (car (cdr x)))))
-
- ;; X is a lambda application; interpret each of the actuals, pair up
- ;; the formals with these values, then interpret the body.
- ((consp (car x))
- (b* (((glcp-er actuals)
- (interp-list (cdr x) alist hyp clk obligs config state))
- (formals (car (cdar x)))
- (body (car (cdr (cdar x)))))
- (if (and (equal (len actuals) (len formals))
- (nonnil-symbol-listp formals)
- (acl2::fast-no-duplicatesp formals))
- (interp-term
- body (pairlis$ formals actuals)
- hyp clk obligs config state)
- (glcp-interp-error
- (acl2::msg "Badly formed lambda application: ~x0~%" x)))))
-
- ;; X is an IF; determine first whether it's an OR, then run the
- ;; necessary cases. Note that gli-or and gli-if are macros and the
- ;; arguments are not necessarily all evaluated.
- ((eq (car x) 'if)
- (if (equal (len x) 4)
- (let ((test (car (cdr x)))
- (tbr (car (cdr (cdr x))))
- (fbr (car (cdr (cdr (cdr x))))))
- (if (hons-equal test tbr)
- (glcp-or
- (interp-term test alist hyp clk obligs config state)
- (interp-term fbr alist hyp clk obligs config state))
- (glcp-if
- (interp-term test alist hyp clk obligs config state)
- (interp-term tbr alist hyp clk obligs config state)
- (interp-term fbr alist hyp clk obligs config state))))
- (glcp-interp-error
- "Error: wrong number of args to IF~%")))
-
- ;; GL-ASIDE call: run the arg in a wormhole and produce
- ;; nil.
- ((eq (car x) 'gl-aside)
- (if (eql (len x) 2)
- (prog2$ (gl-aside-wormhole (cadr x) alist)
- (glcp-value nil))
- (glcp-interp-error
- "Error: wrong number of args to GL-ASIDE~%")))
-
- ;; GL-IGNORE call: don't run the arg
- ((eq (car x) 'gl-ignore)
- (glcp-value nil))
+ `(progn
- ;; GL-ERROR call: symbolically execute the arg and store the result in a
- ;; state global, then quit the interpreter.
- ((eq (car x) 'gl-error)
- (if (eql (len x) 2)
- (b* (((glcp-er result)
- (interp-term (cadr x) alist hyp clk obligs config
- state))
- (state (acl2::f-put-global 'gl-error-result result state)))
- (glcp-interp-error
- (acl2::msg
- "Error: GL-ERROR call encountered. Data associated with the ~
+ (mutual-recursion
+ (defun interp-test
+ (x alist intro-bvars . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list (pos-fix clk) 12 0 0)
+ :verify-guards nil
+ :guard (and (posp clk)
+ (pseudo-termp x)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (b* ((clk (1- clk))
+ ((glcp-er xobj)
+ (interp-term-equivs x alist '(iff) . ,*glcp-common-inputs*)))
+ (simplify-if-test xobj intro-bvars . ,*glcp-common-inputs*)))
+
+ (defun interp-term-equivs
+ (x alist contexts . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list clk 2020 (acl2-count x) 40)
+ :guard (and (natp clk)
+ (pseudo-termp x)
+ (contextsp contexts)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (b* (((when (zp clk))
+ (glcp-interp-error "The clock ran out.~%"))
+ ((glcp-er xobj)
+ (interp-term x alist contexts . ,*glcp-common-inputs*))
+ ((mv er xobj) (try-equivalences-loop xobj
+ (cpathcond)
+ contexts clk
+ (glcp-config->param-bfr config)
+ bvar-db state))
+ ((when er) (glcp-interp-error er)))
+ (glcp-value xobj)))
+
+
+
+ (defun interp-term
+ (x alist contexts . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list (pos-fix clk) 2020 (acl2-count x) 20)
+ :well-founded-relation acl2::nat-list-<
+ :hints (("goal"
+ :in-theory (e/d** ((:rules-of-class :executable-counterpart :here)
+ acl2::open-nat-list-<
+ acl2-count len nfix fix
+ acl2-count-of-general-consp-car
+ acl2-count-of-general-consp-cdr
+ car-cons cdr-cons commutativity-of-+
+ unicity-of-0 null atom
+ eq acl2-count-last-cdr-when-cadr-hack
+ car-cdr-elim natp-compound-recognizer
+ acl2::zp-compound-recognizer
+ acl2::posp-compound-recognizer
+ pos-fix
+ g-ite-depth-sum-of-gl-args-split-ite-then
+ g-ite-depth-sum-of-gl-args-split-ite-else
+ g-ite->test-acl2-count-decr
+ g-ite->then-acl2-count-decr
+ g-ite->else-acl2-count-decr
+ g-apply->args-acl2-count-thm
+ acl2-count-of-car-g-apply->args
+ acl2-count-of-cadr-g-apply->args
+ acl2-count-of-car
+ (:type-prescription acl2-count)
+ (:t len)))))
+ :verify-guards nil
+ :guard (and (posp clk)
+ (pseudo-termp x)
+ (contextsp contexts)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (b* (((when (null x)) (glcp-value nil))
+ ((when (symbolp x))
+ (glcp-value (cdr (hons-assoc-equal x alist))))
+ ((when (atom x))
+ (glcp-interp-error
+ (acl2::msg "GLCP: The unquoted atom ~x0 is not a term~%"
+ x)))
+ ((when (eq (car x) 'quote))
+ (glcp-value (g-concrete-quote (car (cdr x)))))
+ ((when (consp (car x)))
+ (b*
+ (((glcp-er actuals)
+ (interp-list (cdr x)
+ alist . ,*glcp-common-inputs*))
+ (formals (car (cdar x)))
+ (body (car (cdr (cdar x)))))
+ (if (and (mbt (and (equal (len actuals) (len formals))
+ (symbol-listp formals)))
+ (acl2::fast-no-duplicatesp formals)
+ (not (member-eq nil formals)))
+ (interp-term body (pairlis$ formals actuals)
+ contexts . ,*glcp-common-inputs*)
+ (glcp-interp-error (acl2::msg "Badly formed lambda application: ~x0~%"
+ x)))))
+ ((when (eq (car x) 'if))
+ (let ((test (car (cdr x)))
+ (tbr (car (cdr (cdr x))))
+ (fbr (car (cdr (cdr (cdr x))))))
+ (interp-if/or test tbr fbr alist contexts . ,*glcp-common-inputs*)))
+
+ ((when (eq (car x) 'gl-aside))
+ (if (eql (len x) 2)
+ (prog2$ (gl-aside-wormhole (cadr x) alist)
+ (glcp-value nil))
+ (glcp-interp-error "Error: wrong number of args to GL-ASIDE~%")))
+ ((when (eq (car x) 'gl-ignore))
+ (glcp-value nil))
+ ((when (eq (car x) 'gl-hide))
+ (glcp-value (gl-term-to-apply-obj x alist)))
+ ((when (eq (car x) 'gl-error))
+ (if (eql (len x) 2)
+ (b* (((glcp-er result)
+ (interp-term (cadr x)
+ alist nil . ,*glcp-common-inputs*))
+ (state (f-put-global 'gl-error-result
+ result state)))
+ (glcp-interp-error
+ (acl2::msg
+ "Error: GL-ERROR call encountered. Data associated with the ~
error is accessible using (@ ~x0).~%"
- 'gl-error-result)))
- (glcp-interp-error
- "Error: wrong number of args to GL-ERROR~%")))
-
- ;; RETURN-LAST - interpret the last argument, i.e. the logical
- ;; value of the term. Insert exceptions before this point.
- ((eq (car x) 'acl2::return-last)
- (if (eql (len x) 4)
- (if (equal (cadr x) ''acl2::time$1-raw)
- (b* (((mv err & time$-args state)
- (interp-term (caddr x) alist hyp clk obligs config state)))
- (mbe :logic (interp-term (car (last x)) alist hyp clk obligs config state)
- :exec (if (and (not err) (general-concretep time$-args))
- (return-last
- 'acl2::time$1-raw
- (general-concrete-obj time$-args)
- (interp-term (car (last x)) alist hyp clk obligs config state))
- (time$ (interp-term (car (last x)) alist hyp clk obligs config state)))))
- (interp-term (car (last x)) alist hyp clk obligs config state))
- (glcp-interp-error
- "Error: wrong number of args to RETURN-LAST~%")))
-
- ;; X is a function call.
- (t (b* ((fn (car x))
-
- ;; Interpret the actuals first.
- ((glcp-er actuals)
- (interp-list (cdr x) alist hyp clk obligs config state))
-
- ;; This function returns the correct result if the function has
- ;; a symbolic counterpart which is known to it.
- ((mv ok ans)
- (run-gified fn actuals hyp clk state))
- ((when ok) (glcp-value ans))
-
- ((mv fncall-failed ans)
- (if (general-concrete-listp actuals)
- (acl2::magic-ev-fncall
- fn (general-concrete-obj-list actuals)
- state t nil)
- (mv t nil)))
- ((unless fncall-failed) (glcp-value (mk-g-concrete ans)))
-
- ((mv erp body formals obligs)
- (acl2::interp-function-lookup
- fn obligs (glcp-config->overrides config) (w state)))
- ((when erp) (glcp-interp-error erp))
- ((unless (equal (len formals) (len actuals)))
- (glcp-interp-error
- (acl2::msg "~
+ 'gl-error-result)))
+ (glcp-interp-error "Error: wrong number of args to GL-ERROR~%")))
+ ((when (eq (car x) 'return-last))
+ (if (eql (len x) 4)
+ (if (equal (cadr x) ''acl2::time$1-raw)
+ (b* (((mv time$-args err ,@(cdr *glcp-common-retvals*))
+ (let ((clk (1- clk)))
+ (interp-term-equivs
+ (caddr x)
+ alist nil . ,*glcp-common-inputs*))))
+ (mbe :logic (interp-term
+ (car (last x)) alist contexts . ,*glcp-common-inputs*)
+ :exec
+ (if (and (not err)
+ (general-concretep time$-args))
+ (return-last
+ 'acl2::time$1-raw
+ (general-concrete-obj time$-args)
+ (interp-term (car (last x))
+ alist contexts . ,*glcp-common-inputs*))
+ (time$
+ (interp-term (car (last x))
+ alist contexts . ,*glcp-common-inputs*)))))
+ (interp-term (car (last x))
+ alist contexts . ,*glcp-common-inputs*))
+ (glcp-interp-error "Error: wrong number of args to RETURN-LAST~%")))
+ (fn (car x))
+ ;; outside-in rewriting?
+ ((glcp-er actuals)
+ (interp-list (cdr x)
+ alist . ,*glcp-common-inputs*)))
+ (interp-fncall-ifs fn actuals x contexts . ,*glcp-common-inputs*)))
+
+ (defun interp-fncall-ifs
+ (fn actuals x contexts . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list (pos-fix clk) 1919 (g-ite-depth-sum actuals) 20)
+ :guard (and (posp clk)
+ (symbolp fn)
+ (contextsp contexts)
+ (not (eq fn 'quote))
+ (true-listp actuals)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (b* (((unless (glcp-lift-ifsp fn (glcp-config->lift-ifsp config)
+ (w state)))
+ (interp-fncall fn actuals x contexts . ,*glcp-common-inputs*))
+ ((mv has-if test then-args else-args)
+ (gl-args-split-ite actuals))
+ ((unless has-if)
+ (interp-fncall fn actuals x contexts . ,*glcp-common-inputs*))
+ ((glcp-er test-bfr)
+ (simplify-if-test test t . ,*glcp-common-inputs*))
+ ((glcp-er then-obj)
+ (maybe-interp-fncall-ifs fn then-args x contexts test-bfr
+ . ,*glcp-common-inputs*))
+ ((glcp-er else-obj)
+ (maybe-interp-fncall-ifs fn else-args x contexts (bfr-not test-bfr)
+ . ,*glcp-common-inputs*)))
+ (merge-branches test-bfr then-obj else-obj nil contexts . ,*glcp-common-inputs*)))
+
+
+ (defun maybe-interp-fncall-ifs (fn actuals x contexts branchcond . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list (pos-fix clk) 1919 (g-ite-depth-sum actuals) 45)
+ :verify-guards nil
+ :guard (and (posp clk)
+ (symbolp fn)
+ (contextsp contexts)
+ (not (eq fn 'quote))
+ (true-listp actuals)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (let ((branchcond (hyp-fix branchcond (cpathcond))))
+ (if branchcond
+ (let ((pathcond (bfr-and pathcond branchcond)))
+ (interp-fncall-ifs
+ fn actuals x contexts . ,*glcp-common-inputs*))
+ (glcp-value nil))))
+
+ (defun interp-fncall
+ (fn actuals x contexts . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list (pos-fix clk) 1414 0 20)
+ :guard (and (posp clk)
+ (symbolp fn)
+ (not (eq fn 'quote))
+ (true-listp actuals)
+ (contextsp contexts)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (b* ((uninterp (cdr (hons-assoc-equal fn (table-alist
+ 'gl-uninterpreted-functions (w
+ state)))))
+ ((mv fncall-failed ans)
+ (if (and (not uninterp)
+ (general-concrete-listp actuals))
+ (acl2::magic-ev-fncall fn (general-concrete-obj-list actuals)
+ state t nil)
+ (mv t nil)))
+ ((unless fncall-failed)
+ (glcp-value (mk-g-concrete ans)))
+ ((glcp-er successp term bindings)
+ (rewrite fn actuals :fncall contexts . ,*glcp-common-inputs*))
+ ((when successp)
+ (b* ((clk (1- clk)))
+ (interp-term-equivs term bindings contexts . ,*glcp-common-inputs*)))
+ ((mv ok ans)
+ (run-gified fn actuals (cpathcond) clk config bvar-db state))
+ ((when ok) (glcp-value ans))
+ ((when (cdr (hons-assoc-equal fn (table-alist 'gl-uninterpreted-functions (w state)))))
+ (glcp-value (g-apply fn actuals)))
+ ((mv erp body formals obligs1)
+ (acl2::interp-function-lookup fn
+ (is-obligs interp-st)
+ (glcp-config->overrides config)
+ (w state)))
+ ((when erp) (glcp-interp-error erp))
+ (interp-st (update-is-obligs obligs1 interp-st))
+ ((unless (equal (len formals) (len actuals)))
+ (glcp-interp-error
+ (acl2::msg
+ "~
In the function call ~x0, function ~x1 is given ~x2 arguments,
but its arity is ~x3. Its formal parameters are ~x4."
- x fn (len actuals) (len formals) formals))))
- (interp-term
- body (pairlis$ formals actuals) hyp (1- clk)
- obligs config state)))))
- (defun interp-list (x alist hyp clk obligs config state)
- (declare (xargs :measure (make-ord 1 (1+ (nfix clk)) (acl2-count x))
- :guard (and (natp clk)
- (pseudo-term-listp x)
- (acl2::interp-defs-alistp obligs)
- (glcp-config-p config)
- (acl2::interp-defs-alistp (glcp-config->overrides config)))
- :stobjs state))
- (if (atom x)
- (glcp-value nil)
- (b* (((glcp-er car)
- (interp-term (car x) alist hyp clk obligs config state))
- ((glcp-er cdr)
- (interp-list (cdr x) alist hyp clk obligs config state)))
- (glcp-value (gl-cons car cdr)))))))
-
-(defconst *glcp-run-parametrized-template*
- '(defun run-parametrized
- (hyp concl untrans-concl vars bindings id obligs config state)
- (b* ((bound-vars (strip-cars bindings))
- ((glcp-config config) config)
- ((er hyp)
- (if (pseudo-termp hyp)
- (let ((hyp-unbound-vars
- (set-difference-eq (collect-vars hyp)
- bound-vars)))
- (if hyp-unbound-vars
- (prog2$ (flush-hons-get-hash-table-link obligs)
- (glcp-error (acl2::msg "~
+ x fn (len actuals)
+ (len formals)
+ formals)))
+ (clk (1- clk)))
+ (interp-term-equivs body (pairlis$ formals actuals)
+ contexts . ,*glcp-common-inputs*)))
+
+ (defun interp-if/or (test tbr fbr alist contexts . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list (pos-fix clk) 2020 (+ (acl2-count test)
+ (acl2-count tbr)
+ (acl2-count fbr)) 60)
+ :verify-guards nil
+ :guard (and (posp clk)
+ (pseudo-termp test)
+ (pseudo-termp tbr)
+ (pseudo-termp fbr)
+ (contextsp contexts)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (if (hqual test tbr)
+ (interp-or test fbr alist contexts . ,*glcp-common-inputs*)
+ (interp-if test tbr fbr alist contexts . ,*glcp-common-inputs*)))
+
+ (defun maybe-interp (x alist contexts branchcond . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list (pos-fix clk) 2020 (acl2-count x) 45)
+ :verify-guards nil
+ :guard (and (natp clk)
+ (pseudo-termp x)
+ (contextsp contexts)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (let ((branchcond (hyp-fix branchcond (cpathcond))))
+ (if branchcond
+ (let ((pathcond (bfr-and pathcond branchcond)))
+ (interp-term-equivs
+ x alist contexts . ,*glcp-common-inputs*))
+ (glcp-value nil))))
+
+ (defun interp-or (test fbr alist contexts . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list (pos-fix clk) 2020 (+ (acl2-count test)
+ (acl2-count fbr)) 50)
+ :verify-guards nil
+ :guard (and (posp clk)
+ (pseudo-termp test)
+ (pseudo-termp fbr)
+ (contextsp contexts)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (b* (((glcp-er test-obj)
+ (interp-term-equivs
+ test alist (glcp-or-test-contexts contexts) . ,*glcp-common-inputs*))
+ ((glcp-er test-bfr)
+ (simplify-if-test test-obj t . ,*glcp-common-inputs*))
+ ((glcp-er else)
+ (maybe-interp
+ fbr alist contexts (bfr-not test-bfr) . ,*glcp-common-inputs*)))
+ (merge-branches test-bfr test-obj else nil contexts . ,*glcp-common-inputs*)))
+
+ (defun interp-if (test tbr fbr alist contexts . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list (pos-fix clk) 2020 (+ (acl2-count test)
+ (acl2-count tbr)
+ (acl2-count fbr)) 50)
+ :verify-guards nil
+ :guard (and (posp clk)
+ (pseudo-termp test)
+ (pseudo-termp tbr)
+ (pseudo-termp fbr)
+ (contextsp contexts)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (b* (((glcp-er test-bfr)
+ (interp-test
+ test alist t . ,*glcp-common-inputs*))
+ ((glcp-er then)
+ (maybe-interp
+ tbr alist contexts test-bfr . ,*glcp-common-inputs*))
+ ((glcp-er else)
+ (maybe-interp
+ fbr alist contexts (bfr-not test-bfr) . ,*glcp-common-inputs*)))
+ (merge-branches test-bfr then else nil contexts . ,*glcp-common-inputs*)))
+
+ (defun merge-branches (test-bfr then else switchedp contexts . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list (pos-fix clk) 1818
+ (+ (acl2-count then) (acl2-count else))
+ (if switchedp 20 30))
+ :verify-guards nil
+ :guard (and (posp clk)
+ (contextsp contexts)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (b* (((when (eq test-bfr t)) (glcp-value then))
+ ((when (eq test-bfr nil)) (glcp-value else))
+ ((when (hons-equal then else)) (glcp-value then))
+ ((when (or (atom then)
+ (and (g-keyword-symbolp (tag then))
+ (or (not (eq (tag then) :g-apply))
+ (not (symbolp (g-apply->fn then)))
+ (eq (g-apply->fn then) 'quote)))))
+ (if switchedp
+ (merge-branch-subterms
+ (bfr-not test-bfr) else then . ,*glcp-common-inputs*)
+ (merge-branches (bfr-not test-bfr) else then t contexts . ,*glcp-common-inputs*)))
+ (fn (if (eq (tag then) :g-apply)
+ (g-apply->fn then)
+ 'cons))
+ (rules (glcp-get-branch-merge-rules fn (w state)))
+ (runes (rewrite-rules->runes rules))
+ ((glcp-er successp term bindings)
+ (rewrite-apply-rules
+ rules runes 'if (list (g-boolean test-bfr) then else)
+ contexts . ,*glcp-common-inputs*))
+ ((when successp)
+ (b* ((clk (1- clk)))
+ (interp-term-equivs term bindings contexts . ,*glcp-common-inputs*))))
+ (if switchedp
+ (merge-branch-subterms (bfr-not test-bfr) else then . ,*glcp-common-inputs*)
+ (merge-branches (bfr-not test-bfr) else then t contexts . ,*glcp-common-inputs*))))
+
+ (defun merge-branch-subterms (test-bfr then else
+ . ,*glcp-common-inputs*)
+ (declare (xargs :measure (list (pos-fix clk) 1818
+ (+ (acl2-count then) (acl2-count else))
+ 15)
+ :guard (and (posp clk)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (b* (((when (or (atom then)
+ (atom else)
+ (xor (eq (tag then) :g-apply)
+ (eq (tag else) :g-apply))
+ (not (or (eq (tag then) :g-apply)
+ (and (general-consp then)
+ (general-consp else))))
+ (and (eq (tag then) :g-apply)
+ (not (and (symbolp (g-apply->fn then))
+ (not (eq (g-apply->fn then) 'quote))
+ (eq (g-apply->fn then) (g-apply->fn else))
+ (int= (len (g-apply->args then))
+ (len (g-apply->args else))))))))
+ (glcp-value (gobj-ite-merge test-bfr then else (cpathcond))))
+ ((unless (eq (tag then) :g-apply))
+ (b* (((glcp-er car) (merge-branches test-bfr
+ (general-consp-car then)
+ (general-consp-car else)
+ nil nil . ,*glcp-common-inputs*))
+ ((glcp-er cdr) (merge-branches test-bfr
+ (general-consp-cdr then)
+ (general-consp-cdr else)
+ nil nil . ,*glcp-common-inputs*)))
+ (glcp-value ;; (gl-cons-split-ite car cdr)
+ (gl-cons-maybe-split car cdr
+ (glcp-config->split-conses config)
+ (w state)))))
+ ((glcp-er args)
+ (merge-branch-subterm-lists test-bfr
+ (g-apply->args then)
+ (g-apply->args else)
+ . ,*glcp-common-inputs*)))
+ (glcp-value (gl-fncall-maybe-split
+ (g-apply->fn then) args
+ (glcp-config->split-fncalls config)
+ (w state)))))
+
+ (defun merge-branch-subterm-lists (test-bfr then else
+ . ,*glcp-common-inputs*)
+ (declare (xargs :measure (list (pos-fix clk) 1818
+ (+ (acl2-count then) (acl2-count else))
+ 15)
+ :guard (and (posp clk)
+ (equal (len then) (len else))
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (b* (((when (atom then))
+ (glcp-value nil))
+ ((cons then1 thenr) then)
+ ((cons else1 elser) else)
+ ((glcp-er rest) (merge-branch-subterm-lists test-bfr thenr elser
+ . ,*glcp-common-inputs*))
+ ((glcp-er first) (merge-branches test-bfr then1 else1 nil nil
+ . ,*glcp-common-inputs*)))
+ (glcp-value (cons first rest))))
+
+ ;; (defun maybe-simplify-if-test (test-obj intro-bvars branchcond
+ ;; . ,*glcp-common-inputs*)
+ ;; (declare (xargs
+ ;; :measure (list clk 1300 (acl2-count test-obj) 15)
+ ;; :verify-guards nil
+ ;; :guard (and (natp clk)
+ ;; . ,*glcp-common-guards*)
+ ;; :stobjs ,*glcp-stobjs*))
+ ;; (if branchcond
+ ;; (let ((pathcond (bfr-and pathcond branchcond)))
+ ;; (simplify-if-test
+ ;; then intro-bvars . ,*glcp-common-inputs*))
+ ;; (glcp-value nil)))
+
+ ;; returns a glcp-value of a bfr
+ (defun simplify-if-test (test-obj intro-bvars . ,*glcp-common-inputs*)
+ (declare (xargs
+ :measure (list clk 1300 (acl2-count test-obj) 10)
+ :verify-guards nil
+ :guard (and (natp clk)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (if (atom test-obj)
+ (glcp-value (and test-obj t))
+ (pattern-match test-obj
+ ((g-boolean bfr) (glcp-value (hyp-fix bfr (cpathcond))))
+ ((g-number &) (glcp-value t))
+ ((g-concrete v) (glcp-value (and v t)))
+ ((g-var &)
+ (b* (((mv bvar bvar-db) (add-term-bvar-unique test-obj bvar-db))
+ (bvar-db (maybe-add-equiv-term test-obj bvar bvar-db state)))
+ (glcp-value (hyp-fix
+ (bfr-to-param-space (glcp-config->param-bfr config)
+ (bfr-var bvar))
+ (cpathcond)))))
+ ((g-ite test then else)
+ (b* ((hyp pathcond)
+ ((glcp-er test-bfr) (simplify-if-test
+ test intro-bvars . ,*glcp-common-inputs*))
+ (then-hyp test-bfr)
+ (else-hyp (bfr-not test-bfr))
+ ((glcp-er then-bfr)
+ (if then-hyp
+ (let ((pathcond (bfr-and hyp then-hyp)))
+ (simplify-if-test
+ then intro-bvars . ,*glcp-common-inputs*))
+ (glcp-value nil)))
+ ((glcp-er else-bfr)
+ (if else-hyp
+ (let ((pathcond (bfr-and hyp else-hyp)))
+ (simplify-if-test
+ else intro-bvars . ,*glcp-common-inputs*))
+ (glcp-value nil))))
+ ;; Seems unlikely that hyp-fix would give any reductions here:
+ ;; maybe test this
+ (glcp-value (bfr-ite test-bfr then-bfr else-bfr))))
+ ((g-apply fn args)
+ (simplify-if-test-fncall fn args intro-bvars . ,*glcp-common-inputs*))
+ (& ;; cons
+ (glcp-value t)))))
+
+
+ (defun simplify-if-test-fncall (fn args intro-bvars
+ . ,*glcp-common-inputs*)
+
+ (declare (xargs
+ :measure (list clk 1300 (acl2-count args) 10)
+ :verify-guards nil
+ :guard (and (natp clk)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+
+ (b* (((when (or (not (symbolp fn))
+ (eq fn 'quote)))
+ (glcp-interp-error (acl2::msg "Non function symbol in g-apply: ~x0" fn)))
+
+ ((when (and (eq fn 'not)
+ (eql (len args) 1)))
+ (b* (((glcp-er neg-bfr)
+ (simplify-if-test (first args) intro-bvars . ,*glcp-common-inputs*)))
+ (glcp-value (bfr-not neg-bfr))))
+ ((when (and (eq fn 'equal)
+ (eql (len args) 2)
+ (or (eq (car args) nil)
+ (eq (cadr args) nil))))
+ (b* (((glcp-er neg-bfr)
+ (simplify-if-test (or (car args) (cadr args)) intro-bvars . ,*glcp-common-inputs*)))
+ (glcp-value (bfr-not neg-bfr))))
+
+ ((when (and (eq fn 'gl-force-check)
+ (eql (len args) 1)))
+ (b* (((glcp-er sub-bfr)
+ (simplify-if-test (first args) intro-bvars . ,*glcp-common-inputs*)))
+ (glcp-value (bfr-constcheck sub-bfr))))
+
+ ((when (and (eq fn 'gl-force-check-strong)
+ (eql (len args) 1)))
+ (b* (((glcp-er sub-bfr)
+ (simplify-if-test (first args) intro-bvars . ,*glcp-common-inputs*)))
+ (glcp-value (bfr-constcheck-pathcond sub-bfr (cpathcond)))))
+
+ ((when (and (eq fn 'gl-force-true)
+ (eql (len args) 1)))
+ (b* (((glcp-er sub-bfr)
+ (simplify-if-test (first args) intro-bvars . ,*glcp-common-inputs*)))
+ (glcp-value (bfr-check-true sub-bfr))))
+
+ ((when (and (eq fn 'gl-force-false)
+ (eql (len args) 1)))
+ (b* (((glcp-er sub-bfr)
+ (simplify-if-test (first args) intro-bvars . ,*glcp-common-inputs*)))
+ (glcp-value (bfr-check-false sub-bfr))))
+
+ ((when (zp clk))
+ (glcp-interp-error "Clock ran out in simplify-if-test"))
+
+ ((glcp-er successp term bindings)
+ (rewrite fn args :if-test '(iff) . ,*glcp-common-inputs*))
+ ((when successp)
+ (interp-test term bindings intro-bvars
+ . ,*glcp-common-inputs*))
+
+ (x (g-apply fn args))
+ (look (get-term->bvar x bvar-db))
+
+ ((when look)
+ (glcp-value
+ (hyp-fix (bfr-to-param-space (glcp-config->param-bfr config)
+ (bfr-var look))
+ (cpathcond))))
+
+ ((unless intro-bvars)
+ (glcp-interp-abort :intro-bvars-fail))
+
+ (bvar (next-bvar bvar-db))
+ (bvar-db (add-term-bvar x bvar-db))
+ (bvar-db (maybe-add-equiv-term x bvar bvar-db state))
+ ((glcp-er) (add-bvar-constraints x . ,*glcp-common-inputs*)))
+ (glcp-value (hyp-fix (bfr-to-param-space (glcp-config->param-bfr config)
+ (bfr-var bvar))
+ (cpathcond)))))
+
+ (defun add-bvar-constraints (lit . ,*glcp-common-inputs*)
+ (declare (xargs :stobjs ,*glcp-stobjs*
+ :guard (and (posp clk)
+ . ,*glcp-common-guards*)
+ :measure (list (pos-fix clk) 1000 0 0))
+ (ignorable pathcond))
+ (b* ((ccat (is-constraint-db interp-st))
+ ((mv substs ccat) (ec-call (gbc-process-new-lit lit ccat state)))
+ (interp-st (update-is-constraint-db ccat interp-st)))
+ (add-bvar-constraint-substs substs . ,*glcp-common-inputs*)))
+
+ (defun add-bvar-constraint-substs (substs . ,*glcp-common-inputs*)
+ (declare (xargs :stobjs ,*glcp-stobjs*
+ :guard (and (posp clk)
+ . ,*glcp-common-guards*)
+ :measure (list (pos-fix clk) 900 (len substs) 0))
+ (ignorable pathcond))
+ (b* (((when (atom substs)) (glcp-value))
+ (subst (car substs))
+ ((unless (and (consp subst)
+ (symbolp (car subst))
+ (alistp (cdr subst))))
+ (add-bvar-constraint-substs (cdr substs) . ,*glcp-common-inputs*))
+ ((cons thm alist) subst)
+ (thm-body (acl2::meta-extract-formula thm state))
+ ((unless (pseudo-termp thm-body))
+ (add-bvar-constraint-substs (cdr substs) . ,*glcp-common-inputs*))
+ ((mv new-constraint . ,*glcp-common-retvals*)
+ (let* ((pathcond t))
+ (interp-test thm-body alist nil . ,*glcp-common-inputs*)))
+ ((when (eq er :intro-bvars-fail))
+ (add-bvar-constraint-substs (cdr substs) . ,*glcp-common-inputs*))
+ ((when er) (glcp-interp-abort er :nvals 0))
+ (curr-constraint (is-constraint interp-st))
+ (interp-st (update-is-constraint (bfr-and
+ (hyp-fix new-constraint curr-constraint)
+ curr-constraint)
+ interp-st)))
+ (add-bvar-constraint-substs (cdr substs) . ,*glcp-common-inputs*)))
+
+
+ (defun rewrite (fn actuals rwtype contexts . ,*glcp-common-inputs*)
+ (declare (xargs :stobjs ,*glcp-stobjs*
+ :guard (and (posp clk)
+ (symbolp fn)
+ (not (eq fn 'quote))
+ (contextsp contexts)
+ . ,*glcp-common-guards*)
+ :measure (list (pos-fix clk) 1212 0 0))
+ (ignorable rwtype))
+
+ ;; (mv erp obligs1 successp term bindings bvar-db state)
+ (b* ((rules (cdr (hons-assoc-equal fn (table-alist 'gl-rewrite-rules (w state)))))
+ ;; or perhaps we should pass the table in the obligs? see if this is
+ ;; expensive
+ ((unless (and rules (true-listp rules))) ;; optimization (important?)
+ (glcp-value nil nil nil))
+ (fn-rewrites (getprop fn 'acl2::lemmas nil 'current-acl2-world (w state))))
+ (rewrite-apply-rules
+ fn-rewrites rules fn actuals contexts . ,*glcp-common-inputs*)))
+
+
+ (defun rewrite-apply-rules
+ (fn-rewrites rules fn actuals contexts . ,*glcp-common-inputs*)
+ (declare (xargs :stobjs ,*glcp-stobjs*
+ :guard (and (true-listp rules)
+ (posp clk)
+ (symbolp fn)
+ (not (eq fn 'quote))
+ (contextsp contexts)
+ . ,*glcp-common-guards*)
+ :measure (list (pos-fix clk) 88 (len fn-rewrites) 0)))
+ (b* (((when (atom fn-rewrites))
+ ;; no more rules, fail
+ (glcp-value nil nil nil))
+ (rule (car fn-rewrites))
+ ((unless (acl2::weak-rewrite-rule-p rule))
+ (cw "malformed rewrite rule?? ~x0~%" rule)
+ (rewrite-apply-rules
+ (cdr fn-rewrites) rules fn actuals contexts . ,*glcp-common-inputs*))
+ ((unless (member-equal (acl2::rewrite-rule->rune rule) rules))
+ (rewrite-apply-rules
+ (cdr fn-rewrites) rules fn actuals contexts . ,*glcp-common-inputs*))
+ ((glcp-er successp term bindings :nvals 3)
+ (rewrite-apply-rule
+ rule fn actuals contexts . ,*glcp-common-inputs*))
+ ((when successp)
+ (glcp-value successp term bindings)))
+ (rewrite-apply-rules
+ (cdr fn-rewrites) rules fn actuals contexts . ,*glcp-common-inputs*)))
+
+ (defun rewrite-apply-rule
+ (rule fn actuals contexts . ,*glcp-common-inputs*)
+ (declare (xargs :stobjs ,*glcp-stobjs*
+ :guard (and (acl2::weak-rewrite-rule-p rule)
+ (posp clk)
+ (symbolp fn)
+ (not (eq fn 'quote))
+ (contextsp contexts)
+ . ,*glcp-common-guards*)
+ :measure (list (pos-fix clk) 44 0 0)))
+ (b* (((rewrite-rule rule) rule)
+ ((unless (and (symbolp rule.equiv)
+ (not (eq rule.equiv 'quote))
+ ;; (ensure-equiv-relationp rule.equiv (w state))
+ (not (eq rule.subclass 'acl2::meta))
+ (pseudo-termp rule.lhs)
+ (consp rule.lhs)
+ (eq (car rule.lhs) fn)))
+ (cw "malformed gl rewrite rule (lhs)?? ~x0~%" rule)
+ (glcp-value nil nil nil))
+ ((unless (or (eq rule.equiv 'equal)
+ ;; bozo check refinements
+ (member rule.equiv contexts)))
+ (glcp-value nil nil nil))
+ ((mv unify-ok gobj-bindings)
+ (glcp-unify-term/gobj-list (cdr rule.lhs) actuals nil))
+ ((unless unify-ok) (glcp-value nil nil nil))
+ ((unless (pseudo-term-listp rule.hyps))
+ (cw "malformed gl rewrite rule (hyps)?? ~x0~%" rule)
+ (glcp-value nil nil nil))
+ ((glcp-er hyps-ok gobj-bindings :nvals 3)
+ (relieve-hyps rule.rune rule.hyps gobj-bindings . ,*glcp-common-inputs*))
+ ((unless hyps-ok) (glcp-value nil nil nil))
+ ((unless (pseudo-termp rule.rhs))
+ (cw "malformed gl rewrite rule (rhs)?? ~x0~%" rule)
+ (glcp-value nil nil nil)))
+ (glcp-value t rule.rhs gobj-bindings)))
+
+ (defun relieve-hyps (rune hyps bindings . ,*glcp-common-inputs*)
+ (declare (xargs :stobjs ,*glcp-stobjs*
+ :guard (and (pseudo-term-listp hyps)
+ (posp clk)
+ . ,*glcp-common-guards*)
+ :measure (list (pos-fix clk) 22 (len hyps) 0))
+ (ignorable rune))
+ (b* (((when (atom hyps)) (glcp-value t bindings))
+ ((glcp-er ok bindings :nvals 2)
+ (relieve-hyp rune (car hyps) bindings . ,*glcp-common-inputs*))
+ ((when (not ok)) (glcp-value nil bindings)))
+ (relieve-hyps rune (cdr hyps) bindings . ,*glcp-common-inputs*)))
+
+ (defun relieve-hyp (rune hyp bindings . ,*glcp-common-inputs*)
+ (declare (xargs :stobjs ,*glcp-stobjs*
+ :guard (and (pseudo-termp hyp)
+ (posp clk)
+ . ,*glcp-common-guards*)
+ :measure (list (pos-fix clk) 15 0 0))
+ (ignorable rune))
+ ;; "Simple" version for now; maybe free variable bindings, syntaxp, etc later...
+ (b* (((when (and (consp hyp) (eq (car hyp) 'synp)))
+ (b* (((mv erp successp bindings)
+ (glcp-relieve-hyp-synp hyp bindings state))
+ ((when erp) (glcp-interp-error
+ (if (eq erp t) "t" erp) :nvals 2)))
+ (glcp-value successp bindings)))
+ ((mv bfr . ,*glcp-common-retvals*)
+ (interp-test hyp bindings nil . ,*glcp-common-inputs*))
+ ((when (eq er :intro-bvars-fail))
+ (glcp-value nil bindings))
+ ((when er) (glcp-interp-abort er :nvals 2))
+ ((when (eq bfr t))
+ (glcp-value t bindings)))
+ (glcp-value nil bindings)))
+
+ (defun interp-list
+ (x alist . ,*glcp-common-inputs*)
+ (declare
+ (xargs
+ :measure (list (pos-fix clk) 2020 (acl2-count x) 20)
+ :guard (and (natp clk)
+ (pseudo-term-listp x)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*))
+ (if (atom x)
+ (glcp-value nil)
+ (b* (((glcp-er car)
+ (interp-term-equivs (car x)
+ alist nil . ,*glcp-common-inputs*))
+ ((glcp-er cdr)
+ (interp-list (cdr x)
+ alist . ,*glcp-common-inputs*)))
+ (glcp-value (cons car cdr))))))
+
+ (defund interp-top-level-term
+ (term alist . ,*glcp-common-inputs*)
+ (declare (xargs :guard (and (pseudo-termp term)
+ (natp clk)
+ . ,*glcp-common-guards*)
+ :stobjs ,*glcp-stobjs*
+ :verify-guards nil))
+ (b* ((config (glcp-config-update-term term config)))
+ (interp-test
+ term alist t . ,*glcp-common-inputs*)))
+
+ (defund interp-concl
+ (term alist pathcond clk config interp-st bvar-db1 bvar-db state)
+ (declare (xargs :guard (and (pseudo-termp term)
+ (natp clk)
+ . ,*glcp-common-guards*)
+ :stobjs (interp-st bvar-db bvar-db1 state)
+ :verify-guards nil))
+ (b* ((al (gobj-alist-to-param-space alist pathcond))
+ (bvar-db (init-bvar-db (base-bvar bvar-db1) bvar-db))
+ (bvar-db (parametrize-bvar-db pathcond bvar-db1 bvar-db))
+ (constraint (bfr-to-param-space pathcond
+ (is-constraint interp-st)))
+ (constraint-db (parametrize-constraint-db pathcond
+ (is-constraint-db interp-st)))
+ (config (glcp-config-update-param pathcond config))
+ (interp-st (update-is-constraint constraint
+ interp-st))
+ (interp-st (update-is-constraint-db constraint-db interp-st))
+
+ ((unless pathcond)
+ (glcp-value nil))
+ (pathcond (bfr-to-param-space pathcond pathcond)))
+ (interp-top-level-term
+ term al . ,*glcp-common-inputs*)))
+
+ (defund interp-hyp/concl
+ (hyp concl alist clk config interp-st next-bvar bvar-db bvar-db1 state)
+ (declare (xargs :guard (and (pseudo-termp hyp)
+ (pseudo-termp concl)
+ (natp clk)
+ . ,*glcp-common-guards*)
+ :stobjs (interp-st bvar-db bvar-db1 state)
+ :verify-guards nil))
+ (b* ((bvar-db (init-bvar-db next-bvar bvar-db))
+ (bvar-db1 (init-bvar-db next-bvar bvar-db1))
+ (config (glcp-config-update-param t config))
+ ((mv hyp-bfr . ,*glcp-common-retvals*)
+ (let ((pathcond t))
+ (interp-top-level-term
+ hyp alist . ,*glcp-common-inputs*)))
+ ((when er)
+ (mv hyp-bfr nil bvar-db1 . ,*glcp-common-retvals*))
+ ((when (and (glcp-config->abort-vacuous config)
+ (not hyp-bfr)))
+ (mv hyp-bfr nil bvar-db1
+ "Hypothesis is not satisfiable"
+ . ,(cdr *glcp-common-retvals*)))
+ (- (and (not hyp-bfr)
+ (cw "Note: hypothesis is not satisfiable~%")))
+ ((mv concl-bfr . ,(subst 'bvar-db1 'bvar-db *glcp-common-retvals*))
+ (interp-concl
+ concl alist hyp-bfr clk config interp-st bvar-db bvar-db1 state)))
+ (mv hyp-bfr concl-bfr bvar-db1 . ,*glcp-common-retvals*)))
+
+ ;; almost-user-level wrapper
+ (defun interp-term-under-hyp (hyp term al next-bvar config interp-st bvar-db bvar-db1 state)
+ (declare (xargs :stobjs (interp-st bvar-db bvar-db1 state)
+ :verify-guards nil))
+ (b* ((bvar-db (init-bvar-db next-bvar bvar-db))
+ (bvar-db1 (init-bvar-db next-bvar bvar-db1))
+ (interp-st (update-is-obligs nil interp-st))
+ (interp-st (update-is-constraint t interp-st))
+ (interp-st (update-is-constraint-db (table-alist
+ 'gl-bool-constraints (w state))
+ interp-st))
+ ((mv hyp-bfr er interp-st bvar-db state)
+ (interp-top-level-term
+ hyp al t 1000000 config interp-st bvar-db state))
+ ((when er) (mv nil nil nil er interp-st bvar-db bvar-db1 state))
+ (param-al (gobj-alist-to-param-space al hyp-bfr))
+ (bvar-db1 (parametrize-bvar-db hyp-bfr bvar-db bvar-db1))
+ (config (glcp-config-update-param hyp-bfr config))
+ (pathcond (bfr-to-param-space hyp-bfr hyp-bfr))
+ ((mv res-obj erp interp-st bvar-db1 state)
+ (interp-term
+ term param-al nil pathcond 100000 config interp-st bvar-db1 state)))
+ (mv hyp-bfr param-al res-obj erp interp-st bvar-db bvar-db1 state)))))
+
+
+#||
+
+"GL"
+(trace$ (glcp-rewrite-fncall-apply-rule
+ :cond (b* (((rewrite-rule rule) rule)
+ ((unless (eq (cadr rule.rune) 'logand-of-logapp))
+ nil)
+ ((unless (and (eq rule.equiv 'equal)
+ (not (eq rule.subclass 'acl2::meta))
+ (pseudo-termp rule.lhs)
+ (consp rule.lhs)
+ (eq (car rule.lhs) fn)))
+ (cw "malformed gl rewrite rule (lhs)?? ~x0~%" rule))
+ ((mv unify-ok ?gobj-bindings)
+ (glcp-unify-term/gobj-list (cdr rule.lhs) actuals nil)))
+ unify-ok)))
+
+
+||#
+
+(defconst *glcp-clause-proc-template*
+ `(progn
+ (defun run-parametrized
+ (hyp concl vars bindings id obligs config state)
+ (b* ((bound-vars (strip-cars bindings))
+ ((glcp-config config) config)
+ ((er hyp)
+ (if (pseudo-termp hyp)
+ (let ((hyp-unbound-vars
+ (set-difference-eq (collect-vars hyp)
+ bound-vars)))
+ (if hyp-unbound-vars
+ (prog2$ (flush-hons-get-hash-table-link obligs)
+ (glcp-error (acl2::msg "~
In ~@0: The hyp contains the following unbound variables: ~x1~%"
- id hyp-unbound-vars)))
- (value hyp)))
- (glcp-error "The hyp is not a pseudo-term.~%")))
- ((unless (shape-spec-bindingsp bindings))
- (flush-hons-get-hash-table-link obligs)
- (glcp-error
- (acl2::msg "~
+ id hyp-unbound-vars)))
+ (value hyp)))
+ (glcp-error "The hyp is not a pseudo-term.~%")))
+ ((unless (shape-spec-bindingsp bindings))
+ (flush-hons-get-hash-table-link obligs)
+ (glcp-error
+ (acl2::msg "~
In ~@0: the bindings don't satisfy shape-spec-bindingsp: ~x1"
- id bindings)))
- (obj (strip-cadrs bindings))
- ((unless (and (acl2::fast-no-duplicatesp (shape-spec-indices obj))
- (acl2::fast-no-duplicatesp-equal (shape-spec-vars obj))))
- (flush-hons-get-hash-table-link obligs)
- (glcp-error
- (acl2::msg "~
+ id bindings)))
+ (obj (strip-cadrs bindings))
+ ((unless (and (acl2::fast-no-duplicatesp (shape-spec-list-indices obj))
+ (acl2::fast-no-duplicatesp-equal (shape-spec-list-vars obj))))
+ (flush-hons-get-hash-table-link obligs)
+ (glcp-error
+ (acl2::msg "~
In ~@0: the indices or variables contain duplicates in bindings ~x1"
- id bindings)))
- ((unless (subsetp-equal vars bound-vars))
- (flush-hons-get-hash-table-link obligs)
- (glcp-error
- (acl2::msg "~
+ id bindings)))
+ ((unless (subsetp-equal vars bound-vars))
+ (flush-hons-get-hash-table-link obligs)
+ (glcp-error
+ (acl2::msg "~
In ~@0: The conclusion countains the following unbound variables: ~x1~%"
- id (set-difference-eq vars bound-vars))))
- (al (shape-specs-to-interp-al bindings))
- (cov-clause
- (list '(not (gl-cp-hint 'coverage))
- (dumb-negate-lit hyp)
- `(shape-spec-obj-in-range
- ',obj
- ,(list*-macro (append (strip-cars bindings)
- (list ''nil))))))
- ((mv er obligs1 hyp-val state)
- (interp-term hyp al t config.hyp-clk obligs config state))
- ((when er)
- (flush-hons-get-hash-table-link obligs1)
- (glcp-error
- (acl2::msg
- "~x0 failed to run the hyp, error: ~@1~%"
- config.clause-proc-name er)))
- (hyp-test (gtests hyp-val t))
- (hyp-bdd (bfr-or (gtests-nonnil hyp-test)
- (gtests-unknown hyp-test)))
- ((when (not hyp-bdd))
- (if config.abort-vacuous
- (glcp-error "Hypothesis is not satisfiable.")
- (prog2$ (cw "NOTE: Hypothesis is not satisfiable~%")
- (value (cons (list cov-clause) obligs1)))))
- (param-al (gobj-alist-to-param-space al hyp-bdd))
- (hyp-param (bfr-to-param-space hyp-bdd hyp-bdd))
- ((mv er obligs2 val state)
- (interp-term concl param-al hyp-param config.concl-clk obligs1 config state))
- ((when er)
- (flush-hons-get-hash-table-link obligs2)
- (glcp-error
- (acl2::msg
- "~x0 failed with error: ~@1~%" config.clause-proc-name er)))
- ((er val-clause)
- (glcp-analyze-interp-result
- val bindings hyp-bdd id untrans-concl config state)))
- (value (cons (list val-clause cov-clause) obligs2)))))
+ id (set-difference-eq vars bound-vars))))
+ (constraint-db (gbc-db-make-fast
+ (table-alist 'gl-bool-constraints (w state))))
+ ((unless (gbc-db-emptyp constraint-db))
+ (flush-hons-get-hash-table-link obligs)
+ (gbc-db-free constraint-db)
+ (glcp-error
+ (acl2::msg "The constraint database stored in the table ~
+ GL::GL-BOOL-CONSTRAINTS contains nonempty ~
+ substitutions -- somehow it has gotten corrupted!~%")))
+ (config (change-glcp-config config :shape-spec-alist bindings))
+ (al (shape-specs-to-interp-al bindings))
+ (cov-clause
+ (list '(not (gl-cp-hint 'coverage))
+ (dumb-negate-lit hyp)
+ (shape-spec-list-oblig-term
+ obj
+ (strip-cars bindings))))
+ ((acl2::local-stobjs bvar-db bvar-db1 interp-st)
+ (mv erp val state bvar-db bvar-db1 interp-st))
+ (interp-st (update-is-obligs obligs interp-st))
+ (interp-st (update-is-constraint t interp-st))
+ (interp-st (update-is-constraint-db constraint-db interp-st))
+ (next-bvar (shape-spec-max-bvar-list (strip-cadrs bindings)))
+ ((mv hyp-bfr concl-bfr bvar-db1 . ,*glcp-common-retvals*)
+ (interp-hyp/concl
+ hyp concl al config.concl-clk config interp-st next-bvar bvar-db
+ bvar-db1 state))
+ ((when er)
+ (flush-hons-get-hash-table-link (is-obligs interp-st))
+ (gbc-db-free (is-constraint-db interp-st))
+ (mv er nil state bvar-db bvar-db1 interp-st))
+ ((mv erp val-clause state)
+ (glcp-analyze-interp-result
+ hyp-bfr concl-bfr (is-constraint interp-st)
+ bindings id concl config bvar-db1 state))
+ ((when erp)
+ (flush-hons-get-hash-table-link (is-obligs interp-st))
+ (gbc-db-free (is-constraint-db interp-st))
+ (mv erp nil state bvar-db bvar-db1 interp-st))
+ ((mv erp val state)
+ (value (list val-clause cov-clause (is-obligs interp-st)))))
+ (gbc-db-free (is-constraint-db interp-st))
+ (mv erp val state bvar-db bvar-db1 interp-st)))
;; abort-unknown abort-ctrex exec-ctrex abort-vacuous nexamples hyp-clk concl-clk
;; clause-proc-name overrides run-before run-after case-split-override
-(defconst *glcp-run-cases-template*
- '(defun run-cases
- (param-alist concl untrans-concl vars obligs config state)
- (if (atom param-alist)
- (value (cons nil obligs))
- (b* (((er (cons rest obligs))
- (run-cases
- (cdr param-alist) concl untrans-concl vars obligs config state))
- (hyp (caar param-alist))
- (id (cadar param-alist))
- (g-bindings (cddar param-alist))
- (- (glcp-cases-wormhole (glcp-config->run-before config) id))
- ((er (cons clauses obligs))
- (run-parametrized
- hyp concl untrans-concl vars g-bindings id obligs config state))
- (- (glcp-cases-wormhole (glcp-config->run-after config) id)))
- (value (cons (append clauses rest) obligs))))))
-
-(defconst *glcp-clause-proc-template*
- '(defun clause-proc (clause hints state)
- (b* (;; ((unless (sym-counterparts-ok (w state)))
- ;; (glcp-error "The installed symbolic counterparts didn't satisfy all our checks"))
- ((list bindings param-bindings hyp param-hyp concl untrans-concl config) hints)
- ((er overrides)
- (preferred-defs-to-overrides
- (table-alist 'preferred-defs (w state)) state))
- (config (change-glcp-config config :overrides overrides))
- ((er hyp)
- (if (pseudo-termp hyp)
- (value hyp)
- (glcp-error "The hyp is not a pseudo-term.~%")))
- (hyp-clause (cons '(not (gl-cp-hint 'hyp))
- (append clause (list hyp))))
- ((er concl)
- (if (pseudo-termp concl)
- (value concl)
- (glcp-error "The concl is not a pseudo-term.~%")))
- (concl-clause (cons '(not (gl-cp-hint 'concl))
- (append clause (list (list 'not concl))))))
- (if param-bindings
- ;; Case splitting.
- (b* (((er param-hyp)
- (if (pseudo-termp param-hyp)
- (value param-hyp)
- (glcp-error "The param-hyp is not a pseudo-term.~%")))
- (full-hyp (conjoin (list param-hyp hyp)))
- (param-alist (param-bindings-to-alist
- full-hyp param-bindings))
- ;; If the hyp holds, then one of the cases in the
- ;; param-alist holds.
- (params-cov-term (disjoin (strip-cars param-alist)))
- (params-cov-vars (collect-vars params-cov-term))
- (- (cw "Checking case split coverage ...~%"))
- ((er (cons params-cov-res-clauses obligs0))
- (if (glcp-config->case-split-override config)
- (value (cons (list `((not (gl-cp-hint 'casesplit))
- (not ,hyp)
- ,params-cov-term))
- 'obligs))
- (run-parametrized
- hyp params-cov-term params-cov-term params-cov-vars bindings
- "case-split coverage" 'obligs config state)))
- (- (cw "Case-split coverage OK~%"))
- ((er (cons cases-res-clauses obligs1))
+ ,'(defun run-cases
+ (param-alist concl vars obligs config state)
+ (if (atom param-alist)
+ (value (cons nil obligs))
+ (b* (((er (cons rest obligs))
(run-cases
- param-alist concl untrans-concl (collect-vars concl) obligs0 config state)))
- (value (list* hyp-clause concl-clause
- (append cases-res-clauses
- params-cov-res-clauses
- (acl2::interp-defs-alist-clauses
- (flush-hons-get-hash-table-link obligs1))))))
- ;; No case-splitting.
- (b* (((er (cons res-clauses obligs))
- (run-parametrized
- hyp concl untrans-concl (collect-vars concl) bindings
- "main theorem" nil config state)))
- (cw "GL symbolic simulation OK~%")
- (value (list* hyp-clause concl-clause
- (append res-clauses
- (acl2::interp-defs-alist-clauses
- (flush-hons-get-hash-table-link obligs))))))))))
+ (cdr param-alist) concl vars obligs config state))
+ (hyp (caar param-alist))
+ (id (cadar param-alist))
+ (g-bindings (cddar param-alist))
+ (- (glcp-cases-wormhole (glcp-config->run-before config) id))
+ ((er (list val-clause cov-clause obligs))
+ (run-parametrized
+ hyp concl vars g-bindings id obligs config state))
+ (- (glcp-cases-wormhole (glcp-config->run-after config) id)))
+ (value (cons (list* val-clause cov-clause rest) obligs)))))
+
+
+ ,'(defun clause-proc (clause hints state)
+ (b* (;; ((unless (sym-counterparts-ok (w state)))
+ ;; (glcp-error "The installed symbolic counterparts didn't satisfy all our checks"))
+ ((list bindings param-bindings hyp param-hyp concl ?untrans-concl config) hints)
+ ((er overrides)
+ (preferred-defs-to-overrides
+ (table-alist 'preferred-defs (w state)) state))
+ (config (change-glcp-config config :overrides overrides))
+ ((er hyp)
+ (if (pseudo-termp hyp)
+ (value hyp)
+ (glcp-error "The hyp is not a pseudo-term.~%")))
+ (hyp-clause (cons '(not (gl-cp-hint 'hyp))
+ (append clause (list hyp))))
+ ((er concl)
+ (if (pseudo-termp concl)
+ (value concl)
+ (glcp-error "The concl is not a pseudo-term.~%")))
+ (concl-clause (cons '(not (gl-cp-hint 'concl))
+ (append clause (list (list 'not concl))))))
+ (if param-bindings
+ ;; Case splitting.
+ (b* (((er param-hyp)
+ (if (pseudo-termp param-hyp)
+ (value param-hyp)
+ (glcp-error "The param-hyp is not a pseudo-term.~%")))
+ (full-hyp (conjoin (list param-hyp hyp)))
+ (param-alist (param-bindings-to-alist
+ full-hyp param-bindings))
+ ;; If the hyp holds, then one of the cases in the
+ ;; param-alist holds.
+ (params-cov-term (disjoin (strip-cars param-alist)))
+ (params-cov-vars (collect-vars params-cov-term))
+ (- (cw "Checking case split coverage ...~%"))
+ ((er (list params-cov-res-clause
+ params-cov-cov-clause obligs0))
+ (if (glcp-config->case-split-override config)
+ (value (list `((not (gl-cp-hint 'casesplit))
+ (not ,hyp)
+ ,params-cov-term)
+ '('t)
+ 'obligs))
+ (run-parametrized
+ hyp params-cov-term params-cov-vars bindings
+ "case-split coverage" 'obligs config state)))
+ (- (cw "Case-split coverage OK~%"))
+ ((er (cons cases-res-clauses obligs1))
+ (run-cases
+ param-alist concl (collect-vars concl) obligs0 config state)))
+ (clear-memoize-table 'glcp-get-branch-merge-rules)
+ (value (list* hyp-clause concl-clause
+ (append cases-res-clauses
+ (list* params-cov-res-clause
+ params-cov-cov-clause
+ (acl2::interp-defs-alist-clauses
+ (flush-hons-get-hash-table-link obligs1)))))))
+ ;; No case-splitting.
+ (b* (((er (list res-clause cov-clause obligs))
+ (run-parametrized
+ hyp concl (collect-vars concl) bindings
+ "main theorem" nil config state)))
+ (cw "GL symbolic simulation OK~%")
+ (clear-memoize-table 'glcp-get-branch-merge-rules)
+ (value (list* hyp-clause concl-clause
+ res-clause cov-clause
+ (acl2::interp-defs-alist-clauses
+ (flush-hons-get-hash-table-link obligs))))))))))
+
+(defconst *glcp-fnnames*
+ (event-forms-collect-fn-names (list *glcp-interp-template*
+ *glcp-clause-proc-template*)))
diff -Nru acl2-6.2/books/centaur/gl/glcp-unify-defs.lisp acl2-6.3/books/centaur/gl/glcp-unify-defs.lisp
--- acl2-6.2/books/centaur/gl/glcp-unify-defs.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/glcp-unify-defs.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,125 @@
+
+(in-package "GL")
+
+(include-book "general-objects")
+(local (include-book "general-object-thms"))
+
+(verify-guards general-concrete-obj) ;; redundant
+
+;; x is a concrete object
+(defund glcp-unify-concrete (pat x alist)
+ (declare (xargs :guard (pseudo-termp pat)))
+ (b* (((when (eq pat nil))
+ (if (eq x nil)
+ (mv t alist)
+ (mv nil nil)))
+ ((when (atom pat))
+ (let ((pair (hons-assoc-equal pat alist)))
+ (if pair
+ (if (and (general-concretep (cdr pair))
+ (equal (general-concrete-obj (cdr pair)) x))
+ (mv t alist)
+ (mv nil nil))
+ (mv t (cons (cons pat (g-concrete-quote x)) alist)))))
+ ((when (eq (car pat) 'quote))
+ (if (equal (cadr pat) x)
+ (mv t alist)
+ (mv nil nil)))
+ ((when (and (eq (car pat) 'cons)
+ (int= (len pat) 3)))
+ (if (consp x)
+ (b* (((mv car-ok alist)
+ (glcp-unify-concrete (second pat) (car x) alist))
+ ((unless car-ok) (mv nil nil)))
+ (glcp-unify-concrete (third pat) (cdr x) alist))
+ (mv nil nil))))
+ ;; ((and (eq (car pat) 'binary-+)
+ ;; (int= (len pat) 3))
+ ;; (cond ((not (acl2-numberp x))
+ ;; (mv nil nil))
+ ;; ((quotep (second pat))
+ ;; (let ((num (unquote (second pat))))
+ ;; (if (acl2-numberp num)
+ ;; (glcp-unify-concrete (third pat) (- x num) alist)
+ ;; (mv nil nil))))
+ ;; ((quotep (third pat))
+ ;; (let ((num (unquote (third pat))))
+ ;; (if (acl2-numberp num)
+ ;; (glcp-unify-concrete (second pat) (- x num) alist)
+ ;; (mv nil nil))))
+ ;; (t (mv nil nil))))
+ (mv nil nil)))
+
+(defthm symbol-alistp-glcp-unify-concrete
+ (implies (and (symbol-alistp alist)
+ (pseudo-termp pat))
+ (symbol-alistp (mv-nth 1 (glcp-unify-concrete pat x alist))))
+ :hints(("Goal" :in-theory (enable glcp-unify-concrete))))
+
+(mutual-recursion
+ (defun glcp-unify-term/gobj (pat x alist)
+ (declare (xargs :guard (pseudo-termp pat)
+ :guard-debug t))
+ (b* (((when (eq pat nil))
+ (if (eq x nil) (mv t alist) (mv nil nil)))
+ ((when (atom pat))
+ (let ((pair (hons-assoc-equal pat alist)))
+ (if pair
+ (if (equal x (cdr pair))
+ (mv t alist)
+ (mv nil nil))
+ (mv t (cons (cons pat x) alist)))))
+ ((when (eq (car pat) 'quote))
+ (if (and (general-concretep x)
+ (equal (general-concrete-obj x) (cadr pat)))
+ (mv t alist)
+ (mv nil nil)))
+ ((when (atom x))
+ (glcp-unify-concrete pat x alist))
+ ((when (eq (tag x) :g-concrete))
+ (glcp-unify-concrete pat (g-concrete->obj x) alist))
+ ((when (and (eq (car pat) 'if)
+ (eql (len pat) 4)
+ (eq (tag x) :g-ite)))
+ (b* ((test (g-ite->test x))
+ (then (g-ite->then x))
+ (else (g-ite->else x))
+ ((mv ok alist)
+ (glcp-unify-term/gobj (second pat) test alist))
+ ((unless ok) (mv nil nil))
+ ((mv ok alist)
+ (glcp-unify-term/gobj (third pat) then alist))
+ ((unless ok) (mv nil nil)))
+ (glcp-unify-term/gobj (fourth pat) else alist)))
+ ((when (or (eq (tag x) :g-boolean)
+ (eq (tag x) :g-number)
+ (eq (tag x) :g-ite)
+ (eq (tag x) :g-var)))
+ (mv nil nil))
+ ((unless (eq (tag x) :g-apply))
+ ;; cons case
+ (if (and (eq (car pat) 'cons)
+ (int= (len pat) 3))
+ (b* (((mv ok alist) (glcp-unify-term/gobj (cadr pat) (car x) alist))
+ ((unless ok) (mv nil nil)))
+ (glcp-unify-term/gobj (caddr pat) (cdr x) alist))
+ (mv nil nil)))
+ ;; g-apply case remains
+ ((when (equal (g-apply->fn x) (car pat)))
+ (glcp-unify-term/gobj-list (cdr pat) (g-apply->args x) alist)))
+ (mv nil nil)))
+ (defun glcp-unify-term/gobj-list (pat x alist)
+ (declare (xargs :guard (pseudo-term-listp pat)))
+ (b* (((when (atom pat))
+ (if (eq x nil) (mv t alist) (mv nil nil)))
+ ((when (atom x)) (mv nil nil))
+ ((when (g-keyword-symbolp (tag x)))
+ ;;for now at least
+ (mv nil nil))
+ ((mv ok alist)
+ (glcp-unify-term/gobj (car pat) (car x) alist))
+ ((unless ok) (mv nil nil)))
+ (glcp-unify-term/gobj-list (cdr pat) (cdr x) alist))))
+
+(in-theory (disable glcp-unify-term/gobj
+ glcp-unify-term/gobj-list))
diff -Nru acl2-6.2/books/centaur/gl/glcp-unify-thms.lisp acl2-6.3/books/centaur/gl/glcp-unify-thms.lisp
--- acl2-6.2/books/centaur/gl/glcp-unify-thms.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/glcp-unify-thms.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,474 @@
+
+(in-package "GL")
+
+(include-book "glcp-unify-defs")
+(include-book "glcp-geval-thms")
+(include-book "var-bounds")
+(local (include-book "arithmetic/top-with-meta" :dir :system))
+(local (include-book "clause-processors/find-matching" :dir :system))
+
+(defsection glcp-generic-geval-alist
+
+ (local (in-theory (enable glcp-generic-geval-alist)))
+
+ (defthm glcp-generic-geval-alist-pairlis$
+ (equal (glcp-generic-geval-alist
+ (pairlis$ formals actuals)
+ env)
+ (pairlis$ formals
+ (glcp-generic-geval-list actuals env)))
+ :hints(("Goal" :in-theory (enable default-cdr pairlis$ gobj-listp
+ glcp-generic-geval-list)
+ :expand ((glcp-generic-geval nil env))
+ :induct (pairlis$ formals actuals))))
+
+ (defthm glcp-generic-geval-alist-lookup
+ (equal (hons-assoc-equal k (glcp-generic-geval-alist al env))
+ (and (hons-assoc-equal k al)
+ (cons k (glcp-generic-geval (cdr (hons-assoc-equal k al))
+ env)))))
+
+ (defthm glcp-generic-geval-alist-of-acons
+ (equal (glcp-generic-geval-alist (cons (cons k v) al) env)
+ (cons (cons k (glcp-generic-geval v env))
+ (glcp-generic-geval-alist al env)))))
+
+
+
+
+(defsection all-keys-bound
+ (defund all-keys-bound (keys alist)
+ (declare (xargs :guard t))
+ (if (atom keys)
+ t
+ (and (hons-assoc-equal (car keys) alist)
+ (all-keys-bound (cdr keys) alist))))
+
+ (local (in-theory (enable all-keys-bound)))
+
+ (defthmd all-keys-bound-member-implies
+ (implies (and (member k keys)
+ (not (hons-assoc-equal k alist)))
+ (not (all-keys-bound keys alist))))
+
+ (defthmd all-keys-bound-subset
+ (implies (and (subsetp keys1 keys)
+ (all-keys-bound keys alist))
+ (all-keys-bound keys1 alist))
+ :hints(("Goal" :in-theory (enable all-keys-bound-member-implies
+ subsetp))))
+
+ (defcong acl2::set-equiv equal (all-keys-bound keys alist) 1
+ :hints(("Goal" :in-theory (enable acl2::set-equiv)
+ :use ((:instance all-keys-bound-subset
+ (keys1 keys) (keys acl2::keys-equiv))
+ (:instance all-keys-bound-subset
+ (keys1 acl2::keys-equiv) (keys keys)))
+ :do-not-induct t)))
+
+ (defthm all-keys-bound-append
+ (equal (all-keys-bound (append a b) alist)
+ (and (all-keys-bound a alist)
+ (all-keys-bound b alist))))
+
+
+ (acl2::defthm-simple-term-vars-flag
+ (defthm glcp-generic-geval-ev-of-acons-when-all-vars-bound
+ (implies (and (all-keys-bound (acl2::simple-term-vars x) a)
+ (not (hons-assoc-equal k a))
+ (pseudo-termp x))
+ (equal (glcp-generic-geval-ev x (cons (cons k v) a))
+ (glcp-generic-geval-ev x a)))
+ :hints ((and stable-under-simplificationp
+ '(:in-theory (enable glcp-generic-geval-ev-of-fncall-args))))
+ :flag acl2::simple-term-vars)
+ (defthm glcp-generic-geval-ev-lst-of-acons-when-all-vars-bound
+ (implies (and (all-keys-bound (acl2::simple-term-vars-lst x) a)
+ (not (hons-assoc-equal k a))
+ (pseudo-term-listp x))
+ (equal (glcp-generic-geval-ev-lst x (cons (cons k v) a))
+ (glcp-generic-geval-ev-lst x a)))
+ :flag acl2::simple-term-vars-lst))
+
+ (defthm all-keys-bound-of-glcp-generic-geval-alist
+ (equal (all-keys-bound keys (glcp-generic-geval-alist alist env))
+ (all-keys-bound keys alist))))
+
+(defsection glcp-unify-concrete
+ (local (defthm assoc-when-nonnil-key
+ (implies key
+ (equal (assoc key alist)
+ (hons-assoc-equal key alist)))
+ :rule-classes ((:rewrite :backchain-limit-lst 1))))
+
+ (local (in-theory (enable glcp-unify-concrete)))
+
+ (defthm glcp-unify-concrete-preserves-assoc
+ (b* (((mv ok alist1) (glcp-unify-concrete pat x alist)))
+ (implies (and ok (hons-assoc-equal k alist))
+ (equal (hons-assoc-equal k alist1)
+ (hons-assoc-equal k alist)))))
+
+ (defthm alistp-glcp-unify-concrete
+ (b* (((mv ok alist1) (glcp-unify-concrete pat x alist)))
+ (equal (alistp alist1)
+ (or (not ok) (alistp alist)))))
+
+
+ (defthm glcp-unify-concrete-preserves-all-keys-bound
+ (b* (((mv ok alist1) (glcp-unify-concrete pat x alist)))
+ (implies (and ok (all-keys-bound keys alist))
+ (all-keys-bound keys alist1)))
+ :hints (("goal" :induct (all-keys-bound keys alist)
+ :in-theory (enable all-keys-bound))))
+
+ (local (defthm equal-len
+ (implies (syntaxp (quotep y))
+ (Equal (equal (len x) y)
+ (if (zp y)
+ (and (equal y 0) (atom x))
+ (and (consp x)
+ (equal (len (cdr x)) (1- y))))))))
+
+ (defthm all-keys-bound-of-glcp-unify-concrete
+ (b* (((mv ok newalist) (glcp-unify-concrete pat x alist)))
+ (implies ok
+ (all-keys-bound (acl2::simple-term-vars pat) newalist)))
+ :hints (("goal" :induct (glcp-unify-concrete pat x alist)
+ :in-theory (enable all-keys-bound))))
+
+
+
+ (defthm glcp-unify-concrete-preserves-eval
+ (b* (((mv ok newalist) (glcp-unify-concrete pat x alist)))
+ (implies (and ok
+ (pseudo-termp term)
+ (all-keys-bound (acl2::simple-term-vars term) alist))
+ (equal (glcp-generic-geval-ev term (glcp-generic-geval-alist
+ newalist env))
+ (glcp-generic-geval-ev term (glcp-generic-geval-alist
+ alist env))))))
+
+ (defthmd glcp-unify-concrete-correct
+ (b* (((mv ok alist)
+ (glcp-unify-concrete pat x alist)))
+ (implies (and ok
+ (pseudo-termp pat))
+ (equal (glcp-generic-geval-ev pat
+ (glcp-generic-geval-alist alist
+ env))
+ x)))
+ :hints(("Goal" :in-theory (disable general-concretep))))
+
+ (defthm gobj-depends-on-of-glcp-unify-concrete
+ (implies (not (gobj-alist-depends-on k p alist))
+ (not (gobj-alist-depends-on
+ k p (mv-nth 1 (glcp-unify-concrete pat x alist)))))
+ :hints(("Goal" :in-theory (enable g-concrete-quote))))
+
+ (local (defthm hons-assoc-equal-to-member-alist-keys
+ (iff (hons-assoc-equal k a)
+ (member k (acl2::alist-keys a)))
+ :hints(("Goal" :in-theory (enable hons-assoc-equal
+ acl2::alist-keys)))))
+
+ (local (defthm associativity-of-union-equal
+ (equal (union-equal (union-equal a b) c)
+ (union-equal a (union-equal b c)))))
+
+ ;; (defthm alist-keys-of-glcp-unify-concrete
+ ;; (b* (((mv ok alist1) (glcp-unify-concrete pat x alist)))
+ ;; (implies ok
+ ;; (equal (acl2::alist-keys alist1)
+ ;; (union-equal (acl2::simple-term-vars pat)
+ ;; (acl2::alist-keys alist)))))
+ ;; :hints(("Goal" :in-theory (enable acl2::alist-keys))))
+ )
+
+(defsection glcp-unify-term/gobj
+ (local (in-theory (enable pseudo-termp)))
+ (local (defthm assoc-when-nonnil-key
+ (implies key
+ (equal (assoc key alist)
+ (hons-assoc-equal key alist)))
+ :rule-classes ((:rewrite :backchain-limit-lst 1))))
+
+
+ (local (in-theory (enable glcp-unify-term/gobj
+ glcp-unify-term/gobj-list)))
+
+ (flag::make-flag glcp-unify-term/gobj-flg glcp-unify-term/gobj
+ :flag-mapping ((glcp-unify-term/gobj . term)
+ (glcp-unify-term/gobj-list . list)))
+
+ (local (in-theory (disable glcp-unify-term/gobj
+ glcp-unify-term/gobj-list)))
+
+
+ (defthm-glcp-unify-term/gobj-flg
+ (defthm glcp-unify-term/gobj-preserves-assoc
+ (b* (((mv ok alist1) (glcp-unify-term/gobj pat x alist)))
+ (implies (and ok (hons-assoc-equal k alist))
+ (equal (hons-assoc-equal k alist1)
+ (hons-assoc-equal k alist))))
+ :hints ('(:in-theory (enable all-keys-bound)
+ :expand ((:free (x) (glcp-unify-term/gobj pat x alist))
+ (:free (x) (glcp-unify-term/gobj nil x alist)))))
+ :flag term)
+ (defthm glcp-unify-term/gobj-list-preserves-assoc
+ (b* (((mv ok alist1) (glcp-unify-term/gobj-list pat x alist)))
+ (implies (and ok (hons-assoc-equal k alist))
+ (equal (hons-assoc-equal k alist1)
+ (hons-assoc-equal k alist))))
+ :hints ('(:in-theory (enable all-keys-bound)
+ :expand ((:free (x) (glcp-unify-term/gobj-list pat x alist)))))
+ :flag list))
+
+ (defthm-glcp-unify-term/gobj-flg
+ (defthm glcp-unify-term/gobj-preserves-alistp
+ (b* (((mv ok alist1) (glcp-unify-term/gobj pat x alist)))
+ (equal (alistp alist1)
+ (or (not ok) (alistp alist))))
+ :hints ('(:in-theory (enable all-keys-bound)
+ :expand ((:free (x) (glcp-unify-term/gobj pat x alist))
+ (:free (x) (glcp-unify-term/gobj nil x alist)))))
+ :flag term)
+ (defthm glcp-unify-term/gobj-list-preserves-alistp
+ (b* (((mv ok alist1) (glcp-unify-term/gobj-list pat x alist)))
+ (equal (alistp alist1)
+ (or (not ok) (alistp alist))))
+ :hints ('(:in-theory (enable all-keys-bound)
+ :expand ((:free (x) (glcp-unify-term/gobj-list pat x alist)))))
+ :flag list))
+
+ (defthm glcp-unify-term/gobj-preserves-all-keys-bound
+ (b* (((mv ok alist1) (glcp-unify-term/gobj pat x alist)))
+ (implies (and ok (all-keys-bound keys alist))
+ (all-keys-bound keys alist1)))
+ :hints (("goal" :induct (all-keys-bound keys alist)
+ :in-theory (enable all-keys-bound))))
+
+ (defthm glcp-unify-term/gobj-list-preserves-all-keys-bound
+ (b* (((mv ok alist1) (glcp-unify-term/gobj-list pat x alist)))
+ (implies (and ok (all-keys-bound keys alist))
+ (all-keys-bound keys alist1)))
+ :hints (("goal" :induct (all-keys-bound keys alist)
+ :in-theory (enable all-keys-bound))))
+
+ (local (defthm equal-len
+ (implies (syntaxp (quotep y))
+ (Equal (equal (len x) y)
+ (if (zp y)
+ (and (equal y 0) (atom x))
+ (and (consp x)
+ (equal (len (cdr x)) (1- y))))))))
+
+ (defthm-glcp-unify-term/gobj-flg
+ (defthm all-keys-bound-of-glcp-unify-term/gobj
+ (b* (((mv ok newalist) (glcp-unify-term/gobj pat x alist)))
+ (implies ok
+ (all-keys-bound (acl2::simple-term-vars pat) newalist)))
+ :hints ('(:in-theory (enable all-keys-bound)
+ :expand ((:free (x) (glcp-unify-term/gobj pat x alist))
+ (:free (x) (glcp-unify-term/gobj nil x alist)))))
+ :flag term)
+ (defthm all-keys-bound-of-glcp-unify-term/gobj-list
+ (b* (((mv ok newalist) (glcp-unify-term/gobj-list pat x alist)))
+ (implies ok
+ (all-keys-bound (acl2::simple-term-vars-lst pat) newalist)))
+ :hints ('(:in-theory (enable all-keys-bound)
+ :expand ((:free (x) (glcp-unify-term/gobj-list pat x alist)))))
+ :flag list))
+
+
+ (defthm-glcp-unify-term/gobj-flg
+ (defthm glcp-unify-term/gobj-preserves-eval
+ (b* (((mv ok newalist) (glcp-unify-term/gobj pat x alist)))
+ (implies (and ok
+ (pseudo-termp term)
+ (all-keys-bound (acl2::simple-term-vars term) alist))
+ (equal (glcp-generic-geval-ev term (glcp-generic-geval-alist
+ newalist env))
+ (glcp-generic-geval-ev term (glcp-generic-geval-alist
+ alist env)))))
+ :hints ('(:expand ((:free (x) (glcp-unify-term/gobj pat x alist))
+ (:free (x) (glcp-unify-term/gobj nil x alist)))))
+ :flag term)
+ (defthm glcp-unify-term/gobj-list-preserves-eval
+ (b* (((mv ok newalist) (glcp-unify-term/gobj-list pat x alist)))
+ (implies (and ok
+ (pseudo-termp term)
+ (all-keys-bound (acl2::simple-term-vars term) alist))
+ (equal (glcp-generic-geval-ev term (glcp-generic-geval-alist
+ newalist env))
+ (glcp-generic-geval-ev term (glcp-generic-geval-alist
+ alist env)))))
+ :hints ('(:expand ((:free (x) (glcp-unify-term/gobj-list pat x alist)))))
+ :flag list))
+
+ (defthm glcp-unify-term/gobj-preserves-eval-list
+ (b* (((mv ok newalist) (glcp-unify-term/gobj pat x alist)))
+ (implies (and ok
+ (pseudo-term-listp term)
+ (all-keys-bound (acl2::simple-term-vars-lst term) alist))
+ (equal (glcp-generic-geval-ev-lst term (glcp-generic-geval-alist
+ newalist env))
+ (glcp-generic-geval-ev-lst term (glcp-generic-geval-alist
+ alist env)))))
+ :hints (("goal" :induct (len term)
+ :in-theory (e/d () (glcp-unify-term/gobj)))))
+
+ (defthm glcp-unify-term/gobj-list-preserves-eval-list
+ (b* (((mv ok newalist) (glcp-unify-term/gobj-list pat x alist)))
+ (implies (and ok
+ (pseudo-term-listp term)
+ (all-keys-bound (acl2::simple-term-vars-lst term) alist))
+ (equal (glcp-generic-geval-ev-lst term (glcp-generic-geval-alist
+ newalist env))
+ (glcp-generic-geval-ev-lst term (glcp-generic-geval-alist
+ alist env)))))
+ :hints (("goal" :induct (len term)
+ :in-theory (e/d () (glcp-unify-term/gobj-list)))))
+
+ (local (defthm glcp-generic-geval-of-non-kw-cons
+ (implies (and (consp x)
+ (not (equal (tag x) :g-concrete))
+ (not (equal (tag x) :g-boolean))
+ (not (equal (tag x) :g-number))
+ (not (equal (tag x) :g-ite))
+ (not (equal (tag x) :g-var))
+ (not (equal (tag x) :g-apply)))
+ (equal (glcp-generic-geval x env)
+ (cons (glcp-generic-geval (car x) env)
+ (glcp-generic-geval (cdr x) env))))
+ :hints(("Goal" :expand ((:with glcp-generic-geval
+ (glcp-generic-geval x env)))))))
+
+ (local (defthm glcp-generic-geval-of-non-kw-symbolp
+ (implies (and (consp x)
+ (not (g-keyword-symbolp (tag x))))
+ (equal (glcp-generic-geval x env)
+ (cons (glcp-generic-geval (car x) env)
+ (glcp-generic-geval (cdr x) env))))
+ :hints(("Goal" :expand ((:with glcp-generic-geval
+ (glcp-generic-geval x env)))))))
+
+ (local (defthm glcp-generic-geval-of-g-apply
+ (implies (and (eq (tag x) :g-apply)
+ (not (equal (g-apply->fn x) 'quote)))
+ (equal (glcp-generic-geval x env)
+ (glcp-generic-geval-ev
+ (cons (g-apply->fn x)
+ (kwote-lst (glcp-generic-geval-list
+ (g-apply->args x) env)))
+ nil)))
+ :hints(("Goal" :expand ((:with glcp-generic-geval
+ (glcp-generic-geval x env)))))))
+
+ (local (defthm glcp-generic-geval-of-g-concrete
+ (implies (eq (tag x) :g-concrete)
+ (equal (glcp-generic-geval x env)
+ (g-concrete->obj x)))
+ :hints(("Goal" :expand ((:with glcp-generic-geval
+ (glcp-generic-geval x env)))
+ :in-theory (disable glcp-generic-geval-general-concrete-obj-correct)))))
+
+ (local (in-theory (enable glcp-generic-geval-ev-of-fncall-args)))
+
+ (local (defthm pseudo-terms-of-args
+ (implies (and (pseudo-termp x)
+ (consp x)
+ (not (eq (car x) 'quote)))
+ (and (pseudo-termp (cadr x))
+ (pseudo-termp (caddr x))
+ (pseudo-termp (cadddr x))))
+ :hints (("goal" :expand ((pseudo-termp x)
+ (pseudo-term-listp (cdr x))
+ (pseudo-term-listp (cddr x))
+ (pseudo-term-listp (cdddr x)))))))
+
+ (local (defthm symbolp-when-pseudo-termp
+ (implies (not (consp x))
+ (equal (pseudo-termp x)
+ (symbolp x)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+ (local (defthm pseudo-term-listp-cdr-when-pseudo-termp
+ (implies (and (pseudo-termp x)
+ (not (eq (car x) 'quote)))
+ (pseudo-term-listp (cdr x)))))
+
+ (local (in-theory (disable pseudo-term-listp
+ pseudo-termp
+ acl2::cancel_times-equal-correct
+ acl2::cancel_plus-equal-correct
+ tag-when-atom
+ len)))
+
+
+ (defthm-glcp-unify-term/gobj-flg
+ (defthm glcp-unify-term/gobj-correct
+ (b* (((mv ok alist)
+ (glcp-unify-term/gobj pat x alist)))
+ ;; env: boolean vars of x -> boolean values, g-vars of x -> values
+ ;; alist: variables of pat -> symbolic objects (subobjects of x)
+ (implies (and ok
+ (pseudo-termp pat))
+ (equal (glcp-generic-geval-ev pat
+ (glcp-generic-geval-alist
+ alist env))
+ (glcp-generic-geval x env))))
+ :hints ('(:expand ((glcp-unify-term/gobj pat x alist)
+ (glcp-unify-term/gobj nil x alist)))
+ (and stable-under-simplificationp
+ (b* (((mv ok lit)
+ (acl2::find-matching-literal-in-clause
+ '(not (mv-nth '0 (glcp-unify-concrete pat x alist)))
+ clause nil))
+ ((unless ok) nil)
+ (pat (second (third (second lit))))
+ (x (third (third (second lit))))
+ (alist (fourth (third (second lit)))))
+ `(:use ((:instance glcp-unify-concrete-correct
+ (pat ,pat) (x ,x) (alist ,alist))))))
+ (and stable-under-simplificationp
+ '(:expand ((:with glcp-generic-geval
+ (glcp-generic-geval x env))))))
+ :flag term)
+ (defthm glcp-unify-term/gobj-list-correct
+ (b* (((mv ok alist)
+ (glcp-unify-term/gobj-list pat x alist)))
+ (implies (and ok
+ (pseudo-term-listp pat))
+ (equal (glcp-generic-geval-ev-lst pat
+ (glcp-generic-geval-alist alist
+ env))
+ (glcp-generic-geval-list x env))))
+ :hints ('(:expand ((glcp-unify-term/gobj-list pat x alist)))
+ (and stable-under-simplificationp
+ '(:expand ((pseudo-term-listp pat)))))
+ :flag list))
+
+ (local (in-theory (disable gobj-depends-on gobj-list-depends-on)))
+
+ (defthm-glcp-unify-term/gobj-flg
+ (defthm gobj-depends-on-of-glcp-unify-term/gobj
+ (implies (and (not (gobj-alist-depends-on k p alist))
+ (not (gobj-depends-on k p x)))
+ (not (gobj-alist-depends-on
+ k p (mv-nth 1 (glcp-unify-term/gobj pat x alist)))))
+ :hints ('(:expand ((:free (x) (glcp-unify-term/gobj pat x alist))
+ (:free (x) (glcp-unify-term/gobj nil x alist))
+ (gobj-depends-on k p x)
+ (gobj-depends-on k p nil)
+ (gobj-depends-on k p (cdr (hons-assoc-equal pat alist))))))
+ :flag term)
+ (defthm gobj-depends-on-of-glcp-unify-term/gobj-list
+ (implies (and (not (gobj-alist-depends-on k p alist))
+ (not (gobj-list-depends-on k p x)))
+ (not (gobj-alist-depends-on
+ k p (mv-nth 1 (glcp-unify-term/gobj-list pat x alist)))))
+ :hints ('(:expand ((:free (x) (glcp-unify-term/gobj-list pat x alist))
+ (gobj-list-depends-on k p x)
+ (gobj-list-depends-on k p nil))))
+ :flag list)))
diff -Nru acl2-6.2/books/centaur/gl/gobject-type-thms.lisp acl2-6.3/books/centaur/gl/gobject-type-thms.lisp
--- acl2-6.2/books/centaur/gl/gobject-type-thms.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gobject-type-thms.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,5 +1,22 @@
-
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
diff -Nru acl2-6.2/books/centaur/gl/gobject-types.lisp acl2-6.3/books/centaur/gl/gobject-types.lisp
--- acl2-6.2/books/centaur/gl/gobject-types.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gobject-types.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,6 +1,24 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "defagg")
(include-book "tools/pattern-match" :dir :system)
(include-book "misc/untranslate-patterns" :dir :system)
@@ -9,7 +27,7 @@
(defagg g-boolean (bool))
(defagg g-number (num))
(defagg g-ite (test then else))
-(defagg g-apply (fn args))
+(defagg g-apply (fn args) :notinline t)
(defagg g-var (name))
(defconst *g-keywords*
@@ -98,3 +116,10 @@
:rule-classes ((:rewrite :backchain-limit-lst 0)
:type-prescription))
+(defun gl-cons (x y)
+ (declare (xargs :guard t))
+ (cons (if (g-keyword-symbolp x)
+ (g-concrete x)
+ x)
+ y))
+
diff -Nru acl2-6.2/books/centaur/gl/gobjectp-thms.lisp acl2-6.3/books/centaur/gl/gobjectp-thms.lisp
--- acl2-6.2/books/centaur/gl/gobjectp-thms.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gobjectp-thms.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,4 +1,22 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
diff -Nru acl2-6.2/books/centaur/gl/gobjectp.lisp acl2-6.3/books/centaur/gl/gobjectp.lisp
--- acl2-6.2/books/centaur/gl/gobjectp.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gobjectp.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,21 +1,33 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-
(include-book "bfr")
(include-book "defagg")
(include-book "tools/pattern-match" :dir :system)
-
(include-book "bvecs")
-
-;;(in-theory (disable cutil::tag-forward-to-consp))
-
(include-book "gobject-types")
+;;(in-theory (disable cutil::tag-forward-to-consp))
;; Mostly obsolete. Some general utility stuff at the bottom.
-
;; ;; Recognizer for a well-formed cdr of a g-number.
;; (defun wf-g-numberp (x)
;; (declare (xargs :guard t))
diff -Nru acl2-6.2/books/centaur/gl/gtests.lisp acl2-6.3/books/centaur/gl/gtests.lisp
--- acl2-6.2/books/centaur/gl/gtests.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gtests.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,15 +1,30 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-(set-inhibit-warnings "theory")
-
(include-book "hyp-fix")
(include-book "gtypes")
+(include-book "tools/mv-nth" :dir :system)
(local (include-book "gtype-thms"))
(local (include-book "hyp-fix-logic"))
-
-(include-book "tools/mv-nth" :dir :system)
+(set-inhibit-warnings "theory")
(defun mk-g-bdd-ite (bdd then else hyp)
(declare (xargs :guard t))
@@ -31,6 +46,13 @@
false-under-hyp))
(bfr-reasoning)))
+(defthm gobj-depends-on-of-mk-g-bdd-ite
+ (implies (and (not (pbfr-depends-on k p bdd))
+ (not (gobj-depends-on k p then))
+ (not (gobj-depends-on k p else)))
+ (not (gobj-depends-on k p (mk-g-bdd-ite bdd then else hyp))))
+ :hints(("Goal" :in-theory (enable mk-g-bdd-ite))))
+
(in-theory (disable mk-g-bdd-ite))
@@ -58,14 +80,14 @@
(b* (((mv cc uc oc)
(gobj-nonnil-unknown-obj test hyp))
(cc-t (th cc))
- (cc-nil (fh cc)))
+ (cc-nil (fh cc))
+ (uc-nil (fh uc)))
(cond
- ((and (fh uc) cc-t)
+ ((and uc-nil cc-t)
(gobj-nonnil-unknown-obj then hyp))
- ((and (fh uc) cc-nil)
+ ((and uc-nil cc-nil)
(gobj-nonnil-unknown-obj else hyp))
(t (b* ((uc-t (th uc))
- (uc-nil (fh uc))
(hyp1 (bfr-or cc uc))
((mv c1 u1 o1) (gobj-nonnil-unknown-obj then hyp1))
(hyp0 (bfr-or (hf (bfr-not cc)) uc))
@@ -153,7 +175,7 @@
- (local
+ (local
(in-theory (disable (:definition generic-geval)
bfr-eval bfr-eval-list
components-to-number-alt-def
@@ -238,7 +260,21 @@
:do-not '(generalize
fertilize
eliminate-destructors))))
- :rule-classes nil)))
+ :rule-classes nil)
+
+ (defthm gobj-depends-on-of-gobj-nonnil-unknown-obj
+ (implies (not (gobj-depends-on k p x))
+ (mv-let (cc uc uo)
+ (gobj-nonnil-unknown-obj x hyp)
+ (and (not (pbfr-depends-on k p cc))
+ (not (pbfr-depends-on k p uc))
+ (not (gobj-depends-on k p uo)))))
+ :hints (("goal" :induct (gnuo-ind x hyp)
+ :in-theory (disable hyp-fix))
+ (and stable-under-simplificationp
+ '(:expand ((gobj-nonnil-unknown-obj x hyp)
+ (gobj-nonnil-unknown-obj nil hyp)
+ (gobj-depends-on k p x))))))))
@@ -292,10 +328,14 @@
:hints (("goal" :use
((:instance gobj-nonnil-unknown-obj-correct)))))
-(in-theory (disable gtests gtestsp gtests-unknown gtests-obj gtests-nonnil))
-
+(defthm gobj-depends-on-of-gtests
+ (implies (not (gobj-depends-on k p x))
+ (and (not (pbfr-depends-on k p (gtests-nonnil (gtests x hyp))))
+ (not (pbfr-depends-on k p (gtests-unknown (gtests x hyp))))
+ (not (gobj-depends-on k p (gtests-obj (gtests x hyp)))))))
+(in-theory (disable gtests gtestsp gtests-unknown gtests-obj gtests-nonnil))
diff -Nru acl2-6.2/books/centaur/gl/gtype-thms.lisp acl2-6.3/books/centaur/gl/gtype-thms.lisp
--- acl2-6.2/books/centaur/gl/gtype-thms.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gtype-thms.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,22 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
@@ -19,7 +38,7 @@
(not (g-var-p x))
(list (concrete-gobjectp-ind (car x))
(concrete-gobjectp-ind (cdr x))))))
-
+
(defthm gobject-hierarchy-lite-possibilities
(or (equal (gobject-hierarchy-lite x) nil)
@@ -63,10 +82,16 @@
concrete-gobjectp-def
acl2::cons-car-cdr)))))
-(in-theory (disable concrete-gobjectp-def))
+(defthmd gobj-depends-on-when-concrete-gobjectp
+ (implies (concrete-gobjectp x)
+ (not (gobj-depends-on k p x)))
+ :hints (("goal" :induct (concrete-gobjectp-ind x)
+ :expand ((gobj-depends-on k p x)))))
+(in-theory (disable concrete-gobjectp-def))
+(local (in-theory (enable generic-geval)))
(defthm mk-g-concrete-correct
(equal (generic-geval (mk-g-concrete x) b)
@@ -84,6 +109,15 @@
g-concrete-quote))))
+(defthm gobj-depends-on-of-mk-g-concrete
+ (not (gobj-depends-on k p (mk-g-concrete x)))
+ :hints(("Goal" :in-theory (enable gobj-depends-on mk-g-concrete
+ gobj-depends-on-when-concrete-gobjectp))))
+
+(defthm gobj-depends-on-of-g-concrete-quote
+ (not (gobj-depends-on k p (g-concrete-quote x)))
+ :hints(("Goal" :in-theory (enable gobj-depends-on g-concrete-quote))))
+
(defthm mk-g-ite-correct
(equal (generic-geval (mk-g-ite c x y) b)
@@ -96,12 +130,24 @@
'(:expand ((generic-geval c b)))))
:otf-flg t)
+(defthm gobj-depends-on-of-mk-g-ite-rw
+ (implies (and (not (gobj-depends-on k p c))
+ (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y)))
+ (not (gobj-depends-on k p (mk-g-ite c x y))))
+ :hints(("Goal" :in-theory (enable mk-g-ite))))
+
(defthm mk-g-boolean-correct
(equal (generic-geval (mk-g-boolean x) env)
(bfr-eval x (car env)))
:hints(("Goal" :in-theory (enable mk-g-boolean))))
+(defthm gobj-depends-on-of-mk-g-boolean
+ (equal (gobj-depends-on k p (mk-g-boolean x))
+ (pbfr-depends-on k p x))
+ :hints(("Goal" :in-theory (enable mk-g-boolean booleanp))))
+
;; (defthm car-mk-g-number
@@ -109,10 +155,10 @@
;; (eq (car (mk-g-number a b c d e f)) :g-number)))
-(defthm nonzero-natp-implies-us
- (implies (and (natp x) (not (eql x 0)))
- (n2v x))
- :hints(("Goal" :in-theory (enable n2v))))
+;; (defthm nonzero-natp-implies-us
+;; (implies (and (natp x) (not (eql x 0)))
+;; (n2v x))
+;; :hints(("Goal" :in-theory (e/d (n2v bfr-ucons) (logcar logcdr)))))
(encapsulate nil
(local (include-book "arithmetic/top-with-meta" :dir :system))
@@ -135,7 +181,7 @@
(implies (syntaxp (not (equal rnum ''0)))
(equal (components-to-number rnum 0 inum iden)
(components-to-number 0 1 inum iden))))
-
+
(defthm components-to-number-alt-def
(equal (components-to-number rnum rden inum iden)
(complex (* rnum (/ rden))
@@ -170,19 +216,19 @@
;; (equal (generic-geval (gobj-fix x) env)
;; (generic-geval x env))
;; :hints(("Goal" :in-theory (enable gobj-fix))))
-
+
(encapsulate nil
(local (include-book "arithmetic/top-with-meta" :dir :system))
- (local (in-theory
+ (local (in-theory
(e/d*
(boolean-list-bfr-eval-list)
(generic-geval mk-g-number
; (components-to-number)
components-to-number
components-to-number-alt-def
- bfr-eval bfr-eval-list natp v2n
+ bfr-eval bfr-eval-list natp
n2v i2v default-car default-cdr
(:rules-of-class :type-prescription :here)
acl2::cancel_times-equal-correct
@@ -195,18 +241,43 @@
(equal (len (cons x y))
(+ 1 (len y)))
:hints(("Goal" :in-theory (enable len)))))
+
+ (local (defthm boolean-listp-scdr
+ (implies (boolean-listp x)
+ (boolean-listp (scdr x)))
+ :hints(("Goal" :in-theory (enable scdr)))))
+
+ (local (defthm bfr-list->s-of-boolean-list-norm
+ (implies (and (syntaxp (not (equal env ''nil)))
+ (boolean-listp x))
+ (equal (bfr-list->s x env)
+ (bfr-list->s x nil)))))
+
+ (local (defthm bfr-list->u-of-boolean-list-norm
+ (implies (and (syntaxp (not (equal env ''nil)))
+ (boolean-listp x))
+ (equal (bfr-list->u x env)
+ (bfr-list->u x nil)))))
+
+ ;; (local (defthm bfr-list->u-of-list-fix
+ ;; (equal (bfr-list->u (acl2::list-fix x) env)
+ ;; (bfr-list->u x env))))
+
+ ;; (local (defthm bfr-list->s-of-list-fix
+ ;; (equal (bfr-list->s (acl2::list-fix x) env)
+ ;; (bfr-list->s x env))))
+
(defthm mk-g-number-correct
- (flet ((to-nat (n env) (if (natp n) n (v2n (bfr-eval-list n (car env)))))
- (to-int (n env) (if (integerp n) n (v2i (bfr-eval-list n (car
- env))))))
+ (flet ((to-nat (n env) (if (natp n) n (bfr-list->u n (car env))))
+ (to-int (n env) (if (integerp n) n (bfr-list->s n (car env)))))
(equal (generic-geval (mk-g-number rnum rden inum iden) env)
(components-to-number (to-int rnum env)
(to-nat rden env)
(to-int inum env)
(to-nat iden env))))
:hints (("Goal" :do-not preprocess)
- '(:cases ((and (integerp rnum) (natp rden)
- (integerp inum) (natp iden))))
+ ;; '(:cases ((and (integerp rnum) (natp rden)
+ ;; (integerp inum) (natp iden))))
'(:expand ((:free (a c d f)
(mk-g-number a c d f))))
'(:expand ((:free (a b)
@@ -216,7 +287,51 @@
(generic-geval
(g-number x) env))))
(and stable-under-simplificationp
- '(:in-theory (e/d (components-to-number-alt-def natp)))))))
+ '(:in-theory (e/d (components-to-number-alt-def natp))))))
+
+ (defthm pbfr-depends-on-list-of-boolean-listp
+ (implies (and (syntaxp (quotep lst))
+ (boolean-listp lst))
+ (not (pbfr-list-depends-on k p lst)))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on))))
+
+ (local (defthm gobj-depends-on-of-g-number
+ (equal (gobj-depends-on k p (g-number n))
+ (or (pbfr-list-depends-on k p (car n))
+ (pbfr-list-depends-on k p (cadr n))
+ (pbfr-list-depends-on k p (caddr n))
+ (pbfr-list-depends-on k p (cadddr n))))
+ :hints(("Goal" :in-theory (e/d (break-g-number
+ default-car default-cdr)
+ ((pbfr-list-depends-on)))))))
+
+ (local (in-theory (disable gobj-depends-on
+ sets::double-containment
+ default-<-1
+ default-<-2)))
+
+ (defthm gobj-depends-on-of-mk-g-number
+ (implies (and (or (integerp rnum)
+ (not (pbfr-list-depends-on k p rnum)))
+ (or (natp rden)
+ (not (pbfr-list-depends-on k p rden)))
+ (or (integerp inum)
+ (not (pbfr-list-depends-on k p inum)))
+ (or (natp iden)
+ (not (pbfr-list-depends-on k p iden))))
+ (not (gobj-depends-on k p (mk-g-number-fn rnum rden inum iden))))
+ :hints(("Goal" :in-theory (e/d (mk-g-number-fn
+ (:t components-to-number-fn))
+ ((pbfr-list-depends-on) max
+ gobj-depends-on
+ bfr-list->s
+ bfr-list->u
+ norm-bvec-s
+ norm-bvec-u))
+ :expand ((:free (a b c d)
+ (gobj-depends-on k p
+ (components-to-number-fn a b c d)))
+ (mk-g-number-fn rnum rden inum iden))))))
@@ -260,6 +375,12 @@
:do-not-induct t))
:rule-classes ((:rewrite :backchain-limit-lst 0)))
+(defthm g-keyword-symbolp-compound-recognizer
+ (implies (g-keyword-symbolp x)
+ (and (symbolp x)
+ (not (booleanp x))))
+ :rule-classes :compound-recognizer)
+
;; (defthm gobjectp-gl-cons
;; (gobjectp (gl-cons x y)))
@@ -268,6 +389,31 @@
(cons (generic-geval x env)
(generic-geval y env))))
+(defthm gobj-depends-on-of-gl-cons
+ (equal (gobj-depends-on k p (gl-cons x y))
+ (or (gobj-depends-on k p x)
+ (gobj-depends-on k p y)))
+ :hints(("Goal" :in-theory (enable gl-cons)
+ :expand ((gobj-depends-on k p (cons x y))))))
+
+(defthm generic-geval-list-gl-cons
+ (equal (generic-geval-list (gl-cons x y) env)
+ (cons (generic-geval x env)
+ (generic-geval-list y env)))
+ :hints(("Goal" :expand ((:free (x) (generic-geval-list (cons x y) env))))))
+
+(defthm gobj-list-depends-on-of-gl-cons
+ (equal (gobj-list-depends-on k p (gl-cons x y))
+ (or (gobj-depends-on k p x)
+ (gobj-list-depends-on k p y)))
+ :hints(("Goal" :in-theory (enable gl-cons))))
+
+(defthm generic-geval-list-atom
+ (implies (not (consp x))
+ (equal (generic-geval-list x env) nil))
+ :hints(("Goal" :expand ((generic-geval-list x env))))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
(in-theory (disable gl-cons))
(defthmd generic-geval-of-gobj-list
@@ -302,21 +448,190 @@
(defthm generic-geval-g-apply
- (equal (generic-geval (g-apply fn args) env)
- (generic-geval-ev (cons fn (kwote-lst (generic-geval args env)))
- nil))
+ (implies (not (equal fn 'quote))
+ (equal (generic-geval (g-apply fn args) env)
+ (generic-geval-ev (cons fn (kwote-lst (generic-geval-list args env)))
+ nil)))
:hints (("goal" :expand ((generic-geval (g-apply fn args) env))
:in-theory (enable generic-geval-apply))))
(defthmd generic-geval-g-apply-p
- (implies (g-apply-p x)
+ (implies (and (g-apply-p x)
+ (not (equal (g-apply->fn x) 'quote)))
(equal (generic-geval x env)
(generic-geval-ev
(cons (g-apply->fn x)
- (kwote-lst (generic-geval (g-apply->args x) env)))
+ (kwote-lst (generic-geval-list (g-apply->args x) env)))
nil)))
:hints (("goal" :expand ((generic-geval x env))
:in-theory (enable generic-geval-apply)))
:rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+
+
+(defsection gobj-depends-on
+
+ (local (in-theory (enable gobj-depends-on)))
+
+ (defthm gobj-list-depends-on-of-g-apply->args
+ (implies (and (not (gobj-depends-on k p x))
+ (eq (tag x) :g-apply))
+ (not (gobj-list-depends-on k p (g-apply->args x)))))
+
+ (defthm gobj-depends-on-of-g-ite->test
+ (implies (and (not (gobj-depends-on k p x))
+ (eq (tag x) :g-ite))
+ (not (gobj-depends-on k p (g-ite->test x)))))
+
+ (defthm gobj-depends-on-of-g-ite->then
+ (implies (and (not (gobj-depends-on k p x))
+ (eq (tag x) :g-ite))
+ (not (gobj-depends-on k p (g-ite->then x)))))
+
+ (defthm gobj-depends-on-of-g-ite->else
+ (implies (and (not (gobj-depends-on k p x))
+ (eq (tag x) :g-ite))
+ (not (gobj-depends-on k p (g-ite->else x)))))
+
+ (defthm gobj-depends-on-car-of-gobj-list
+ (implies (not (gobj-list-depends-on k p x))
+ (not (gobj-depends-on k p (car x)))))
+
+ (defthm gobj-list-depends-on-cdr-of-gobj-list
+ (implies (not (gobj-list-depends-on k p x))
+ (not (gobj-list-depends-on k p (cdr x)))))
+
+ (defthm gobj-list-depends-on-of-cons
+ (equal (gobj-list-depends-on k p (cons a b))
+ (not (and (not (gobj-depends-on k p a))
+ (not (gobj-list-depends-on k p b))))))
+
+ (defthm gobj-list-depends-on-of-atom
+ (implies (not (consp x))
+ (equal (gobj-list-depends-on k p x) nil))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm gobj-depends-on-car-of-gobj
+ (implies (and (not (gobj-depends-on k p x))
+ (NOT (EQUAL (TAG X) :G-CONCRETE))
+ (NOT (EQUAL (TAG X) :G-BOOLEAN))
+ (NOT (EQUAL (TAG X) :G-NUMBER))
+ (NOT (EQUAL (TAG X) :G-ITE))
+ (NOT (EQUAL (TAG X) :G-VAR))
+ (NOT (EQUAL (TAG X) :G-APPLY)))
+ (not (gobj-depends-on k p (car x)))))
+
+ (defthm gobj-depends-on-cdr-of-gobj
+ (implies (and (not (gobj-depends-on k p x))
+ (NOT (EQUAL (TAG X) :G-CONCRETE))
+ (NOT (EQUAL (TAG X) :G-BOOLEAN))
+ (NOT (EQUAL (TAG X) :G-NUMBER))
+ (NOT (EQUAL (TAG X) :G-ITE))
+ (NOT (EQUAL (TAG X) :G-VAR))
+ (NOT (EQUAL (TAG X) :G-APPLY)))
+ (not (gobj-depends-on k p (cdr x)))))
+
+ (defthm gobj-depends-on-of-g-boolean->bool
+ (implies (and (not (gobj-depends-on k p x))
+ (eq (tag x) :g-boolean))
+ (not (pbfr-depends-on k p (g-boolean->bool x)))))
+
+ (defthm gobj-depends-on-of-g-number->num-0
+ (implies (and (not (gobj-depends-on k p x))
+ (eq (tag x) :g-number))
+ (not (pbfr-list-depends-on k p (mv-nth 0 (break-g-number (g-number->num x)))))))
+
+ (defthm gobj-depends-on-of-g-number->num-1
+ (implies (and (not (gobj-depends-on k p x))
+ (eq (tag x) :g-number))
+ (not (pbfr-list-depends-on k p (mv-nth 1 (break-g-number (g-number->num x)))))))
+
+ (defthm gobj-depends-on-of-g-number->num-2
+ (implies (and (not (gobj-depends-on k p x))
+ (eq (tag x) :g-number))
+ (not (pbfr-list-depends-on k p (mv-nth 2 (break-g-number (g-number->num x)))))))
+
+ (defthm gobj-depends-on-of-g-number->num-3
+ (implies (and (not (gobj-depends-on k p x))
+ (eq (tag x) :g-number))
+ (not (pbfr-list-depends-on k p (mv-nth 3 (break-g-number
+ (g-number->num x)))))))
+
+ (defthm-gobj-flag
+ (defthm generic-geval-of-set-var-when-gobj-depends-on
+ (implies (and (not (gobj-depends-on k p x))
+ (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k v env)))
+ (equal (generic-geval x (cons (bfr-param-env p (bfr-set-var k v env))
+ var-env))
+ (generic-geval x (cons (bfr-param-env p env)
+ var-env))))
+ :hints ('(:expand ((:free (env) (:with generic-geval (generic-geval x env))))))
+ :flag gobj)
+ (defthm generic-geval-list-of-set-var-when-gobj-depends-on
+ (implies (and (not (gobj-list-depends-on k p x))
+ (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k v env)))
+ (equal (generic-geval-list x (cons (bfr-param-env p (bfr-set-var k v env))
+ var-env))
+ (generic-geval-list x (cons (bfr-param-env p env)
+ var-env))))
+ :hints ('(:expand ((:free (env) (generic-geval-list x env)))))
+ :flag list))
+
+ (defthm gobj-depends-on-of-atom
+ (implies (not (consp x))
+ (not (gobj-depends-on k p x)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm gobj-depends-on-of-cons
+ (implies (not (g-keyword-symbolp x))
+ (equal (gobj-depends-on k p (cons x y))
+ (not (and (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))))))
+ :hints(("Goal" :in-theory (enable g-keyword-symbolp))))
+
+
+
+ (defthm gobj-depends-on-of-g-apply
+ (equal (gobj-depends-on k p (g-apply fn args))
+ (gobj-list-depends-on k p args)))
+
+ (defthm gobj-depends-on-of-g-ite
+ (equal (gobj-depends-on k p (g-ite test then else))
+ (not (and (not (gobj-depends-on k p test))
+ (not (gobj-depends-on k p then))
+ (not (gobj-depends-on k p else))))))
+
+ (defthm gobj-depends-on-of-g-number
+ (equal (gobj-depends-on k p (g-number num))
+ (not (b* (((mv rn rd in id) (break-g-number num)))
+ (and (not (pbfr-list-depends-on k p rn))
+ (not (pbfr-list-depends-on k p rd))
+ (not (pbfr-list-depends-on k p in))
+ (not (pbfr-list-depends-on k p id)))))))
+
+ (defthm gobj-depends-on-of-g-boolean
+ (equal (gobj-depends-on k p (g-boolean bool))
+ (pbfr-depends-on k p bool)))
+
+ (defthm gobj-depends-on-of-g-concrete
+ (equal (gobj-depends-on k p (g-concrete val)) nil))
+
+ (defthm gobj-depends-on-of-g-var
+ (equal (gobj-depends-on k p (g-var val)) nil))
+
+
+ (defthm gobj-depends-on-when-g-concrete
+ (implies (equal (tag x) :g-concrete)
+ (equal (gobj-depends-on k p x) nil))
+ :hints (("goal" :expand ((not (gobj-depends-on k p x)))))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm gobj-depends-on-when-g-var
+ (implies (equal (tag x) :g-var)
+ (equal (gobj-depends-on k p x) nil))
+ :hints (("goal" :expand ((gobj-depends-on k p x))))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
diff -Nru acl2-6.2/books/centaur/gl/gtypes.lisp acl2-6.3/books/centaur/gl/gtypes.lisp
--- acl2-6.2/books/centaur/gl/gtypes.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/gtypes.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,22 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
@@ -273,24 +292,41 @@
;; Number
;; -------------------------
+(defun norm-bvec-s (v)
+ (declare (xargs :guard T))
+ (if (boolean-listp v)
+ (bfr-list->s v nil)
+ v))
+
+(defun norm-bvec-u (v)
+ (declare (xargs :guard t))
+ (if (boolean-listp v)
+ (bfr-list->u v nil)
+ v))
+
+
(defun mk-g-number-fn (rnum rden inum iden)
(declare (xargs :guard t))
- (if (and (integerp rnum) (natp rden)
- (integerp inum) (natp iden))
- (components-to-number rnum rden inum iden)
- (flet ((to-uvec (n)
- (if (natp n)
- (n2v n)
- n))
- (to-svec (n)
- (if (integerp n)
- (i2v n)
- n)))
- (let* ((rst (and (not (or (eql iden 1) (equal iden '(t)))) (list (to-uvec iden))))
- (rst (and (not (or (eql inum 0) (equal inum '(nil)))) (cons (to-svec inum) rst)))
- (rst (and (or rst (not (or (eql rden 1) (equal rden '(t))))) (cons (to-uvec rden) rst))))
- (g-number (cons (to-svec rnum) rst))))))
-
+ (b* ((rnum-norm (norm-bvec-s rnum))
+ (rden-norm (norm-bvec-u rden))
+ (inum-norm (norm-bvec-s inum))
+ (iden-norm (norm-bvec-u iden)))
+ (if (and (integerp rnum-norm) (natp rden-norm)
+ (integerp inum-norm) (natp iden-norm))
+ (components-to-number rnum-norm rden-norm inum-norm iden-norm)
+ (flet ((to-uvec (n)
+ (if (natp n)
+ (n2v n)
+ n))
+ (to-svec (n)
+ (if (integerp n)
+ (i2v n)
+ n)))
+ (let* ((rst (and (not (or (eql iden 1) (equal iden '(t)))) (list (to-uvec iden))))
+ (rst (and (not (or (eql inum 0) (equal inum '(nil)))) (cons (to-svec inum) rst)))
+ (rst (and (or rst (not (or (eql rden 1) (equal rden '(t))))) (cons (to-uvec rden) rst))))
+ (g-number (cons (to-svec rnum) rst)))))))
+
(defmacro mk-g-number (rnum &optional
(rden '1)
@@ -313,13 +349,6 @@
;; the case, that is, if the first is a g-keyword-symbol it wraps it in a g-concrete.
-(defun gl-cons (x y)
- (declare (xargs :guard t))
- (cons (if (g-keyword-symbolp x)
- (g-concrete x)
- x)
- y))
-
(defun gl-list-macro (lst)
(if (atom lst)
nil
@@ -345,3 +374,32 @@
(implies (gobj-listp x)
(gobj-listp (gl-cons k x)))
:hints(("Goal" :in-theory (enable gl-cons tag)))))
+
+
+(mutual-recursion
+ (defun gobj-depends-on (k p x)
+ (if (atom x)
+ nil
+ (pattern-match x
+ ((g-boolean b) (pbfr-depends-on k p b))
+ ((g-number n)
+ (b* (((mv rn rd in id) (break-g-number n)))
+ (or (pbfr-list-depends-on k p rn)
+ (pbfr-list-depends-on k p rd)
+ (pbfr-list-depends-on k p in)
+ (pbfr-list-depends-on k p id))))
+ ((g-ite test then else)
+ (or (gobj-depends-on k p test)
+ (gobj-depends-on k p then)
+ (gobj-depends-on k p else)))
+ ((g-concrete &) nil)
+ ((g-var &) nil)
+ ((g-apply & args) (gobj-list-depends-on k p args))
+ (& (or (gobj-depends-on k p (car x))
+ (gobj-depends-on k p (cdr x)))))))
+ (defun gobj-list-depends-on (k p x)
+ (if (atom x)
+ nil
+ (or (gobj-depends-on k p (car x))
+ (gobj-list-depends-on k p (cdr x))))))
+
diff -Nru acl2-6.2/books/centaur/gl/hyp-fix-logic.lisp acl2-6.3/books/centaur/gl/hyp-fix-logic.lisp
--- acl2-6.2/books/centaur/gl/hyp-fix-logic.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/hyp-fix-logic.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,10 +1,25 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-
(include-book "hyp-fix")
-
(local (in-theory (disable (force))))
;; The interface for these three functions is summed up by the theorem below.
@@ -32,7 +47,10 @@
(defthm hyp-fix-correct
(implies (bfr-eval hyp env)
(equal (bfr-eval (hyp-fix x hyp) env)
- (bfr-eval x env))))
+ (bfr-eval x env)))
+ :hints ((and stable-under-simplificationp
+ (member-equal '(not (bfr-mode)) clause)
+ '(:in-theory (enable bfr-eval)))))
(defthmd hyp-ops-correct
@@ -55,7 +73,10 @@
(equal (hyp-fix x hyp)
x)))
-
+(defthm pbfr-depends-on-of-hyp-fix
+ (implies (not (pbfr-depends-on k p x))
+ (not (pbfr-depends-on k p (hyp-fix x hyp))))
+ :hints(("Goal" :in-theory (enable hyp-fix))))
;; (local (bfr-reasoning-mode t))
diff -Nru acl2-6.2/books/centaur/gl/hyp-fix.lisp acl2-6.3/books/centaur/gl/hyp-fix.lisp
--- acl2-6.2/books/centaur/gl/hyp-fix.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/hyp-fix.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,16 +1,124 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "bfr")
+(local (include-book "centaur/aig/aig-vars" :dir :system))
+;; determines whether x, a non-negated aig, is trivially necessarily true or
+;; false assuming hyp. Just traverses the top-level ANDs of hyp. Returns (mv
+;; known val).
+(defund aig-under-hyp1 (x hyp)
+ (declare (xargs :guard t))
+ (b* (((when (hqual hyp x)) (mv t t))
+ ((when (atom hyp)) (mv nil nil))
+ ((when (eq (cdr hyp) nil))
+ (mv (hqual (car hyp) x) nil))
+ ((mv known1 val1) (aig-under-hyp1 x (car hyp)))
+ ((when known1) (mv known1 val1)))
+ (aig-under-hyp1 x (cdr hyp))))
+
+(defthm aig-under-hyp1-correct
+ (b* (((mv known val) (aig-under-hyp1 x hyp)))
+ (implies (and known
+ (acl2::aig-eval hyp env))
+ (equal (acl2::aig-eval x env) val)))
+ :hints (("Goal" :induct (aig-under-hyp1 x hyp)
+ :in-theory (e/d ((:i aig-under-hyp1))
+ ((:d aig-under-hyp1) acl2::aig-eval))
+ :expand ((aig-under-hyp1 x hyp)
+ (aig-under-hyp1 hyp hyp)))
+ (and stable-under-simplificationp
+ '(:expand ((acl2::aig-eval hyp env))))))
+
+(defthm booleanp-of-aig-under-hyp1-val
+ (booleanp (mv-nth 1 (aig-under-hyp1 x hyp)))
+ :hints(("Goal" :in-theory (enable aig-under-hyp1)))
+ :rule-classes :type-prescription)
+
+(defund aig-under-hyp (x hyp)
+ (declare (xargs :guard t))
+ (cond ((booleanp x) x)
+ ((atom x) (mv-let (known val)
+ (aig-under-hyp1 x hyp)
+ (if known val x)))
+ ((eq (cdr x) nil)
+ (b* (((mv known val) (aig-under-hyp1 (car x) hyp)))
+ (if known (not val) x)))
+ (t (b* ((x1 (aig-under-hyp (car x) hyp)))
+ (and x1
+ (acl2::aig-and x1 (aig-under-hyp (cdr x) hyp)))))))
+
+(defthm aig-under-hyp-correct
+ (b* ((xx (aig-under-hyp x hyp)))
+ (implies (acl2::aig-eval hyp env)
+ (equal (acl2::aig-eval xx env)
+ (acl2::aig-eval x env))))
+ :hints(("Goal" :in-theory (enable aig-under-hyp))))
+
+(defthm aig-under-hyp-of-booleans
+ (implies (booleanp x)
+ (equal (aig-under-hyp x hyp)
+ x))
+ :hints(("Goal" :in-theory (enable aig-under-hyp)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+(defthm aig-under-hyp-idempotent
+ (equal (aig-under-hyp (aig-under-hyp x hyp) hyp)
+ (aig-under-hyp x hyp))
+ :hints(("Goal" :in-theory (enable aig-under-hyp
+ acl2::aig-and))))
+
+
+(defthm aig-under-hyp-bfr-depends-on
+ (implies (and (bfr-mode)
+ (not (bfr-depends-on k x)))
+ (not (bfr-depends-on k (aig-under-hyp x hyp))))
+ :hints(("Goal" :in-theory (e/d (aig-under-hyp
+ bfr-depends-on)
+ (sets::subset sets::in sets::union)))))
+
+(defthm aig-under-hyp-pbfr-depends-on
+ (implies (and (bfr-mode)
+ (not (pbfr-depends-on k p x)))
+ (not (pbfr-depends-on k p (aig-under-hyp x hyp))))
+ :hints(("Goal" :in-theory (e/d (pbfr-depends-on bfr-from-param-space))
+ :do-not-induct t))
+ :otf-flg t)
+
+;; (defthm booleanp-of-aig-under-hyp-val
+;; (booleanp (mv-nth 1 (aig-under-hyp x hyp)))
+;; :hints(("Goal" :in-theory (enable aig-under-hyp)))
+;; :rule-classes :type-prescription)
+
+
(defun hyp-fix (x hyp)
(declare (xargs :guard t))
- (let ((and (bfr-and x hyp)))
- (if and
- (if (hqual and hyp)
- t
- x)
- nil)))
+ (bfr-case
+ :bdd (let ((and (bfr-and x hyp)))
+ (if and
+ (if (hqual and hyp)
+ t
+ x)
+ nil))
+ :aig (aig-under-hyp x hyp)))
;; (prove-congruences (bfr-equiv bfr-equiv) hyp-fix)
diff -Nru acl2-6.2/books/centaur/gl/ite-merge.lisp acl2-6.3/books/centaur/gl/ite-merge.lisp
--- acl2-6.2/books/centaur/gl/ite-merge.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/ite-merge.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,19 +1,33 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "general-objects")
-
-(local (include-book "general-object-thms"))
-
-(local (include-book "hyp-fix-logic"))
-
(include-book "bvec-ite")
(include-book "hyp-fix")
+(include-book "split-args")
(include-book "std/misc/two-nats-measure" :dir :system)
-
(include-book "tools/mv-nth" :dir :system)
(local (include-book "misc/invariants" :dir :system))
-
+(local (include-book "general-object-thms"))
+(local (include-book "hyp-fix-logic"))
(verify-guards
general-concrete-obj
@@ -31,20 +45,20 @@
(general-number-components x))
((mv yrn yrd yin yid)
(general-number-components y)))
- (flet ((ubv-ite (c a b)
- (let ((res (bfr-ite-bvv-fn c a b)))
- (if (boolean-listp res)
- (v2n res)
- res)))
- (sbv-ite (c a b)
- (let ((res (bfr-ite-bss-fn c a b)))
- (if (boolean-listp res)
- (v2i res)
- res))))
- (mk-g-number (sbv-ite c xrn yrn)
- (ubv-ite c xrd yrd)
- (sbv-ite c xin yin)
- (ubv-ite c xid yid)))))
+ (mk-g-number (bfr-ite-bss-fn c xrn yrn)
+ (bfr-ite-bvv-fn c xrd yrd)
+ (bfr-ite-bss-fn c xin yin)
+ (bfr-ite-bvv-fn c xid yid))))
+
+(defthm gobj-depends-on-of-merge-general-numbers
+ (implies (and (not (pbfr-depends-on k p c))
+ (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))
+ (general-numberp x)
+ (general-numberp y))
+ (not (gobj-depends-on k p (merge-general-numbers c x y))))
+ :hints(("Goal" :in-theory (enable merge-general-numbers
+ gobj-depends-on))))
(in-theory (disable merge-general-numbers))
@@ -61,6 +75,16 @@
(val (bfr-ite c av bv)))
(mk-g-boolean val)))
+(defthm gobj-depends-on-of-merge-general-booleans
+ (implies (and (not (pbfr-depends-on k p c))
+ (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y))
+ (general-booleanp x)
+ (general-booleanp y))
+ (not (gobj-depends-on k p (merge-general-booleans c x y))))
+ :hints(("Goal" :in-theory (enable merge-general-booleans
+ gobj-depends-on))))
+
(in-theory (disable merge-general-booleans))
@@ -114,7 +138,13 @@
((eq (tag x) :g-apply)
(if (eq (tag y) :g-apply)
(if (equal (g-apply->fn x) (g-apply->fn y))
- 'applies
+ (if (equal (len (g-apply->args x))
+ (len (g-apply->args y)))
+ 'applies
+ (if (< (len (g-apply->args x))
+ (len (g-apply->args y)))
+ '<
+ '>))
(if (hlexorder (cdr x) (cdr y)) '< '>))
'<))
((eq (tag y) :g-apply) '>)
@@ -156,6 +186,18 @@
(bool-cond-itep-falsebr x))
(mv t x nil)))
+(defthm gobj-depends-on-of-breakdown-ite-by-cond
+ (implies (not (gobj-depends-on k p x))
+ (b* (((mv test x y) (breakdown-ite-by-cond x)))
+ (and (not (pbfr-depends-on k p test))
+ (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y)))))
+ :hints(("Goal" :in-theory (enable breakdown-ite-by-cond
+ bool-cond-itep
+ bool-cond-itep-truebr
+ bool-cond-itep-falsebr
+ bool-cond-itep-cond))))
+
@@ -179,7 +221,9 @@
(and (not (equal x y))
(equal (tag x) :g-apply)
(equal (tag y) :g-apply)
- (equal (g-apply->fn x) (g-apply->fn y)))))
+ (equal (g-apply->fn x) (g-apply->fn y))
+ (equal (len (g-apply->args x))
+ (len (g-apply->args y))))))
:hints (("goal" :in-theory (enable general-booleanp general-numberp
general-consp general-concrete-atom
tag ite-merge-ordering)))))
@@ -194,10 +238,10 @@
(local
(encapsulate nil
(local (add-bfr-pat (hyp-fix . ?)))
- (local (in-theory (disable* acl2-count integer-abs
+ (local (in-theory (disable* acl2-count integer-abs
equal-of-booleans-rewrite not
hyp-fix-of-hyp-fixedp
-
+
; bfr-eval-nonnil-forward
default-+-2 o<
default-<-1
@@ -307,7 +351,15 @@
true-under-hyp
false-under-hyp)
((two-nats-measure)
- (maybe-merge-measure)))))))))
+ (maybe-merge-measure)))))))
+
+ (defthm ite-merge-lists-measure-thm
+ (implies (consp x)
+ (and (o< (ite-merge-measure (car x) (car y))
+ (ite-merge-measure x y))
+ (o< (ite-merge-measure (cdr x) (cdr y))
+ (ite-merge-measure x y))))
+ :hints(("Goal" :in-theory (enable ite-merge-measure acl2-count))))))
@@ -336,24 +388,26 @@
:measure (maybe-merge-measure x y)))
(let ((ordersym (ite-merge-ordering x y)))
(case ordersym
- (equal (mv t x))
+ (equal (mv 'merged x))
(booleans (mv 'merged (merge-general-booleans c x y)))
(numbers (mv 'merged (merge-general-numbers c x y)))
(conses (let ((hyp (bfr-and hyp (hf (bfr-ite c xhyp yhyp)))))
- (mv 'merged (gl-cons (ite-merge (hf c)
- (general-consp-car x)
- (general-consp-car y)
- hyp)
- (ite-merge (hf c)
- (general-consp-cdr x)
- (general-consp-cdr y)
- hyp)))))
+ (mv 'merged (gl-cons ;; gl-cons-split-ite ;;
+ (ite-merge (hf c)
+ (general-consp-car x)
+ (general-consp-car y)
+ hyp)
+ (ite-merge (hf c)
+ (general-consp-cdr x)
+ (general-consp-cdr y)
+ hyp)))))
(applies (let ((hyp (bfr-and hyp (hf (bfr-ite c xhyp yhyp)))))
- (mv 'merged (g-apply (g-apply->fn x)
- (ite-merge (hf c)
- (g-apply->args x)
- (g-apply->args y)
- hyp)))))
+ (mv 'merged (g-apply ;; gl-fncall-split-ite ;;
+ (g-apply->fn x)
+ (ite-merge-lists (hf c)
+ (g-apply->args x)
+ (g-apply->args y)
+ hyp)))))
(otherwise (mv ordersym nil)))))
@@ -365,7 +419,8 @@
:hints (("goal" :do-not-induct t
:in-theory '(ite-merge-measure-thm
merge-rest-measure-thm
- maybe-merge-measure-thm)))))
+ maybe-merge-measure-thm
+ ite-merge-lists-measure-thm)))))
(cond ((not hyp) nil)
((hons-equal x y) x)
((th c) x)
@@ -378,20 +433,36 @@
(maybe-merge c first-x first-y first-x-cond first-y-cond hyp)))
(case merge-flg
(merged
- (if (and (eq first-x-cond t)
- (eq first-y-cond t))
- first
- (merge-rest (hf (bfr-ite c first-x-cond first-y-cond))
- first c rest-x rest-y hyp)))
+ (cond ((and (eq first-x-cond t)
+ (eq first-y-cond t))
+ first)
+ ((eq first-x-cond t)
+ (mk-g-ite (mk-g-boolean (hf (bfr-or c first-y-cond)))
+ first rest-y))
+ ((eq first-y-cond t)
+ (mk-g-ite (mk-g-boolean (hf (bfr-or (bfr-not c)
+ first-x-cond)))
+ first rest-x))
+ (t (merge-rest (hf (bfr-ite c first-x-cond first-y-cond))
+ first c rest-x rest-y hyp))))
(< (if (eq first-x-cond t)
(mk-g-ite (mk-g-boolean c) first-x y)
(merge-rest (bfr-and c first-x-cond)
first-x c rest-x y hyp)))
(t ;; >
(if (eq first-y-cond t)
- (mk-g-ite (mk-g-boolean c) x first-y)
+ (mk-g-ite (mk-g-boolean (bfr-not c)) first-y x)
(merge-rest (bfr-and (bfr-not c) first-y-cond)
- first-y c x rest-y hyp)))))))))
+ first-y c x rest-y hyp))))))))
+
+ (defun ite-merge-lists (c x y hyp)
+ ;; (if c x y), x and y lists
+ (declare (xargs :guard (equal (len x) (len y))
+ :measure (ite-merge-measure x y)))
+ (if (atom x)
+ nil
+ (cons (ite-merge c (car x) (car y) hyp)
+ (ite-merge-lists c (cdr x) (cdr y) hyp)))))
(in-theory (disable ite-merge merge-rest))
@@ -402,8 +473,6 @@
-
-
;; (local
;; (defthm merge-general-numbers-gobjectp
;; (implies (and (gobjectp a) (gobjectp b)
@@ -420,35 +489,35 @@
(implies (boolean-listp x)
(equal (bfr-eval-list x env)
x))))
-
- (local (defthm rewrite-v2i-of-boolean-list
- (implies (and (syntaxp (not (and (consp x)
- (eq (car x) 'bfr-eval-list))))
- (bind-free '((env . (car env))) (env))
- (boolean-listp x))
- (equal (v2i x)
- (v2i (bfr-eval-list x env))))
- :hints(("Goal" :in-theory (enable bfr-eval-list-when-boolean-listp)))
- :rule-classes ((:rewrite :backchain-limit-lst 0))))
-
- (local (defthm rewrite-v2n-of-boolean-list
- (implies (and (syntaxp (not (and (consp x)
- (eq (car x) 'bfr-eval-list))))
- (bind-free '((env . (car env))) (env))
- (boolean-listp x))
- (equal (v2n x)
- (v2n (bfr-eval-list x env))))
- :hints(("Goal" :in-theory (enable bfr-eval-list-when-boolean-listp)))
- :rule-classes ((:rewrite :backchain-limit-lst 0))))
-
- (defthm bfr-eval-list-of-bfr-ite-bvv-fn-under-v2n
- (equal (v2n (bfr-eval-list (bfr-ite-bvv-fn c a b) env))
- (v2n (if (bfr-eval c env)
- (bfr-eval-list a env)
- (bfr-eval-list b env))))
- :hints(("Goal" :in-theory (enable bfr-ite-bvv-fn v2n)
- :induct t)
- (bfr-reasoning)))
+
+ ;; (local (defthm rewrite-v2i-of-boolean-list
+ ;; (implies (and (syntaxp (not (and (consp x)
+ ;; (eq (car x) 'bfr-eval-list))))
+ ;; (bind-free '((env . (car env))) (env))
+ ;; (boolean-listp x))
+ ;; (equal (v2i x)
+ ;; (bfr-list->s x env)))
+ ;; :hints(("Goal" :in-theory (enable bfr-eval-list-when-boolean-listp)))
+ ;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+ ;; (local (defthm rewrite-v2n-of-boolean-list
+ ;; (implies (and (syntaxp (not (and (consp x)
+ ;; (eq (car x) 'bfr-eval-list))))
+ ;; (bind-free '((env . (car env))) (env))
+ ;; (boolean-listp x))
+ ;; (equal (v2n x)
+ ;; (bfr-list->u x env)))
+ ;; :hints(("Goal" :in-theory (enable bfr-eval-list-when-boolean-listp)))
+ ;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+ ;; (defthm bfr-list->u-of-bfr-ite-bvv-fn-under
+ ;; (equal (bfr-list->u (bfr-ite-bvv-fn c a b) env)
+ ;; (if (bfr-eval c env)
+ ;; (bfr-list->u a env)
+ ;; (bfr-list->u b env)))
+ ;; :hints(("Goal" :in-theory (enable bfr-ite-bvv-fn)
+ ;; :induct t)
+ ;; (bfr-reasoning)))
(defthm merge-general-numbers-correct
(implies (and (general-numberp a) (general-numberp b))
@@ -526,7 +595,7 @@
;; env)))
;; :hints(("Goal" :in-theory (enable hyp-fix hyp-fixedp)))))
-
+
;; (local
;; (defthm breakdown-ite-by-cond-nonnil
;; (implies (and hyp (bfr-and c hyp)
@@ -564,7 +633,8 @@
:hints (("goal" :do-not-induct t
:in-theory '(ite-merge-measure-thm
merge-rest-measure-thm
- maybe-merge-measure-thm)))))
+ maybe-merge-measure-thm
+ ite-merge-lists-measure-thm)))))
@@ -642,7 +712,9 @@
true-under-hyp
hyp-fixedp
hyp-fix
- breakdown-ite-by-cond))))))))
+ breakdown-ite-by-cond
+ (:type-prescription len)
+ (tau-system)))))))))
;; (local
@@ -688,17 +760,40 @@
(not (equal (ite-merge-ordering x y) 'merged))
:hints(("Goal" :in-theory (enable ite-merge-ordering)))))
+
+
+(local (defthm generic-geval-list-when-not-consp
+ (implies (not (consp x))
+ (equal (generic-geval-list x env) nil))
+ :hints(("Goal" :in-theory (enable generic-geval-list)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+(local (defthm generic-geval-list-when-len-0
+ (implies (equal (len x) 0)
+ (equal (generic-geval-list x env) nil))
+ :hints(("Goal" :in-theory (enable generic-geval-list)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+(local (defthm len-when-not-consp
+ (implies (not (consp x))
+ (equal (len x) 0))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+(local (defthm len-when-consp
+ (implies (consp x)
+ (posp (len x)))
+ :rule-classes :type-prescription))
+
(local
(encapsulate
nil
(local (in-theory (e/d* (generic-geval-g-apply-p)
- ((force) member-equal
+ ((force) member-equal
ite-merge merge-rest maybe-merge
general-number-components-ev
-
+
boolean-list-bfr-eval-list
mv-nth
- (:type-prescription len)
default-car default-cdr
hons-assoc-equal
(:rewrite bfr-eval-booleanp)
@@ -706,11 +801,10 @@
generic-geval
hyp-fix-of-hyp-fixedp
eval-concrete-gobjectp
- acl2-numberp-v2n
default-unary-/
-
- (:type-prescription v2n)
- (:type-prescription v2i)
+
+ len
+
bfr-eval-list-consts
default-*-1 default-*-2
(:type-prescription booleanp)
@@ -737,36 +831,56 @@
;; :in-theory (enable false-under-hyp true-under-hyp))))
(def-ite-merge-thm ite-merge-correct-lemma
- (ite-merge (implies (bfr-eval (double-rewrite hyp) (car env))
- (equal (generic-geval (ite-merge c x y hyp) env)
- (if (bfr-eval c (car env))
- (generic-geval x env)
- (generic-geval y env))))
- :name ite-merge-correct)
- (maybe-merge (mv-let (flg ans)
- (maybe-merge c x y xhyp yhyp hyp)
- (implies (and (equal flg 'merged)
- (bfr-eval hyp (car env)))
- (and (implies (and (bfr-eval c (car env))
- (bfr-eval xhyp (car env)))
- (equal (generic-geval ans env)
- (generic-geval x env)))
- (implies (and (not (bfr-eval c (car env)))
- (bfr-eval yhyp (car env)))
- (equal (generic-geval ans env)
- (generic-geval y env))))))
- :name maybe-merge-correct)
-
- (merge-rest (implies (bfr-eval hyp (car env))
- (equal (generic-geval (merge-rest firstcond first c x y hyp) env)
- (if (bfr-eval firstcond (car env))
- (generic-geval first env)
- (if (bfr-eval c (car env))
- (generic-geval x env)
- (generic-geval y env)))))
- :name merge-rest-correct)
- :hints (("goal" :induct (ite-merge-ind flag firstcond first xhyp yhyp c x y hyp)
- :do-not-induct t
+ (defthm ite-merge-correct
+ (implies (bfr-eval (double-rewrite hyp) (car env))
+ (equal (generic-geval (ite-merge c x y hyp) env)
+ (if (bfr-eval c (car env))
+ (generic-geval x env)
+ (generic-geval y env))))
+ :hints ('(:expand ((ite-merge c x y hyp))))
+ :flag ite-merge)
+ (defthm ite-merge-lists-correct
+ (implies (and (bfr-eval (double-rewrite hyp) (car env))
+ (equal (len x) (len y)))
+ (equal (generic-geval-list (ite-merge-lists c x y hyp) env)
+ (if (bfr-eval c (car env))
+ (generic-geval-list x env)
+ (generic-geval-list y env))))
+ :hints ('(:expand ((ite-merge-lists c x y hyp)
+ (generic-geval-list x env)
+ (generic-geval-list y env)
+ (generic-geval-list nil env)
+ (:free (a b) (generic-geval-list (cons a b) env)))))
+ :flag ite-merge-lists)
+ (defthm maybe-merge-correct
+ (mv-let (flg ans)
+ (maybe-merge c x y xhyp yhyp hyp)
+ (implies (and (equal flg 'merged)
+ (bfr-eval hyp (car env)))
+ (and (implies (and (bfr-eval c (car env))
+ (bfr-eval xhyp (car env)))
+ (equal (generic-geval ans env)
+ (generic-geval x env)))
+ (implies (and (not (bfr-eval c (car env)))
+ (bfr-eval yhyp (car env)))
+ (equal (generic-geval ans env)
+ (generic-geval y env))))))
+ :hints ('(:expand ((maybe-merge c x y xhyp yhyp hyp)))
+ (and stable-under-simplificationp
+ '(:in-theory (enable generic-geval))))
+ :flag maybe-merge)
+
+ (defthm merge-rest-correct
+ (implies (bfr-eval hyp (car env))
+ (equal (generic-geval (merge-rest firstcond first c x y hyp) env)
+ (if (bfr-eval firstcond (car env))
+ (generic-geval first env)
+ (if (bfr-eval c (car env))
+ (generic-geval x env)
+ (generic-geval y env)))))
+ :hints ('(:expand ((merge-rest firstcond first c x y hyp))))
+ :flag merge-rest)
+ :hints (("goal" :do-not-induct t
:in-theory (set-difference-theories
(list* '(:induction ite-merge-ind)
'(:rewrite ite-merge-ind-equivalences)
@@ -778,10 +892,10 @@
;; ("Subgoal *1/13" :by nil)
;; ("Subgoal *1/12" :by nil)
;; ("Subgoal *1/11" :by nil)
- (and ;;(subgoal-of "Subgoal *1/" id)
- stable-under-simplificationp
- (flag::expand-calls-computed-hint
- clause '(ite-merge merge-rest maybe-merge)))
+ ;; (and ;;(subgoal-of "Subgoal *1/" id)
+ ;; stable-under-simplificationp
+ ;; (flag::expand-calls-computed-hint
+ ;; clause '(ite-merge merge-rest maybe-merge)))
(and ;;(subgoal-of "Subgoal *1/" id)
stable-under-simplificationp
(or (cw "enabling~%")
@@ -798,14 +912,60 @@
;; ite-merge-guard merge-rest-guard
;; maybe-merge-guard
hyp-fix hyp-fixedp)
- ()))))))))
+ ()))))))
+ (local (Defthm gobj-list-depends-on-nil
+ (not (gobj-list-depends-on k p nil))
+ :hints(("Goal" :in-theory (enable gobj-list-depends-on)))))
+
+ (def-ite-merge-thm gobj-depends-on-of-ite-merge-lemma
+ (defthm gobj-depends-on-of-ite-merge
+ (implies (and (not (pbfr-depends-on k p c))
+ (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y)))
+ (not (gobj-depends-on k p (ite-merge c x y hyp))))
+ :hints ('(:expand ((ite-merge c x y hyp)
+ (ite-merge c x y nil)
+ (ite-merge c x x hyp))))
+ :flag ite-merge)
+ (defthm gobj-depends-on-of-ite-merge-lists
+ (implies (and (not (pbfr-depends-on k p c))
+ (not (gobj-list-depends-on k p x))
+ (not (gobj-list-depends-on k p y)))
+ (not (gobj-list-depends-on k p (ite-merge-lists c x y hyp))))
+ :hints ('(:expand ((ite-merge-lists c x y hyp))))
+ :flag ite-merge-lists)
+ (defthm gobj-depends-on-of-maybe-merge
+ (mv-let (flg ans)
+ (maybe-merge c x y xhyp yhyp hyp)
+ (declare (ignore flg))
+ (implies (and (not (pbfr-depends-on k p c))
+ (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y)))
+ (not (gobj-depends-on k p ans))))
+ :hints ('(:expand ((maybe-merge c x y xhyp yhyp hyp)
+ (maybe-merge c x x xhyp yhyp hyp)))
+ (and stable-under-simplificationp
+ '(:in-theory (enable generic-geval))))
+ :flag maybe-merge)
+
+ (defthm gobj-depends-on-of-merge-rest
+ (implies (and (not (pbfr-depends-on k p firstcond))
+ (not (gobj-depends-on k p first))
+ (not (pbfr-depends-on k p c))
+ (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y)))
+ (not (gobj-depends-on k p (merge-rest firstcond first c x y hyp))))
+ :hints ('(:expand ((merge-rest firstcond first c x y hyp)
+ (merge-rest firstcond first c x y nil))))
+ :flag merge-rest)
+ :hints (("goal" :do-not-induct t)))))
(verify-guards ite-merge
:hints (("Goal" :in-theory (e/d** ((:ruleset minimal-rules))))
(and stable-under-simplificationp
- '(:in-theory
+ '(:in-theory
(e/d** ((:ruleset minimal-rules)
ite-merge-invariants))))
(and stable-under-simplificationp
@@ -865,3 +1025,10 @@
(generic-geval y env))))
:hints(("Goal" :in-theory (e/d (gobj-ite-merge)))))
+(defthm gobj-depends-on-of-gobj-ite-merge
+ (implies (and (not (pbfr-depends-on k p c))
+ (not (gobj-depends-on k p x))
+ (not (gobj-depends-on k p y)))
+ (not (gobj-depends-on k p (gobj-ite-merge c x y hyp))))
+ :hints(("Goal" :in-theory (enable gobj-ite-merge))))
+
diff -Nru acl2-6.2/books/centaur/gl/package.lsp acl2-6.3/books/centaur/gl/package.lsp
--- acl2-6.2/books/centaur/gl/package.lsp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/package.lsp 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,22 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "ACL2")
@@ -10,6 +29,9 @@
hons-acons hons-get hut het hqual hons-equal
hons-assoc-equal make-fal
definline definlined
+ defxdoc defsection define
+
+ alist-keys alist-vals
qv bfr-and bfr-not bfr-and
bfr-p bfr-or bfr-xor bfr-iff bfr-ite bfr-eval bfr-eval-list
@@ -130,13 +152,33 @@
mk-g-number mk-g-boolean mk-g-ite mk-g-concrete
gobjectp glc glr gl-fnsym gl-interp
gl-interp-raw gl-interp
- gl-aside gl-ignore nonnil-symbol-listp env
+ gl-aside gl-ignore nonnil-symbol-listp
xor
gl-bdd-mode gl-aig-mode gl-mbe
+ logcons logcar logcdr loghead logtail logapp
+ b-ior b-and b-xor b-not bfix bitp boolfix
+
numlist
- defsection))
+ defsection
+
+ ;; some imports for better xdoc integration
+ hardware-verification
+ proof-automation
+ boolean-reasoning
+ satlink
+ ubdds
+ aig
+ acl2::hons-and-memoization
+ xdoc
+ set-max-mem
+ the-method
+ aignet
+ gl
+
+
+ ))
'(nat-listp ; included 12/4/2012 by Matt K., for addition to *acl2-exports*
)))
diff -Nru acl2-6.2/books/centaur/gl/param.lisp acl2-6.3/books/centaur/gl/param.lisp
--- acl2-6.2/books/centaur/gl/param.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/param.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,36 +1,38 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-(include-book "shape-spec")
-
-
+(include-book "bfr-param")
+(include-book "gtypes")
+(include-book "bvar-db")
+(include-book "tools/clone-stobj" :dir :system)
+(include-book "centaur/ubdds/param" :dir :system)
+(include-book "centaur/ubdds/lite" :dir :system)
+(include-book "centaur/aig/misc" :dir :system)
(local (include-book "gtype-thms"))
(local (include-book "data-structures/no-duplicates" :dir :system))
(local (include-book "tools/mv-nth" :dir :system))
(local (include-book "ihs/ihs-lemmas" :dir :system))
-
-(include-book "centaur/ubdds/param" :dir :system)
-(include-book "centaur/ubdds/lite" :dir :system)
-(include-book "../aig/misc")
-(local (include-book "../aig/eval-restrict"))
-
+(local (include-book "centaur/aig/eval-restrict" :dir :system))
(local (in-theory (disable acl2::append-of-nil)))
-(defun bfr-to-param-space (p x)
- (declare (xargs :guard t)
- (ignorable p))
- (bfr-case :bdd (acl2::to-param-space p x)
- :aig (acl2::aig-restrict
- x (acl2::aig-extract-iterated-assigns-alist p 10))))
-
-(defun bfr-list-to-param-space (p x)
- (declare (xargs :guard t)
- (ignorable p))
- (bfr-case :bdd (acl2::to-param-space-list p x)
- :aig (acl2::aig-restrict-list
- x (acl2::aig-extract-iterated-assigns-alist p 10))))
-
;; (local
;; (defthm bfr-p-to-param-space
;; (implies (bfr-p x)
@@ -47,15 +49,20 @@
(defund gnumber-to-param-space (n p)
(declare (xargs :guard t))
- (and (consp n)
- (cons (bfr-list-to-param-space p (car n))
- (and (consp (cdr n))
- (cons (bfr-list-to-param-space p (cadr n))
- (and (consp (cddr n))
- (cons (bfr-list-to-param-space p (caddr n))
- (and (consp (cdddr n))
- (list (bfr-list-to-param-space
- p (cadddr n)))))))))))
+ (b* (((mv rnum rden inum iden) (break-g-number n)))
+ (mk-g-number (bfr-list-to-param-space p rnum)
+ (bfr-list-to-param-space p rden)
+ (bfr-list-to-param-space p inum)
+ (bfr-list-to-param-space p iden))))
+ ;; (and (consp n)
+ ;; (cons (bfr-list-to-param-space p (car n))
+ ;; (and (consp (cdr n))
+ ;; (cons (bfr-list-to-param-space p (cadr n))
+ ;; (and (consp (cddr n))
+ ;; (cons (bfr-list-to-param-space p (caddr n))
+ ;; (and (consp (cdddr n))
+ ;; (list (bfr-list-to-param-space
+ ;; p (cadddr n)))))))))))
;; (local
;; (defthm wf-g-numberp-gnumber-to-param-space
@@ -63,24 +70,48 @@
;; (wf-g-numberp (gnumber-to-param-space n p)))
;; :hints(("Goal" :in-theory (enable wf-g-numberp gnumber-to-param-space)))))
-
-(defund gobj-to-param-space (x p)
- (declare (xargs :guard t
- :verify-guards nil))
- (if (atom x)
- x
- (pattern-match x
- ((g-concrete &) x)
- ((g-boolean b) (mk-g-boolean (bfr-to-param-space p b)))
- ((g-number n) (g-number (gnumber-to-param-space n p)))
- ((g-ite if then else)
- (mk-g-ite (gobj-to-param-space if p)
- (gobj-to-param-space then p)
- (gobj-to-param-space else p)))
- ((g-apply fn args) (g-apply fn (gobj-to-param-space args p)))
- ((g-var &) x)
- (& (gl-cons (gobj-to-param-space (car x) p)
- (gobj-to-param-space (cdr x) p))))))
+(mutual-recursion
+ (defun gobj-to-param-space (x p)
+ (declare (xargs :guard t
+ :verify-guards nil))
+ (if (atom x)
+ x
+ (pattern-match x
+ ((g-concrete &) x)
+ ((g-boolean b) (mk-g-boolean (bfr-to-param-space p b)))
+ ((g-number n) (gnumber-to-param-space n p))
+ ((g-ite if then else)
+ (mk-g-ite (gobj-to-param-space if p)
+ (gobj-to-param-space then p)
+ (gobj-to-param-space else p)))
+ ((g-apply fn args) (g-apply fn (gobj-list-to-param-space args p)))
+ ((g-var &) x)
+ (& (gl-cons (gobj-to-param-space (car x) p)
+ (gobj-to-param-space (cdr x) p))))))
+ (defun gobj-list-to-param-space (x p)
+ (declare (xargs :guard t))
+ (if (atom x)
+ nil
+ (cons (gobj-to-param-space (car x) p)
+ (gobj-list-to-param-space (cdr x) p)))))
+
+;; (defthm tag-of-gobj-to-param-space
+;; (implies (and (syntaxp (quotep tag))
+;; (g-keyword-symbolp tag)
+;; (not (equal (tag x) tag))
+;; (not (equal (tag x) :g-ite)))
+;; (not (equal (tag (gobj-to-param-space x p)) tag)))
+;; :hints (("goal" :expand ((gobj-to-param-space x p))
+;; :in-theory (e/d (g-keyword-symbolp
+;; mk-g-boolean
+;; gnumber-to-param-space
+;; mk-g-number
+;; mk-g-ite
+;; gl-cons)
+;; (norm-bvec-s
+;; norm-bvec-u
+;; break-g-number))
+;; :do-not-induct t)))
;; (local (in-theory (enable tag-when-g-var-p
;; tag-when-g-ite-p
@@ -98,17 +129,7 @@
(verify-guards gobj-to-param-space
:hints(("Goal" :in-theory (e/d () ((force))))))
-(defun bfr-param-env (p env)
- (declare (xargs :guard t)
- (ignorable p))
- (bfr-case :bdd (acl2::param-env p env)
- :aig env))
-
-(defund genv-param (p env)
- (declare (xargs :guard (consp env))
- (ignorable p))
- (cons (bfr-param-env p (car env))
- (cdr env)))
+
;; (local
;; (defthmd gobjectp-g-number-2
@@ -181,25 +202,6 @@
;; g-ite->then g-ite->else tag)))))
-(local
- (defthm bfr-eval-to-param-space
- (implies (bfr-eval p env)
- (equal (bfr-eval (bfr-to-param-space p x)
- (bfr-param-env p env))
- (bfr-eval x env)))
- :hints(("Goal" :in-theory (e/d* (bfr-eval
- bfr-to-param-space
- acl2::param-env-to-param-space))))))
-
-(local
- (defthm bfr-eval-list-to-param-space-list
- (implies (bfr-eval p env)
- (equal (bfr-eval-list (bfr-list-to-param-space p x)
- (bfr-param-env p env))
- (bfr-eval-list x env)))
- :hints(("Goal" :in-theory (enable bfr-eval-list
- bfr-eval
- bfr-list-to-param-space)))))
(local
(defthm nth-open-const-idx
@@ -222,54 +224,267 @@
'(t))
:hints (("goal" :in-theory (enable bfr-eval-list)))))
-(defthm gobj-to-param-space-correct
+(defthm gnumber-to-param-space-correct
(implies (bfr-eval p (car env))
- (equal (generic-geval (gobj-to-param-space x p)
- (genv-param p env))
- (generic-geval x env)))
- :hints(("Goal" :in-theory
- (e/d* ((:induction gobj-to-param-space)
- genv-param
- ;; gobjectp-g-boolean-2
- ;; gobjectp-g-number-2
- gnumber-to-param-space
- break-g-number
- default-car default-cdr)
- ((force) bfr-eval-list
- components-to-number-alt-def
- boolean-listp bfr-eval
- (:rules-of-class :type-prescription :here)
- ; generic-geval-when-g-var-tag
-
+ (equal (generic-geval (gnumber-to-param-space n p)
+ (cons (bfr-param-env p (car env))
+ (cdr env)))
+ (generic-geval (g-number n) env)))
+ :hints(("Goal" :in-theory (e/d (gnumber-to-param-space
+ generic-geval)
+ (components-to-number-alt-def
+ break-g-number
+ bfr-param-env)))))
+
+(defthm gnumber-to-param-space-correct-with-unparam-env
+ (implies (syntaxp (not (case-match env
+ (('cons ('bfr-param-env . &) . &) t))))
+ (equal (generic-geval (gnumber-to-param-space n p)
+ env)
+ (generic-geval (g-number n)
+ (genv-unparam p env))))
+ :hints(("Goal" :in-theory (e/d (gnumber-to-param-space
+ generic-geval genv-unparam)
+ (components-to-number-alt-def
+ break-g-number
+ bfr-param-env)))))
+
+
+(local (defthm generic-geval-g-number-of-g-number->num
+ (implies (equal (tag x) :g-number)
+ (equal (generic-geval (g-number (g-number->num x)) env)
+ (generic-geval x env)))
+ :hints(("Goal" :in-theory (enable generic-geval)))))
+
+(defthm-gobj-flag
+ (defthm gobj-to-param-space-correct
+ (implies (bfr-eval p (car env))
+ (equal (generic-geval (gobj-to-param-space x p)
+ (genv-param p env))
+ (generic-geval x env)))
+ :flag gobj)
+ (defthm gobj-list-to-param-space-correct
+ (implies (bfr-eval p (car env))
+ (equal (generic-geval-list (gobj-list-to-param-space x p)
+ (genv-param p env))
+ (generic-geval-list x env)))
+ :flag list)
+ :hints(("Goal" :in-theory
+ (e/d* (genv-param
+ ;; gobjectp-g-boolean-2
+ ;; gobjectp-g-number-2
+ default-car default-cdr)
+ ((force) bfr-eval-list
+ components-to-number-alt-def
+ boolean-listp bfr-eval
+ (:rules-of-class :type-prescription :here)
+; generic-geval-when-g-var-tag
+
; bfr-eval-of-non-consp-cheap
; bfr-eval-when-not-consp
- bfr-to-param-space
- bfr-list-to-param-space
- bfr-param-env
- ;;break-g-number
- generic-geval
- hons-assoc-equal)
- ((:type-prescription len)))
- :induct (gobj-to-param-space x p)
- :expand ((gobj-to-param-space x p)))
- (and stable-under-simplificationp
- (flag::expand-calls-computed-hint
- acl2::clause '(generic-geval)))))
+ bfr-to-param-space
+ bfr-list-to-param-space
+ bfr-param-env
+ ;;break-g-number
+ generic-geval
+ hons-assoc-equal)
+ ((:type-prescription len)))
+ :expand ((gobj-to-param-space x p)
+ (gobj-list-to-param-space x p))
+ :do-not-induct t)
+ (and stable-under-simplificationp
+ '(:expand ((:free (env) (generic-geval x env)))))
+ (and stable-under-simplificationp
+ (flag::expand-calls-computed-hint
+ acl2::clause '(generic-geval generic-geval-list)))))
+
+(defthm-gobj-flag
+ (defthm gobj-to-param-space-correct-with-unparam-env
+ (implies (syntaxp (not (and (consp env) (eq (car env) 'genv-param))))
+ (equal (generic-geval (gobj-to-param-space x p) env)
+ (generic-geval x (genv-unparam p env))))
+ :flag gobj)
+ (defthm gobj-list-to-param-space-correct-with-unparam-env
+ (implies (syntaxp (not (and (consp env) (eq (car env) 'genv-param))))
+ (equal (generic-geval-list (gobj-list-to-param-space x p) env)
+ (generic-geval-list x (genv-unparam p env))))
+ :flag list)
+ :hints(("Goal" :in-theory
+ (e/d* (genv-unparam
+ ;; gobjectp-g-boolean-2
+ ;; gobjectp-g-number-2
+ default-car default-cdr)
+ ((force) bfr-eval-list
+ components-to-number-alt-def
+ boolean-listp bfr-eval
+ (:rules-of-class :type-prescription :here)
+; generic-geval-when-g-var-tag
+
+; bfr-eval-of-non-consp-cheap
+; bfr-eval-when-not-consp
+ bfr-to-param-space
+ bfr-list-to-param-space
+ bfr-param-env
+ ;;break-g-number
+ generic-geval
+ hons-assoc-equal)
+ ((:type-prescription len)))
+ :expand ((gobj-to-param-space x p)
+ (gobj-list-to-param-space x p))
+ :do-not-induct t)
+ (and stable-under-simplificationp
+ '(:expand ((:free (env) (generic-geval x env)))))
+ (and stable-under-simplificationp
+ (flag::expand-calls-computed-hint
+ acl2::clause '(generic-geval generic-geval-list)))))
-(defun shape-spec-to-gobj-param (spec p)
- (declare (xargs :guard (shape-specp spec)))
- (gobj-to-param-space (shape-spec-to-gobj spec) p))
-
-(defun shape-spec-to-env-param (x obj p)
- (declare (xargs :guard (shape-specp x)))
- (genv-param p (shape-spec-to-env x obj)))
(defthm eval-bfr-to-param-space-self
(implies (bfr-eval x (car env))
(bfr-eval (bfr-to-param-space x x) (car (genv-param x env))))
:hints(("Goal" :in-theory (enable bfr-eval bfr-to-param-space genv-param
- bfr-param-env
+ bfr-param-env bfr-unparam-env
default-car))))
+
+
+(defun gobj-alist-to-param-space (alist p)
+ (declare (xargs :guard t))
+ (if (atom alist)
+ nil
+ (if (consp (car alist))
+ (cons (cons (caar alist) (gobj-to-param-space (cdar alist) p))
+ (gobj-alist-to-param-space (cdr alist) p))
+ (gobj-alist-to-param-space (cdr alist) p))))
+
+(defthm alistp-gobj-alist-to-param-space
+ (alistp (gobj-alist-to-param-space x pathcond)))
+
+
+
+
+
+(acl2::defstobj-clone bvar-db1 bvar-db :suffix "1")
+
+
+;; Copies the entries of bvar-db into bvar-db1 but parametrizes all the bound g
+;; objects.
+(defund parametrize-bvar-db-aux (n p bvar-db bvar-db1)
+ (declare (xargs :stobjs (bvar-db bvar-db1)
+ :guard (and (natp n)
+ (<= (base-bvar bvar-db) n)
+ (<= n (next-bvar bvar-db)))
+ :measure (nfix (- (next-bvar bvar-db) (nfix n)))))
+ (b* (((when (mbe :logic (zp (- (next-bvar bvar-db) (nfix n)))
+ :exec (int= (next-bvar bvar-db) n)))
+ bvar-db1)
+ (gobj (get-bvar->term n bvar-db))
+ (pgobj (gobj-to-param-space gobj p))
+ (bvar-db1 (add-term-bvar pgobj bvar-db1)))
+ (parametrize-bvar-db-aux (+ 1 (lnfix n)) p bvar-db bvar-db1)))
+
+(defund parametrize-term-equivs (p x)
+ (declare (xargs :guard (alistp x)))
+ (if (atom x)
+ nil
+ (hons-acons (gobj-to-param-space (caar x) p)
+ (cdar x)
+ (parametrize-term-equivs p (cdr x)))))
+
+
+(defund parametrize-bvar-db (p bvar-db bvar-db1)
+ (declare (xargs :stobjs (bvar-db bvar-db1)
+ :verify-guards nil))
+ (b* ((base (base-bvar bvar-db))
+ (bvar-db1 (init-bvar-db base bvar-db1))
+ (bvar-db1 (parametrize-bvar-db-aux base p bvar-db bvar-db1)))
+ (update-term-equivs (parametrize-term-equivs p (term-equivs bvar-db))
+ bvar-db1)))
+
+
+
+
+(defsection parametrize-bvar-db
+ (local (in-theory (enable parametrize-bvar-db parametrize-bvar-db-aux)))
+ (local (include-book "arithmetic/top-with-meta" :dir :system))
+ (local (include-book "centaur/misc/arith-equivs" :dir :system))
+
+ (local (defthm alistp-when-term-equivsp
+ (implies (and (bind-free '((bvar-db . bvar-db)) (bvar-db))
+ (term-equivsp$a x bvar-db))
+ (alistp x))
+ :hints(("Goal" :in-theory (enable alistp)))))
+
+ (defthm get-bvar->term-of-parametrize-bvar-db-aux
+ (implies (and (<= (base-bvar$a bvar-db1) (nfix m))
+ (< (nfix m) (+ (next-bvar$a bvar-db1)
+ (- (next-bvar$a bvar-db) (nfix n)))))
+ (equal (get-bvar->term$a m (parametrize-bvar-db-aux n p bvar-db bvar-db1))
+ (if (<= (next-bvar$a bvar-db1) (nfix m))
+ (gobj-to-param-space
+ (get-bvar->term$a (+ (- (nfix m) (next-bvar$a bvar-db1))
+ (nfix n))
+ bvar-db)
+ p)
+ (get-bvar->term$a m bvar-db1)))))
+
+ (defthm base-bvar-of-parametrize-bvar-db-aux
+ (equal (base-bvar$a (parametrize-bvar-db-aux n p bvar-db bvar-db1))
+ (base-bvar$a bvar-db1)))
+
+ (defthm next-bvar-of-parametrize-bvar-db-aux
+ (equal (next-bvar$a (parametrize-bvar-db-aux n p bvar-db bvar-db1))
+ (+ (nfix (- (next-bvar$a bvar-db) (nfix n))) (next-bvar$a
+ bvar-db1))))
+
+ (local (defthm bvar-listp-when-same-next/base
+ (implies (and (bvar-listp$a x bvar-db)
+ (equal (base-bvar$a bvar-db) (base-bvar$a bvar-db1))
+ (equal (next-bvar$a bvar-db) (next-bvar$a bvar-db1)))
+ (bvar-listp$a x bvar-db1))
+ :hints(("Goal" :induct (len x)))))
+
+ (local (defthm term-equivsp-when-same-next/base
+ (implies (and (term-equivsp$a x bvar-db)
+ (equal (base-bvar$a bvar-db) (base-bvar$a bvar-db1))
+ (equal (next-bvar$a bvar-db) (next-bvar$a bvar-db1)))
+ (term-equivsp$a x bvar-db1))
+ :hints(("Goal" :induct (len x)))))
+
+ (defthm term-equivsp-of-parametrize-term-equivs
+ (implies (and (bind-free (and (consp x)
+ (equal (car x) 'term-equivs$a)
+ `((bvar-db . ,(cadr x))))
+ (bvar-db))
+ (term-equivsp x bvar-db)
+ (equal (base-bvar$a bvar-db) (base-bvar$a bvar-db1))
+ (equal (next-bvar$a bvar-db) (next-bvar$a bvar-db1)))
+ (term-equivsp$a (parametrize-term-equivs p x) bvar-db1))
+ :hints(("Goal" :in-theory (enable parametrize-term-equivs))))
+
+
+ (verify-guards parametrize-bvar-db)
+
+
+ (defthm normalize-parametrize-bvar-db
+ (implies (syntaxp (not (equal bvar-db1 ''nil)))
+ (equal (parametrize-bvar-db p bvar-db bvar-db1)
+ (parametrize-bvar-db p bvar-db nil))))
+
+ (defthm base-bvar-of-parametrize-bvar-db
+ (equal (base-bvar$a (parametrize-bvar-db p bvar-db bvar-db1))
+ (base-bvar$a bvar-db)))
+
+ (defthm next-bvar-of-parametrize-bvar-db
+ (equal (next-bvar$a (parametrize-bvar-db p bvar-db bvar-db1))
+ (next-bvar$a bvar-db)))
+
+ (defthm get-bvar->term-of-parametrize-bvar-db
+ (implies (and (<= (base-bvar$a bvar-db) (nfix n))
+ (< (nfix n) (next-bvar$a bvar-db)))
+ (equal (get-bvar->term$a n (parametrize-bvar-db p bvar-db bvar-db1))
+ (gobj-to-param-space
+ (get-bvar->term$a n bvar-db) p)))))
+
diff -Nru acl2-6.2/books/centaur/gl/portcullis.acl2 acl2-6.3/books/centaur/gl/portcullis.acl2
--- acl2-6.2/books/centaur/gl/portcullis.acl2 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/portcullis.acl2 2013-09-30 17:53:14.000000000 +0000
@@ -1,10 +1,28 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(ld "package.lsp")
-(ld "centaur/vl/package.lsp" :dir :system)
-(ld "cutil/package.lsp" :dir :system)
-(ld "centaur/aignet/package.lsp" :dir :system)
(ld "tools/flag-package.lsp" :dir :system)
+(include-book "centaur/vl/portcullis" :dir :system)
+(include-book "cutil/portcullis" :dir :system)
+(include-book "centaur/aignet/portcullis" :dir :system)
; cert-flags: ? t :ttags :all
-(certify-book "portcullis" ? t :ttags :all)
+
diff -Nru acl2-6.2/books/centaur/gl/portcullis.lisp acl2-6.3/books/centaur/gl/portcullis.lisp
--- acl2-6.2/books/centaur/gl/portcullis.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/portcullis.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,21 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
diff -Nru acl2-6.2/books/centaur/gl/rewrites.lisp acl2-6.3/books/centaur/gl/rewrites.lisp
--- acl2-6.2/books/centaur/gl/rewrites.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/rewrites.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,345 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "GL")
+(include-book "def-gl-rewrite")
+(include-book "symbolic-arithmetic-fns")
+(local (include-book "centaur/bitops/congruences" :dir :system))
+(local (include-book "centaur/bitops/ihs-extensions" :dir :system))
+(local (include-book "arithmetic/top-with-meta" :dir :system))
+
+(def-gl-rewrite integerp-of-logapp
+ (integerp (logapp a b c)))
+
+(defun plus-of-logapp-ind (n a c carry)
+ (if (zp n)
+ (list a c carry)
+ (plus-of-logapp-ind (1- n) (logcdr a) (logcdr c)
+ (b-ior (b-and carry (logcar a))
+ (b-and carry (logcar c))))))
+
+(local
+ (defthmd plus-of-logapp-lemma
+ (implies (and (bitp carry) (integerp c))
+ (equal (+ (logapp n a b) c carry)
+ (+ (+ carry
+ (loghead n a)
+ (loghead n c))
+ (ash (+ (ifix b) (logtail n c)) (nfix n)))))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-recursive-redefs)
+ :induct (plus-of-logapp-ind n a c carry))
+ (and stable-under-simplificationp
+ '(:in-theory (enable acl2::equal-logcons-strong
+ b-xor b-and b-ior))))))
+
+(def-gl-rewrite plus-of-logapp-1
+ (implies (integerp c)
+ (equal (+ (logapp n a b) c)
+ (+ (+ (loghead n a)
+ (loghead n c))
+ (ash (+ (ifix b) (logtail n c)) (nfix n)))))
+ :hints (("goal" :use ((:instance plus-of-logapp-lemma
+ (carry 0)))
+ :in-theory (disable plus-of-logapp-lemma))))
+
+(def-gl-rewrite plus-of-logapp-2
+ (implies (integerp c)
+ (equal (+ c (logapp n a b))
+ (+ (+ (loghead n a)
+ (loghead n c))
+ (ash (+ (ifix b) (logtail n c)) (nfix n)))))
+ :hints (("goal" :use ((:instance plus-of-logapp-lemma
+ (carry 0)))
+ :in-theory (disable plus-of-logapp-lemma))))
+
+;; (def-gl-rewrite loghead-of-logapp
+;; (implies (<= (nfix n) (nfix m))
+;; (equal (loghead n (logapp m a b))
+;; (loghead n a)))
+;; :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+;; acl2::ihsext-recursive-redefs))))
+
+(def-gl-rewrite loghead-of-logapp
+ (equal (loghead n (logapp m a b))
+ (logapp (min (nfix m) (nfix n)) a (loghead (nfix (- (nfix n) (nfix m))) b)))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs))))
+
+(def-gl-rewrite loghead-of-0
+ (equal (loghead 0 x) 0))
+
+(def-gl-rewrite logapp-tail-0
+ (equal (logapp n a 0) (loghead n a)))
+
+(def-gl-rewrite logbitp-of-logapp
+ (equal (logbitp n (logapp m a b))
+ (if (< (nfix n) (nfix m))
+ (logbitp n a)
+ (logbitp (- (nfix n) (nfix m)) b)))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs))))
+
+(def-gl-rewrite loghead-of-plus
+ (implies (and (integerp a) (integerp b))
+ (equal (loghead n (+ a b))
+ (loghead n (+ (loghead n a) (loghead n b)))))
+ :hints(("Goal" :use ((:instance acl2::loghead-of-plus-loghead-first
+ (m n))
+ (:instance acl2::loghead-of-plus-loghead-first
+ (m n) (a (loghead n b)) (b a))))))
+
+(def-gl-rewrite logbitp-of-plus
+ (implies (and (integerp a) (integerp b))
+ (equal (logbitp n (+ a b))
+ (logbitp n (+ (loghead (+ 1 (nfix n)) a)
+ (loghead (+ 1 (nfix n)) b)))))
+ :hints (("goal" :in-theory (e/d* (acl2::bitops-congruences)
+ (acl2::bitops-congruence-incompatible)))))
+
+
+(def-gl-rewrite logand-of-logapp
+ (equal (logand mask (logapp n a b))
+ (logapp n (logand mask a)
+ (logand (logtail n mask) b)))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs))))
+
+(def-gl-rewrite logand-of-logapp-2
+ (equal (logand (logapp n a b) mask)
+ (logapp n (logand mask a)
+ (logand (logtail n mask) b)))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs))))
+
+(def-gl-rewrite logior-of-logapp
+ (equal (logior mask (logapp n a b))
+ (logapp n (logior mask a)
+ (logior (logtail n mask) b)))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs))))
+
+(def-gl-rewrite logior-of-logapp-2
+ (equal (logior (logapp n a b) mask)
+ (logapp n (logior mask a)
+ (logior (logtail n mask) b)))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs))))
+
+(def-gl-rewrite logtail-of-logapp
+ (equal (logtail m (logapp n a b))
+ (logapp (- (nfix n) (nfix m))
+ (logtail m a)
+ (logtail (- (nfix m) (nfix n)) b)))
+ :hints(("Goal" :in-theory (e/d* (acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs)
+ (acl2::logtail-identity
+ acl2::bitmaskp**)))))
+
+(def-gl-rewrite logand-minus-1-first
+ (equal (logand -1 n)
+ (ifix n)))
+
+(def-gl-rewrite logand-minus-1-second
+ (equal (logand n -1)
+ (ifix n)))
+
+(def-gl-rewrite logior-minus-1-first
+ (equal (logior -1 n) -1))
+
+(def-gl-rewrite logior-minus-1-second
+ (equal (logior n -1) -1))
+
+(def-gl-rewrite logior-0-first
+ (equal (logior 0 n) (ifix n)))
+
+(def-gl-rewrite logior-0-second
+ (equal (logior 0 n) (ifix n)))
+
+(def-gl-rewrite ifix-of-logapp
+ (equal (ifix (logapp n a b))
+ (logapp n a b)))
+
+;; (def-gl-rewrite logand-of-logapp
+;; (implies (and (<= 0 (ifix mask))
+;; (< (ifix mask) (ash 1 (nfix n))))
+;; (equal (logand mask (logapp n a b))
+;; (logand mask a)))
+;; :hints (("goal" :in-theory (enable* acl2::ihsext-recursive-redefs
+;; acl2::ihsext-inductions))))
+
+(def-gl-rewrite integerp-of-maybe-integer
+ (equal (integerp (maybe-integer i x intp))
+ (and intp t))
+ :hints(("Goal" :in-theory (enable maybe-integer))))
+
+(def-gl-rewrite <-of-maybe-integer-1
+ (implies intp
+ (equal (< (maybe-integer i x intp) a)
+ (< (ifix i) a)))
+ :hints(("Goal" :in-theory (enable maybe-integer))))
+
+(def-gl-rewrite <-of-maybe-integer-2
+ (implies intp
+ (equal (< a (maybe-integer i x intp))
+ (< a (ifix i))))
+ :hints(("Goal" :in-theory (enable maybe-integer))))
+
+(local (defthm <-logapp-0-local
+ (equal (< (logapp n i j) 0)
+ (< (ifix j) 0))
+ :hints(("Goal" :in-theory (e/d* ;; acl2::ihsext-bounds-thms
+ (acl2::ihsext-recursive-redefs
+ acl2::ihsext-inductions)
+ ((force)))))))
+(def-gl-rewrite <-logapp-0
+ (equal (< (logapp n i j) 0)
+ (< (ifix j) 0)))
+
+(def-gl-rewrite integerp-int-set-sign
+ (integerp (int-set-sign negp i)))
+
+(def-gl-rewrite <-int-set-sign-0
+ (equal (< (int-set-sign negp i) 0)
+ (and negp t)))
+
+(defun ifix-or-zero (ip i)
+ (if ip (ifix i) 0))
+
+(def-gl-rewrite ifix-of-maybe-integer
+ (equal (ifix (maybe-integer i x intp))
+ (ifix-or-zero intp i))
+ :hints(("Goal" :in-theory (enable maybe-integer))))
+
+(def-gl-rewrite ifix-or-zero-of-logapp
+ (equal (ifix-or-zero ip (logapp n a b))
+ (logapp n (ifix-or-zero ip a)
+ (ifix-or-zero ip b))))
+
+(def-gl-rewrite ifix-or-zero-of-int-set-sign
+ (equal (ifix-or-zero ip (int-set-sign negp i))
+ (int-set-sign (and ip negp) (ifix-or-zero ip i)))
+ :hints(("Goal" :in-theory (enable int-set-sign))))
+
+(defun nfix-or-zero (ip i)
+ (if ip (nfix i) 0))
+
+(def-gl-rewrite nfix-of-maybe-integer
+ (equal (nfix (maybe-integer i x intp))
+ (nfix-or-zero intp i))
+ :hints(("Goal" :in-theory (enable maybe-integer))))
+
+(local (defthm logapp-with-non-integer
+ (implies (zip b)
+ (equal (logapp n a b)
+ (loghead n a)))))
+
+(def-gl-rewrite nfix-or-zero-of-logapp
+ (equal (nfix-or-zero ip (logapp n a b))
+ (logapp n (ifix-or-zero (and ip (<= 0 (ifix b))) a)
+ (nfix-or-zero ip b)))
+ :hints(("Goal" :in-theory (enable nfix))))
+
+(local (defthm loghead-with-zip
+ (implies (zip a)
+ (equal (loghead n a) 0))))
+
+(def-gl-rewrite loghead-of-maybe-integer
+ (equal (loghead n (maybe-integer i x intp))
+ (ifix-or-zero intp (loghead n (ifix i))))
+ :hints(("Goal" :in-theory (enable non-int-fix maybe-integer))))
+
+(def-gl-rewrite ifix-or-zero-of-loghead
+ (equal (ifix-or-zero ip (loghead n i))
+ (loghead n (ifix-or-zero ip i))))
+
+
+(def-gl-rewrite equal-of-logapp
+ (equal (equal (logapp n a b) c)
+ (and (integerp c)
+ (equal (loghead n c) (loghead n a))
+ (equal (logtail n c) (ifix b))))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs))))
+
+(def-gl-rewrite logand-0-first
+ (equal (logand 0 x)
+ 0))
+
+(def-gl-rewrite logand-0-second
+ (equal (logand x 0)
+ 0))
+
+(def-gl-rewrite integerp-floor
+ (equal (integerp (floor x y)) t))
+
+;; (local (defthm logapp-of-non-integer-second
+;; (implies (not (integerp b))
+;; (equal (logapp n a b)
+;; (logapp n a 0)))
+;; :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+;; acl2::ihsext-recursive-redefs)))
+;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+#||
+
+
+
+
+(trace$ gl::glcp-unify-term/gobj)
+
+(thm (IMPLIES
+ (and (GL::INTEGER-WITH-NBITSP 64 ACL2::X0)
+ (UNSIGNED-BYTE-P 64 ACL2::X1)
+ (UNSIGNED-BYTE-P 64 ACL2::X2))
+ (OR (LOGBITP 10 ACL2::X1)
+ (EQUAL (UNSIGNED-BYTE-FIX 64
+ (AAA_AAS-G7 ACL2::X2 (LOGHEAD 64 ACL2::X0)))
+ (LOGIOR 2 (ACL2::LOGSQUASH 32 ACL2::X2)
+ (LOGAND 2261 ACL2::X0)))))
+ :hints (("goal" :in-theory nil)
+ (gl::try-gl
+ ;; :fixes
+ ;; (((nfix (st-get :eflags st)) (loghead 64 acl2::x)))
+ :subterms-types
+ (((nfix (st-get :eflags st)) (gl::integer-with-nbitsp 64 acl2::x))
+ ((u64-tr-get n g) (unsigned-byte-p 64 acl2::x))
+; ((st-set :pc val st) (unknownp acl2::x))
+ ((st-get :oracle st) (unknownp acl2::x)))
+ :type-gens (((unknownp acl2::x) (gl::g-var 0)))
+; :bad-subterms (st)
+ )))
+
+||#
+
+(gl::def-gl-rewrite not-to-if
+ (iff (not x)
+ (if x nil t)))
+
+
+;; (defthm merge-if-of-cons
+;; (implies (consp z)
+;; (equal (if c (cons x y) z)
+;; (cons (if c x (car z))
+;; (if c y (cdr z)))))
+;; :rule-classes nil)
+
+;; (table gl-branch-merge-rules
+;; 'cons
+;; '(merge-if-of-cons))
diff -Nru acl2-6.2/books/centaur/gl/run-gified-cp.lisp acl2-6.3/books/centaur/gl/run-gified-cp.lisp
--- acl2-6.2/books/centaur/gl/run-gified-cp.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/run-gified-cp.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,6 +1,24 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "bfr")
(include-book "gobjectp")
(include-book "gtypes")
@@ -13,6 +31,8 @@
(include-book "centaur/ubdds/witness" :dir :system)
(local (include-book "std/lists/take" :dir :system))
(local (include-book "gtype-thms"))
+(local (include-book "arithmetic/top-with-meta" :dir :system))
+(local (include-book "centaur/misc/arith-equivs" :dir :system))
(local (defun before-run-gified-ev-tag () nil))
@@ -36,13 +56,13 @@
(symbolp x)
(pairlis$ a b)
(cons a b)
+ (atom a)
(binary-+ a b)
(hide a)
(mv-nth n x)
(mv-list n x)
(acl2::return-last a b c)
(force x)
- (gobj-listp x)
(bfr-eval x env)
(acl2::typespec-check ts x)
(iff a b)
@@ -127,9 +147,9 @@
(defun run-gified-lhs-and-okp-breakdown (lhs okp)
(case-match okp
- (('mv-nth ''0 (acl2::fn . '(fn actuals hyp clk state)))
+ (('mv-nth ''0 (acl2::fn . '(fn actuals hyp clk config bvar-db state)))
(case-match lhs
- ((ev ('mv-nth ''1 (!fn . '(fn actuals hyp clk state))) 'env)
+ ((ev ('mv-nth ''1 (!fn . '(fn actuals hyp clk config bvar-db state))) 'env)
(mv nil ev acl2::fn))
(& (mv "lhs mismatched" nil nil))))
(& (mv "okp mismatched" nil nil))))
@@ -140,30 +160,30 @@
(run-gified-lhs-and-okp-breakdown lhs okp)
(implies (not erp)
(and (equal lhs
- `(,geval (mv-nth '1 (,run-gified fn actuals hyp clk state))
+ `(,geval (mv-nth '1 (,run-gified fn actuals hyp clk config bvar-db state))
env))
(equal okp
- `(mv-nth '0 (,run-gified fn actuals hyp clk state))))))
+ `(mv-nth '0 (,run-gified fn actuals hyp clk config bvar-db state))))))
:rule-classes :forward-chaining))
(in-theory (disable run-gified-lhs-and-okp-breakdown))
-(defun run-gified-rhs-breakdown (rhs acl2::geval-fn)
+(defun run-gified-rhs-breakdown (rhs)
(case-match rhs
((ev ('cons 'fn
('acl2::kwote-lst
- (!geval-fn . '(actuals env))))
+ (geval-list . '(actuals env))))
. '('nil))
- (mv nil ev))
- (& (mv "rhs mismatched" nil))))
+ (mv nil ev geval-list))
+ (& (mv "rhs mismatched" nil nil))))
(local
(defthm run-gified-rhs-breakdown-correct
- (mv-let (erp evfn)
- (run-gified-rhs-breakdown rhs geval-fn)
+ (mv-let (erp evfn geval-list)
+ (run-gified-rhs-breakdown rhs)
(implies (not erp)
(equal rhs
- `(,evfn (cons fn (acl2::kwote-lst (,geval-fn actuals env)))
+ `(,evfn (cons fn (acl2::kwote-lst (,geval-list actuals env)))
'nil))))
:rule-classes :forward-chaining))
@@ -210,7 +230,7 @@
(& (mv (acl2::msg "bad gl-function-info table entry: ~x0" entry) nil))))))
(in-theory (disable geval-rule-alist))
-
+
(defun run-gified-case-breakdown (body)
@@ -280,14 +300,14 @@
('equal (the-geval (!gfn . gformals) . '(env))
(!fn . evals)))
(let ((nformals (len gformals)))
- (if (<= 2 nformals)
- (let ((formals (take (- nformals 2) gformals)))
+ (if (<= 5 nformals)
+ (let ((formals (take (- nformals 5) gformals)))
(if (and (equal the-geval geval)
(evals-of-formalsp formals evals geval 'env)
(nonnil-symbol-listp gformals)
(acl2::fast-no-duplicatesp gformals)
(not (member 'env gformals))
- (equal (nthcdr (- nformals 2) gformals) '(hyp clk)))
+ (equal (nthcdr (- nformals 5) gformals) '(hyp clk config bvar-db state)))
(mv nil gformals)
(mv (acl2::msg "Malformed geval theorem: ~x0" thm) nil)))
(mv (acl2::msg "Malformed geval theorem: ~x0" thm) nil))))
@@ -314,19 +334,19 @@
; (defthmd member-is-member-equal
; (equal (member x y)
; (member-equal x y))))
-;
-; (local (in-theory (enable member-is-member-equal)))
+;
+; (local (in-theory (enable member-is-member-equal)))
(local
(defthm run-gified-check-geval-thm-formals
(mv-let (erp formals)
(run-gified-check-geval-thm thm gfn fn geval)
(implies (not erp)
- (and (<= 2 (len formals))
+ (and (<= 5 (len formals))
(nonnil-symbol-listp formals)
(no-duplicatesp-equal formals)
(not (member-equal 'env formals))
- (equal (nthcdr (+ -2 (len formals)) formals) '(hyp clk)))))
+ (equal (nthcdr (+ -5 (len formals)) formals) '(hyp clk config bvar-db state)))))
:rule-classes nil))
(local
@@ -338,7 +358,7 @@
`(implies (bfr-eval hyp (car env))
(equal (,geval (,gfn . ,formals) env)
(,fn . ,(make-evals-of-formals
- (take (- (len formals) 2)
+ (take (- (len formals) 5)
formals)
geval 'env)))))))
:rule-classes :forward-chaining))
@@ -355,7 +375,7 @@
(local
(defthm nthcdr-nil
(equal (nthcdr n nil) nil)))
-
+
(local
(defthm nth-of-nthcdr
(equal (nth n (nthcdr m y))
@@ -371,7 +391,7 @@
;; :hints (("goal" :induct (nthcdr n x)))))
-
+
(local
(encapsulate nil
@@ -477,7 +497,7 @@
:hints (("goal" :induct (replace-term-flg flag new old avoid x))
(and stable-under-simplificationp
'(:in-theory (enable equality-cp-ev-constraint-0)))))
-
+
(in-theory (disable replace-term replace-term-list))
(defthm replace-term-list-correct-disjoin
@@ -549,12 +569,12 @@
(defthm run-gified-check-geval-thm-correct
(mv-let (erp formals)
(run-gified-check-geval-thm thm gfn fn geval)
- (let ((hyp (run-gified-ev (nth (+ -2 (len formals)) args)
+ (let ((hyp (run-gified-ev (nth (+ -5 (len formals)) args)
a))
(env (cdr (assoc-equal 'env a))))
(implies (and (not erp)
(run-gified-ev
- thm
+ thm
(cons (cons 'env (cdr (assoc-equal 'env a)))
(pairlis$ formals (run-gified-ev-lst args a))))
(not (eq geval 'quote))
@@ -567,23 +587,23 @@
a)
(run-gified-ev
`(,fn . ,(make-evals-of-formals
- (take (- (len formals) 2)
+ (take (- (len formals) 5)
args)
geval 'env))
a)))))
:hints(("Goal"
:in-theory (e/d () ;; equal-nthcdr-cons
- (nth-of-nthcdr assoc-equal-pairlis-nth
+ (nth-of-nthcdr acl2::car-nthcdr assoc-equal-pairlis-nth
run-gified-check-geval-thm))
:use ((:instance run-gified-check-geval-thm-form)
(:instance run-gified-check-geval-thm-formals)
(:instance
nth-of-nthcdr
- (n 0) (m (+ -2 (len args)))
+ (n 0) (m (+ -5 (len args)))
(y (mv-nth 1 (run-gified-check-geval-thm thm gfn fn geval))))
(:instance
assoc-equal-pairlis-nth
- (n (- (len args) 2))
+ (n (- (len args) 5))
(keys (mv-nth 1 (run-gified-check-geval-thm thm gfn fn geval)))
(vals (run-gified-ev-lst args a)))))
(and stable-under-simplificationp
@@ -622,7 +642,7 @@
(defthm run-gified-get-geval-thm-correct
(mv-let (erp thm formals)
(run-gified-get-geval-thm gfn fn geval-alist geval)
- (let ((hyp (run-gified-ev (nth (+ -2 (len formals)) args) a))
+ (let ((hyp (run-gified-ev (nth (+ -5 (len formals)) args) a))
(env (cdr (assoc-equal 'env a))))
(implies
(and (not erp)
@@ -636,7 +656,7 @@
a)
(run-gified-ev `(,fn
. ,(make-evals-of-formals
- (take (- (len formals) 2) args) geval 'env))
+ (take (- (len formals) 5) args) geval 'env))
a)))))
:hints(("Goal" :in-theory (e/d (use-by-hint) ())
:use ((:instance run-gified-ev-falsify
@@ -653,7 +673,7 @@
(defthm run-gified-get-geval-thm-correct-corollary
(mv-let (erp thm formals)
(run-gified-get-geval-thm gfn fn geval-alist geval)
- (let ((hyp (run-gified-ev (nth (+ -2 (len formals)) args) a))
+ (let ((hyp (run-gified-ev (nth (+ -5 (len formals)) args) a))
(env (cdr (assoc-equal 'env a))))
(implies
(and (not erp)
@@ -676,7 +696,7 @@
nil)
(run-gified-ev `(,fn
. ,(make-evals-of-formals
- (take (- (len formals) 2) args) geval 'env))
+ (take (- (len formals) 5) args) geval 'env))
a)))))
:hints(("Goal" :in-theory (e/d (run-gified-ev-constraint-0)
(run-gified-get-geval-thm-correct))
@@ -726,9 +746,9 @@
:in-theory (disable ev-function-clause-correct-for-run-gified-ev)))))
(in-theory (disable run-gified-get-eval-thm))
-
-
-
+
+
+
(defun nths-matching-formalsp (acl2::idx formals acl2::varname list)
(declare (xargs :measure (acl2-count formals)))
(if (atom formals)
@@ -757,10 +777,10 @@
(in-theory (disable nths-matching-formalsp))
-
-
+
+
@@ -793,34 +813,42 @@
-(defun geval-car-cdr-of-gobj-listp-thm (geval rune)
- `((not (use-by-hint ',rune))
- (not (gobj-listp x))
- (if (equal (car (,geval x env))
- (,geval (car x) env))
- (equal (cdr (,geval x env))
- (,geval (cdr x) env))
- 'nil)))
+(defun geval-list-def-thm (geval-list geval)
+ `((not (use-by-hint ',geval-list))
+ (equal (,geval-list x env)
+ (if (atom x)
+ 'nil
+ (cons (,geval (car x) env)
+ (,geval-list (cdr x) env))))))
(local
- (defthm geval-car-cdr-of-gobj-listp-thm-correct
+ (defthm geval-list-def-thm-correct
(implies (and (run-gified-ev-theoremp
- (disjoin (geval-car-cdr-of-gobj-listp-thm
- geval rune)))
+ (disjoin (geval-list-def-thm
+ geval-list geval)))
;; (gobjectp (run-gified-ev x a))
;; (or (atom (run-gified-ev x a))
;; (gobjectp (car (run-gified-ev x a))))
- (gobj-listp (run-gified-ev x a))
- (not (equal geval 'quote)))
- (and (equal (car (run-gified-ev (list geval x env) a))
- (run-gified-ev (list geval `(car ,x) env) a))
- (equal (cdr (run-gified-ev (list geval x env) a))
- (run-gified-ev (list geval `(cdr ,x) env) a))))
+ (not (equal geval 'quote))
+ (not (equal geval-list 'quote)))
+ (and (implies (atom (run-gified-ev x a))
+ (equal (run-gified-ev (list geval-list x env) a)
+ nil))
+ (implies (consp (run-gified-ev x a))
+ (equal (run-gified-ev (list geval-list x env) a)
+ (cons (run-gified-ev (list geval
+ (kwote (car (run-gified-ev x a)))
+ (kwote (run-gified-ev env a)))
+ nil)
+ (run-gified-ev (list geval-list
+ (kwote (cdr (run-gified-ev x a)))
+ (kwote (run-gified-ev env a)))
+ nil))))))
:hints(("Goal" :in-theory (enable use-by-hint run-gified-ev-constraint-0
- geval-car-cdr-of-gobj-listp-thm)
+ geval-list-def-thm)
:use ((:instance run-gified-ev-falsify
- (x (disjoin (geval-car-cdr-of-gobj-listp-thm
- geval rune)))
+ (x (disjoin (geval-list-def-thm
+ geval-list geval)))
(a `((x . ,(run-gified-ev x a))
(env . ,(run-gified-ev env a))))))))))
@@ -829,12 +857,12 @@
;; (natp n) (< 0 n))
;; (or (atom x) (gobjectp (car x))))
;; :rule-classes nil)
-
-;; (defthm geval-car-cdr-of-gobj-listp-thm-correct-corollary
+
+;; (defthm geval-geval-list-def-thm-correct-corollary
;; (implies (and (run-gified-ev-theoremp
-;; (disjoin (geval-car-cdr-of-gobj-listp-thm
+;; (disjoin (geval-geval-list-def-thm
;; geval rune)))
;; (gobjectp (run-gified-ev x a))
;; (gobj-listp (acl2::simple-take n (run-gified-ev x a)))
@@ -844,17 +872,17 @@
;; (run-gified-ev (list geval `(car ,x) env) a))
;; (equal (cdr (run-gified-ev (list geval x env) a))
;; (run-gified-ev (list geval `(cdr ,x) env) a))))
-;; :hints(("Goal" :use (geval-car-cdr-of-gobj-listp-thm-correct
+;; :hints(("Goal" :use (geval-geval-list-def-thm-correct
;; (:instance gobj-listp-simple-take-implies
;; (x (run-gified-ev x a))))
-;; :in-theory (disable geval-car-cdr-of-gobj-listp-thm
-;; geval-car-cdr-of-gobj-listp-thm-correct)
+;; :in-theory (disable geval-geval-list-def-thm
+;; geval-geval-list-def-thm-correct)
;; :do-not-induct t))
;; :rule-classes ((:rewrite :backchain-limit-lst (0 nil 0 nil nil nil))))
-;; (defthm geval-car-cdr-of-gobj-listp-thm-correct-corollary2
+;; (defthm geval-geval-list-def-thm-correct-corollary2
;; (implies (and (run-gified-ev-theoremp
-;; (disjoin (geval-car-cdr-of-gobj-listp-thm
+;; (disjoin (geval-geval-list-def-thm
;; geval rune)))
;; (gobj-listp (run-gified-ev x a))
;; (not (equal geval 'quote)))
@@ -862,41 +890,41 @@
;; (run-gified-ev (list geval `(car ,x) env) a))
;; (equal (cdr (run-gified-ev (list geval x env) a))
;; (run-gified-ev (list geval `(cdr ,x) env) a))))
-;; :hints(("Goal" :use geval-car-cdr-of-gobj-listp-thm-correct
+;; :hints(("Goal" :use geval-geval-list-def-thm-correct
;; :in-theory (e/d (gobj-listp-impl-gobjectp)
-;; (geval-car-cdr-of-gobj-listp-thm
-;; geval-car-cdr-of-gobj-listp-thm-correct))
+;; (geval-geval-list-def-thm
+;; geval-geval-list-def-thm-correct))
;; :do-not-induct t))
;; :rule-classes ((:rewrite :backchain-limit-lst (0 1 nil))))
-(defun geval-consp-when-gobj-listp-thm (geval rune)
- `((not (use-by-hint ',rune))
- ;; (not (gobjectp x))
-;; (not (if (consp x)
-;; (gobjectp (car x))
-;; 't))
- (not (gobj-listp x))
- (equal (consp (,geval x env))
- (consp x))))
-
-(local
- (defthm geval-consp-when-gobj-listp-thm-correct
- (implies (and (run-gified-ev-theoremp
- (disjoin (geval-consp-when-gobj-listp-thm
- geval rune)))
- ;; (gobjectp (run-gified-ev x a))
- ;; (or (atom (run-gified-ev x a))
- ;; (gobjectp (car (run-gified-ev x a))))
- (gobj-listp (run-gified-ev x a))
- (not (equal geval 'quote)))
- (equal (consp (run-gified-ev (list geval x env) a))
- (consp (run-gified-ev x a))))
- :hints(("Goal" :in-theory (enable use-by-hint run-gified-ev-constraint-0)
- :use ((:instance run-gified-ev-falsify
- (x (disjoin (geval-consp-when-gobj-listp-thm
- geval rune)))
- (a `((x . ,(run-gified-ev x a))
- (env . ,(run-gified-ev env a))))))))))
+;; (defun geval-consp-when-gobj-listp-thm (geval rune)
+;; `((not (use-by-hint ',rune))
+;; ;; (not (gobjectp x))
+;; ;; (not (if (consp x)
+;; ;; (gobjectp (car x))
+;; ;; 't))
+;; (not (gobj-listp x))
+;; (equal (consp (,geval x env))
+;; (consp x))))
+
+;; (local
+;; (defthm geval-consp-when-gobj-listp-thm-correct
+;; (implies (and (run-gified-ev-theoremp
+;; (disjoin (geval-consp-when-gobj-listp-thm
+;; geval rune)))
+;; ;; (gobjectp (run-gified-ev x a))
+;; ;; (or (atom (run-gified-ev x a))
+;; ;; (gobjectp (car (run-gified-ev x a))))
+;; (gobj-listp (run-gified-ev x a))
+;; (not (equal geval 'quote)))
+;; (equal (consp (run-gified-ev (list geval x env) a))
+;; (consp (run-gified-ev x a))))
+;; :hints(("Goal" :in-theory (enable use-by-hint run-gified-ev-constraint-0)
+;; :use ((:instance run-gified-ev-falsify
+;; (x (disjoin (geval-consp-when-gobj-listp-thm
+;; geval rune)))
+;; (a `((x . ,(run-gified-ev x a))
+;; (env . ,(run-gified-ev env a))))))))))
;; (defthm geval-consp-when-gobj-listp-thm-correct-corollary
;; (implies (and (run-gified-ev-theoremp
@@ -950,8 +978,7 @@
(a `((env . ,(run-gified-ev env a))))))))))
-(in-theory (disable geval-consp-when-gobj-listp-thm
- geval-car-cdr-of-gobj-listp-thm
+(in-theory (disable geval-list-def-thm
geval-of-nil-thm))
(local
@@ -964,7 +991,7 @@
(defun make-n-cdrs (n term)
(if (zp n)
term
- (list 'cdr (make-n-cdrs (1- n) term))))
+ (make-n-cdrs (1- n) (list 'cdr term))))
(local (defthm cdr-nthcdr
@@ -985,7 +1012,7 @@
`((args . ,args) (a . ,a))
'acl2::? nil mfc state)
args)))
-
+
(defthmd my-run-gified-ev-constraint-0
(implies (and (syntaxp (test-constraint-0-result args a mfc state))
@@ -1005,12 +1032,13 @@
(implies (and (gobj-listp lst)
(nthcdr n lst))
(consp (nthcdr n lst)))
- :hints(("Goal" :in-theory (enable gobj-listp))))
+ :hints(("Goal" :in-theory (e/d (gobj-listp)))))
(defthm gobj-listp-nthcdr
(implies (gobj-listp lst)
(gobj-listp (nthcdr n lst)))
- :hints(("Goal" :in-theory (enable gobj-listp))))
+ :hints(("Goal" :in-theory (e/d (gobj-listp)
+ (cdr-nthcdr)))))
(defthm gobj-listp-take
(implies (gobj-listp gobj)
@@ -1028,7 +1056,7 @@
(< (nfix n) (nfix m)))
(gobj-listp (acl2::take n gobj)))
:hints (("goal" :induct (count-down2-cdr m n gobj)
- :in-theory (enable gobj-listp acl2::take-redefinition))))
+ :in-theory (enable gobj-listp acl2::take-redefinition nfix))))
;; (Defthm gobjectp-nth-when-gobj-listp-take
;; (implies (and (gobj-listp (acl2::take m x))
@@ -1047,63 +1075,51 @@
(equal (cdr x) nil))
:rule-classes ((:rewrite :backchain-limit-lst 0)))
+ (defthm nthcdr-when-not-consp
+ (implies (and (not (consp x))
+ (not (zp n)))
+ (equal (nthcdr n x) nil)))
+
+ (defthm nthcdr-of-cons
+ (implies (not (zp n))
+ (equal (nthcdr n (cons a b))
+ (nthcdr (+ -1 n) b))))
- (defthm nthcdr-run-gified-of-geval
+ (defthm nthcdr-run-gified-of-geval-list
(implies (and (run-gified-ev-theoremp
- (disjoin (geval-consp-when-gobj-listp-thm
- gevalfn geval-consp)))
- (run-gified-ev-theoremp
- (disjoin (geval-car-cdr-of-gobj-listp-thm
- gevalfn geval-car-cdr)))
- (not (equal gevalfn 'quote))
- (gobj-listp (run-gified-ev args a))
+ (disjoin (geval-list-def-thm
+ geval-list geval)))
+ (not (equal geval 'quote))
+ (not (equal geval-list 'quote))
;; (acl2::take n (run-gified-ev args a))
)
(equal
- (nthcdr n (run-gified-ev (list gevalfn args env) a))
- (run-gified-ev (list gevalfn (make-n-cdrs n args) env) a)))
- :hints(("Goal" :in-theory (e/d (my-run-gified-ev-constraint-0) (nthcdr nth))
- :induct (make-n-cdrs n args))
- (and stable-under-simplificationp
- (cond
- ((member-equal '(zp n) clause)
- '(:use ((:instance geval-car-cdr-of-gobj-listp-thm-correct
- (geval gevalfn)
- (x (list 'quote (run-gified-ev args a)))
- (env (list 'quote (run-gified-ev env a)))
- (a nil)
- (rune geval-car-cdr))
- (:instance geval-car-cdr-of-gobj-listp-thm-correct
- (geval gevalfn)
- (x (list 'quote
- (nthcdr (+ -1 n)
- (run-gified-ev args a))))
- (env (list 'quote (run-gified-ev env a)))
- (a nil)
- (rune geval-car-cdr)))
- :in-theory (e/d (my-run-gified-ev-constraint-0)
- (geval-car-cdr-of-gobj-listp-thm-correct
- nthcdr nth))))
- ((member-equal '(not (zp n)) clause)
- '(:in-theory (e/d (nthcdr) (nth))))))))
+ (nthcdr n (run-gified-ev (list geval-list args env) a))
+ (run-gified-ev (list geval-list (make-n-cdrs n args) env) a)))
+ :hints(("Goal" :in-theory (e/d (my-run-gified-ev-constraint-0)
+ (nthcdr nth))
+ :induct (make-n-cdrs n args)
+ :expand ((:free (x) (nthcdr 0 x))))))
(defthm nth-run-gified-of-geval
(implies (and (run-gified-ev-theoremp
- (disjoin (geval-consp-when-gobj-listp-thm
- gevalfn geval-consp)))
+ (disjoin (geval-list-def-thm
+ geval-list geval)))
(run-gified-ev-theoremp
- (disjoin (geval-car-cdr-of-gobj-listp-thm
- gevalfn geval-car-cdr)))
- (not (equal gevalfn 'quote))
- (gobj-listp (run-gified-ev args a)))
+ (disjoin (geval-of-nil-thm
+ geval geval-nil)))
+ (not (equal geval 'quote))
+ (not (equal geval-list 'quote)))
(equal
- (nth n (run-gified-ev (list gevalfn args env) a))
- (run-gified-ev (list gevalfn (list 'car (make-n-cdrs n args)) env) a)))
+ (nth n (run-gified-ev (list geval-list args env) a))
+ (run-gified-ev (list geval (list 'car (make-n-cdrs n args)) env) a)))
:hints(("Goal" :use ((:instance
car-nthcdr
(a (run-gified-ev (list gevalfn args env) a))))
- :in-theory (disable car-nthcdr))))
+ :in-theory (e/d (run-gified-ev-constraint-0)
+ (car-nthcdr acl2::car-nthcdr))
+ :cases ((consp (run-gified-ev args a))))))
(defthm run-gified-ev-lst-kwote-lst
(equal (run-gified-ev-lst (acl2::kwote-lst x) a)
@@ -1169,25 +1185,21 @@
(run-gified-ev-theoremp
(disjoin (acl2::ev-lookup-var-clause evalfn var-name)))
(run-gified-ev-theoremp
- (disjoin (geval-consp-when-gobj-listp-thm
- gevalfn geval-consp)))
+ (disjoin (geval-list-def-thm
+ geval-list gevalfn)))
(run-gified-ev-theoremp
(disjoin (geval-of-nil-thm
gevalfn geval-nil)))
- (run-gified-ev-theoremp
- (disjoin (geval-car-cdr-of-gobj-listp-thm
- gevalfn geval-car-cdr)))
(not (equal gevalfn 'quote))
- (not (equal evalfn 'quote))
- ;; (gobj-listp (acl2::take n actuals))
- (gobj-listp actuals))
+ (not (equal geval-list 'quote))
+ (not (equal evalfn 'quote)))
(equal (run-gified-ev-lst
(acl2::ev-apply-arglist-on-result
n
evalfn
(acl2::kwote-lst
(run-gified-ev
- (list gevalfn
+ (list geval-list
(list 'quote actuals)
env)
nil))
@@ -1201,9 +1213,9 @@
actuals))
gevalfn env)
nil)))
- :hints(("Goal"
+ :hints(("Goal"
:induct t
- :in-theory (enable gobj-listp acl2::take-redefinition)
+ :in-theory (enable acl2::take-redefinition)
:expand ((:free (a b c)
(acl2::ev-apply-arglist-on-result
n a b c))))
@@ -1241,7 +1253,7 @@
(defthm get-geval-thm-success-impl-len
(implies (not (mv-nth 0 (run-gified-get-geval-thm gfn fn geval-alist geval)))
- (<= 2 (len (mv-nth 2 (run-gified-get-geval-thm gfn fn geval-alist
+ (<= 5 (len (mv-nth 2 (run-gified-get-geval-thm gfn fn geval-alist
geval)))))
:hints(("Goal" :in-theory (enable run-gified-get-geval-thm
run-gified-check-geval-thm)))
@@ -1270,17 +1282,19 @@
((unless (equal (len args) (len formals)))
(mv "The number of arguments doesn't match." nil))
((mv erp eval-thm)
- (run-gified-get-eval-thm fnname (take (- (len formals) 2) formals)
+ (run-gified-get-eval-thm fnname (take (- (len formals) 5) formals)
evalfn eval-alist))
((when erp) (mv erp nil))
- ((unless (and (nths-matching-formalsp 0 (take (- (len formals) 2) formals)
+ ((unless (and (nths-matching-formalsp 0 (take (- (len formals) 5) formals)
'actuals
- (take (- (len formals) 2) args))
- (equal (nthcdr (- (len formals) 2) args) '(hyp clk))))
+ (take (- (len formals) 5) args))
+ (equal (nthcdr (- (len formals) 5) args) '(hyp clk
+ config
+ bvar-db state))))
(mv (acl2::msg "Malformed function args: ~x0" (caddr body))
nil))
(clauses (list* geval-thm eval-thm clauses)))
- (mv nil clauses))))
+ (mv nil clauses))))
#!ACL2
(progn
@@ -1303,7 +1317,7 @@
access
`(b* ,(access-b*-bindings (car args) (car forms) (cdr args))
,rest-expr)))
-
+
(defun ev-constraint-for-search (lemmas hyp-terms ev-term)
(if (atom lemmas)
@@ -1319,8 +1333,8 @@
rune
(ev-constraint-for-search
(cdr lemmas) hyp-terms ev-term)))))
-
-
+
+
(defun ev-constraint-for-fn (ev fn world)
@@ -1330,13 +1344,13 @@
(defmacro ev-constraint-for (ev fn)
`(ev-constraint-for-fn ',ev ',fn world))
-
+
(local
(encapsulate nil
(local
- (in-theory (disable geval-consp-when-gobj-listp-thm-correct
+ (in-theory (disable
cheap-default-car cheap-default-cdr acl2::take-redefinition
ev-quote-clause-correct-for-run-gified-ev
ev-lookup-var-clause-correct-for-run-gified-ev
@@ -1368,14 +1382,14 @@
(:REWRITE RUN-GIFIED-EV-CONSTRAINT-3)
(:REWRITE ACL2::SYMBOLP-ASSOC-EQUAL)
(:DEFINITION ACL2::LIST-FIX)
- (:REWRITE GEVAL-CAR-CDR-OF-GOBJ-LISTP-THM-CORRECT)
+ (:REWRITE GEVAL-LIST-DEF-THM-CORRECT)
(:DEFINITION SYMBOL-LISTP)
(:REWRITE CHEAP-DEFAULT-CDR)
(:TYPE-PRESCRIPTION SYMBOL-LISTP))))
(local
(in-theory (set-difference-theories
(current-theory :here)
- (list (EV-CONSTRAINT-FOR RUN-GIFIED-EV GOBJ-LISTP)
+ (list ; (EV-CONSTRAINT-FOR RUN-GIFIED-EV GOBJ-LISTP)
(EV-CONSTRAINT-FOR RUN-GIFIED-EV BFR-EVAL)
(EV-CONSTRAINT-FOR RUN-GIFIED-EV FORCE)
(EV-CONSTRAINT-FOR RUN-GIFIED-EV MV-LIST)
@@ -1408,26 +1422,23 @@
(run-gified-ev-theoremp
(disjoin (acl2::ev-lookup-var-clause evalfn var-name)))
(run-gified-ev-theoremp
- (disjoin (geval-consp-when-gobj-listp-thm
- gevalfn geval-consp)))
- (run-gified-ev-theoremp
- (disjoin (geval-car-cdr-of-gobj-listp-thm
- gevalfn geval-car-cdr)))
+ (disjoin (geval-list-def-thm
+ geval-list gevalfn)))
(run-gified-ev-theoremp
(disjoin (geval-of-nil-thm
gevalfn geval-nil)))
(not (equal evalfn 'quote))
(not (equal gevalfn 'quote))
+ (not (equal geval-list 'quote))
(mv-nth 0 (run-gified-ev body a))
(bfr-eval (cdr (assoc-equal 'hyp a))
- (cadr (assoc-equal 'env a)))
- (gobj-listp (cdr (assoc-equal 'actuals a))))
- (equal (run-gified-ev
+ (cadr (assoc-equal 'env a))))
+ (equal (run-gified-ev
`(,gevalfn (mv-nth '1 ,body) env)
a)
(run-gified-ev
`(,evalfn (cons fn (acl2::kwote-lst
- (,gevalfn actuals env)))
+ (,geval-list actuals env)))
'nil)
a))))
:hints (("goal" :induct (run-gified-process-body body eval-alist evalfn
@@ -1443,15 +1454,15 @@
nth-of-nthcdr
(n 0)
(y (MV-NTH 3 (RUN-GIFIED-CASE-BREAKDOWN BODY)))
- (m (+ -2 (LEN (MV-NTH 3 (RUN-GIFIED-CASE-BREAKDOWN
+ (m (+ -5 (LEN (MV-NTH 3 (RUN-GIFIED-CASE-BREAKDOWN
BODY))))))
(:instance
nths-matching-formalsp-make-nths-matching-formals-ev1
- (list (ACL2::TAKE (+ -2
+ (list (ACL2::TAKE (+ -5
(LEN (MV-NTH 3 (RUN-GIFIED-CASE-BREAKDOWN BODY))))
(MV-NTH 3 (RUN-GIFIED-CASE-BREAKDOWN BODY))))
(formals (ACL2::TAKE
- (+ -2
+ (+ -5
(LEN (MV-NTH 3 (RUN-GIFIED-CASE-BREAKDOWN BODY))))
(MV-NTH
2
@@ -1475,50 +1486,44 @@
(run-gified-ev-theoremp
(disjoin (acl2::ev-lookup-var-clause evalfn var-name)))
(run-gified-ev-theoremp
- (disjoin (geval-consp-when-gobj-listp-thm
- gevalfn geval-consp)))
- (run-gified-ev-theoremp
- (disjoin (geval-car-cdr-of-gobj-listp-thm
- gevalfn geval-car-cdr)))
+ (disjoin (geval-list-def-thm
+ geval-list gevalfn)))
(run-gified-ev-theoremp
(disjoin (geval-of-nil-thm
gevalfn geval-nil)))
(not (equal evalfn 'quote))
(not (equal gevalfn 'quote))
+ (not (equal geval-list 'quote))
(mv-nth 0 (run-gified-ev body a))
(bfr-eval (cdr (assoc-equal 'hyp a))
- (cadr (assoc-equal 'env a)))
- (gobj-listp (cdr (assoc-equal 'actuals a))))
- (equal (run-gified-ev
+ (cadr (assoc-equal 'env a))))
+ (equal (run-gified-ev
(list gevalfn
(list 'quote (mv-nth 1 (run-gified-ev body a)))
(list 'quote (cdr (assoc-equal 'env a))))
nil)
(run-gified-ev
`(,evalfn (cons fn (acl2::kwote-lst
- (,gevalfn actuals env)))
+ (,geval-list actuals env)))
'nil)
a))))
:hints(("Goal" :in-theory (e/d (run-gified-ev-constraint-0)
(run-gified-process-body-correct))
:use ((:instance run-gified-process-body-correct))))))
-
-(defun run-gified-clause-proc (clause hints state)
+
+(defun run-gified-clause-proc (clause geval-nil state)
(declare ; (ignore hints)
(xargs :stobjs state
:verify-guards nil))
- (b* (((list geval-consp geval-car-cdr geval-nil) hints)
- ((mv ok subst)
+ (b* (((mv ok subst)
(acl2::simple-one-way-unify-lst
'((implies
(if (bfr-eval hyp (car env))
- (if (gobj-listp actuals)
- okp-term
- 'nil)
+ okp-term
'nil)
(equal lhs-term rhs-term)))
clause nil))
@@ -1526,8 +1531,7 @@
clause)
nil state))
((unless (and (eq (cdr (assoc-equal 'hyp subst)) 'hyp)
- (eq (cdr (assoc-equal 'env subst)) 'env)
- (eq (cdr (assoc-equal 'actuals subst)) 'actuals)))
+ (eq (cdr (assoc-equal 'env subst)) 'env)))
(mv "Clause variables are different than expected" nil state))
(lhs (cdr (assoc-equal 'lhs-term subst)))
(rhs (cdr (assoc-equal 'rhs-term subst)))
@@ -1539,13 +1543,15 @@
(mv "The geval function is QUOTE which is silly." nil state))
((when (equal run-gified-fn 'quote))
(mv "The run-gified function is QUOTE which is silly." nil state))
- ((mv erp ev-fn)
- (run-gified-rhs-breakdown rhs geval-fn))
+ ((mv erp ev-fn geval-list-fn)
+ (run-gified-rhs-breakdown rhs))
+ ((when (eq geval-list-fn 'quote))
+ (mv "The geval-list function is QUOTE which is silly." nil state))
((when erp) (mv erp nil state))
(world (w state))
(body (acl2::body run-gified-fn nil world))
(body-clause (function-def-clause run-gified-fn run-gified-fn
- '(fn actuals hyp clk state)
+ '(fn actuals hyp clk config bvar-db state)
body))
((when (eq ev-fn 'quote))
(mv "The eval function is QUOTE which is silly."
@@ -1564,8 +1570,7 @@
ev-fn (cdr (hons-get :quote eval-rule-alist)))
(acl2::ev-lookup-var-clause
ev-fn (cdr (hons-get :lookup-var eval-rule-alist)))
- (geval-consp-when-gobj-listp-thm geval-fn geval-consp)
- (geval-car-cdr-of-gobj-listp-thm geval-fn geval-car-cdr)
+ (geval-list-def-thm geval-list-fn geval-fn)
(geval-of-nil-thm geval-fn geval-nil)
body-clause
clauses))))
@@ -1580,7 +1585,7 @@
(local
(encapsulate nil
- (local
+ (local
(defun cdr-down2 (a b)
(if (atom a)
@@ -1615,33 +1620,31 @@
(acl2::simple-one-way-unify-lst
template term alist))
a)))))))))
-
-
(local
(defthm run-gified-lhs-and-okp-breakdown-correct-eval
(mv-let (erp geval run-gified)
(run-gified-lhs-and-okp-breakdown lhs okp)
(implies (not erp)
(and (equal (run-gified-ev lhs a)
- (run-gified-ev
- `(,geval (mv-nth '1 (,run-gified fn actuals hyp clk state))
+ (run-gified-ev
+ `(,geval (mv-nth '1 (,run-gified fn actuals hyp clk config bvar-db state))
env)
a))
(equal (run-gified-ev okp a)
(run-gified-ev
- `(mv-nth '0 (,run-gified fn actuals hyp clk state))
+ `(mv-nth '0 (,run-gified fn actuals hyp clk config bvar-db state))
a)))))
:hints (("goal" :use run-gified-lhs-and-okp-breakdown-correct
:in-theory (disable run-gified-lhs-and-okp-breakdown-correct)))))
(local
(defthm run-gified-rhs-breakdown-correct-eval
- (mv-let (erp evfn)
- (run-gified-rhs-breakdown rhs geval-fn)
+ (mv-let (erp evfn geval-list-fn)
+ (run-gified-rhs-breakdown rhs)
(implies (not erp)
(equal (run-gified-ev rhs a)
(run-gified-ev
- `(,evfn (cons fn (acl2::kwote-lst (,geval-fn actuals env)))
+ `(,evfn (cons fn (acl2::kwote-lst (,geval-list-fn actuals env)))
'nil)
a))))))
@@ -1653,7 +1656,7 @@
(in-theory (disable acl2::ev-collect-apply-lemmas body table-alist w)))
(local (in-theory (disable run-gified-process-body assoc-equal)))
-
+(local (in-theory (disable SIMPLE-ONE-WAY-UNIFY-LST-WITH-RUN-GIFIED-EV)))
(defthm run-gified-clause-proc-correct
(implies (and (pseudo-term-listp clause)
(alistp a)
@@ -1687,9 +1690,11 @@
. run-gified-fn))))
'(:clause-processor
(acl2::simple-generalize-cp
- clause '(((MV-NTH '1 (RUN-GIFIED-RHS-BREAKDOWN
- RHS GEVAL-FN)) . evalfn)
-
+ clause '(((MV-NTH '1 (RUN-GIFIED-RHS-BREAKDOWN RHS))
+ . evalfn)
+ ((MV-NTH '2 (RUN-GIFIED-RHS-BREAKDOWN RHS))
+ . geval-list-fn)
+
((MV-NTH '1
(GEVAL-RULE-ALIST (TABLE-ALIST 'GL-FUNCTION-INFO
(W STATE))
@@ -1702,7 +1707,7 @@
'(:use ((:instance run-gified-ev-falsify
(x (disjoin (function-def-clause
run-gified-fn run-gified-fn
- '(fn actuals hyp clk state)
+ '(fn actuals hyp clk config bvar-db state)
(body run-gified-fn nil (w
state)))))
(a a)))
@@ -1711,8 +1716,7 @@
(acl2::simple-generalize-cp
clause '(((MV-NTH '1 (ACL2::SIMPLE-ONE-WAY-UNIFY-LST
'((IMPLIES (IF (BFR-EVAL HYP (CAR ENV))
- (IF (GOBJ-LISTP ACTUALS)
- OKP-TERM 'NIL)
+ OKP-TERM
'NIL)
(EQUAL LHS-TERM RHS-TERM)))
CLAUSE 'NIL)) . subst))))))
diff -Nru acl2-6.2/books/centaur/gl/rws.lisp acl2-6.3/books/centaur/gl/rws.lisp
--- acl2-6.2/books/centaur/gl/rws.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/rws.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,14 +1,33 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
(include-book "clause-processors/use-by-hint" :dir :system)
(include-book "clause-processors/multi-env-trick" :dir :system)
(include-book "tools/bstar" :dir :system)
(include-book "tools/mv-nth" :dir :system)
(include-book "tools/flag" :dir :system)
(include-book "tools/rulesets" :dir :system)
-(include-book "centaur/misc/equal-sets" :dir :system)
-(include-book "centaur/misc/alist-equiv" :dir :system)
+(include-book "misc/hons-help" :dir :system)
+(local (include-book "centaur/misc/equal-sets" :dir :system))
+(local (include-book "centaur/misc/alist-equiv" :dir :system))
;;; What does 'rws' abbreviate, in anything, asks Boyer???
@@ -169,7 +188,7 @@
nil
(hons (beta-reduce-term (car x))
(beta-reduce-list (cdr x))))))
-
+
(flag::make-flag beta-reduce-flag beta-reduce-term)
@@ -432,7 +451,7 @@
used
(hons-acons rule t used))))
(mv ans (hons-acons x ans mem) used)))))))
-
+
(defun term-rw-lst (x rws mem used)
(declare (xargs :guard (and (pseudo-term-listp x)
(term-rw-mem-wfp mem)
@@ -464,7 +483,7 @@
((mv ans rule) (fncall-rewrite (cons (car x) args) rws))
(used (if (hons-get rule used) used (hons-acons rule t used))))
(mv ans (hons-acons x ans mem) used)))))))
-
+
(defun term-rw-lst-indep-ind (x rws mem used)
(declare (xargs :guard (and (pseudo-term-listp x)
(term-rw-mem-wfp mem)
@@ -505,7 +524,7 @@
(implies (and (term-rw-mem-wfp mem)
(hons-assoc-equal x mem))
(pseudo-termp (cdr (hons-assoc-equal x mem)))))
-
+
(defthm-term-rw-ind len-term-rw-lst1
(term-rw t :skip t)
@@ -699,14 +718,9 @@
(cons (cdr (hons-get (caar used) used-al))
(used-and-used-al-to-alist-lists (cdr used) used-al))
(used-and-used-al-to-alist-lists (cdr used) used-al))))
-
-
-(acl2::def-multi-env-fns dumb-ev dumb-ev-lst)
-(defmacro alist-keys (x)
- `(acl2::alist-keys ,x))
-(add-macro-alias alist-keys acl2::alist-keys)
+(acl2::def-multi-env-fns dumb-ev dumb-ev-lst)
(defun alists-apply-alists-dumb-ev (used-al)
(let ((used (used-al-to-used used-al)))
@@ -893,7 +907,7 @@
(dumb-ev-lst x a)))))
:hints (("goal" :use ((:instance term-rw-lst-correct (used-al nil)))
:in-theory (e/d** (used-al-to-used)))))
-
+
(defthm fncall-rewrite-if
@@ -956,7 +970,7 @@
used-al-to-used
used-al-to-used-term-rw-term-rw-alist-lst
term-rw-mem-wfp)))))
-
+
(local (defun or-list (x)
(if (atom x)
@@ -1011,15 +1025,11 @@
(list* (cadr eq)
(caddr eq)
name))))
-
-(defun rws-from-ruleset-fn (runes world)
-
-; What is the reason for this switch over to program mode? Who did
-; it????? Asks Boyer.
+(defun rws-from-ruleset-fn (runes world)
(declare (xargs :mode :program))
(if (atom runes)
nil
diff -Nru acl2-6.2/books/centaur/gl/shape-spec-defs.lisp acl2-6.3/books/centaur/gl/shape-spec-defs.lisp
--- acl2-6.2/books/centaur/gl/shape-spec-defs.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/shape-spec-defs.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,652 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "GL")
+(include-book "gobject-types")
+(include-book "symbolic-arithmetic-fns")
+
+; Modified slightly 12/4/2012 by Matt K. to be redundant with new ACL2
+; definition.
+(defund nat-listp (l)
+ (declare (xargs :guard t))
+ (cond ((atom l)
+ (eq l nil))
+ (t (and (natp (car l))
+ (nat-listp (cdr l))))))
+
+
+;; An shape spec is an object that is similar to a g object, but a) where there
+;; would be BDDs in a g object, there are natural numbers in an shape spec, and
+;; b) no G-APPLY constructs are allowed in an shape spec.
+
+(defund number-specp (nspec)
+ (declare (xargs :guard t))
+ (and (consp nspec)
+ (nat-listp (car nspec))
+ (if (atom (cdr nspec))
+ (not (cdr nspec))
+ (and (nat-listp (cadr nspec))
+ (if (atom (cddr nspec))
+ (not (cddr nspec))
+ (and (nat-listp (caddr nspec))
+ (if (atom (cdddr nspec))
+ (not (cdddr nspec))
+ (and (nat-listp (cadddr nspec))
+ (not (cddddr nspec))))))))))
+
+
+(defagg g-integer (sign bits var))
+(defagg g-integer? (sign bits var intp))
+(defagg g-call (fn args inverse))
+
+(defund ss-unary-functionp (x)
+ (declare (xargs :guard t))
+ (and (not (eq x 'quote))
+ (or (symbolp x)
+ (and (consp x)
+ (eq (car x) 'lambda)
+ (consp (cdr x))
+ (symbol-listp (cadr x))
+ (eql (len (cadr x)) 1)
+ (consp (cddr x))
+ (pseudo-termp (caddr x))
+ (not (cdddr x))))))
+
+
+
+(mutual-recursion
+ (defun shape-specp (x)
+ (declare (xargs :guard t
+ :measure (acl2-count x)))
+ (if (atom x)
+ (and (not (g-keyword-symbolp x))
+ (not (member x '(:g-integer :g-integer? :g-call))))
+ (case (tag x)
+ (:g-number (number-specp (g-number->num x)))
+ (:g-integer (and (natp (g-integer->sign x))
+ (nat-listp (g-integer->bits x))))
+ (:g-integer? (and (natp (g-integer?->sign x))
+ (nat-listp (g-integer?->bits x))
+ (natp (g-integer?->intp x))))
+ (:g-boolean (natp (g-boolean->bool x)))
+ (:g-concrete t)
+ (:g-var t)
+ (:g-ite
+ (and (shape-specp (g-ite->test x))
+ (shape-specp (g-ite->then x))
+ (shape-specp (g-ite->else x))))
+ (:g-apply nil)
+ (:g-call (and (symbolp (g-call->fn x))
+ (not (eq (g-call->fn x) 'quote))
+ (shape-spec-listp (g-call->args x))
+ (ss-unary-functionp (g-call->inverse x))))
+ (otherwise (and (shape-specp (car x))
+ (shape-specp (cdr x)))))))
+ (defun shape-spec-listp (x)
+ (declare (xargs :guard t
+ :measure (acl2-count x)))
+ (if (atom x)
+ (eq x nil)
+ (and (shape-specp (car x))
+ (shape-spec-listp (cdr x))))))
+
+(in-theory (disable shape-specp shape-spec-listp))
+
+
+
+(mutual-recursion
+ (defun shape-spec-ind (x)
+ (if (atom x)
+ x
+ (case (tag x)
+ ((:g-number :g-integer :g-integer? :g-boolean :g-concrete :g-var) x)
+ (:g-ite (list (shape-spec-ind (g-ite->test x))
+ (shape-spec-ind (g-ite->then x))
+ (shape-spec-ind (g-ite->else x))))
+ (:g-call (shape-spec-list-ind (g-call->args x)))
+ (otherwise (list (shape-spec-ind (car x))
+ (shape-spec-ind (cdr x)))))))
+ (defun shape-spec-list-ind (x)
+ (if (atom x)
+ nil
+ (cons (shape-spec-ind (car x))
+ (shape-spec-list-ind (cdr x))))))
+
+
+(flag::make-flag shape-spec-flag shape-spec-ind
+ :flag-mapping ((shape-spec-ind . ss)
+ (shape-spec-list-ind . list)))
+
+
+
+
+(defund shape-spec-obj-in-range-iff (x obj)
+ (declare (xargs :guard (shape-specp x)
+ :guard-hints(("Goal" :in-theory (enable shape-specp)))))
+ (if (atom x)
+ (iff x obj)
+ (pattern-match x
+ ((g-number &)
+ obj)
+ ((g-integer & & &) obj)
+ ((g-integer? & & & &) t)
+ ((g-boolean &) t)
+ ((g-var &) t)
+ ((g-ite if then else)
+ (or (and (shape-spec-obj-in-range-iff if t)
+ (shape-spec-obj-in-range-iff then obj))
+ (and (shape-spec-obj-in-range-iff if nil)
+ (shape-spec-obj-in-range-iff else obj))))
+ ((g-call & & &) nil)
+ ((g-concrete y) (iff y obj))
+ (& obj))))
+
+(defund integer-in-range (vlist obj)
+ (declare (xargs :guard t))
+ (and (integerp obj)
+ (if (atom vlist)
+ (eql obj 0)
+ (and (<= (- (ash 1 (len (cdr vlist)))) obj)
+ (< obj (ash 1 (len (cdr vlist))))))))
+
+(defund natural-in-range (vlist obj)
+ (declare (xargs :guard t))
+ (and (natp obj)
+ (and (<= 0 obj)
+ (< obj (ash 1 (len vlist))))))
+
+(defund number-spec-in-range (nspec obj)
+ (declare (xargs :guard (number-specp nspec)
+ :guard-hints(("Goal" :in-theory (enable number-specp)))))
+ (and (acl2-numberp obj)
+ (integer-in-range (car nspec) (numerator (realpart obj)))
+ (if (consp (cdr nspec))
+ (and (natural-in-range (cadr nspec) (denominator (realpart obj)))
+ (if (consp (cddr nspec))
+ (and (integer-in-range
+ (caddr nspec) (numerator (imagpart obj)))
+ (if (consp (cdddr nspec))
+ (natural-in-range
+ (cadddr nspec) (denominator (imagpart obj)))
+ (eql (denominator (imagpart obj)) 1)))
+ (rationalp obj)))
+ (integerp obj))))
+
+(defund shape-spec-obj-in-range (x obj)
+ (declare (xargs :guard (shape-specp x)
+ :guard-hints(("Goal" :in-theory (enable shape-specp)))))
+ (if (atom x)
+ (equal x obj)
+ (pattern-match x
+ ((g-number n) (number-spec-in-range n obj))
+ ((g-integer & & &) (integerp obj))
+ ((g-integer? & & & &) t)
+ ((g-boolean &) (booleanp obj))
+ ((g-var &) t)
+ ((g-concrete y) (equal y obj))
+ ((g-ite if then else)
+ (or (and (shape-spec-obj-in-range-iff if t)
+ (shape-spec-obj-in-range then obj))
+ (and (shape-spec-obj-in-range-iff if nil)
+ (shape-spec-obj-in-range else obj))))
+ ((g-call & & &) nil)
+ (& (and (consp obj)
+ (shape-spec-obj-in-range (car x) (car obj))
+ (shape-spec-obj-in-range (cdr x) (cdr obj)))))))
+
+
+(defun-nx shape-spec-slice-to-env (obj)
+ (mv-let (ok bsl vsl) obj
+ (declare (ignore ok))
+ (cons bsl vsl)))
+
+(defun-nx ss-append-envs (x y)
+ (cons (append (car x) (car y))
+ (append (cdr x) (cdr y))))
+
+
+
+
+
+(defund integer-env-slice (vlist obj)
+ (declare (xargs :guard (and (nat-listp vlist)
+ (integerp obj))
+ :guard-hints(("Goal" :in-theory (enable nat-listp)))))
+ (if (atom vlist)
+ (mv (eql obj 0) nil)
+ (if (atom (cdr vlist))
+ (if (eql obj 0)
+ (mv t (list (cons (car vlist) nil)))
+ (mv (eql obj -1) (list (cons (car vlist) t))))
+ (mv-let (rest-ok rest-bslice)
+ (integer-env-slice (cdr vlist) (ash obj -1))
+ (mv rest-ok (cons (cons (car vlist) (logbitp 0 obj)) rest-bslice))))))
+
+(local
+ (defthm true-listp-integer-env-slice
+ (true-listp (mv-nth 1 (integer-env-slice vlist obj)))
+ :hints(("Goal" :in-theory (enable integer-env-slice)))))
+
+(defund natural-env-slice (vlist obj)
+ (declare (xargs :guard (and (nat-listp vlist)
+ (integerp obj))
+ :guard-hints(("Goal" :in-theory (enable nat-listp)))))
+ (if (atom vlist)
+ (mv (eql obj 0) nil)
+ (mv-let (rest-ok rest-bslice)
+ (natural-env-slice (cdr vlist) (ash obj -1))
+ (mv rest-ok (cons (cons (car vlist) (logbitp 0 obj)) rest-bslice)))))
+
+(local
+ (defthm true-listp-natural-env-slice
+ (true-listp (mv-nth 1 (natural-env-slice vlist obj)))
+ :hints(("Goal" :in-theory (enable natural-env-slice)))))
+
+(defund number-spec-env-slice (nspec obj)
+ (declare (xargs :guard (number-specp nspec)
+ :guard-hints(("Goal" :in-theory (enable number-specp)))))
+ (mv-let (rn-ok rn-bspec)
+ (integer-env-slice (car nspec) (numerator (realpart (fix obj))))
+ (if (consp (cdr nspec))
+ (mv-let (rd-ok rd-bspec)
+ (natural-env-slice (cadr nspec) (denominator (realpart (fix obj))))
+ (if (consp (cddr nspec))
+ (mv-let (in-ok in-bspec)
+ (integer-env-slice
+ (caddr nspec) (numerator (imagpart (fix obj))))
+ (if (consp (cdddr nspec))
+ (mv-let (id-ok id-bspec)
+ (natural-env-slice
+ (cadddr nspec)
+ (denominator (imagpart (fix obj))))
+ (mv (and (acl2-numberp obj)
+ rn-ok rd-ok in-ok id-ok)
+ (append rn-bspec rd-bspec
+ in-bspec id-bspec)))
+ (mv (and (acl2-numberp obj)
+ (eql (denominator (imagpart obj)) 1)
+ rn-ok rd-ok in-ok)
+ (append rn-bspec rd-bspec
+ in-bspec))))
+ (mv (and (acl2-numberp obj)
+ (eql (imagpart obj) 0)
+ rn-ok rd-ok)
+ (append rn-bspec rd-bspec))))
+ (mv (and (acl2-numberp obj)
+ (eql (denominator (realpart obj)) 1)
+ (eql (imagpart obj) 0) rn-ok)
+ rn-bspec))))
+
+(local
+ (defthm true-listp-number-spec-env-slice-1
+ (true-listp (mv-nth 1 (number-spec-env-slice nspec obj)))
+ :hints(("Goal" :in-theory (enable number-spec-env-slice)))))
+
+(defun g-integer-env-slice (sign bits var obj)
+ (declare (xargs :guard (and (natp sign) (nat-listp bits))))
+ (b* ((obj (ifix obj))
+ ((mv & slice) (natural-env-slice bits (loghead (len bits) obj)))
+ (rest (logtail (len bits) obj))
+ (signval (< rest 0)))
+ (mv (cons (cons sign signval)
+ slice)
+ (list (cons var rest)))))
+
+(mutual-recursion
+ (defun shape-spec-arbitrary-slice (x)
+ (declare (xargs :guard (shape-specp x)
+ :verify-guards nil))
+ (if (atom x)
+ (mv nil nil)
+ (pattern-match x
+ ((g-number nspec)
+ (mv-let (ok bsl)
+ (number-spec-env-slice nspec 0)
+ (declare (ignore ok))
+ (mv bsl nil)))
+ ((g-integer sign bits var)
+ (g-integer-env-slice sign bits var 0))
+ ((g-integer? sign bits var intp)
+ (mv-let (bsl vsl)
+ (g-integer-env-slice sign bits var 0)
+ (mv (cons (cons intp t) bsl) vsl)))
+ ((g-boolean n) (mv (list (cons n nil)) nil))
+ ((g-var v) (mv nil (list (cons v nil))))
+ ((g-ite if then else)
+ (b* (((mv if-bsl if-vsl)
+ (shape-spec-arbitrary-slice if))
+ ((mv then-bsl then-vsl)
+ (shape-spec-arbitrary-slice then))
+ ((mv else-bsl else-vsl)
+ (shape-spec-arbitrary-slice else)))
+ (mv (append if-bsl then-bsl else-bsl)
+ (append if-vsl then-vsl else-vsl))))
+ ((g-concrete &) (mv nil nil))
+ ((g-call & args &) (shape-spec-list-arbitrary-slice args))
+ (& (b* (((mv car-bsl car-vsl)
+ (shape-spec-arbitrary-slice (car x)))
+ ((mv cdr-bsl cdr-vsl)
+ (shape-spec-arbitrary-slice (cdr x))))
+ (mv (append car-bsl cdr-bsl)
+ (append car-vsl cdr-vsl)))))))
+
+ (defun shape-spec-list-arbitrary-slice (x)
+ (declare (xargs :guard (shape-spec-listp x)))
+ (if (atom x)
+ (mv nil nil)
+ (b* (((mv bsl1 vsl1) (shape-spec-arbitrary-slice (car x)))
+ ((mv bsl2 vsl2) (shape-spec-list-arbitrary-slice (cdr x))))
+ (mv (append bsl1 bsl2)
+ (append vsl1 vsl2))))))
+
+(local
+ (defthm-shape-spec-flag
+ (defthm true-listp-shape-spec-arbitrary-slice-1
+ (true-listp (mv-nth 1 (shape-spec-arbitrary-slice x)))
+ :hints ('(:expand ((shape-spec-arbitrary-slice x))))
+ :flag ss)
+ (defthm true-listp-shape-spec-list-arbitrary-slice-1
+ (true-listp (mv-nth 1 (shape-spec-list-arbitrary-slice x)))
+ :flag list)))
+
+(local
+ (defthm-shape-spec-flag
+ (defthm true-listp-shape-spec-arbitrary-slice-0
+ (true-listp (mv-nth 0 (shape-spec-arbitrary-slice x)))
+ :hints ('(:expand ((shape-spec-arbitrary-slice x))))
+ :flag ss)
+ (defthm true-listp-shape-spec-list-arbitrary-slice-0
+ (true-listp (mv-nth 0 (shape-spec-list-arbitrary-slice x)))
+ :flag list)))
+
+
+(verify-guards shape-spec-arbitrary-slice
+ :hints(("Goal" :in-theory (enable shape-specp
+ shape-spec-listp))))
+
+(in-theory (disable shape-spec-arbitrary-slice shape-spec-list-arbitrary-slice))
+
+(defund shape-spec-iff-env-slice (x obj)
+ (declare (xargs :guard (shape-specp x)
+ :verify-guards nil))
+ (if (atom x)
+ (mv (iff x obj) nil nil)
+ (pattern-match x
+ ((g-number nspec)
+ (mv-let (ok bsl)
+ (number-spec-env-slice nspec 0)
+ (declare (ignore ok))
+ (mv obj bsl nil)))
+ ((g-integer sign bits var)
+ (mv-let (bsl vsl)
+ (g-integer-env-slice sign bits var 0)
+ (mv obj bsl vsl)))
+ ((g-integer? sign bits var intp)
+ (mv-let (bsl vsl)
+ (g-integer-env-slice sign bits var 0)
+ (if obj
+ (mv t (cons (cons intp t) bsl) vsl)
+ (mv t (cons (cons intp nil) bsl)
+ (list (cons var nil))))))
+ ((g-boolean n) (mv t (list (cons n obj)) nil))
+ ((g-var v) (mv t nil (list (cons v obj))))
+ ((g-ite if then else)
+ (b* (((mv then-ok then-bslice then-vslice)
+ (shape-spec-iff-env-slice then obj))
+ ((mv else-ok else-bslice else-vslice)
+ (shape-spec-iff-env-slice else obj))
+ ((mv if-t-ok if-t-bslice if-t-vslice)
+ (shape-spec-iff-env-slice if t))
+ ((mv if-nil-ok if-nil-bslice if-nil-vslice)
+ (shape-spec-iff-env-slice if nil)))
+ (if (and then-ok if-t-ok)
+ (mv t (append if-t-bslice then-bslice else-bslice)
+ (append if-t-vslice then-vslice else-vslice))
+ (mv (and else-ok if-nil-ok)
+ (append if-nil-bslice then-bslice else-bslice)
+ (append if-nil-vslice then-vslice else-vslice)))))
+ ((g-concrete y) (mv (iff y obj) nil nil))
+ ((g-call & args &)
+ (mv-let (bsl vsl)
+ (shape-spec-list-arbitrary-slice args)
+ (mv nil bsl vsl)))
+ (& (b* (((mv car-bsl car-vsl)
+ (shape-spec-arbitrary-slice (car x)))
+ ((mv cdr-bsl cdr-vsl)
+ (shape-spec-arbitrary-slice (cdr x))))
+ (mv obj
+ (append car-bsl cdr-bsl)
+ (append car-vsl cdr-vsl)))))))
+
+(local
+ (defthm true-listp-shape-spec-iff-env-slice-1
+ (true-listp (mv-nth 1 (shape-spec-iff-env-slice x obj)))
+ :hints(("Goal" :in-theory (enable shape-spec-iff-env-slice)))))
+
+(local
+ (defthm true-listp-shape-spec-iff-env-slice-2
+ (true-listp (mv-nth 2 (shape-spec-iff-env-slice x obj)))
+ :hints(("Goal" :in-theory (enable shape-spec-iff-env-slice)))))
+
+(verify-guards shape-spec-iff-env-slice
+ :hints(("Goal" :in-theory (enable shape-specp))))
+
+(defund shape-spec-env-slice (x obj)
+ (declare (xargs :guard (shape-specp x)
+ :verify-guards nil))
+ (if (atom x)
+ (mv (equal x obj) nil nil)
+ (pattern-match x
+ ((g-number nspec)
+ (mv-let (ok bspec)
+ (number-spec-env-slice nspec obj)
+ (mv ok bspec nil)))
+ ((g-integer sign bits var)
+ (mv-let (bsl vsl)
+ (g-integer-env-slice sign bits var obj)
+ (mv (integerp obj) bsl vsl)))
+ ((g-integer? sign bits var intp)
+ (mv-let (bsl vsl)
+ (g-integer-env-slice sign bits var obj)
+ (if (integerp obj)
+ (mv t (cons (cons intp t) bsl) vsl)
+ (mv t (cons (cons intp nil) bsl)
+ (list (cons var obj))))))
+ ((g-boolean n)
+ (mv (booleanp obj)
+ (list (cons n obj))
+ nil))
+ ((g-var v) (mv t nil (list (cons v obj))))
+ ((g-ite if then else)
+ (b* (((mv then-ok then-bslice then-vslice)
+ (shape-spec-env-slice then obj))
+ ((mv else-ok else-bslice else-vslice)
+ (shape-spec-env-slice else obj))
+ ((mv if-t-ok if-t-bslice if-t-vslice)
+ (shape-spec-iff-env-slice if t))
+ ((mv if-nil-ok if-nil-bslice if-nil-vslice)
+ (shape-spec-iff-env-slice if nil)))
+ (if (and then-ok if-t-ok)
+ (mv t (append if-t-bslice then-bslice else-bslice)
+ (append if-t-vslice then-vslice else-vslice))
+ (mv (and else-ok if-nil-ok)
+ (append if-nil-bslice then-bslice else-bslice)
+ (append if-nil-vslice then-vslice else-vslice)))))
+ ((g-concrete y)
+ (mv (equal obj y) nil nil))
+ ((g-call & args &)
+ (mv-let (bsl vsl)
+ (shape-spec-list-arbitrary-slice args)
+ (mv nil bsl vsl)))
+ (& (b* (((mv car-ok car-bslice car-vslice)
+ (shape-spec-env-slice (car x) (ec-call (car obj))))
+ ((mv cdr-ok cdr-bslice cdr-vslice)
+ (shape-spec-env-slice (cdr x) (ec-call (cdr obj)))))
+ (mv (and (consp obj) car-ok cdr-ok)
+ (append car-bslice cdr-bslice)
+ (append car-vslice cdr-vslice)))))))
+
+(local
+ (defthm true-listp-shape-spec-env-slice-1
+ (true-listp (mv-nth 1 (shape-spec-env-slice x obj)))
+ :hints(("Goal" :in-theory (enable shape-spec-env-slice)))))
+
+(local
+ (defthm true-listp-shape-spec-env-slice-2
+ (true-listp (mv-nth 2 (shape-spec-env-slice x obj)))
+ :hints(("Goal" :in-theory (enable shape-spec-env-slice)))))
+
+(verify-guards shape-spec-env-slice
+ :hints(("Goal" :in-theory (enable shape-specp))))
+
+
+
+
+(defun shape-spec-bindingsp (x)
+ (declare (xargs :guard t))
+ (if (atom x)
+ (equal x nil)
+ (and (consp (car x))
+ (symbolp (caar x))
+ (not (keywordp (caar x)))
+ (caar x)
+ (consp (cdar x))
+ (shape-specp (cadar x))
+ (shape-spec-bindingsp (cdr x)))))
+
+
+(local
+ (defthm nat-listp-true-listp
+ (implies (nat-listp x)
+ (true-listp x))
+ :hints(("Goal" :in-theory (enable nat-listp)))
+ :rule-classes (:rewrite :forward-chaining)))
+
+
+(defund number-spec-indices (nspec)
+ (declare (xargs :guard (number-specp nspec)
+ :guard-hints (("goal" :in-theory (enable number-specp)))))
+ (append (car nspec)
+ (and (consp (cdr nspec))
+ (append (cadr nspec)
+ (and (consp (cddr nspec))
+ (append (caddr nspec)
+ (and (consp (cdddr nspec))
+ (cadddr nspec))))))))
+
+
+(mutual-recursion
+ (defun shape-spec-indices (x)
+ (declare (xargs :guard (shape-specp x)
+ :verify-guards nil))
+ (if (atom x)
+ nil
+ (pattern-match x
+ ((g-number nspec)
+ (number-spec-indices nspec))
+ ((g-integer sign bits &)
+ (cons sign bits))
+ ((g-integer? sign bits & intp)
+ (list* intp sign bits))
+ ((g-boolean n) (list n))
+ ((g-var &) nil)
+ ((g-ite if then else)
+ (append (shape-spec-indices if)
+ (shape-spec-indices then)
+ (shape-spec-indices else)))
+ ((g-concrete &) nil)
+ ((g-call & args &) (shape-spec-list-indices args))
+ (& (append (shape-spec-indices (car x))
+ (shape-spec-indices (cdr x)))))))
+ (defun shape-spec-list-indices (x)
+ (declare (xargs :guard (shape-spec-listp x)))
+ (if (atom x)
+ nil
+ (append (shape-spec-indices (car x))
+ (shape-spec-list-indices (cdr x))))))
+
+
+
+(defund numlist-to-vars (lst)
+ (declare (xargs :guard (nat-listp lst)
+ :guard-hints (("goal" :in-theory (enable nat-listp)))))
+ (if (atom lst)
+ nil
+ (cons (bfr-var (car lst))
+ (numlist-to-vars (cdr lst)))))
+
+(defund num-spec-to-num-gobj (nspec)
+ (declare (xargs :guard (number-specp nspec)
+ :guard-hints (("goal" :in-theory (enable number-specp)))))
+ (cons (numlist-to-vars (car nspec))
+ (and (consp (cdr nspec))
+ (cons (numlist-to-vars (cadr nspec))
+ (and (consp (cddr nspec))
+ (cons (numlist-to-vars (caddr nspec))
+ (and (consp (cdddr nspec))
+ (list (numlist-to-vars
+ (cadddr nspec))))))))))
+
+(mutual-recursion
+ (defun shape-spec-to-gobj (x)
+ (declare (xargs :guard (shape-specp x)
+ :guard-hints (("goal" :in-theory (enable shape-specp
+ shape-spec-listp)))))
+ (if (atom x)
+ x
+ (pattern-match x
+ ((g-number nspec)
+ (g-number (num-spec-to-num-gobj nspec)))
+ ((g-integer sign bits var)
+ (g-apply 'logapp
+ (list (len bits)
+ (g-number (list (bfr-logapp-nus
+ (len bits) (numlist-to-vars bits) nil)))
+ (g-apply 'int-set-sign
+ (list (g-boolean (bfr-var sign))
+ (g-var var))))))
+ ((g-integer? sign bits var intp)
+ (g-apply 'maybe-integer
+ (list
+ (g-apply 'logapp
+ (list (len bits)
+ (g-number (list (bfr-logapp-nus
+ (len bits) (numlist-to-vars bits) nil)))
+ (g-apply 'int-set-sign
+ (list (g-boolean (bfr-var sign))
+ (g-var var)))))
+ (g-var var)
+ (g-boolean (bfr-var intp)))))
+ ((g-boolean n) (g-boolean (bfr-var n)))
+ ((g-var &) x)
+ ((g-ite if then else)
+ (g-ite (shape-spec-to-gobj if)
+ (shape-spec-to-gobj then)
+ (shape-spec-to-gobj else)))
+ ((g-concrete &) x)
+ ((g-call fn args &) (g-apply fn (shape-spec-to-gobj-list args)))
+ (& (gl-cons (shape-spec-to-gobj (car x))
+ (shape-spec-to-gobj (cdr x)))))))
+ (defun shape-spec-to-gobj-list (x)
+ (declare (xargs :guard (shape-spec-listp x)))
+ (if (atom x)
+ nil
+ (cons (shape-spec-to-gobj (car x))
+ (shape-spec-to-gobj-list (cdr x))))))
diff -Nru acl2-6.2/books/centaur/gl/shape-spec.lisp acl2-6.3/books/centaur/gl/shape-spec.lisp
--- acl2-6.2/books/centaur/gl/shape-spec.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/shape-spec.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,24 +1,35 @@
-
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
+(include-book "shape-spec-defs")
(include-book "gtypes")
-(include-book "gl-doc-string")
+(include-book "symbolic-arithmetic-fns")
+(local (include-book "symbolic-arithmetic"))
(local (include-book "gtype-thms"))
(local (include-book "data-structures/no-duplicates" :dir :system))
(local (include-book "tools/mv-nth" :dir :system))
-(local (include-book "ihs/ihs-lemmas" :dir :system))
+(local (include-book "centaur/bitops/ihsext-basics" :dir :system))
+(local (include-book "arithmetic/top-with-meta" :dir :system))
(local (include-book "centaur/misc/fast-alists" :dir :system))
-; Modified slightly 12/4/2012 by Matt K. to be redundant with new ACL2
-; definition.
-(defund nat-listp (l)
- (declare (xargs :guard t))
- (cond ((atom l)
- (eq l nil))
- (t (and (natp (car l))
- (nat-listp (cdr l))))))
(defund slice-to-bdd-env (slice env)
(declare (xargs :guard (and (alistp slice)
@@ -39,45 +50,6 @@
(verify-guards slice-to-bdd-env
:hints (("goal" :in-theory (enable nat-listp))))
-
-;; An shape spec is an object that is similar to a g object, but a) where there
-;; would be BDDs in a g object, there are natural numbers in an shape spec, and
-;; b) no G-APPLY constructs are allowed in an shape spec.
-
-(defund number-specp (nspec)
- (declare (xargs :guard t))
- (and (consp nspec)
- (nat-listp (car nspec))
- (if (atom (cdr nspec))
- (not (cdr nspec))
- (and (nat-listp (cadr nspec))
- (if (atom (cddr nspec))
- (not (cddr nspec))
- (and (nat-listp (caddr nspec))
- (if (atom (cdddr nspec))
- (not (cdddr nspec))
- (nat-listp (cadddr nspec)))))))))
-
-
-(defund shape-specp (x)
- (declare (xargs :guard t))
- (if (atom x)
- (not (g-keyword-symbolp x))
- (case (tag x)
- (:g-number (number-specp (g-number->num x)))
- (:g-boolean (natp (g-boolean->bool x)))
- (:g-concrete t)
- (:g-var t)
- (:g-ite
- (and (shape-specp (g-ite->test x))
- (shape-specp (g-ite->then x))
- (shape-specp (g-ite->else x))))
- (:g-apply nil)
- (otherwise (and (shape-specp (car x))
- (shape-specp (cdr x)))))))
-
-
-
(local
(defthm nat-listp-true-listp
(implies (nat-listp x)
@@ -86,17 +58,6 @@
:rule-classes (:rewrite :forward-chaining)))
-(defund number-spec-indices (nspec)
- (declare (xargs :guard (number-specp nspec)
- :guard-hints (("goal" :in-theory (enable number-specp)))))
- (append (car nspec)
- (and (consp (cdr nspec))
- (append (cadr nspec)
- (and (consp (cddr nspec))
- (append (caddr nspec)
- (and (consp (cdddr nspec))
- (cadddr nspec))))))))
-
(local
(defthm nat-listp-append
(implies (and (nat-listp a)
@@ -114,319 +75,80 @@
(nat-listp (number-spec-indices nspec)))
:hints(("Goal" :in-theory (enable number-specp number-spec-indices))))
-(defund shape-spec-indices (x)
- (declare (xargs :guard (shape-specp x)
- :verify-guards nil))
- (if (atom x)
- nil
- (pattern-match x
- ((g-number nspec)
- (number-spec-indices nspec))
- ((g-boolean n) (list n))
- ((g-var &) nil)
- ((g-ite if then else)
- (append (shape-spec-indices if)
- (shape-spec-indices then)
- (shape-spec-indices else)))
- ((g-concrete &) nil)
- (& (append (shape-spec-indices (car x))
- (shape-spec-indices (cdr x)))))))
-
-(defthm nat-listp-shape-spec-indices
- (implies (shape-specp x)
- (nat-listp (shape-spec-indices x)))
- :hints(("Goal" :in-theory (enable shape-specp shape-spec-indices
- nat-listp))))
-
-(verify-guards shape-spec-indices
- :hints (("goal" :in-theory (enable shape-specp))))
-
-(defund shape-spec-vars (x)
- (declare (xargs :guard (shape-specp x)
- :verify-guards nil))
- (if (atom x)
- nil
- (pattern-match x
- ((g-number &) nil)
- ((g-boolean &) nil)
- ((g-var v) (list v))
- ((g-ite if then else)
- (append (shape-spec-vars if)
- (shape-spec-vars then)
- (shape-spec-vars else)))
- ((g-concrete &) nil)
- (& (append (shape-spec-vars (car x))
- (shape-spec-vars (cdr x)))))))
-
-(local
- (defthm true-listp-shape-spec-vars
- (true-listp (shape-spec-vars x))
- :hints(("Goal" :in-theory (enable shape-spec-vars)))))
-
-(verify-guards shape-spec-vars
- :hints(("Goal" :in-theory (enable shape-specp))))
-
-
-(defund integer-env-slice (vlist obj)
- (declare (xargs :guard (and (nat-listp vlist)
- (integerp obj))
- :guard-hints(("Goal" :in-theory (enable nat-listp)))))
- (if (atom vlist)
- (mv (eql obj 0) nil)
- (if (atom (cdr vlist))
- (if (eql obj 0)
- (mv t (list (cons (car vlist) nil)))
- (mv (eql obj -1) (list (cons (car vlist) t))))
- (mv-let (rest-ok rest-bslice)
- (integer-env-slice (cdr vlist) (ash obj -1))
- (mv rest-ok (cons (cons (car vlist) (logbitp 0 obj)) rest-bslice))))))
-
-(local
- (defthm true-listp-integer-env-slice
- (true-listp (mv-nth 1 (integer-env-slice vlist obj)))
- :hints(("Goal" :in-theory (enable integer-env-slice)))))
-(defund natural-env-slice (vlist obj)
- (declare (xargs :guard (and (nat-listp vlist)
- (integerp obj))
- :guard-hints(("Goal" :in-theory (enable nat-listp)))))
- (if (atom vlist)
- (mv (eql obj 0) nil)
- (mv-let (rest-ok rest-bslice)
- (natural-env-slice (cdr vlist) (ash obj -1))
- (mv rest-ok (cons (cons (car vlist) (logbitp 0 obj)) rest-bslice)))))
-
-(local
- (defthm true-listp-natural-env-slice
- (true-listp (mv-nth 1 (natural-env-slice vlist obj)))
- :hints(("Goal" :in-theory (enable natural-env-slice)))))
-
-(defund number-spec-env-slice (nspec obj)
- (declare (xargs :guard (number-specp nspec)
- :guard-hints(("Goal" :in-theory (enable number-specp)))))
- (mv-let (rn-ok rn-bspec)
- (integer-env-slice (car nspec) (numerator (realpart (fix obj))))
- (if (consp (cdr nspec))
- (mv-let (rd-ok rd-bspec)
- (natural-env-slice (cadr nspec) (denominator (realpart (fix obj))))
- (if (consp (cddr nspec))
- (mv-let (in-ok in-bspec)
- (integer-env-slice
- (caddr nspec) (numerator (imagpart (fix obj))))
- (if (consp (cdddr nspec))
- (mv-let (id-ok id-bspec)
- (natural-env-slice
- (cadddr nspec)
- (denominator (imagpart (fix obj))))
- (mv (and (acl2-numberp obj)
- rn-ok rd-ok in-ok id-ok)
- (append rn-bspec rd-bspec
- in-bspec id-bspec)))
- (mv (and (acl2-numberp obj)
- (eql (denominator (imagpart obj)) 1)
- rn-ok rd-ok in-ok)
- (append rn-bspec rd-bspec
- in-bspec))))
- (mv (and (acl2-numberp obj)
- (eql (imagpart obj) 0)
- rn-ok rd-ok)
- (append rn-bspec rd-bspec))))
- (mv (and (acl2-numberp obj)
- (eql (denominator (realpart obj)) 1)
- (eql (imagpart obj) 0) rn-ok)
- rn-bspec))))
-
-(local
- (defthm true-listp-number-spec-env-slice-1
- (true-listp (mv-nth 1 (number-spec-env-slice nspec obj)))
- :hints(("Goal" :in-theory (enable number-spec-env-slice)))))
-
-(defun shape-spec-arbitrary-slice (x)
- (declare (xargs :guard (shape-specp x)
- :verify-guards nil))
- (if (atom x)
- (mv nil nil)
- (pattern-match x
- ((g-number nspec)
- (mv-let (ok bsl)
- (number-spec-env-slice nspec 0)
- (declare (ignore ok))
- (mv bsl nil)))
- ((g-boolean n) (mv (list (cons n nil)) nil))
- ((g-var v) (mv nil (list (cons v nil))))
- ((g-ite if then else)
- (b* (((mv if-bsl if-vsl)
- (shape-spec-arbitrary-slice if))
- ((mv then-bsl then-vsl)
- (shape-spec-arbitrary-slice then))
- ((mv else-bsl else-vsl)
- (shape-spec-arbitrary-slice else)))
- (mv (append if-bsl then-bsl else-bsl)
- (append if-vsl then-vsl else-vsl))))
- ((g-concrete &) (mv nil nil))
- (& (b* (((mv car-bsl car-vsl)
- (shape-spec-arbitrary-slice (car x)))
- ((mv cdr-bsl cdr-vsl)
- (shape-spec-arbitrary-slice (cdr x))))
- (mv (append car-bsl cdr-bsl)
- (append car-vsl cdr-vsl)))))))
-
-(local
- (defthm true-listp-shape-spec-arbitrary-slice-1
- (true-listp (mv-nth 1 (shape-spec-arbitrary-slice x)))))
+(defthm-shape-spec-flag
+ (defthm nat-listp-shape-spec-indices
+ (implies (shape-specp x)
+ (nat-listp (shape-spec-indices x)))
+ :flag ss)
+ (defthm nat-listp-shape-spec-list-indices
+ (implies (shape-spec-listp x)
+ (nat-listp (shape-spec-list-indices x)))
+ :flag list)
+ :hints(("Goal" :in-theory (enable shape-specp shape-spec-listp
+ shape-spec-indices
+ nat-listp))))
-(local
- (defthm true-listp-shape-spec-arbitrary-slice-0
- (true-listp (mv-nth 0 (shape-spec-arbitrary-slice x)))))
+(verify-guards shape-spec-indices
+ :hints (("goal" :in-theory (enable shape-specp shape-spec-listp))))
-(verify-guards shape-spec-arbitrary-slice
- :hints(("Goal" :in-theory (enable shape-specp))))
+(in-theory (disable shape-spec-indices shape-spec-list-indices))
-(defund shape-spec-iff-env-slice (x obj)
- (declare (xargs :guard (shape-specp x)
- :verify-guards nil))
- (if (atom x)
- (mv (iff x obj) nil nil)
- (pattern-match x
- ((g-number nspec)
- (mv-let (ok bsl)
- (number-spec-env-slice nspec 0)
- (declare (ignore ok))
- (mv obj bsl nil)))
- ((g-boolean n) (mv t (list (cons n obj)) nil))
- ((g-var v) (mv t nil (list (cons v obj))))
- ((g-ite if then else)
- (b* (((mv then-ok then-bslice then-vslice)
- (shape-spec-iff-env-slice then obj))
- ((mv else-ok else-bslice else-vslice)
- (shape-spec-iff-env-slice else obj))
- ((mv if-t-ok if-t-bslice if-t-vslice)
- (shape-spec-iff-env-slice if t))
- ((mv if-nil-ok if-nil-bslice if-nil-vslice)
- (shape-spec-iff-env-slice if nil)))
- (if (and then-ok if-t-ok)
- (mv t (append if-t-bslice then-bslice else-bslice)
- (append if-t-vslice then-vslice else-vslice))
- (mv (and else-ok if-nil-ok)
- (append if-nil-bslice then-bslice else-bslice)
- (append if-nil-vslice then-vslice else-vslice)))))
- ((g-concrete y) (mv (iff y obj) nil nil))
- (& (b* (((mv car-bsl car-vsl)
- (shape-spec-arbitrary-slice (car x)))
- ((mv cdr-bsl cdr-vsl)
- (shape-spec-arbitrary-slice (cdr x))))
- (mv obj
- (append car-bsl cdr-bsl)
- (append car-vsl cdr-vsl)))))))
+(mutual-recursion
+ (defun shape-spec-vars (x)
+ (declare (xargs :guard (shape-specp x)
+ :verify-guards nil))
+ (if (atom x)
+ nil
+ (pattern-match x
+ ((g-number &) nil)
+ ((g-integer & & v) (list v))
+ ((g-integer? & & v &) (list v))
+ ((g-boolean &) nil)
+ ((g-var v) (list v))
+ ((g-ite if then else)
+ (append (shape-spec-vars if)
+ (shape-spec-vars then)
+ (shape-spec-vars else)))
+ ((g-concrete &) nil)
+ ((g-call & args &) (shape-spec-list-vars args))
+ (& (append (shape-spec-vars (car x))
+ (shape-spec-vars (cdr x)))))))
+ (defun shape-spec-list-vars (x)
+ (declare (xargs :guard (shape-spec-listp x)))
+ (if (atom x)
+ nil
+ (append (shape-spec-vars (car x))
+ (shape-spec-list-vars (cdr x))))))
-(local
- (defthm true-listp-shape-spec-iff-env-slice-1
- (true-listp (mv-nth 1 (shape-spec-iff-env-slice x obj)))
- :hints(("Goal" :in-theory (enable shape-spec-iff-env-slice)))))
(local
- (defthm true-listp-shape-spec-iff-env-slice-2
- (true-listp (mv-nth 2 (shape-spec-iff-env-slice x obj)))
- :hints(("Goal" :in-theory (enable shape-spec-iff-env-slice)))))
+ (defthm-shape-spec-flag
+ (defthm true-listp-shape-spec-vars
+ (implies (shape-specp x)
+ (true-listp (shape-spec-vars x)))
+ :flag ss)
+ (defthm true-listp-shape-spec-list-vars
+ (implies (shape-spec-listp x)
+ (true-listp (shape-spec-list-vars x)))
+ :flag list)
+ :hints(("Goal" :in-theory (enable shape-specp shape-spec-vars
+ true-listp)))))
-(verify-guards shape-spec-iff-env-slice
- :hints(("Goal" :in-theory (enable shape-specp))))
-
-(defund shape-spec-env-slice (x obj)
- (declare (xargs :guard (shape-specp x)
- :verify-guards nil))
- (if (atom x)
- (mv (equal x obj) nil nil)
- (pattern-match x
- ((g-number nspec)
- (mv-let (ok bspec)
- (number-spec-env-slice nspec obj)
- (mv ok bspec nil)))
- ((g-boolean n)
- (mv (booleanp obj)
- (list (cons n obj))
- nil))
- ((g-var v) (mv t nil (list (cons v obj))))
- ((g-ite if then else)
- (b* (((mv then-ok then-bslice then-vslice)
- (shape-spec-env-slice then obj))
- ((mv else-ok else-bslice else-vslice)
- (shape-spec-env-slice else obj))
- ((mv if-t-ok if-t-bslice if-t-vslice)
- (shape-spec-iff-env-slice if t))
- ((mv if-nil-ok if-nil-bslice if-nil-vslice)
- (shape-spec-iff-env-slice if nil)))
- (if (and then-ok if-t-ok)
- (mv t (append if-t-bslice then-bslice else-bslice)
- (append if-t-vslice then-vslice else-vslice))
- (mv (and else-ok if-nil-ok)
- (append if-nil-bslice then-bslice else-bslice)
- (append if-nil-vslice then-vslice else-vslice)))))
- ((g-concrete y)
- (mv (equal obj y) nil nil))
- (& (b* (((mv car-ok car-bslice car-vslice)
- (shape-spec-env-slice (car x) (ec-call (car obj))))
- ((mv cdr-ok cdr-bslice cdr-vslice)
- (shape-spec-env-slice (cdr x) (ec-call (cdr obj)))))
- (mv (and (consp obj) car-ok cdr-ok)
- (append car-bslice cdr-bslice)
- (append car-vslice cdr-vslice)))))))
-
-(local
- (defthm true-listp-shape-spec-env-slice-1
- (true-listp (mv-nth 1 (shape-spec-env-slice x obj)))
- :hints(("Goal" :in-theory (enable shape-spec-env-slice)))))
+(verify-guards shape-spec-vars
+ :hints(("Goal" :in-theory (enable shape-specp shape-spec-listp))))
-(local
- (defthm true-listp-shape-spec-env-slice-2
- (true-listp (mv-nth 2 (shape-spec-env-slice x obj)))
- :hints(("Goal" :in-theory (enable shape-spec-env-slice)))))
+(in-theory (disable shape-spec-vars shape-spec-list-vars))
-(verify-guards shape-spec-env-slice
- :hints(("Goal" :in-theory (enable shape-specp))))
-(defund numlist-to-vars (lst)
- (declare (xargs :guard (nat-listp lst)
- :guard-hints (("goal" :in-theory (enable nat-listp)))))
- (if (atom lst)
- nil
- (cons (bfr-var (car lst))
- (numlist-to-vars (cdr lst)))))
-(defund num-spec-to-num-gobj (nspec)
- (declare (xargs :guard (number-specp nspec)
- :guard-hints (("goal" :in-theory (enable number-specp)))))
- (cons (numlist-to-vars (car nspec))
- (and (consp (cdr nspec))
- (cons (numlist-to-vars (cadr nspec))
- (and (consp (cddr nspec))
- (cons (numlist-to-vars (caddr nspec))
- (and (consp (cdddr nspec))
- (list (numlist-to-vars
- (cadddr nspec))))))))))
-
-(defund shape-spec-to-gobj (x)
- (declare (xargs :guard (shape-specp x)
- :guard-hints (("goal" :in-theory (enable shape-specp)))))
- (if (atom x)
- x
- (pattern-match x
- ((g-number nspec)
- (g-number (num-spec-to-num-gobj nspec)))
- ((g-boolean n) (g-boolean (bfr-var n)))
- ((g-var &) x)
- ((g-ite if then else)
- (g-ite (shape-spec-to-gobj if)
- (shape-spec-to-gobj then)
- (shape-spec-to-gobj else)))
- ((g-concrete &) x)
- (& (gl-cons (shape-spec-to-gobj (car x))
- (shape-spec-to-gobj (cdr x)))))))
+(in-theory (disable shape-spec-to-gobj
+ shape-spec-to-gobj-list))
@@ -504,29 +226,57 @@
;; (bfr-eval (bfr-var n) env)))))
(local
- (defthm bfr-eval-list-numlist-subset-append
+ (defthm bfr-list->s-numlist-subset-append
(implies (and (nat-listp lst)
(subsetp-equal lst (strip-cars bsl1)))
- (equal (bfr-eval-list (numlist-to-vars lst)
+ (equal (bfr-list->s (numlist-to-vars lst)
+ (slice-to-bdd-env (append bsl1 bsl2) env))
+ (bfr-list->s (numlist-to-vars lst)
+ (slice-to-bdd-env bsl1 env))))
+ :hints(("Goal" :in-theory (enable numlist-to-vars scdr s-endp
+ slice-to-bdd-env
+ subsetp-equal
+ nat-listp)
+ :induct (numlist-to-vars lst)))))
+
+(local
+ (defthm bfr-list->s-numlist-no-intersect-append
+ (implies (and (nat-listp lst)
+ (nat-listp (strip-cars bsl1))
+ (not (intersectp-equal lst (strip-cars bsl1))))
+ (equal (bfr-list->s (numlist-to-vars lst)
(slice-to-bdd-env (append bsl1 bsl2) env))
- (bfr-eval-list (numlist-to-vars lst)
- (slice-to-bdd-env bsl1 env))))
- :hints(("Goal" :in-theory (enable numlist-to-vars
+ (bfr-list->s (numlist-to-vars lst)
+ (slice-to-bdd-env bsl2 env))))
+ :hints(("Goal" :in-theory (enable numlist-to-vars scdr s-endp
+ slice-to-bdd-env
+ nat-listp)
+ :induct (numlist-to-vars lst)))))
+
+(local
+ (defthm bfr-list->u-numlist-subset-append
+ (implies (and (nat-listp lst)
+ (subsetp-equal lst (strip-cars bsl1)))
+ (equal (bfr-list->u (numlist-to-vars lst)
+ (slice-to-bdd-env (append bsl1 bsl2) env))
+ (bfr-list->u (numlist-to-vars lst)
+ (slice-to-bdd-env bsl1 env))))
+ :hints(("Goal" :in-theory (enable numlist-to-vars scdr s-endp
slice-to-bdd-env
subsetp-equal
nat-listp)
:induct (numlist-to-vars lst)))))
(local
- (defthm bfr-eval-list-numlist-no-intersect-append
+ (defthm bfr-list->u-numlist-no-intersect-append
(implies (and (nat-listp lst)
(nat-listp (strip-cars bsl1))
(not (intersectp-equal lst (strip-cars bsl1))))
- (equal (bfr-eval-list (numlist-to-vars lst)
+ (equal (bfr-list->u (numlist-to-vars lst)
(slice-to-bdd-env (append bsl1 bsl2) env))
- (bfr-eval-list (numlist-to-vars lst)
+ (bfr-list->u (numlist-to-vars lst)
(slice-to-bdd-env bsl2 env))))
- :hints(("Goal" :in-theory (enable numlist-to-vars
+ :hints(("Goal" :in-theory (enable numlist-to-vars scdr s-endp
slice-to-bdd-env
nat-listp)
:induct (numlist-to-vars lst)))))
@@ -574,23 +324,91 @@
;; :hints(("Goal" :in-theory (enable gobj-fix)))))
+
+
+(def-eval-g sspec-geval
+ (logapp int-set-sign maybe-integer
+ cons car cdr consp if not equal nth len iff
+ shape-spec-slice-to-env
+ ss-append-envs
+ shape-spec-obj-in-range-iff
+ shape-spec-obj-in-range
+ shape-spec-env-slice
+ shape-spec-iff-env-slice))
+
+
+
+(local (in-theory (disable logapp integer-length
+ loghead logtail sspec-geval
+ acl2::member-equal-of-strip-cars-when-member-equal-of-hons-duplicated-members-aux
+ acl2::consp-of-car-when-alistp
+ sets::double-containment)))
+
+(defun expands-with-hint (def expands)
+ (if (atom expands)
+ nil
+ (cons `(:with ,def ,(car expands))
+ (expands-with-hint def (cdr expands)))))
+
+(defthm bfr-eval-list-of-append
+ (equal (bfr-eval-list (append a b) env)
+ (append (bfr-eval-list a env)
+ (bfr-eval-list b env))))
+
+(defthm bfr-list->s-of-append
+ (implies (consp b)
+ (equal (bfr-list->s (append a b) env)
+ (logapp (len a) (bfr-list->s a env)
+ (bfr-list->s b env))))
+ :hints(("Goal" :in-theory (enable scdr s-endp acl2::logapp** append)
+ :induct (append a b)
+ :expand ((:free (a b) (bfr-list->s (cons a b) env))))))
+
+(defthm bfr-list->u-of-append
+ (equal (bfr-list->u (append a b) env)
+ (logapp (len a) (bfr-list->u a env)
+ (bfr-list->u b env)))
+ :hints(("Goal" :in-theory (enable acl2::logapp** append)
+ :induct (append a b)
+ :expand ((:free (a b) (bfr-list->u (cons a b) env))))))
+
+(local (in-theory (enable gl-cons)))
+
(local
- (defthm shape-spec-to-gobj-eval-slice-subset-append-1
- (implies (and (shape-specp x)
- (alistp vsl1)
- (subsetp-equal (shape-spec-indices x)
- (strip-cars bsl1)))
- (equal (generic-geval
- (shape-spec-to-gobj x)
- (cons (slice-to-bdd-env
- (append bsl1 bsl2) env)
- vsl1))
- (generic-geval
- (shape-spec-to-gobj x)
- (cons (slice-to-bdd-env
- bsl1 env)
- vsl1))))
- :hints(("Goal" :in-theory (e/d (break-g-number
+ (defthm-shape-spec-flag
+ (defthm shape-spec-to-gobj-eval-slice-subset-append-1
+ (implies (and (shape-specp x)
+ (alistp vsl1)
+ (subsetp-equal (shape-spec-indices x)
+ (strip-cars bsl1)))
+ (equal (sspec-geval
+ (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env
+ (append bsl1 bsl2) env)
+ vsl1))
+ (sspec-geval
+ (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env
+ bsl1 env)
+ vsl1))))
+ :flag ss)
+ (defthm shape-spec-to-gobj-list-eval-slice-subset-append-1
+ (implies (and (shape-spec-listp x)
+ (alistp vsl1)
+ (subsetp-equal (shape-spec-list-indices x)
+ (strip-cars bsl1)))
+ (equal (sspec-geval-list
+ (shape-spec-to-gobj-list x)
+ (cons (slice-to-bdd-env
+ (append bsl1 bsl2) env)
+ vsl1))
+ (sspec-geval-list
+ (shape-spec-to-gobj-list x)
+ (cons (slice-to-bdd-env
+ bsl1 env)
+ vsl1))))
+ :flag list)
+ :hints(("Goal" :in-theory (e/d (break-g-number
num-spec-to-num-gobj
number-spec-indices
number-specp
@@ -602,43 +420,64 @@
acl2::consp-by-len
boolean-listp
binary-append))
- :induct (shape-spec-to-gobj x)
:expand ((shape-spec-to-gobj x)
+ (shape-spec-to-gobj-list x)
(shape-spec-indices x)
+ (shape-spec-list-indices x)
(shape-spec-vars x)
- (shape-specp x)))
+ (shape-spec-list-vars x)
+ (shape-specp x)
+ (shape-spec-listp x)))
(and stable-under-simplificationp
- (flag::expand-calls-computed-hint
- acl2::clause '(generic-geval)))
- (and stable-under-simplificationp
- '(:in-theory (enable g-boolean->bool
- g-apply->fn
- g-apply->args))))))
+ (let ((calls1 (acl2::find-calls-of-fns-term
+ (car (last clause)) '(sspec-geval) nil))
+ (calls2 (acl2::find-calls-of-fns-term
+ (car (last clause)) '(sspec-geval-list) nil)))
+ (and (or calls1 calls2)
+ `(:computed-hint-replacement t
+ :expand (,@(expands-with-hint 'sspec-geval calls1)
+ ,@(expands-with-hint 'sspec-geval-list calls2)))))))))
(local
- (defthm shape-spec-to-gobj-eval-slice-subset-append-2
- (implies (and (shape-specp x)
- (alistp vsl1)
- (subsetp-equal (shape-spec-vars x)
- (strip-cars vsl1)))
- (equal (generic-geval
- (shape-spec-to-gobj x)
- (cons (slice-to-bdd-env
- bsl1 env)
- (append vsl1 vsl2)))
- (generic-geval
- (shape-spec-to-gobj x)
- (cons (slice-to-bdd-env
- bsl1 env)
- vsl1))))
- :hints(("Goal" :in-theory (e/d (break-g-number
+ (defthm-shape-spec-flag
+ (defthm shape-spec-to-gobj-eval-slice-subset-append-2
+ (implies (and (shape-specp x)
+ (alistp vsl1)
+ (subsetp-equal (shape-spec-vars x)
+ (strip-cars vsl1)))
+ (equal (sspec-geval
+ (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env
+ bsl1 env)
+ (append vsl1 vsl2)))
+ (sspec-geval
+ (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env
+ bsl1 env)
+ vsl1))))
+ :flag ss)
+ (defthm shape-spec-to-gobj-list-eval-slice-subset-append-2
+ (implies (and (shape-spec-listp x)
+ (alistp vsl1)
+ (subsetp-equal (shape-spec-list-vars x)
+ (strip-cars vsl1)))
+ (equal (sspec-geval-list
+ (shape-spec-to-gobj-list x)
+ (cons (slice-to-bdd-env
+ bsl1 env)
+ (append vsl1 vsl2)))
+ (sspec-geval-list
+ (shape-spec-to-gobj-list x)
+ (cons (slice-to-bdd-env
+ bsl1 env)
+ vsl1))))
+ :flag list)
+ :hints(("Goal" :in-theory (e/d (break-g-number
num-spec-to-num-gobj
number-spec-indices
number-specp
subsetp-equal
- hons-assoc-equal
- strip-cars
(:induction shape-spec-to-gobj))
(member-equal
acl2::list-fix-when-true-listp
@@ -646,39 +485,67 @@
acl2::consp-by-len
boolean-listp
binary-append))
- :induct (shape-spec-to-gobj x)
:expand ((shape-spec-to-gobj x)
+ (shape-spec-to-gobj-list x)
(shape-spec-indices x)
+ (shape-spec-list-indices x)
(shape-spec-vars x)
- (shape-specp x)))
+ (shape-spec-list-vars x)
+ (shape-specp x)
+ (shape-spec-listp x)))
(and stable-under-simplificationp
- (flag::expand-calls-computed-hint
- acl2::clause '(generic-geval))))))
-
-
+ (let ((calls1 (acl2::find-calls-of-fns-term
+ (car (last clause)) '(sspec-geval) nil))
+ (calls2 (acl2::find-calls-of-fns-term
+ (car (last clause)) '(sspec-geval-list) nil)))
+ (and (or calls1 calls2)
+ `(:computed-hint-replacement t
+ :expand (,@(expands-with-hint 'sspec-geval calls1)
+ ,@(expands-with-hint 'sspec-geval-list calls2)))))))))
(local
- (defthm shape-spec-to-gobj-eval-slice-no-intersect-append-1
- (implies (and (shape-specp x)
- (alistp vsl1)
- (nat-listp (strip-cars bsl1))
- (not (intersectp-equal
- (shape-spec-indices x)
- (strip-cars bsl1))))
- (equal (generic-geval
- (shape-spec-to-gobj x)
- (cons (slice-to-bdd-env
- (append bsl1 bsl2) env)
- vsl1))
- (generic-geval
- (shape-spec-to-gobj x)
- (cons (slice-to-bdd-env
- bsl2 env)
- vsl1))))
+ (defthm-shape-spec-flag
+ (defthm shape-spec-to-gobj-eval-slice-no-intersect-append-1
+ (implies (and (shape-specp x)
+ (alistp vsl1)
+ (nat-listp (strip-cars bsl1))
+ (not (intersectp-equal
+ (shape-spec-indices x)
+ (strip-cars bsl1))))
+ (equal (sspec-geval
+ (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env
+ (append bsl1 bsl2) env)
+ vsl1))
+ (sspec-geval
+ (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env
+ bsl2 env)
+ vsl1))))
+ :flag ss)
+ (defthm shape-spec-list-to-gobj-eval-slice-no-intersect-append-1
+ (implies (and (shape-spec-listp x)
+ (alistp vsl1)
+ (nat-listp (strip-cars bsl1))
+ (not (intersectp-equal
+ (shape-spec-list-indices x)
+ (strip-cars bsl1))))
+ (equal (sspec-geval-list
+ (shape-spec-to-gobj-list x)
+ (cons (slice-to-bdd-env
+ (append bsl1 bsl2) env)
+ vsl1))
+ (sspec-geval-list
+ (shape-spec-to-gobj-list x)
+ (cons (slice-to-bdd-env
+ bsl2 env)
+ vsl1))))
+ :flag list)
:hints(("Goal" :in-theory (e/d (break-g-number
num-spec-to-num-gobj
number-spec-indices
number-specp
+ subsetp-equal
(:induction shape-spec-to-gobj))
(member-equal
acl2::list-fix-when-true-listp
@@ -686,32 +553,59 @@
acl2::consp-by-len
boolean-listp
binary-append))
- :induct (shape-spec-to-gobj x)
:expand ((shape-spec-to-gobj x)
+ (shape-spec-to-gobj-list x)
(shape-spec-indices x)
+ (shape-spec-list-indices x)
(shape-spec-vars x)
- (shape-specp x)))
+ (shape-spec-list-vars x)
+ (shape-specp x)
+ (shape-spec-listp x)))
(and stable-under-simplificationp
- (flag::expand-calls-computed-hint
- acl2::clause '(generic-geval))))))
+ (let ((calls1 (acl2::find-calls-of-fns-term
+ (car (last clause)) '(sspec-geval) nil))
+ (calls2 (acl2::find-calls-of-fns-term
+ (car (last clause)) '(sspec-geval-list) nil)))
+ (and (or calls1 calls2)
+ `(:computed-hint-replacement t
+ :expand (,@(expands-with-hint 'sspec-geval calls1)
+ ,@(expands-with-hint 'sspec-geval-list calls2)))))))))
(local
- (defthm shape-spec-to-gobj-eval-slice-no-intersect-append-2
- (implies (and (shape-specp x)
- (alistp vsl1)
- (not (intersectp-equal (shape-spec-vars x)
- (strip-cars vsl1))))
- (equal (generic-geval
- (shape-spec-to-gobj x)
- (cons (slice-to-bdd-env
- bsl1 env)
- (append vsl1 vsl2)))
- (generic-geval
- (shape-spec-to-gobj x)
- (cons (slice-to-bdd-env
- bsl1 env)
- vsl2))))
+ (defthm-shape-spec-flag
+ (defthm shape-spec-to-gobj-eval-slice-no-intersect-append-2
+ (implies (and (shape-specp x)
+ (alistp vsl1)
+ (not (intersectp-equal (shape-spec-vars x)
+ (strip-cars vsl1))))
+ (equal (sspec-geval
+ (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env
+ bsl1 env)
+ (append vsl1 vsl2)))
+ (sspec-geval
+ (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env
+ bsl1 env)
+ vsl2))))
+ :flag ss)
+ (defthm shape-spec-list-to-gobj-eval-slice-no-intersect-append-2
+ (implies (and (shape-spec-listp x)
+ (alistp vsl1)
+ (not (intersectp-equal (shape-spec-list-vars x)
+ (strip-cars vsl1))))
+ (equal (sspec-geval-list
+ (shape-spec-to-gobj-list x)
+ (cons (slice-to-bdd-env
+ bsl1 env)
+ (append vsl1 vsl2)))
+ (sspec-geval-list
+ (shape-spec-to-gobj-list x)
+ (cons (slice-to-bdd-env
+ bsl1 env)
+ vsl2))))
+ :flag list)
:hints(("Goal" :in-theory (e/d (break-g-number
num-spec-to-num-gobj
number-spec-indices
@@ -722,17 +616,25 @@
acl2::list-fix-when-true-listp
acl2::list-fix-when-len-zero
acl2::consp-by-len
- acl2::hons-assoc-equal-append
boolean-listp
binary-append))
- :induct (shape-spec-to-gobj x)
:expand ((shape-spec-to-gobj x)
+ (shape-spec-to-gobj-list x)
(shape-spec-indices x)
+ (shape-spec-list-indices x)
(shape-spec-vars x)
- (shape-specp x)))
+ (shape-spec-list-vars x)
+ (shape-specp x)
+ (shape-spec-listp x)))
(and stable-under-simplificationp
- (flag::expand-calls-computed-hint
- acl2::clause '(generic-geval))))))
+ (let ((calls1 (acl2::find-calls-of-fns-term
+ (car (last clause)) '(sspec-geval) nil))
+ (calls2 (acl2::find-calls-of-fns-term
+ (car (last clause)) '(sspec-geval-list) nil)))
+ (and (or calls1 calls2)
+ `(:computed-hint-replacement t
+ :expand (,@(expands-with-hint 'sspec-geval calls1)
+ ,@(expands-with-hint 'sspec-geval-list calls2)))))))))
(local
@@ -756,9 +658,15 @@
:hints(("Goal" :in-theory (enable number-spec-env-slice)))))
(local
- (defthm alistp-shape-spec-arbitrary-slice-1
- (alistp (mv-nth 1 (shape-spec-arbitrary-slice x)))
- :hints(("Goal" :in-theory (enable shape-spec-arbitrary-slice)))))
+ (defthm-shape-spec-flag
+ (defthm alistp-shape-spec-arbitrary-slice-1
+ (alistp (mv-nth 1 (shape-spec-arbitrary-slice x)))
+ :flag ss)
+ (defthm alistp-shape-spec-list-arbitrary-slice-1
+ (alistp (mv-nth 1 (shape-spec-list-arbitrary-slice x)))
+ :flag list)
+ :hints(("Goal" :in-theory (enable shape-spec-arbitrary-slice
+ shape-spec-list-arbitrary-slice)))))
(local
(defthm alistp-shape-spec-iff-env-slice-2
@@ -783,11 +691,19 @@
(subsetp-equal x (append y z)))))
(local
- (defthm shape-spec-vars-subset-cars-arbitrary-env-slice
- (equal (strip-cars (mv-nth 1 (shape-spec-arbitrary-slice x)))
- (shape-spec-vars x))
+ (defthm-shape-spec-flag
+ (defthm shape-spec-vars-subset-cars-arbitrary-env-slice
+ (equal (strip-cars (mv-nth 1 (shape-spec-arbitrary-slice x)))
+ (shape-spec-vars x))
+ :flag ss)
+ (defthm shape-spec-list-vars-subset-cars-arbitrary-env-slice
+ (equal (strip-cars (mv-nth 1 (shape-spec-list-arbitrary-slice x)))
+ (shape-spec-list-vars x))
+ :flag list)
:hints(("Goal" :in-theory (enable shape-spec-vars
- shape-spec-arbitrary-slice)))))
+ shape-spec-list-vars
+ shape-spec-arbitrary-slice
+ shape-spec-list-arbitrary-slice)))))
(local
(defthm shape-spec-vars-subset-cars-iff-env-slice
@@ -835,12 +751,22 @@
(local
- (defthm shape-spec-indices-subset-cars-arbitrary-env-slice
- (implies (shape-specp x)
- (equal (strip-cars (mv-nth 0 (shape-spec-arbitrary-slice x)))
- (shape-spec-indices x)))
- :hints (("goal" :in-theory (enable shape-spec-arbitrary-slice
+ (defthm-shape-spec-flag
+ (defthm shape-spec-indices-subset-cars-arbitrary-env-slice
+ (implies (shape-specp x)
+ (equal (strip-cars (mv-nth 0 (shape-spec-arbitrary-slice x)))
+ (shape-spec-indices x)))
+ :flag ss)
+ (defthm shape-spec-list-indices-subset-cars-arbitrary-env-slice
+ (implies (shape-spec-listp x)
+ (equal (strip-cars (mv-nth 0 (shape-spec-list-arbitrary-slice x)))
+ (shape-spec-list-indices x)))
+ :flag list)
+ :hints (("goal" :in-theory (enable shape-spec-list-arbitrary-slice
+ shape-spec-arbitrary-slice
+ shape-spec-list-indices
shape-spec-indices
+ shape-spec-listp
shape-specp)))))
@@ -893,32 +819,32 @@
(local
- (defthm generic-geval-of-g-ite
- (equal (generic-geval (g-ite if then else) env)
- (if (generic-geval if env)
- (generic-geval then env)
- (generic-geval else env)))
- :hints(("Goal" :in-theory (enable generic-geval)))))
+ (defthm sspec-geval-of-g-ite
+ (equal (sspec-geval (g-ite if then else) env)
+ (if (sspec-geval if env)
+ (sspec-geval then env)
+ (sspec-geval else env)))
+ :hints(("Goal" :in-theory (enable sspec-geval)))))
(local
(encapsulate nil
- (defthm generic-geval-when-g-concrete-tag
+ (defthm sspec-geval-when-g-concrete-tag
(implies (equal (tag x) :g-concrete)
- (equal (generic-geval x env)
+ (equal (sspec-geval x env)
(g-concrete->obj x)))
- :hints(("Goal" :in-theory (enable tag generic-geval)))
+ :hints(("Goal" :in-theory (e/d (tag sspec-geval))))
:rule-classes ((:rewrite :backchain-limit-lst 0)))))
(local
(encapsulate nil
- (defthm generic-geval-when-g-var-tag
+ (defthm sspec-geval-when-g-var-tag
(implies (equal (tag x) :g-var)
- (equal (generic-geval x env)
+ (equal (sspec-geval x env)
(cdr (hons-assoc-equal (g-var->name x) (cdr env)))))
- :hints(("Goal" :in-theory (enable tag generic-geval))))))
+ :hints(("Goal" :in-theory (enable tag sspec-geval))))))
(local (in-theory (disable member-equal equal-of-booleans-rewrite binary-append
intersectp-equal subsetp-equal)))
@@ -933,13 +859,13 @@
acl2::subsetp-car-member
acl2::append-when-not-consp
tag-when-atom
- generic-geval)))
+ sspec-geval)))
(defthm shape-spec-to-gobj-eval-iff-slice
(implies (and (shape-specp x)
(no-duplicatesp (shape-spec-indices x))
(no-duplicatesp (shape-spec-vars x))
(mv-nth 0 (shape-spec-iff-env-slice x obj)))
- (iff (generic-geval
+ (iff (sspec-geval
(shape-spec-to-gobj x)
(cons (slice-to-bdd-env
(mv-nth 1 (shape-spec-iff-env-slice x obj))
@@ -954,11 +880,9 @@
(shape-spec-to-gobj x)
(shape-specp x)
(:free (a b env)
- (generic-geval (cons a b) env))))
- (and stable-under-simplificationp
- '(:in-theory (enable generic-geval)))
+ (sspec-geval (cons a b) env))))
(and stable-under-simplificationp
- '(:in-theory (enable slice-to-bdd-env generic-geval)))))))
+ '(:in-theory (enable slice-to-bdd-env sspec-geval sspec-geval-list)))))))
(local
(defthm bfr-eval-list-numlist-update-non-member
@@ -970,6 +894,28 @@
:hints(("Goal" :in-theory (enable numlist-to-vars bfr-eval-list
nat-listp member-equal)))))
+(local
+ (defthm bfr-list->s-numlist-update-non-member
+ (implies (and (natp n) (nat-listp lst)
+ (not (member-equal n lst)))
+ (equal (bfr-list->s (numlist-to-vars lst)
+ (bfr-set-var n x env))
+ (bfr-list->s (numlist-to-vars lst) env)))
+ :hints(("Goal" :in-theory (enable numlist-to-vars bfr-list->s
+ scdr s-endp
+ nat-listp member-equal)))))
+
+(local
+ (defthm bfr-list->u-numlist-update-non-member
+ (implies (and (natp n) (nat-listp lst)
+ (not (member-equal n lst)))
+ (equal (bfr-list->u (numlist-to-vars lst)
+ (bfr-set-var n x env))
+ (bfr-list->u (numlist-to-vars lst) env)))
+ :hints(("Goal" :in-theory (enable numlist-to-vars bfr-list->u
+ scdr s-endp
+ nat-listp member-equal)))))
+
(local
(defthm consp-numlist-to-vars
@@ -979,22 +925,48 @@
+;; (local
+;; (defthm v2i-redef
+;; (equal (v2i x)
+;; (if (atom x)
+;; 0
+;; (if (atom (cdr x))
+;; (if (car x) -1 0)
+;; (logcons (if (car x) 1 0) (v2i (cdr x))))))
+;; :hints(("Goal" :in-theory (enable v2i acl2::ash**))
+;; (and stable-under-simplificationp
+;; '(:in-theory (enable logcons))))
+;; :rule-classes ((:definition :clique (v2i)
+;; :controller-alist ((v2i t))))))
+
+;; (local
+;; (defthm v2n-redef
+;; (equal (v2n x)
+;; (if (atom x)
+;; 0
+;; (logcons (if (car x) 1 0) (v2n (cdr x)))))
+;; :hints(("Goal" :in-theory (enable v2n acl2::ash**))
+;; (and stable-under-simplificationp
+;; '(:in-theory (enable logcons))))
+;; :rule-classes ((:definition :clique (v2n)
+;; :controller-alist ((v2n t))))))
+
(local
(encapsulate nil
- (local (in-theory (e/d (ash) (floor))))
+ (local (in-theory (e/d* (acl2::ihsext-recursive-redefs) (floor))))
(defthm eval-slice-integer-env-slice
(implies (and (mv-nth 0 (integer-env-slice lst n))
(no-duplicatesp lst)
(integerp n)
(nat-listp lst))
- (equal (v2i (bfr-eval-list
+ (equal (bfr-list->s
(numlist-to-vars lst)
- (slice-to-bdd-env (mv-nth 1 (integer-env-slice lst n)) env)))
+ (slice-to-bdd-env (mv-nth 1 (integer-env-slice lst n)) env))
n))
:hints(("Goal" :in-theory (enable integer-env-slice
numlist-to-vars
bfr-eval-list
- v2i nat-listp
+ nat-listp scdr s-endp
slice-to-bdd-env
integer-env-slice
logbitp)
@@ -1005,19 +977,37 @@
(no-duplicatesp lst)
(natp n)
(nat-listp lst))
- (equal (v2n (bfr-eval-list
+ (equal (bfr-list->u
(numlist-to-vars lst)
- (slice-to-bdd-env (mv-nth 1 (natural-env-slice lst n)) env)))
+ (slice-to-bdd-env (mv-nth 1 (natural-env-slice lst n)) env))
n))
:hints(("Goal" :in-theory (enable natural-env-slice
numlist-to-vars
bfr-eval-list
- v2n nat-listp
+ nat-listp
slice-to-bdd-env
natural-env-slice
logbitp)
:induct (natural-env-slice lst n))))
+ ;; (defthm eval-slice-bfr-list->s-natural-env-slice
+ ;; (implies (and (mv-nth 0 (natural-env-slice lst n))
+ ;; (no-duplicatesp lst)
+ ;; (natp n)
+ ;; (nat-listp lst))
+ ;; (equal (bfr-list->s
+ ;; (numlist-to-vars lst)
+ ;; (slice-to-bdd-env (mv-nth 1 (natural-env-slice lst n)) env))
+ ;; n))
+ ;; :hints(("Goal" :in-theory (enable natural-env-slice
+ ;; numlist-to-vars
+ ;; bfr-eval-list
+ ;; nat-listp
+ ;; slice-to-bdd-env
+ ;; natural-env-slice
+ ;; logbitp)
+ ;; :induct (natural-env-slice lst n))))
+
(defthm realpart-when-imagpart-0
(implies (and (acl2-numberp x)
@@ -1056,6 +1046,64 @@
;; :hints(("Goal" :in-theory (enable gobjectp-def g-concrete-p tag)))
;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+;; (local (defthm loghead-non-integer
+;; (implies (not (integerp x))
+;; (equal (loghead n x) 0))
+;; :hints(("Goal" :in-theory (enable loghead)))
+;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+;; (local (defthm logcdr-non-integer
+;; (implies (not (integerp x))
+;; (equal (logcdr x) 0))
+;; :hints(("Goal" :in-theory (enable logcdr)))))
+
+
+(local (defun cdr-logcdr (bits x)
+ (if (atom bits)
+ x
+ (cdr-logcdr (cdr bits) (logcdr x)))))
+
+(defthm natural-env-slice-ok-of-loghead
+ (mv-nth 0 (natural-env-slice bits (loghead (len bits) x)))
+ :hints(("Goal" :in-theory (enable len acl2::loghead** acl2::logtail**)
+ :expand ((:free (x)(natural-env-slice bits x)))
+ :induct (cdr-logcdr bits x))))
+
+
+;; (defthm v2i-of-append
+;; (implies (consp b)
+;; (equal (v2i (append a b))
+;; (logapp (len a) (v2n a) (v2i b))))
+;; :hints(("Goal" :in-theory (e/d* (acl2::ihsext-recursive-redefs append len))
+;; :induct (append a b))))
+
+(defthm len-bfr-eval-list
+ (equal (len (bfr-eval-list x env)) (len x)))
+
+(defthm len-numlist-to-vars
+ (equal (len (numlist-to-vars bits)) (len bits))
+ :hints(("Goal" :in-theory (enable numlist-to-vars))))
+
+(defthm logapp-of-loghead
+ (equal (logapp n (loghead n x) y)
+ (logapp n x y))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs))))
+
+(defthm logapp-to-logtail
+ (equal (logapp n obj (logtail n obj))
+ (ifix obj))
+ :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs))))
+
+(defthm int-set-sign-of-own-sign
+ (implies (integerp x)
+ (equal (int-set-sign (< x 0) x)
+ x))
+ :hints(("Goal" :in-theory (e/d* (int-set-sign
+ acl2::ihsext-inductions
+ acl2::ihsext-recursive-redefs))))
+ :otf-flg t)
(local
@@ -1063,15 +1111,42 @@
(local (in-theory
(e/d () (;; gobjectp-tag-rw-to-types
;; gobjectp-ite-case
- ;; generic-geval-non-gobjectp
+ ;; sspec-geval-non-gobjectp
break-g-number
sets::double-containment))))
+
+ (local (defthm g-keyword-symbolp-of-shape-spec-to-gobj
+ (equal (g-keyword-symbolp (shape-spec-to-gobj x))
+ (g-keyword-symbolp x))
+ :hints(("Goal" :expand ((shape-spec-to-gobj x))))))
+ (local (defthm not-equal-shape-spec-to-gobj-keyword
+ (implies (and (not (g-keyword-symbolp x))
+ (g-keyword-symbolp y))
+ (not (equal (shape-spec-to-gobj x) y)))
+ :rule-classes ((:rewrite :backchain-limit-lst (0 1)))))
+ (local (defthm g-keyword-symbolp-compound-recognizer
+ (implies (g-keyword-symbolp x)
+ (and (symbolp x)
+ (not (booleanp x))))
+ :rule-classes :compound-recognizer))
+ (local (defthm shape-spec-to-gobj-when-atom
+ (implies (atom x)
+ (equal (shape-spec-to-gobj x) x))
+ :hints(("Goal" :in-theory (enable shape-spec-to-gobj)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+
+ (local (defthm kwote-lst-of-cons
+ (equal (kwote-lst (cons a b))
+ (cons (kwote a) (kwote-lst b)))))
+ (local (in-theory (disable kwote-lst)))
+
(defthm shape-spec-to-gobj-eval-slice
(implies (and (shape-specp x)
(no-duplicatesp (shape-spec-indices x))
(no-duplicatesp (shape-spec-vars x))
(mv-nth 0 (shape-spec-env-slice x obj)))
- (equal (generic-geval
+ (equal (sspec-geval
(shape-spec-to-gobj x)
(cons (slice-to-bdd-env
(mv-nth 1 (shape-spec-env-slice x obj))
@@ -1092,18 +1167,28 @@
(shape-spec-env-slice x obj))
:induct (shape-spec-env-slice x obj))
(and stable-under-simplificationp
- '(:in-theory (enable generic-geval break-g-number
+ '(:in-theory (enable slice-to-bdd-env)
+ :expand ((:free (x y env)
+ (sspec-geval (cons x y) env))
+ (:free (x y env)
+ (sspec-geval-list (cons x y) env)))))
+ (and stable-under-simplificationp
+ '(:in-theory (enable sspec-geval break-g-number
number-spec-env-slice
number-specp
number-spec-indices
- num-spec-to-num-gobj)))
- (and stable-under-simplificationp
- '(:in-theory (enable slice-to-bdd-env generic-geval)))))))
-
+ num-spec-to-num-gobj)))))))
+
(local
- (defthm alistp-shape-spec-arbitrary-slice-0
- (alistp (mv-nth 0 (shape-spec-arbitrary-slice x)))
- :hints(("Goal" :in-theory (enable shape-spec-arbitrary-slice)))))
+ (defthm-shape-spec-flag
+ (defthm alistp-shape-spec-arbitrary-slice-0
+ (alistp (mv-nth 0 (shape-spec-arbitrary-slice x)))
+ :flag ss)
+ (defthm alistp-shape-spec-list-arbitrary-slice-0
+ (alistp (mv-nth 0 (shape-spec-list-arbitrary-slice x)))
+ :flag list)
+ :hints(("Goal" :in-theory (enable shape-spec-arbitrary-slice
+ shape-spec-list-arbitrary-slice)))))
(local
(defthm alistp-shape-spec-iff-env-slice-1
@@ -1124,23 +1209,6 @@
(cons (slice-to-bdd-env bsl nil) vsl)))
-(defund shape-spec-obj-in-range-iff (x obj)
- (declare (xargs :guard (shape-specp x)
- :guard-hints(("Goal" :in-theory (enable shape-specp)))))
- (if (atom x)
- (iff x obj)
- (pattern-match x
- ((g-number &)
- obj)
- ((g-boolean &) t)
- ((g-var &) t)
- ((g-ite if then else)
- (or (and (shape-spec-obj-in-range-iff if t)
- (shape-spec-obj-in-range-iff then obj))
- (and (shape-spec-obj-in-range-iff if nil)
- (shape-spec-obj-in-range-iff else obj))))
- ((g-concrete y) (iff y obj))
- (& obj))))
(local
(defthm shape-spec-obj-in-range-iff-shape-spec-iff-env-slice
@@ -1149,50 +1217,33 @@
:hints(("Goal" :in-theory (enable shape-spec-obj-in-range-iff
shape-spec-iff-env-slice)))))
-(defund integer-in-range (vlist obj)
- (declare (xargs :guard t))
- (and (integerp obj)
- (if (atom vlist)
- (eql obj 0)
- (and (<= (- (ash 1 (len (cdr vlist)))) obj)
- (< obj (ash 1 (len (cdr vlist))))))))
(local
(encapsulate nil
- (local (include-book "ihs/ihs-lemmas" :dir :system))
(local (in-theory (e/d (ash) (floor))))
- (local (defthm expt-2-of-posp
- (implies (posp x)
- (integerp (* 1/2 (expt 2 x))))
- :rule-classes nil))
- (local
- (encapsulate nil
- (local (defthm rw-equal-minus
- (implies (and (posp x) (rationalp y))
- (equal (equal (expt 2 x) (- y))
- (equal (- (expt 2 x)) y)))))
- (defthm negative-expt-2-of-posp
- (implies (and (posp x) (rationalp y)
- (equal (expt 2 x) (- y)))
- (integerp (* 1/2 y)))
- :rule-classes nil)))
+ (local (include-book "ihs/ihs-lemmas" :dir :system))
+ ;; (local (defthm expt-2-of-posp
+ ;; (implies (posp x)
+ ;; (integerp (* 1/2 (expt 2 x))))
+ ;; :rule-classes nil))
+ ;; (local
+ ;; (encapsulate nil
+ ;; (local (defthm rw-equal-minus
+ ;; (implies (and (posp x) (rationalp y))
+ ;; (equal (equal (expt 2 x) (- y))
+ ;; (equal (- (expt 2 x)) y)))))
+ ;; (defthm negative-expt-2-of-posp
+ ;; (implies (and (posp x) (rationalp y)
+ ;; (equal (expt 2 x) (- y)))
+ ;; (integerp (* 1/2 y)))
+ ;; :rule-classes nil)))
(defthm integer-in-range-integer-env-slice
(implies (integerp obj)
(equal (mv-nth 0 (integer-env-slice vlist obj))
(integer-in-range vlist obj)))
- :hints(("Goal" :in-theory (enable integer-env-slice
- integer-in-range))
- ("Subgoal *1/4.4"
- :use ((:instance negative-expt-2-of-posp
- (x (+ 1 (len (cddr vlist))))
- (y obj))))))))
-
-(defund natural-in-range (vlist obj)
- (declare (xargs :guard t))
- (and (natp obj)
- (and (<= 0 obj)
- (< obj (ash 1 (len vlist))))))
+ :hints(("Goal" :in-theory (enable* integer-env-slice
+ integer-in-range))))))
(local
(encapsulate nil
@@ -1206,23 +1257,6 @@
:hints(("Goal" :in-theory (enable natural-env-slice
natural-in-range))))))
-(defund number-spec-in-range (nspec obj)
- (declare (xargs :guard (number-specp nspec)
- :guard-hints(("Goal" :in-theory (enable number-specp)))))
- (and (acl2-numberp obj)
- (integer-in-range (car nspec) (numerator (realpart obj)))
- (if (consp (cdr nspec))
- (and (natural-in-range (cadr nspec) (denominator (realpart obj)))
- (if (consp (cddr nspec))
- (and (integer-in-range
- (caddr nspec) (numerator (imagpart obj)))
- (if (consp (cdddr nspec))
- (natural-in-range
- (cadddr nspec) (denominator (imagpart obj)))
- (eql (denominator (imagpart obj)) 1)))
- (rationalp obj)))
- (integerp obj))))
-
(local
(defthm number-spec-in-range-number-spec-env-slice
(equal (mv-nth 0 (number-spec-env-slice nspec obj))
@@ -1230,32 +1264,13 @@
:hints(("Goal" :in-theory (enable number-spec-env-slice
number-spec-in-range)))))
-(defund shape-spec-obj-in-range (x obj)
- (declare (xargs :guard (shape-specp x)
- :guard-hints(("Goal" :in-theory (enable shape-specp)))))
- (if (atom x)
- (equal x obj)
- (pattern-match x
- ((g-number n) (number-spec-in-range n obj))
- ((g-boolean &) (booleanp obj))
- ((g-var &) t)
- ((g-concrete y) (equal y obj))
- ((g-ite if then else)
- (or (and (shape-spec-obj-in-range-iff if t)
- (shape-spec-obj-in-range then obj))
- (and (shape-spec-obj-in-range-iff if nil)
- (shape-spec-obj-in-range else obj))))
- (& (and (consp obj)
- (shape-spec-obj-in-range (car x) (car obj))
- (shape-spec-obj-in-range (cdr x) (cdr obj)))))))
-
(local
(defthm shape-spec-obj-in-range-env-slice
(iff (mv-nth 0 (shape-spec-env-slice x obj))
(shape-spec-obj-in-range x obj))
:hints(("Goal" :in-theory (enable shape-spec-obj-in-range
shape-spec-env-slice)))))
-
+
@@ -1264,7 +1279,7 @@
(no-duplicatesp (shape-spec-indices x))
(no-duplicatesp (shape-spec-vars x))
(shape-spec-obj-in-range x obj))
- (equal (generic-geval
+ (equal (sspec-geval
(shape-spec-to-gobj x)
(shape-spec-to-env x obj))
obj))
@@ -1273,17 +1288,17 @@
-(defun shape-spec-to-gobj-list (x)
- (if (atom x)
- nil
- (cons (shape-spec-to-gobj (car x))
- (shape-spec-to-gobj-list (cdr x)))))
-
-(defun shape-spec-listp (x)
- (if (atom x)
- (equal x nil)
- (and (shape-specp (car x))
- (shape-spec-listp (cdr x)))))
+;; (defun shape-spec-to-gobj-list (x)
+;; (if (atom x)
+;; nil
+;; (cons (shape-spec-to-gobj (car x))
+;; (shape-spec-to-gobj-list (cdr x)))))
+
+;; (defun shape-spec-listp (x)
+;; (if (atom x)
+;; (equal x nil)
+;; (and (shape-specp (car x))
+;; (shape-spec-listp (cdr x)))))
;; (defthm shape-spec-listp-impl-shape-spec-to-gobj-list
;; (implies (shape-spec-listp x)
@@ -1300,13 +1315,14 @@
(defthm shape-spec-listp-implies-shape-specp
(implies (shape-spec-listp x)
(shape-specp x))
- :hints(("Goal" :expand ((shape-specp x))
+ :hints(("Goal" :expand ((shape-specp x)
+ (shape-spec-listp x))
:in-theory (enable tag)
- :induct (shape-spec-listp x))))
+ :induct (len x))))
+
-
@@ -1369,6 +1385,9 @@
(defthm shape-spec-obj-in-range-open-cons
(implies (and (not (g-keyword-symbolp (car obj)))
+ (not (eq (car obj) :g-integer))
+ (not (eq (car obj) :g-integer?))
+ (not (eq (car obj) :g-call))
(consp obj))
(equal (shape-spec-obj-in-range obj (cons carx cdrx))
(and (shape-spec-obj-in-range (car obj) carx)
@@ -1376,7 +1395,7 @@
:hints(("Goal" :in-theory (enable shape-spec-obj-in-range
g-keyword-symbolp-def
member-equal)))
- :rule-classes ((:rewrite :backchain-limit-lst (1 0))))
+ :rule-classes ((:rewrite :backchain-limit-lst (1 0 0 0 0))))
(defun binary-and* (a b)
(declare (xargs :guard t))
@@ -1426,6 +1445,11 @@
(implies (consp X)
(natp (+ -1 (len x)))))
+(defthm shape-spec-obj-in-range-open-g-integer
+ (equal (shape-spec-obj-in-range `(:g-integer . ,rest) x)
+ (integerp x))
+ :hints(("Goal" :in-theory (enable shape-spec-obj-in-range))))
+
(defthm shape-spec-obj-in-range-open-integer
(equal (shape-spec-obj-in-range `(:g-number ,bits) x)
(if (consp bits)
@@ -1433,7 +1457,7 @@
(<= (- (expt 2 (1- (len bits)))) x)
(< x (expt 2 (1- (len bits)))))
(equal x 0)))
- :hints(("Goal" :in-theory (enable shape-spec-obj-in-range
+ :hints(("Goal" :in-theory (enable shape-spec-obj-in-range
number-spec-in-range
integer-in-range
g-number->num
@@ -1489,6 +1513,16 @@
(equal (shape-spec-obj-in-range lst obj) t)))
+(defthm shape-spec-obj-in-range-solve-integer?
+ (equal (shape-spec-obj-in-range `(:g-integer? . ,rest) x) t)
+ :hints(("Goal" :in-theory (enable shape-spec-obj-in-range))))
+
+(defthm shape-spec-obj-in-range-backchain-g-integer
+ (implies (integerp x)
+ (equal (shape-spec-obj-in-range `(:g-integer . ,rest) x)
+ t))
+ :hints(("Goal" :in-theory (enable shape-spec-obj-in-range))))
+
(defthm shape-spec-obj-in-range-backchain-integer-1
(implies (and (consp bits)
@@ -1543,16 +1577,18 @@
;; simplification approach. The backchain ruleset will be tried first to
;; reduce the goals to as few as possible clauses with conclusions that are
;; calls of shape-spec-obj-in-range on "atomic" shape specs (numbers, booleans,
-;; concretes.) Then shape-spec-obj-in-range-open will
+;; concretes.) Then shape-spec-obj-in-range-open will
(def-ruleset! shape-spec-obj-in-range-backchain
'(shape-spec-obj-in-range-open-cons
+ shape-spec-obj-in-range-solve-integer?
+ shape-spec-obj-in-range-backchain-g-integer
shape-spec-obj-in-range-backchain-integer-1
shape-spec-obj-in-range-backchain-integer-2
shape-spec-obj-in-range-backchain-boolean
shape-spec-obj-in-range-backchain-concrete
shape-spec-obj-in-range-backchain-atom
shape-spec-obj-in-range-backchain-list-of-g-booleans
- shape-spec-obj-in-range-var
+ shape-spec-obj-in-range-var
car-cons cdr-cons natp-compound-recognizer
(shape-spec-obj-in-range) (g-keyword-symbolp) (ash)
(expt) (unary--) (binary-+) (consp) (integerp) (len)
@@ -1561,6 +1597,8 @@
(def-ruleset! shape-spec-obj-in-range-open
'(shape-spec-obj-in-range-open-cons
+ shape-spec-obj-in-range-solve-integer?
+ shape-spec-obj-in-range-open-g-integer
shape-spec-obj-in-range-open-integer
shape-spec-obj-in-range-open-boolean
shape-spec-obj-in-range-open-concrete
@@ -1575,108 +1613,862 @@
(expt) (unary--) (binary-+) (consp) (integerp) (len)
(car) (cdr) (booleanp) (list-of-g-booleansp) (tag) eql
len-plus-one len-zero (zp) (boolean-listp) (true-listp)))
-
-(defdoc shape-specs ":Doc-section ACL2::GL
-Simplified symbolic objects useful for coverage proofs in GL~/
+(defxdoc shape-specs
+ :parents (reference)
+ :short "Simplified symbolic objects useful for coverage proofs in GL."
+
+ :long "Shape specifiers are a simplified format of GL symbolic objects,
+capable of representing Booleans, numbers, conses, free variables, and function
+calls. While less expressive than full-fledged symbolic objects, shape spec
+objects make it easier to prove coverage lemmas necessary for proving theorems
+by symbolic simulation. Here, we document common constructions of shape-spec
+objects and what it means to prove coverage.
+
+Creating Shape Spec Objects
+
+Shape spec objects are analogues of symbolic objects , but with several tweaks that make
+it more straightforward to prove that a given concrete object is covered:
+
+Symbolic objects contain arbitrary Boolean formulas (BDDs or AIGs), whereas
+shape specifiers are restricted to contain only independent Boolean variables.
+Therefore, every bit in a shape specifier is independent from every other
+bit.
+The @(':g-apply') symbolic object construct is replaced by the @(':g-call')
+shape specifier construct. The @(':g-call') object has an additional field that holds a
+user-provided inverse function, which is useful for proving coverage; see @(see
+g-call).
+
+
+Shape spec objects may be created using the following constructors
+ (roughly in order of usefulness). Additionally, a non-keyword atom is a shape
+spec representing itself:
+
+
+
+@('(G-BOOLEAN )')
+
+Represents a Boolean. @('num') (a natural number) may not be repeated in
+any other @(':G-BOOLEAN') or @(':G-NUMBER') construct in the shape-spec.
+
+@('(G-NUMBER (list ))')
+
+Represents a two's-complement integer with bits corresponding to the list,
+least significant bit first. Rationals and complex rationals are also
+available; @(see SYMBOLIC-OBJECTS). A :G-NUMBER construct with a list of
+length @('N') represents integers @('X') where @('(<= (- (expt 2 n)) x)') and
+@('(< x (expt 2 n))'). The @('list-of-nums') must be natural numbers, may not
+repeat, and may not occur in any other @(':G-BOOLEAN') or @(':G-NUMBER')
+construct.
+
+@('(cons )')
+
+Represents a cons; Car and Cdr should be well-formed shape specifiers.
+
+@('(G-VAR )')
+
+A free variable that may represent any object. This is primarily useful
+when using GL's term-level capabilities; see @(see term-level-reasoning).
+
+@('(G-CALL )')
+
+Represents a call of the named function applied to the given arguments.
+The @('inverse') does not affect the symbolic object generated, which is
+@('(:G-APPLY . )'), but is used in the coverage proof; see
+@(see g-call). This construct is primarily useful when using GL's term-level
+capabilities; see @(see term-level-reasoning).
+
+@('(G-ITE )')
+Represents an if/then/else, where @('test'), @('then'), and @('else') are
+shape specs.
+
+
+
+
+What is a Coverage Proof?
+
+In order to prove a theorem by symbolic simulation, one binds each variable
+mentioned in the theorem to a symbolic object and then symbolically simulates
+the conclusion of the theorem on these symbolic objects. If the result is
+true, what can we conclude? It depends on the coverage of the symbolic inputs.
+For example, one might symbolically simulate the term @('(< (+ A B) 7)') with
+@('A') and @('B') bound to symbolic objects representing two-bit natural
+numbers and recieve a result of @('T'). From this, it would be fallacious to
+conclude @('(< (+ 6 8) 7)'), because the symbolic simulation didn't cover the
+case where @('A') was 6 and @('B') 7. In fact, it isn't certain that we can
+conclude @('(< (+ 2 2) 7)') from our symbolic simulation, because the symbolic
+object bindings for @('A') and @('B') might have interedependencies such that
+@('A') and @('B') can't simultaneously represent 2. (For example, the bindings
+could be such that bit 0 of @('A') and @('B') are always opposite.) In order
+to prove a useful theorem from the result of such a symbolic simulation, we
+must show that some set of concrete input vectors is covered by the symbolic
+objects bound to @('A') and @('B'). But in general, it is a tough
+computational problem to determine the set of concrete input vectors that are
+covered by a given symbolic input vector.
+
+To make these determinations easier, shape spec objects are somewhat
+restricted. Whereas symbolic objects generally use BDDs (or AIGs, depending on
+the mode ) to represent
+individual Booleans or bits of numeric values (see @(see symbolic-objects)),
+shape specs instead use natural numbers representing Boolean variables.
+Additionally, shape specs are restricted such that no Boolean variable number may
+be used more than once among the bindings for the variables of a theorem; this
+prevents interdependencies among them.
+
+While in general it is a difficult problem to determine whether a symbolic
+object can evaluate to a given concrete object, a function
+@('SHAPE-SPEC-OBJ-IN-RANGE') can make that determination about shape specs.
+@('SHAPE-SPEC-OBJ-IN-RANGE') takes two arguments, a shape spec and some object,
+and returns T if that object is in the coverage set of the shape spec, and NIL
+otherwise. Therefore, if we wish to conclude that shape specs bound to @('A')
+and @('B') cover all two-bit natural numbers, we may prove the following
+theorem:
-Shape specifiers are a simplified format of GL symbolic objects,
-capable of representing Booleans, numbers, and conses, as well as
-unconstrained variables and if-then-else objects. While less
-expressive than full-fledged symbolic objects, shape spec objects make
-it easier to prove coverage lemmas necessary for proving theorems by
-symbolic simulation. Here, we document common constructions of
-shape-spec objects and what it means to prove coverage.~/
-
-------------------------------------------------------
-
-CREATING SHAPE SPEC OBJECTS
-Shape spec objects are a straightforward transformation of symbolic
-objects: wherever a BDD occurs in a symbolic object, a shape specifier
-instead contains a natural number representing a BDD variable.
-Furthermore, ~c[G-APPLY] constructs are prohibited, and the BDD
-variable numbers used in an shape spec may not repeat, nor may the
-variable names used in ~c[G-VAR] constructs. See
-~il[GL::SYMBOLIC-OBJECTS]. The most common and useful constructions
-of shape spec objects are as follows:
-
- (:G-BOOLEAN . )
-Represents a Boolean.
-
- (:G-NUMBER )
-Represents a two's-complement integer with bits corresponding to the
-list, least significant bit first. Rationals and complex rationals
-are also available; ~l[GL::SYMBOLIC-OBJECTS]. A :G-NUMBER construct with
-a list of length ~c[N] represents integers ~c[X] where
- ~c[(<= (- (expt 2 n) x)] and ~c[(< x (expt 2 n))].
-
- ( . )
-Represents a cons; Car and Cdr should be well-formed shape specifiers.
-
-
-Represents the atom itself; must not be one of the six distinguished
-keyword symbols :G-CONCRETE, :G-BOOLEAN, :G-NUMBER, :G-ITE, :G-VAR, or
-:G-APPLY.
-
-------------------------------------------------------
-
-WHAT IS A COVERAGE PROOF?
-In order to prove a theorem by symbolic simulation, one binds each
-variable mentioned in the theorem to a symbolic object and then
-symbolically simulates the conclusion of the theorem on these symbolic
-objects. If the result is true, what can we conclude? It depends on
-the coverage of the symbolic inputs. For example, one might
-symbolically simulate the term ~c[(< (+ A B) 7)] with ~c[A] and ~c[B]
-bound to symbolic objects representing two-bit natural numbers and
-recieve a result of ~c[T]. From this, it would be fallacious to
-conclude ~c[(< (+ 6 8) 7)], because the symbolic simulation didn't
-cover the case where ~c[A] was 6 and ~c[B] 7. In fact, it isn't
-certain that we can conclude ~c[(< (+ 2 2) 7)] from our symbolic
-simulation, because the symbolic object bindings for ~c[A] and ~c[B]
-might have interedependencies such that ~c[A] and ~c[B] can't
-simultaneously represent 2. (For example, the bindings could be such
-that bit 0 of ~c[A] and ~c[B] are always opposite.) In order to prove
-a useful theorem from the result of such a symbolic simulation, we
-must show that some set of concrete input vectors is covered by the
-symbolic objects bound to ~c[A] and ~c[B]. But in general, it is a
-tough computational problem to determine the set of concrete input
-vectors that are covered by a given symbolic input vector.
-
-To make these determinations easier, shape spec objects are somewhat
-restricted. Whereas symbolic objects generally use BDDs to represent
-individual Booleans or bits of numeric values (~l[GL::SYMBOLIC-OBJECTS]),
-shape specs instead use natural numbers representing UBDD variables.
-Additionally, shape specs are restricted such that no BDD variable
-number may be used more than once among the bindings for the variables
-of a theorem; this is to prevent interdependencies among them.
-
-While in general it is a difficult problem to determine whether a
-symbolic object can evaluate to a given concrete object, a function
-~c[SHAPE-SPEC-OBJ-IN-RANGE] can make that determination about shape
-specs. ~c[SHAPE-SPEC-OBJ-IN-RANGE] takes two arguments, a shape spec
-and some object, and returns T if that object is in the coverage set
-of the shape spec, and NIL otherwise. Therefore, if we wish to
-conclude that shape specs bound to ~c[A] and ~c[B] cover all two-bit
-natural numbers, we may prove the following theorem:
-~bv[]
+@({
(implies (and (natp a) (< a 4)
(natp b) (< b 4))
(shape-spec-obj-in-range (list a-binding b-binding)
(list a b)))
-~ev[]
+})
+
+When proving a theorem using the GL clause processor, variable bindings are
+given as shape specs so that coverage obligations may be stated in terms of
+@('SHAPE-SPEC-OBJ-IN-RANGE'). The shape specs are converted to symbolic
+objects and may be parametrized based on some restrictions from the hypotheses,
+restricting their range further. Thus, in order to prove a theorem about
+fixed-length natural numbers, for example, one may provide a shape specifier
+that additionally covers negative integers of the given length; parametrization
+can then restrict the symbolic inputs used in the simulation to only cover the
+naturals, while the coverage proof may still be done using the simpler,
+unparametrized shape spec.
")
+
+(defxdoc g-call
+ :parents (shape-specs term-level-reasoning)
+ :short "A shape-spec representing a function call."
+ :long
+ "Note: This is an advanced topic. You should first read @(see
+term-level-reasoning) to see whether this is of interest, then be familiar with
+@(see shape-specs) before reading this.
+
+@('G-CALL') is the constructor for a shape-spec representing a function
+call. Usage:
+
+@({
+ (g-call
+
+ )
+ })
+
+This yields a G-APPLY object (see @(see symbolic-objects)):
+@({
+ (g-apply
+ )
+ })
+
+The inverse function field does not affect the symbolic object that is
+generated from the g-call object, but it determines how we attempt to prove the
+coverage obligation.
+
+The basic coverage obligation for assigning some variable V a shape spec SS
+is that for every possible value of V satisfying the hypotheses, there must be
+an environment under which the symbolic object derived from SS evaluates to
+that value. The coverage proof must show that there exists such an
+environment.
+
+Providing an inverse function INV basically says:
+
+
+ \"If we need (FN ARGS) to evaluate to VAL, then ARGS should be (INV VAL).\"
+
+
+So to prove that (G-CALL FN ARGS INV) covers VAL, we first prove that ARGS
+cover (INV VAL), then that (FN (INV VAL)) equals VAL. The argument that this
+works is:
+
+
+
+We first prove ARGS covers (INV VAL) -- that is, there exists some
+environment E under which the symbolic objects derived from ARGS evaluate
+to (INV VAL).
+
+Since (FN (INV VAL)) equals VAL, this same environment E suffices to make
+the symbolic object (FN ARGS) evaluate to VAL.
+
+
+
+We'll now show an example. We build on the memory example discussed in @(see
+term-level-reasoning). Suppose we want to initially assign a memory object
+@('mem') a symbolic value under which address 1 has been assigned a 10-bit
+integer. That is, we want to be able to assume only the following about
+@('mem'):
+
+@({
+ (signed-byte-p 10 (access-mem 1 mem))
+ })
+
+Assuming our memory follows the standard record rules, i.e.
+
+@({
+ (update-mem addr (access-mem addr mem) mem) = mem,
+})
+
+we can represent any such memory as
+
+@({
+ (update-mem 1 )
+})
+
+Our shape-spec for this will therefore be:
+
+@({
+ (g-call 'update-mem
+ (list 1
+ (g-number (list 0 1 2 3 4 5 6 7 8 9)) ;; 10-bit integer
+ (g-var 'mem)) ;; free variable
+ )
+})
+
+What is an appropriate inverse? The inverse needs to take any memory
+satisfying our assumption and generate the list of necessary arguments to
+update-mem that fit this template. The following works:
+
+@({
+ (lambda (m) (list 1 (access-mem 1 m) m))
+})
+
+because for any value m satisfying our assumptions,
+
+
+
+the first argument returned is 1, which is covered by our shape-spec 1
+
+the second argument returned will (by the assumption) be a 10-bit integer,
+which is covered by our g-number shape-spec
+
+the third argument returned matches our g-var shape-spec since anything at
+all is covered by it
+
+the final term we end up with is:
+@({
+ (update-mem 1 (access-mem 1 m) m)
+})
+ which (by the record rule above) equals m.
+
+
+
+GL tries to manage coverage proofs itself, and when using G-CALL constructs
+some rules besides the ones it typically uses may be necessary -- for example,
+the redundant record update rule used here. You may add these rules to the
+rulesets used for coverage proofs as follows:
+
+@({
+ (acl2::add-to-ruleset gl::shape-spec-obj-in-range-backchain
+ redundant-mem-update)
+ (acl2::add-to-ruleset gl::shape-spec-obj-in-range-open
+ redundant-mem-update)
+})
+
+There are two rulesets because these are used in slightly different phases of
+the coverage proof.
+
+This feature has not yet been widely used and the detailed mechanisms
+for (e.g.) adding rules to the coverage strategy are likely to change.
")
+
+
+
+
+
+(defund shape-spec-call-free (x)
+ (declare (xargs :guard t))
+ (or (atom x)
+ (pattern-match x
+ ((g-number &) t)
+ ((g-boolean &) t)
+ ((g-integer & & &) t)
+ ((g-integer? & & & &) t)
+ ((g-var &) t)
+ ((g-ite test then else)
+ (and (shape-spec-call-free test)
+ (shape-spec-call-free then)
+ (shape-spec-call-free else)))
+ ((g-concrete &) t)
+ ((g-call & & &) nil)
+ (& (and (shape-spec-call-free (car x))
+ (shape-spec-call-free (cdr x)))))))
+
+(local
+ (defsection shape-spec-call-free
+
+
+ (local (in-theory (enable shape-spec-call-free)))
+
+ (defthm shape-spec-call-free-by-tag
+ (implies (and (or (g-keyword-symbolp (tag x))
+ (member (tag x) '(:g-integer :g-integer?)))
+ (not (eq (tag x) :g-ite))
+ (not (eq (tag x) :g-apply))
+ (not (eq (tag x) :g-call)))
+ (shape-spec-call-free x))
+ :hints(("Goal" :in-theory (enable g-keyword-symbolp))))
+
+ (Defthm shape-spec-call-free-when-atom
+ (implies (not (consp x))
+ (shape-spec-call-free x))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))))
+
+(defsection car-term
+ (defund car-term (x)
+ (declare (xargs :guard (pseudo-termp x)))
+ (if (and (consp x)
+ (eq (car x) 'cons))
+ (cadr x)
+ `(car ,x)))
+ (local (in-theory (enable car-term)))
+ (defthm pseudo-termp-car-term
+ (implies (pseudo-termp x)
+ (pseudo-termp (car-term x))))
+
+ (defthm car-term-correct
+ (equal (sspec-geval-ev (car-term x) a)
+ (car (sspec-geval-ev x a)))))
+
+(defsection cdr-term
+ (defund cdr-term (x)
+ (declare (xargs :guard (pseudo-termp x)))
+ (if (and (consp x)
+ (eq (car x) 'cons))
+ (caddr x)
+ `(cdr ,x)))
+ (local (in-theory (enable cdr-term)))
+ (defthm pseudo-termp-cdr-term
+ (implies (pseudo-termp x)
+ (pseudo-termp (cdr-term x))))
+
+ (defthm cdr-term-correct
+ (equal (sspec-geval-ev (cdr-term x) a)
+ (cdr (sspec-geval-ev x a)))))
+
+
+
+(defsection make-nth-terms
+ (defund make-nth-terms (x start n)
+ (declare (xargs :guard (and (natp start) (natp n))))
+ (if (zp n)
+ nil
+ (cons `(nth ',(lnfix start) ,x)
+ (make-nth-terms x (1+ (lnfix start)) (1- n)))))
+
+ (local (in-theory (enable make-nth-terms)))
+
+ (defthm pseudo-term-listp-make-nth-terms
+ (implies (and (pseudo-termp x)
+ (natp start))
+ (pseudo-term-listp (make-nth-terms x start n)))
+ :hints(("Goal" :in-theory (enable make-nth-terms))))
+
+ (defthm ev-of-make-nth-terms
+ (equal (sspec-geval-ev-lst (make-nth-terms x start n) a)
+ (take n (nthcdr start (sspec-geval-ev x a))))
+ :hints(("Goal" :in-theory (enable acl2::take-redefinition
+ nthcdr)))))
+
+(defsection shape-spec-oblig-term
+
+ ;; (defund sspec-apply-get-inverse-fn (fn state)
+ ;; (declare (xargs :stobjs state))
+ ;; (b* ((inverse (cdr (hons-assoc-equal fn (table-alist
+ ;; 'gl-inverse-functions (w
+ ;; state))))))
+ ;; (and (symbolp inverse)
+ ;; (not (eq inverse 'quote))
+ ;; inverse)))
+
+ ;; (defthm sspec-apply-get-inverse-type
+ ;; (symbolp (sspec-apply-get-inverse-fn fn state))
+ ;; :hints(("Goal" :in-theory (enable sspec-apply-get-inverse-fn)))
+ ;; :rule-classes :type-prescription)
+
+ ;; (defthm sspec-apply-get-inverse-not-equote
+ ;; (not (equal (sspec-apply-get-inverse-fn fn state) 'quote))
+ ;; :hints(("Goal" :in-theory (enable sspec-apply-get-inverse-fn))))
+
+ (definlined ss-unary-function-fix (x)
+ (declare (xargs :guard (ss-unary-functionp x)))
+ (mbe :logic (if (ss-unary-functionp x)
+ x
+ nil)
+ :exec x))
+
+ (defthm ss-unary-functionp-of-ss-unary-function-fix
+ (ss-unary-functionp (ss-unary-function-fix x))
+ :hints(("Goal" :in-theory (enable ss-unary-function-fix))))
+
+ (defthm pseudo-termp-with-unary-function
+ (implies (and (ss-unary-functionp f)
+ (pseudo-termp arg))
+ (pseudo-termp (list f arg)))
+ :hints(("Goal" :in-theory (enable ss-unary-functionp))))
+
+ (mutual-recursion
+ (defun shape-spec-oblig-term (x obj-term iff-flg)
+ (declare (xargs :guard (and (shape-specp x)
+ (pseudo-termp obj-term))
+ :guard-hints (("goal" :expand ((shape-specp x)
+ (shape-spec-listp x)
+ (:free (a b) (pseudo-termp
+ (cons a b))))
+ :in-theory (disable pseudo-termp)))
+ :guard-debug t))
+ (if (shape-spec-call-free x)
+ `(,(if iff-flg 'shape-spec-obj-in-range-iff 'shape-spec-obj-in-range)
+ ',x ,obj-term)
+ (pattern-match x
+ ((g-ite test then else)
+ `(if (if ,(shape-spec-oblig-term test ''t t)
+ ,(shape-spec-oblig-term then obj-term iff-flg)
+ 'nil)
+ 't
+ (if ,(shape-spec-oblig-term test ''nil t)
+ ,(shape-spec-oblig-term else obj-term iff-flg)
+ 'nil)))
+ ((g-call fn args inverse)
+ (b* ((inverse (ss-unary-function-fix inverse))
+ (arity (len args))
+ (inverse-term `(,inverse ,obj-term))
+ (nths (make-nth-terms inverse-term 0 arity)))
+ `(if ,(shape-spec-list-oblig-term args nths)
+ (,(if iff-flg 'iff 'equal)
+ (,fn . ,nths)
+ ,obj-term)
+ 'nil)))
+ (& (if iff-flg
+ obj-term
+ `(if (consp ,obj-term)
+ (if ,(shape-spec-oblig-term (car x) (car-term obj-term) nil)
+ ,(shape-spec-oblig-term (cdr x) (cdr-term obj-term) nil)
+ 'nil)
+ 'nil))))))
+ (defun shape-spec-list-oblig-term (x obj-terms)
+ (declare (xargs :guard (and (shape-spec-listp x)
+ (pseudo-term-listp obj-terms))))
+ (if (atom x)
+ (if (eq obj-terms nil)
+ ''t
+ ''nil)
+ (if (consp obj-terms)
+ `(if ,(shape-spec-oblig-term (car x) (car obj-terms) nil)
+ ,(shape-spec-list-oblig-term (cdr x) (cdr obj-terms))
+ 'nil)
+ ''nil))))
+
+
+
+ (mutual-recursion
+ (defun shape-spec-env-term (x obj-term iff-flg)
+ (declare (xargs :guard (and (shape-specp x)
+ (pseudo-termp obj-term))
+ :guard-hints (("goal" :expand ((shape-specp x)
+ (shape-spec-listp x)
+ (:free (a b) (pseudo-termp
+ (cons a b))))
+ :in-theory (disable pseudo-termp)))
+ :guard-debug t))
+ (if (shape-spec-call-free x)
+ `(shape-spec-slice-to-env
+ (,(if iff-flg 'shape-spec-iff-env-slice 'shape-spec-env-slice)
+ ',x ,obj-term))
+ (pattern-match x
+ ((g-ite test then else)
+ (b* ((then-term (shape-spec-env-term then obj-term iff-flg))
+ (else-term (shape-spec-env-term else obj-term iff-flg))
+ (both `(ss-append-envs ,then-term ,else-term)))
+ `(if (if ,(shape-spec-oblig-term test ''t t)
+ ,(shape-spec-oblig-term then obj-term iff-flg)
+ 'nil)
+ (ss-append-envs
+ ,(shape-spec-env-term test ''t t)
+ ,both)
+ (ss-append-envs
+ ,(shape-spec-env-term test ''nil t)
+ ,both))))
+ ((g-call & args inverse)
+ (b* ((inverse (ss-unary-function-fix inverse))
+ (inverse-term `(,inverse ,obj-term))
+ (nths (make-nth-terms inverse-term 0 (len args))))
+ (shape-spec-list-env-term args nths)))
+ (& `(ss-append-envs
+ ,(shape-spec-env-term (car x) (car-term obj-term) nil)
+ ,(shape-spec-env-term (cdr x) (cdr-term obj-term) nil))))))
+ (defun shape-spec-list-env-term (x obj-terms)
+ (declare (xargs :guard (and (shape-spec-listp x)
+ (pseudo-term-listp obj-terms))))
+ (if (atom x)
+ ''(nil)
+ `(ss-append-envs
+ ,(shape-spec-env-term (car x) (car obj-terms) nil)
+ ,(shape-spec-list-env-term (cdr x) (cdr obj-terms))))))
+
+ (local (in-theory (enable shape-spec-oblig-term shape-spec-env-term)))
+
+
+ (flag::make-flag shape-spec-term-flag shape-spec-env-term
+ :flag-mapping ((shape-spec-env-term . ss)
+ (shape-spec-list-env-term . list)))
+ (defthm-shape-spec-term-flag
+ (defthm pseudo-termp-shape-spec-oblig-term
+ (implies (and (pseudo-termp obj-term)
+ (shape-specp x))
+ (pseudo-termp (shape-spec-oblig-term x obj-term iff-flg)))
+ :flag ss)
+ (defthm pseudo-term-listp-shape-spec-oblig-term
+ (implies (and (pseudo-term-listp obj-terms)
+ (shape-spec-listp x))
+ (pseudo-termp (shape-spec-list-oblig-term x obj-terms)))
+ :flag list)
+ :hints(("Goal" ;;:induct (shape-spec-oblig-term x obj-term iff-flg)
+ :in-theory (disable pseudo-termp)
+ :expand ((shape-specp x)
+ (shape-spec-listp x)
+ (:free (a b) (pseudo-termp (cons a b)))))))
+
+ (defthm-shape-spec-term-flag
+ (defthm pseudo-termp-shape-spec-env-term
+ (implies (and (pseudo-termp obj-term)
+ (shape-specp x))
+ (pseudo-termp (shape-spec-env-term x obj-term iff-flg)))
+ :flag ss)
+ (defthm pseudo-termp-shape-spec-list-env-term
+ (implies (and (pseudo-term-listp obj-terms)
+ (shape-spec-listp x))
+ (pseudo-termp (shape-spec-list-env-term x obj-terms)))
+ :flag list)
+ :hints(("Goal" ;; :induct (shape-spec-env-term x obj-term iff-flg)
+ :in-theory (disable pseudo-termp)
+ :expand ((shape-specp x)
+ (shape-spec-listp x)
+ (:free (a b) (pseudo-termp (cons a b)))))))
+
+ (defthm-shape-spec-term-flag
+ (defthm indices-of-shape-spec-env-term
+ (implies (shape-specp x)
+ (equal (strip-cars
+ (car (sspec-geval-ev (shape-spec-env-term x obj-term iff-flg) a)))
+ (shape-spec-indices x)))
+ :flag ss)
+ (defthm indices-of-shape-spec-list-env-term
+ (implies (shape-spec-listp x)
+ (equal (strip-cars
+ (car (sspec-geval-ev (shape-spec-list-env-term x obj-terms) a)))
+ (shape-spec-list-indices x)))
+ :flag list)
+ :hints (("goal" ;; :induct (shape-spec-env-term x obj-term iff-flg)
+ :expand ((shape-spec-indices x)
+ (shape-spec-list-indices x)
+ (shape-specp x)
+ (shape-spec-listp x)))
+ (and stable-under-simplificationp
+ '(:use ((:instance shape-spec-indices-subset-cars-env-slice
+ (obj (sspec-geval-ev obj-term a)))
+ (:instance shape-spec-indices-subset-cars-iff-env-slice
+ (obj (sspec-geval-ev obj-term a))))
+ :in-theory (disable shape-spec-indices-subset-cars-env-slice
+ shape-spec-indices-subset-cars-iff-env-slice)))))
+
+ (defthm-shape-spec-term-flag
+ (defthm vars-of-shape-spec-env-term
+ (implies (shape-specp x)
+ (equal (strip-cars
+ (cdr (sspec-geval-ev (shape-spec-env-term x obj-term iff-flg) a)))
+ (shape-spec-vars x)))
+ :flag ss)
+ (defthm vars-of-shape-spec-list-env-term
+ (implies (shape-spec-listp x)
+ (equal (strip-cars
+ (cdr (sspec-geval-ev (shape-spec-list-env-term x obj-terms) a)))
+ (shape-spec-list-vars x)))
+ :flag list)
+ :hints (("goal" ;; :induct (shape-spec-env-term x obj-term iff-flg)
+ :expand ((shape-spec-vars x)
+ (shape-spec-list-vars x)
+ (shape-specp x)
+ (shape-spec-listp x)))
+ (and stable-under-simplificationp
+ '(:use ((:instance shape-spec-vars-subset-cars-env-slice
+ (obj (sspec-geval-ev obj-term a)))
+ (:instance shape-spec-vars-subset-cars-iff-env-slice
+ (obj (sspec-geval-ev obj-term a))))
+ :in-theory (disable shape-spec-vars-subset-cars-env-slice
+ shape-spec-vars-subset-cars-iff-env-slice)))))
+
+
+ (defthm-shape-spec-term-flag
+ (defthm alistp-car-shape-spec-env-term
+ (alistp (car (sspec-geval-ev (shape-spec-env-term x obj-term iff-flg)
+ a)))
+ :flag ss)
+ (defthm alistp-car-shape-spec-list-env-term
+ (alistp (car (sspec-geval-ev (shape-spec-list-env-term x obj-terms)
+ a)))
+ :flag list))
+
+ (defthm-shape-spec-term-flag
+ (defthm alistp-cdr-shape-spec-env-term
+ (alistp (cdr (sspec-geval-ev (shape-spec-env-term x obj-term iff-flg)
+ a)))
+ :flag ss)
+ (defthm alistp-cdr-shape-spec-list-env-term
+ (alistp (cdr (sspec-geval-ev (shape-spec-list-env-term x obj-terms)
+ a)))
+ :flag list))
+
+ (local (defthm g-keyword-symbolp-of-shape-spec-to-gobj
+ (equal (g-keyword-symbolp (shape-spec-to-gobj x))
+ (g-keyword-symbolp x))
+ :hints(("Goal" :expand ((shape-spec-to-gobj x))))))
+
+ ;; (local (defthm equal-keyword-shape-spec-to-gobj
+ ;; (implies (and (syntaxp (quotep key))
+ ;; (g-keyword-symbolp key))
+ ;; (equal (equal (shape-spec-to-gobj x) key)
+ ;; (equal x key)))
+ ;; :hints(("Goal" :in-theory (enable shape-spec-to-gobj)))))
+
+ (defthm sspec-geval-of-gl-cons
+ (equal (sspec-geval (gl-cons a b) env)
+ (cons (sspec-geval a env)
+ (sspec-geval b env)))
+ :hints(("Goal" :in-theory (enable sspec-geval g-keyword-symbolp))))
+
+ (defthm sspec-geval-of-g-apply
+ (implies (not (eq fn 'quote))
+ (equal (sspec-geval (g-apply fn args) env)
+ (sspec-geval-ev (cons fn (kwote-lst (sspec-geval-list args env))) nil)))
+ :hints(("Goal" :in-theory (enable sspec-geval g-keyword-symbolp))))
+
+
+ ;; (local (defthm non-keyword-symbol-by-shape-spec-call-free
+ ;; (implies (and (not (shape-spec-call-free x))
+ ;; (not (eq (tag x) :g-ite))
+ ;; (not (eq (tag x) :g-apply)))
+ ;; (not (g-keyword-symbolp (tag x))))
+ ;; :hints(("Goal" :in-theory (enable g-keyword-symbolp)))))
+
+
+ (local (in-theory (disable shape-spec-call-free)))
+
+ (local (in-theory (disable iff kwote-lst)))
+
+ (local
+ (progn
+
+ (defthm shape-spec-to-gobj-of-cons
+ (implies (and (not (shape-spec-call-free x))
+ (not (member (tag x) '(:g-ite :g-call))))
+ (equal (shape-spec-to-gobj x)
+ (gl-cons (shape-spec-to-gobj (car x))
+ (shape-spec-to-gobj (cdr x)))))
+ :hints(("Goal" :in-theory (enable shape-spec-to-gobj))))
+
+ (defthm shape-spec-indices-of-cons
+ (implies (and (not (shape-spec-call-free x))
+ (not (member (tag x) '(:g-ite :g-call))))
+ (equal (shape-spec-indices x)
+ (append (shape-spec-indices (car x))
+ (shape-spec-indices (cdr x)))))
+ :hints(("Goal" :in-theory (enable shape-spec-indices))))
+
+ (defthm shape-spec-vars-of-cons
+ (implies (and (not (shape-spec-call-free x))
+ (not (member (tag x) '(:g-ite :g-call))))
+ (equal (shape-spec-vars x)
+ (append (shape-spec-vars (car x))
+ (shape-spec-vars (cdr x)))))
+ :hints(("Goal" :in-theory (enable shape-spec-vars))))
+
+ (defthm shape-specp-car/cdr
+ (implies (and (not (shape-spec-call-free x))
+ (not (member (tag x) '(:g-ite :g-call)))
+ (shape-specp x))
+ (and (shape-specp (car x))
+ (shape-specp (cdr x))))
+ :hints(("Goal" :in-theory (enable shape-specp))))
+
+ (defthm shape-spec-to-gobj-of-g-call
+ (implies (equal (tag x) :g-call)
+ (equal (shape-spec-to-gobj x)
+ (g-apply (g-call->fn x)
+ (shape-spec-to-gobj-list (g-call->args x)))))
+ :hints(("Goal" :in-theory (enable shape-spec-to-gobj))))
+
+ (defthm shape-spec-indices-of-g-call
+ (implies (equal (tag x) :g-call)
+ (equal (shape-spec-indices x)
+ (shape-spec-list-indices (g-call->args x))))
+ :hints(("Goal" :in-theory (enable shape-spec-indices))))
+
+ (defthm shape-spec-vars-of-g-call
+ (implies (equal (tag x) :g-call)
+ (equal (shape-spec-vars x)
+ (shape-spec-list-vars (g-call->args x))))
+ :hints(("Goal" :in-theory (enable shape-spec-vars))))
+
+ (defthm shape-specp-g-call
+ (implies (and (equal (tag x) :g-call)
+ (shape-specp x))
+ (and (shape-spec-listp (g-call->args x))
+ (symbolp (g-call->fn x))
+ (not (equal (g-call->fn x) 'quote))
+ (ss-unary-functionp (g-call->inverse x))))
+ :hints(("Goal" :in-theory (enable shape-specp))))
+
+ (defthm shape-spec-to-gobj-of-g-ite
+ (implies (equal (tag x) :g-ite)
+ (equal (shape-spec-to-gobj x)
+ (g-ite (shape-spec-to-gobj (g-ite->test x))
+ (shape-spec-to-gobj (g-ite->then x))
+ (shape-spec-to-gobj (g-ite->else x)))))
+ :hints(("Goal" :in-theory (enable shape-spec-to-gobj))))
+
+ (defthm shape-spec-indices-of-g-ite
+ (implies (equal (tag x) :g-ite)
+ (equal (shape-spec-indices x)
+ (append (shape-spec-indices (g-ite->test x))
+ (shape-spec-indices (g-ite->then x))
+ (shape-spec-indices (g-ite->else x)))))
+ :hints(("Goal" :in-theory (enable shape-spec-indices))))
+
+ (defthm shape-spec-vars-of-g-ite
+ (implies (equal (tag x) :g-ite)
+ (equal (shape-spec-vars x)
+ (append (shape-spec-vars (g-ite->test x))
+ (shape-spec-vars (g-ite->then x))
+ (shape-spec-vars (g-ite->else x)))))
+ :hints(("Goal" :in-theory (enable shape-spec-vars))))
+
+ (defthm shape-specp-g-ite
+ (implies (and (equal (tag x) :g-ite)
+ (shape-specp x))
+ (and (shape-specp (g-ite->test x))
+ (shape-specp (g-ite->then x))
+ (shape-specp (g-ite->else x))))
+ :hints(("Goal" :in-theory (enable shape-specp))))))
+
+ (local (in-theory (disable not)))
+
+ (local (in-theory (disable (:t shape-spec-oblig-term)
+ (:t shape-spec-env-term)
+ shape-spec-call-free-by-tag
+ acl2::consp-by-len
+ acl2::true-listp-append
+ acl2::no-duplicatesp-equal-when-atom
+ acl2::no-duplicatesp-equal-non-cons
+ acl2::consp-of-append
+ default-car
+ tag-when-atom
+ default-cdr)))
+
+
+ (local
+ (defthm-shape-spec-term-flag
+ (defthm shape-spec-oblig-term-correct-lemma
+ (let ((env (sspec-geval-ev (shape-spec-env-term
+ x obj-term iff-flg)
+ a)))
+ (implies (and (sspec-geval-ev (shape-spec-oblig-term x obj-term iff-flg) a)
+ (shape-specp x)
+ (no-duplicatesp (shape-spec-indices x))
+ (no-duplicatesp (shape-spec-vars x)))
+ (if iff-flg
+ (iff (sspec-geval (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env (car env) ee)
+ (cdr env)))
+ (sspec-geval-ev obj-term a))
+ (equal (sspec-geval (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env (car env) ee)
+ (cdr env)))
+ (sspec-geval-ev obj-term a)))))
+ :rule-classes nil
+ :flag ss)
+ (defthm shape-spec-list-oblig-term-correct
+ (let ((env (sspec-geval-ev (shape-spec-list-env-term
+ x obj-terms)
+ a)))
+ (implies (and (sspec-geval-ev (shape-spec-list-oblig-term x obj-terms) a)
+ (shape-spec-listp x)
+ (no-duplicatesp (shape-spec-list-indices x))
+ (no-duplicatesp (shape-spec-list-vars x)))
+ (equal (sspec-geval-list (shape-spec-to-gobj-list x)
+ (cons (slice-to-bdd-env (car env) ee)
+ (cdr env)))
+ (sspec-geval-ev-lst obj-terms a))))
+ :flag list)
+ :hints (("goal" ;; :induct (shape-spec-oblig-term
+ ;; x obj-term iff-flg)
+ :in-theory (e/d (sspec-geval-ev-of-fncall-args)
+ (gl-cons (:d shape-spec-env-term)
+ (:d shape-spec-oblig-term)))
+ :expand ((:free (iff-flg) (shape-spec-env-term
+ x obj-term iff-flg))
+ (:free (iff-flg) (shape-spec-oblig-term
+ x obj-term iff-flg))
+ (:free (env) (sspec-geval-list nil env))
+ (:free (a b env) (sspec-geval-list (cons a b) env))
+ (shape-spec-to-gobj-list x)
+ (shape-spec-listp x)
+ (shape-spec-list-indices x)
+ (shape-spec-list-vars x))
+ :do-not-induct t))
+ ;; (shape-specp x)
+ ;; (shape-spec-indices x)
+ ;; (shape-spec-vars x)
+ ;; (:with sspec-geval
+ ;; (:free (a b env) (sspec-geval (cons a b) env)))
+ ))
+
+ (defthm shape-spec-oblig-term-correct
+ (let ((env (sspec-geval-ev (shape-spec-env-term
+ x obj-term nil)
+ a)))
+ (implies (and (sspec-geval-ev (shape-spec-oblig-term x obj-term nil) a)
+ (shape-specp x)
+ (no-duplicatesp (shape-spec-indices x))
+ (no-duplicatesp (shape-spec-vars x)))
+ (equal (sspec-geval (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env (car env) ee)
+ (cdr env)))
+ (sspec-geval-ev obj-term a))))
+ :hints (("goal" :use ((:instance shape-spec-oblig-term-correct-lemma
+ (iff-flg nil))))))
+
+ (defthm shape-spec-list-oblig-term-correct
+ (let ((env (sspec-geval-ev (shape-spec-list-env-term
+ x obj-terms)
+ a)))
+ (implies (and (sspec-geval-ev (shape-spec-list-oblig-term x obj-terms) a)
+ (shape-spec-listp x)
+ (no-duplicatesp (shape-spec-list-indices x))
+ (no-duplicatesp (shape-spec-list-vars x)))
+ (equal (sspec-geval-list (shape-spec-to-gobj-list x)
+ (cons (slice-to-bdd-env (car env) ee)
+ (cdr env)))
+ (sspec-geval-ev-lst obj-terms a)))))
+
+ (defthm shape-spec-oblig-term-correct-iff
+ (let ((env (sspec-geval-ev (shape-spec-env-term
+ x obj-term t)
+ a)))
+ (implies (and (sspec-geval-ev (shape-spec-oblig-term x obj-term t) a)
+ (shape-specp x)
+ (no-duplicatesp (shape-spec-indices x))
+ (no-duplicatesp (shape-spec-vars x)))
+ (iff (sspec-geval (shape-spec-to-gobj x)
+ (cons (slice-to-bdd-env (car env) ee)
+ (cdr env)))
+ (sspec-geval-ev obj-term a))))
+ :hints (("goal" :use ((:instance shape-spec-oblig-term-correct-lemma
+ (iff-flg t)))))))
+
-When proving a theorem using the GL clause processor, variable
-bindings are given as shape specs so that coverage obligations may be
-stated in terms of ~c[SHAPE-SPEC-OBJ-IN-RANGE]. The shape specs are
-converted to symbolic objects and may be parametrized based on some
-restrictions from the hypotheses, restricting their range further.
-Thus, in order to prove a theorem about fixed-length natural numbers,
-for example, one may provide a shape specifier that additionally
-covers negative integers of the given length; parametrization can then
-restrict the symbolic inputs used in the simulation to only cover the
-naturals, while the coverage proof may still be done using the
-simpler, unparametrized shape spec.
-~/
-")
diff -Nru acl2-6.2/books/centaur/gl/solutions.lisp acl2-6.3/books/centaur/gl/solutions.lisp
--- acl2-6.2/books/centaur/gl/solutions.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/solutions.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,270 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+
+
+; solutions.lisp - Solutions to the tutorial exercises
+;
+; Original authors: Sol Swords
+; Jared Davis
+
+(in-package "ACL2")
+(include-book "gl")
+; cert_param: (hons-only)
+
+
+;; Solutions to exercises in the GL Basic Tutorial
+;;
+;; We space these out excessively, so you can avoid looking at answers you
+;; haven't gotten to yet.
+
+
+
+
+
+
+
+
+
+
+
+
+
+(def-gl-thm 1a
+ :hyp (and (unsigned-byte-p 4 x)
+ (unsigned-byte-p 4 y))
+ :concl (equal (+ x y) (+ y x))
+ :g-bindings '((x (:g-number (1 2 3 4 5)))
+ (y (:g-number (6 7 8 9 10)))))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+(def-gl-thm 1b-using-auto-bindings
+ :hyp (and (unsigned-byte-p 4 x)
+ (unsigned-byte-p 4 y))
+ :concl (equal (+ x y) (+ y x))
+ :g-bindings (gl::auto-bindings (:nat x 4)
+ (:nat y 4)))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+(def-gl-thm 1b-using-g-int
+ :hyp (and (unsigned-byte-p 4 x)
+ (unsigned-byte-p 4 y))
+ :concl (equal (+ x y) (+ y x))
+ :g-bindings `((x ,(gl::g-int 0 1 5))
+ (y ,(gl::g-int 6 1 5))))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;; We already did 1b manually (see 1a).
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+(def-gl-thm 1c
+ :hyp (and (unsigned-byte-p 20 x)
+ (unsigned-byte-p 20 y))
+ :concl (equal (+ x y) (+ y x))
+ :g-bindings (gl::auto-bindings (:nat x 20)
+ (:nat y 20)))
+
+;; The above took 24 seconds.
+
+
+(value-triple (hons-summary)) ;; It allocated 8 million honses.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+; 1d doesn't require a new proof.
+
+#||
+
+:u
+(def-gl-thm 1c
+ :hyp (and (unsigned-byte-p 20 x)
+ (unsigned-byte-p 20 y))
+ :concl (equal (+ x y) (+ y x))
+ :g-bindings (gl::auto-bindings (:nat x 20)
+ (:nat y 20)))
+
+||#
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+(value-triple (clear-memoize-tables))
+(value-triple (hons-clear nil))
+
+(def-gl-thm 1e
+ :hyp (and (unsigned-byte-p 20 x)
+ (unsigned-byte-p 20 y))
+ :concl (equal (+ x y) (+ y x))
+ :g-bindings (gl::auto-bindings (:mix (:nat x 20)
+ (:nat y 20))))
+
+(value-triple (clear-memoize-tables))
+(value-triple (hons-clear nil))
+
+(def-gl-thm 1e-alt
+ :hyp (and (unsigned-byte-p 20 x)
+ (unsigned-byte-p 20 y))
+ :concl (equal (+ x y) (+ y x))
+ :g-bindings `((x ,(gl::g-int 0 2 21))
+ (y ,(gl::g-int 1 2 21))))
+
+
+
+
+
+
+
+
+
+
+
+; To make this execute much faster, we'll want a higher memory ceiling.
+
+; Added 8/24/13 by Matt K.: This book failed to certify because of a missing
+; :ttags for the include-book form below.. However, the difference between
+; using the two forms below, and not, was trivial when I used time$ to time the
+; proof of 1f below:
+;
+; ; including memory-mgmt:
+; 36.39 seconds realtime, 36.29 seconds runtime
+; (3,472,888,144 bytes allocated).
+;
+; ; NOT including memory-mgmt:
+; 36.46 seconds realtime, 36.37 seconds runtime
+; (3,472,888,240 bytes allocated).
+;
+; (include-book "centaur/misc/memory-mgmt" :dir :system)
+; (value-triple (set-max-mem (* 8 (expt 2 30))))
+
+; Added by Matt K., 9/21/2013:
+
+; With cmucl, one gets the following error for 1f (below) using a value here of
+; 3000, even if -dynamic-space-size is set to 1632 on the command line, which
+; is the maximum allowable in our CMUCL implementation, "CMU Common Lisp
+; snapshot-2013-06 (20D Unicode)".
+; *A1 gc_alloc_large failed, nbytes=65244752.
+; CMUCL has run out of dynamic heap space (1632 MB).
+; You can control heap size with the -dynamic-space-size commandline option.
+; So we use a smaller for limit CMUCL. Note: Adding the two forms just above, to
+; invoke set-max-mem, didn't solve the problem, whether I added them just above
+; or added them at the beginning of this book.
+
+#-cmucl
+(def-gl-thm 1f
+ :hyp (and (unsigned-byte-p 3000 x)
+ (unsigned-byte-p 3000 y))
+ :concl (equal (+ x y) (+ y x))
+ :g-bindings (gl::auto-bindings (:mix (:nat x 3000)
+ (:nat y 3000))))
+
+#+cmucl
+(def-gl-thm 1f
+ :hyp (and (unsigned-byte-p 2000 x)
+ (unsigned-byte-p 2000 y))
+ :concl (equal (+ x y) (+ y x))
+ :g-bindings (gl::auto-bindings (:mix (:nat x 2000)
+ (:nat y 2000))))
+
+
diff -Nru acl2-6.2/books/centaur/gl/split-args.lisp acl2-6.3/books/centaur/gl/split-args.lisp
--- acl2-6.2/books/centaur/gl/split-args.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/split-args.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,324 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+
+(in-package "GL")
+(include-book "gtypes")
+(local (include-book "gtype-thms"))
+(local (include-book "tools/mv-nth" :dir :system))
+
+(defun hide-if (x) x)
+
+(defund gl-args-split-ite-cond (test args)
+ (declare (xargs :guard t))
+ (b* (((when (atom args)) (mv nil nil))
+ (obj (car args))
+ ((mv rest-then rest-else)
+ (gl-args-split-ite-cond test (cdr args)))
+ ((when (and (consp obj)
+ (eq (tag obj) :g-ite)
+ (hons-equal (g-ite->test obj) test)))
+ (mv (cons (g-ite->then obj) rest-then)
+ (cons (g-ite->else obj) rest-else))))
+ (mv (cons obj rest-then)
+ (cons obj rest-else))))
+
+
+(defund gl-args-split-ite (args)
+ (declare (xargs :guard t))
+ (b* (((when (atom args))
+ (mv nil nil nil nil))
+ (obj (car args))
+ ((when (and (consp obj)
+ (eq (tag obj) :g-ite)))
+ (b* ((test (g-ite->test obj))
+ (then (g-ite->then obj))
+ (else (g-ite->else obj))
+ ((mv then-rest else-rest)
+ (gl-args-split-ite-cond test (cdr args))))
+ (mv t test (cons then then-rest) (cons else else-rest))))
+ ((mv has-if test then else)
+ (gl-args-split-ite (cdr args)))
+ ((unless has-if)
+ (mv nil nil nil nil)))
+ (mv has-if test (cons obj then) (cons obj else))))
+
+(defund g-ite-depth (x)
+ (declare (xargs :guard t))
+ (if (mbe :logic (eq (tag x) :g-ite)
+ :exec (and (consp x)
+ (eq (tag x) :g-ite)))
+ (+ 1 (max (g-ite-depth (g-ite->then x))
+ (g-ite-depth (g-ite->else x))))
+ 0))
+
+(defthm posp-g-ite-depth
+ (implies (equal (tag x) :g-ite)
+ (posp (g-ite-depth x)))
+ :hints(("Goal" :in-theory (enable g-ite-depth)))
+ :rule-classes :type-prescription)
+
+
+(defthm g-ite-depth-of-g-ite->then
+ (implies (eq (tag x) :g-ite)
+ (< (g-ite-depth (g-ite->then x))
+ (g-ite-depth x)))
+ :hints(("Goal" :expand ((g-ite-depth x))))
+ :rule-classes :linear)
+
+(defthm g-ite-depth-of-g-ite->else
+ (implies (eq (tag x) :g-ite)
+ (< (g-ite-depth (g-ite->else x))
+ (g-ite-depth x)))
+ :hints(("Goal" :expand ((g-ite-depth x))))
+ :rule-classes :linear)
+
+(defund g-ite-depth-sum (x)
+ (declare (xargs :guard t))
+ (if (atom x)
+ 0
+ (+ (g-ite-depth (car x))
+ (g-ite-depth-sum (cdr x)))))
+
+(defthm g-ite-depth-of-g-concrete
+ (equal (g-ite-depth (g-concrete x)) 0)
+ :hints(("Goal" :in-theory (enable g-ite-depth))))
+
+(defthm g-ite-depth-sum-of-gl-args-split-ite-cond-0
+ (<= (g-ite-depth-sum (mv-nth 0 (gl-args-split-ite-cond test args)))
+ (g-ite-depth-sum args))
+ :hints(("Goal" :in-theory (enable gl-args-split-ite-cond
+ g-ite-depth-sum gl-cons)))
+ :rule-classes :linear)
+
+(defthm g-ite-depth-sum-of-gl-args-split-ite-cond-1
+ (<= (g-ite-depth-sum (mv-nth 1 (gl-args-split-ite-cond test args)))
+ (g-ite-depth-sum args))
+ :hints(("Goal" :in-theory (enable gl-args-split-ite-cond
+ g-ite-depth-sum gl-cons)))
+ :rule-classes :linear)
+
+(defthm g-ite-depth-sum-of-gl-args-split-ite-then
+ (b* (((mv has-ite ?test ?then ?else)
+ (gl-args-split-ite args)))
+ (implies has-ite
+ (< (g-ite-depth-sum then) (g-ite-depth-sum args))))
+ :hints(("Goal" :in-theory (enable gl-args-split-ite
+ g-ite-depth-sum gl-cons)))
+ :rule-classes :linear)
+
+(defthm g-ite-depth-sum-of-gl-args-split-ite-else
+ (b* (((mv has-ite ?test ?then ?else)
+ (gl-args-split-ite args)))
+ (implies has-ite
+ (< (g-ite-depth-sum else) (g-ite-depth-sum args))))
+ :hints(("Goal" :in-theory (enable gl-args-split-ite
+ g-ite-depth-sum gl-cons)))
+ :rule-classes :linear)
+
+
+
+
+
+(defsection gl-args-split-ite-cond
+ (local (in-theory (enable gl-args-split-ite-cond)))
+
+ (defthm gl-args-split-ite-cond-correct
+ (b* (((mv then else)
+ (gl-args-split-ite-cond test args)))
+ (and (implies (generic-geval test env)
+ (equal (generic-geval-list then env)
+ (generic-geval-list args env)))
+ (implies (not (generic-geval test env))
+ (equal (generic-geval-list else env)
+ (generic-geval-list args env)))))
+ :hints (("goal" :induct (gl-args-split-ite-cond test args)
+ :expand ((generic-geval-list args env)
+ (generic-geval-list nil env)
+ (:free (a b) (generic-geval-list (cons a b) env))
+ (:with generic-geval (generic-geval (car args)
+ env))))))
+
+ (defthm gobj-listp-gl-args-split-ite-cond
+ (b* (((mv then else)
+ (gl-args-split-ite-cond test args)))
+ (and (true-listp then)
+ (true-listp else))))
+
+ (defthm gobj-list-depends-on-of-gl-args-split-ite-cond
+ (b* (((mv then else)
+ (gl-args-split-ite-cond test args)))
+ (implies (not (gobj-list-depends-on k p args))
+ (and (not (gobj-list-depends-on k p then))
+ (not (gobj-list-depends-on k p else)))))))
+
+(defsection gl-args-split-ite
+ (local (in-theory (enable gl-args-split-ite)))
+
+ (defthm gl-args-split-ite-correct
+ (b* (((mv has-ite test then else)
+ (gl-args-split-ite args)))
+ (implies has-ite
+ (and (implies (generic-geval test env)
+ (equal (generic-geval-list then env)
+ (generic-geval-list args env)))
+ (implies (not (generic-geval test env))
+ (equal (generic-geval-list else env)
+ (generic-geval-list args env))))))
+ :hints (("goal"
+ :induct (gl-args-split-ite args)
+ :expand ((generic-geval-list args env)
+ (generic-geval-list nil env)
+ (:free (a b) (generic-geval-list (cons a b) env))
+ (gobj-listp args)
+ (:with generic-geval (generic-geval (car args) env))))))
+
+ (defthm gobj-listp-gl-args-split-ite
+ (b* (((mv ?has-ite ?test then else)
+ (gl-args-split-ite args)))
+ (and (true-listp then)
+ (true-listp else))))
+
+
+ (defthm gobj-list-depends-on-of-gl-args-split-ite
+ (b* (((mv ?has-if test then else)
+ (gl-args-split-ite args)))
+ (implies (not (gobj-list-depends-on k p args))
+ (and (not (gobj-depends-on k p test))
+ (not (gobj-list-depends-on k p then))
+ (not (gobj-list-depends-on k p else)))))))
+
+
+
+(defsection gl-fncall-split-ite
+ (defun debug-fncall-split-ite (fn args)
+ (declare (xargs :guard t)
+ (ignore fn args))
+ nil)
+
+ (defund gl-fncall-split-ite (fn args)
+ (declare (xargs :guard t
+ :measure (g-ite-depth-sum args)))
+ (b* (((mv has-ite test then else)
+ (gl-args-split-ite args))
+ ((unless has-ite) (g-apply fn args)))
+ (debug-fncall-split-ite fn args)
+ (g-ite test
+ (gl-fncall-split-ite fn then)
+ (gl-fncall-split-ite fn else))))
+
+ (local (in-theory (enable gl-fncall-split-ite)))
+
+ (defthm gl-fncall-split-ite-correct
+ (equal (generic-geval (gl-fncall-split-ite fn args) env)
+ (generic-geval (g-apply fn args) env))
+ :hints(("Goal" :in-theory (enable generic-geval))))
+
+ (defthm gobj-depends-on-of-gl-args-split-ite
+ (implies (not (gobj-list-depends-on k p args))
+ (not (gobj-depends-on k p (gl-fncall-split-ite fn args))))))
+
+(defsection gl-cons-split-ite
+ (defun debug-cons-split-ite (car cdr)
+ (declare (xargs :guard t)
+ (ignore car cdr))
+ nil)
+ (defund gl-cons-split-ite (car cdr)
+ (declare (xargs :guard t
+ :hints(("Goal" :in-theory (enable g-ite-depth-sum)))
+ :measure (g-ite-depth-sum (list car cdr))))
+ (if (and (not (and (consp car) (eq (tag car) :g-ite)))
+ (not (and (consp cdr) (eq (tag cdr) :g-ite))))
+ (gl-cons car cdr)
+ (progn$
+ (debug-cons-split-ite car cdr)
+ ;; (break$)
+ (if (and (consp car) (eq (tag car) :g-ite))
+ (if (and (consp cdr)
+ (eq (tag cdr) :g-ite)
+ (hons-equal (g-ite->test cdr) (g-ite->test car)))
+ (g-ite (g-ite->test car)
+ (gl-cons-split-ite (g-ite->then car)
+ (g-ite->then cdr))
+ (gl-cons-split-ite (g-ite->else car)
+ (g-ite->else cdr)))
+ (g-ite (g-ite->test car)
+ (gl-cons-split-ite (g-ite->then car) cdr)
+ (gl-cons-split-ite (g-ite->else car) cdr)))
+ (g-ite (g-ite->test cdr)
+ (gl-cons-split-ite car (g-ite->then cdr))
+ (gl-cons-split-ite car (g-ite->else cdr)))))))
+
+ (local (in-theory (enable gl-cons-split-ite)))
+
+ (defthm gl-cons-split-ite-correct
+ (equal (generic-geval (gl-cons-split-ite car cdr) env)
+ (cons (generic-geval car env)
+ (generic-geval cdr env)))
+ :hints(("Goal" :in-theory (e/d (generic-geval) (gl-cons)))))
+
+ (defthm gobj-depends-on-of-gl-cons-split-ite
+ (implies (and (not (gobj-depends-on k p car))
+ (not (gobj-depends-on k p cdr)))
+ (not (gobj-depends-on k p (gl-cons-split-ite car cdr))))
+ :hints(("Goal" :in-theory (e/d () (gl-cons gobj-depends-on))))))
+
+
+(defsection gl-cons-maybe-split
+ (defund gl-cons-maybe-split (car cdr split-flg w)
+ (declare (xargs :guard (plist-worldp w)))
+ (if (and split-flg
+ (not (cdr (hons-assoc-equal 'cons (table-alist 'gl-if-opaque-fns w)))))
+ (gl-cons-split-ite car cdr)
+ (gl-cons car cdr)))
+
+ (local (in-theory (enable gl-cons-maybe-split)))
+
+ (defthm gl-cons-maybe-split-correct
+ (equal (generic-geval (gl-cons-maybe-split car cdr flg w) env)
+ (cons (generic-geval car env)
+ (generic-geval cdr env)))
+ :hints(("Goal" :in-theory (e/d (generic-geval) (gl-cons)))))
+
+ (defthm gobj-depends-on-of-gl-cons-maybe-split
+ (implies (and (not (gobj-depends-on k p car))
+ (not (gobj-depends-on k p cdr)))
+ (not (gobj-depends-on k p (gl-cons-maybe-split car cdr flg w))))
+ :hints(("Goal" :in-theory (e/d () (gl-cons gobj-depends-on))))))
+
+(defsection gl-fncall-maybe-split
+
+ (defund gl-fncall-maybe-split (fn args flg w)
+ (declare (xargs :guard (plist-worldp w)))
+ (if (and flg
+ (not (cdr (hons-assoc-equal 'fn (table-alist 'gl-if-opaque-fns w)))))
+ (gl-fncall-split-ite fn args)
+ (g-apply fn args)))
+
+ (local (in-theory (enable gl-fncall-maybe-split)))
+
+ (defthm gl-fncall-maybe-split-correct
+ (equal (generic-geval (gl-fncall-maybe-split fn args flg w) env)
+ (generic-geval (g-apply fn args) env))
+ :hints(("Goal" :in-theory (enable generic-geval))))
+
+ (defthm gobj-depends-on-of-gl-args-maybe-split
+ (implies (not (gobj-list-depends-on k p args))
+ (not (gobj-depends-on k p (gl-fncall-maybe-split fn args flg w))))))
+
diff -Nru acl2-6.2/books/centaur/gl/symbolic-arithmetic-fns.lisp acl2-6.3/books/centaur/gl/symbolic-arithmetic-fns.lisp
--- acl2-6.2/books/centaur/gl/symbolic-arithmetic-fns.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/symbolic-arithmetic-fns.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,388 +1,593 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-
(include-book "bvec-ite")
(include-book "tools/mv-nth" :dir :system)
+(include-book "ihs/logops-definitions" :dir :system)
+
+(defund int-set-sign (negp i)
+ (declare (xargs :guard (integerp i)))
+ (let ((i (lifix i)))
+ (acl2::logapp (integer-length i) i (if negp -1 0))))
+
+(defthm sign-of-int-set-sign
+ (iff (< (int-set-sign negp i) 0)
+ negp)
+ :hints(("Goal" :in-theory (e/d* (int-set-sign)
+ (acl2::logapp
+ acl2::ifix-under-int-equiv)))))
+
+(defthm int-set-sign-integerp
+ (integerp (int-set-sign negp i))
+ :rule-classes :type-prescription)
+
+(defund non-int-fix (x)
+ (declare (xargs :guard t))
+ (and (not (integerp x)) x))
-
-
+(defthm non-int-fix-when-non-integer
+ (implies (not (integerp x))
+ (equal (non-int-fix x) x))
+ :hints(("Goal" :in-theory (enable non-int-fix)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+(defund maybe-integer (i x intp)
+ (declare (xargs :guard (integerp i)))
+ (if intp
+ (ifix i)
+ (non-int-fix x)))
+
+(defthm maybe-integer-t
+ (equal (maybe-integer i x t)
+ (ifix i))
+ :hints(("Goal" :in-theory (enable maybe-integer))))
+
+(defthm maybe-integer-nil
+ (equal (maybe-integer i x nil)
+ (non-int-fix x))
+ :hints(("Goal" :in-theory (enable maybe-integer))))
-;; equality of two unsigned bdd vectors
-(defund =-uu (a b)
+;; equality of two unsigned bool/bfr vectors
+;; (defund =-uu (a b)
+;; (declare (xargs :guard t
+;; :measure (+ (len a) (len b))))
+;; (if (and (atom a) (atom b))
+;; t
+;; (b* (((mv head1 tail1) (car/cdr a))
+;; ((mv head2 tail2) (car/cdr b)))
+;; (and (iff head1 head2)
+;; (=-uu tail1 tail2)))))
+
+(defund bfr-=-uu (a b)
(declare (xargs :guard t
:measure (+ (len a) (len b))))
(if (and (atom a) (atom b))
t
- (b* (((mv head1 tail1)
- (if (atom a) (mv nil nil) (mv (car a) (cdr a))))
- ((mv head2 tail2)
- (if (atom b) (mv nil nil) (mv (car b) (cdr b)))))
+ (b* (((mv head1 tail1) (car/cdr a))
+ ((mv head2 tail2) (car/cdr b)))
(bfr-and (bfr-iff head1 head2)
- (=-uu tail1 tail2)))))
+ (bfr-=-uu tail1 tail2)))))
+
+
-(defund =-ss (a b)
+;; (defund =-ss (a b)
+;; (declare (xargs :guard t
+;; :measure (+ (len a) (len b))))
+;; (b* (((mv head1 tail1 end1) (first/rest/end a))
+;; ((mv head2 tail2 end2) (first/rest/end b)))
+;; (if (and end1 end2)
+;; (iff head1 head2)
+;; (and (iff head1 head2)
+;; (=-ss tail1 tail2)))))
+
+(defund bfr-=-ss (a b)
(declare (xargs :guard t
:measure (+ (len a) (len b))))
- (b* (((mv head1 tail1 end1)
- (if (atom a)
- (mv nil nil t)
- (if (atom (cdr a))
- (mv (car a) a t)
- (mv (car a) (cdr a) nil))))
- ((mv head2 tail2 end2)
- (if (atom b)
- (mv nil nil t)
- (if (atom (cdr b))
- (mv (car b) b t)
- (mv (car b) (cdr b) nil)))))
+ (b* (((mv head1 tail1 end1) (first/rest/end a))
+ ((mv head2 tail2 end2) (first/rest/end b)))
(if (and end1 end2)
(bfr-iff head1 head2)
(bfr-and (bfr-iff head1 head2)
- (=-ss tail1 tail2)))))
+ (bfr-=-ss tail1 tail2)))))
-(defund s-nthcdr (place n)
+(defund logtail-ns (place n)
(declare (xargs :guard (natp place)))
- (if (or (zp place) (atom n) (atom (cdr n)))
+ (if (or (zp place) (s-endp n))
n
- (s-nthcdr (1- place) (cdr n))))
+ (logtail-ns (1- place) (scdr n))))
(defund s-sign (x)
(declare (xargs :guard t))
- (if (atom x) nil (car (last x))))
+ (b* (((mv first rest endp) (first/rest/end x)))
+ (if endp
+ first
+ (s-sign rest))))
+
+;; (defund +-ss (c v1 v2)
+;; (declare (xargs :measure (+ (len v1) (len v2))
+;; :guard t))
+;; (b* (((mv head1 tail1 end1) (first/rest/end v1))
+;; ((mv head2 tail2 end2) (first/rest/end v2))
+;; (axorb (xor head1 head2))
+;; (s (xor c axorb)))
+;; (if (and end1 end2)
+;; (let ((last (if axorb (not c) head1)))
+;; (scons s (sterm last)))
+;; (let* ((c (or (and c axorb)
+;; (and head1 head2)))
+;; (rst (+-ss c tail1 tail2)))
+;; (scons s rst)))))
-(defund +-ss (c v1 v2)
+(defund bfr-+-ss (c v1 v2)
(declare (xargs :measure (+ (len v1) (len v2))
:guard t))
- (b* (((mv head1 tail1 end1)
- (if (atom v1)
- (mv nil nil t)
- (if (atom (cdr v1))
- (mv (car v1) v1 t)
- (mv (car v1) (cdr v1) nil))))
- ((mv head2 tail2 end2)
- (if (atom v2)
- (mv nil nil t)
- (if (atom (cdr v2))
- (mv (car v2) v2 t)
- (mv (car v2) (cdr v2) nil))))
+ (b* (((mv head1 tail1 end1) (first/rest/end v1))
+ ((mv head2 tail2 end2) (first/rest/end v2))
(axorb (bfr-xor head1 head2))
(s (bfr-xor c axorb)))
(if (and end1 end2)
(let ((last (bfr-ite axorb (bfr-not c) head1)))
- (if (hqual s last)
- (list s)
- (list s last)))
+ (bfr-scons s (bfr-sterm last)))
(let* ((c (bfr-or (bfr-and c axorb)
(bfr-and head1 head2)))
- (rst (+-ss c tail1 tail2)))
- (if (and (atom (cdr rst))
- (hqual s (car rst)))
- rst
- (cons s rst))))))
+ (rst (bfr-+-ss c tail1 tail2)))
+ (bfr-scons s rst)))))
+(defthm not-s-endp-compound-recognizer
+ (implies (not (s-endp x))
+ (consp x))
+ :hints(("Goal" :in-theory (enable s-endp)))
+ :rule-classes :compound-recognizer)
+
+;; (defund lognot-s (x)
+;; (declare (xargs :guard t))
+;; (b* (((mv head tail end) (first/rest/end x)))
+;; (if end
+;; (sterm (not head))
+;; (scons (not head)
+;; (lognot-s tail)))))
+
+;; (defund lognot-bv (x)
+;; (declare (xargs :guard t
+;; :measure (len x)))
+;; (if (atom x)
+;; nil
+;; (cons (not (car x))
+;; (lognot-bv (cdr x)))))
+(defund bfr-lognot-s (x)
+ (declare (xargs :guard t))
+ (b* (((mv head tail end) (first/rest/end x)))
+ (if end
+ (bfr-sterm (bfr-not head))
+ (bfr-scons (bfr-not head)
+ (bfr-lognot-s tail)))))
+
+;; (defund unary-minus-s (x)
+;; (declare (xargs :guard t))
+;; (+-ss t nil (lognot-s x)))
-
-(defund lognot-bv (x)
- (declare (xargs :guard t
- :measure (len x)))
- (if (atom x)
- nil
- (prog2$
- (acl2::last-chance-wash-memory)
- (cons (bfr-not (car x))
- (lognot-bv (cdr x))))))
-
-(defund unary-minus-s (x)
+(defund bfr-unary-minus-s (x)
(declare (xargs :guard t))
- (if (consp x)
- (+-ss t nil (lognot-bv x))
- nil))
+ (bfr-+-ss t nil (bfr-lognot-s x)))
+
+;; (defund *-ss (v1 v2)
+;; (declare (xargs :guard t
+;; :measure (+ (len v1) (len v2))))
+;; (b* (((mv dig1 rest end1) (first/rest/end v1)))
+;; (if end1
+;; (if dig1
+;; (unary-minus-s v2)
+;; nil)
+;; (let ((rest (*-ss rest v2)))
+;; (+-ss nil
+;; (if dig1 v2 nil)
+;; (scons nil rest))))))
-(defund *-ss (v1 v2)
+(defund bfr-*-ss (v1 v2)
(declare (xargs :guard t
:measure (+ (len v1) (len v2))))
- (b* (((mv dig1 end1)
- (if (atom v1)
- (mv nil t)
- (if (atom (cdr v1))
- (mv (car v1) t)
- (mv (car v1) nil)))))
+ (b* (((mv dig1 rest end1) (first/rest/end v1)))
(if end1
(bfr-ite-bss dig1
- (unary-minus-s v2)
+ (bfr-unary-minus-s v2)
nil)
- (let ((rest (*-ss (cdr v1) v2)))
- (+-ss nil
+ (let ((rest (bfr-*-ss rest v2)))
+ (bfr-+-ss nil
(bfr-ite-bss dig1 v2 nil)
- (cons nil rest))))))
+ (bfr-scons nil rest))))))
-(defund <-=-ss (a b)
+;; (defund <-=-ss (a b)
+;; (declare (xargs :guard t
+;; :measure (+ (len a) (len b))))
+;; (b* (((mv head1 tail1 end1) (first/rest/end a))
+;; ((mv head2 tail2 end2) (first/rest/end b)))
+;; (if (and end1 end2)
+;; (mv (and head1 (not head2))
+;; (iff head1 head2))
+;; (mv-let (rst< rst=)
+;; (<-=-ss tail1 tail2)
+;; (mv (or rst< (and rst= head2 (not head1)))
+;; (and rst= (iff head1 head2)))))))
+
+(defund bfr-<-=-ss (a b)
(declare (xargs :guard t
:measure (+ (len a) (len b))))
- (b* (((mv head1 tail1 end1)
- (if (atom a)
- (mv nil nil t)
- (if (atom (cdr a))
- (mv (car a) a t)
- (mv (car a) (cdr a) nil))))
- ((mv head2 tail2 end2)
- (if (atom b)
- (mv nil nil t)
- (if (atom (cdr b))
- (mv (car b) b t)
- (mv (car b) (cdr b) nil)))))
+ (b* (((mv head1 tail1 end1) (first/rest/end a))
+ ((mv head2 tail2 end2) (first/rest/end b)))
(if (and end1 end2)
(mv (bfr-and head1 (bfr-not head2))
(bfr-iff head1 head2))
(mv-let (rst< rst=)
- (<-=-ss tail1 tail2)
+ (bfr-<-=-ss tail1 tail2)
(mv (bfr-or rst< (bfr-and rst= head2 (bfr-not head1)))
(bfr-and rst= (bfr-iff head1 head2)))))))
-(defund <-ss (a b)
+
+;; (defund <-ss (a b)
+;; (declare (xargs :guard t))
+;; (b* (((mv head1 tail1 end1) (first/rest/end a))
+;; ((mv head2 tail2 end2) (first/rest/end b)))
+;; (if (and end1 end2)
+;; (and head1 (not head2))
+;; (mv-let (rst< rst=)
+;; (<-=-ss tail1 tail2)
+;; (or rst< (and rst= head2 (not head1)))))))
+
+(defund bfr-<-ss (a b)
(declare (xargs :guard t))
- (b* (((mv head1 tail1 end1)
- (if (atom a)
- (mv nil nil t)
- (if (atom (cdr a))
- (mv (car a) a t)
- (mv (car a) (cdr a) nil))))
- ((mv head2 tail2 end2)
- (if (atom b)
- (mv nil nil t)
- (if (atom (cdr b))
- (mv (car b) b t)
- (mv (car b) (cdr b) nil)))))
+ (b* (((mv head1 tail1 end1) (first/rest/end a))
+ ((mv head2 tail2 end2) (first/rest/end b)))
(if (and end1 end2)
(bfr-and head1 (bfr-not head2))
(mv-let (rst< rst=)
- (<-=-ss tail1 tail2)
+ (bfr-<-=-ss tail1 tail2)
(bfr-or rst< (bfr-and rst= head2 (bfr-not head1)))))))
+;; (defund logapp-nss (n a b)
+;; (declare (xargs :guard (natp n)))
+;; (if (zp n)
+;; b
+;; (b* (((mv first rest &) (first/rest/end a)))
+;; (scons first (logapp-nss (1- n) rest b)))))
+
+(defund bfr-logapp-nss (n a b)
+ (declare (xargs :guard (natp n)))
+ (if (zp n)
+ b
+ (b* (((mv first rest &) (first/rest/end a)))
+ (bfr-scons first (bfr-logapp-nss (1- n) rest b)))))
+
+(defund bfr-logapp-nus (n a b)
+ (declare (xargs :guard (natp n)))
+ (if (zp n)
+ b
+ (b* (((mv first rest) (car/cdr a)))
+ (bfr-scons first (bfr-logapp-nus (1- n) rest b)))))
+
+;; (defund ash-ss (place n shamt)
+;; (declare (xargs :guard (posp place)
+;; :measure (len shamt)))
+;; (b* (((mv shdig shrst shend) (first/rest/end shamt)))
+;; (if shend
+;; (if shdig
+;; (logtail-ns 1 n)
+;; (logapp-nss (1- place) nil n))
+;; (let ((rst (ash-ss (* 2 place) n shrst)))
+;; (if shdig
+;; rst
+;; (logtail-ns place rst))))))
-
-
-(defund ash-ss (place n shamt)
+(defund bfr-ash-ss (place n shamt)
(declare (xargs :guard (posp place)
:measure (len shamt)))
- (b* (((mv shdig shrst shend)
- (if (atom shamt)
- (mv nil nil t)
- (if (atom (cdr shamt))
- (mv (car shamt) shamt t)
- (mv (car shamt) (cdr shamt) nil)))))
+ (b* (((mv shdig shrst shend) (first/rest/end shamt)))
(if shend
(bfr-ite-bss shdig
- (s-nthcdr 1 n)
- (make-list-ac (1- place) nil n))
- (let ((rst (ash-ss (* 2 place) n shrst)))
+ (logtail-ns 1 n)
+ (bfr-logapp-nss (1- place) nil n))
+ (let ((rst (bfr-ash-ss (* 2 place) n shrst)))
(bfr-ite-bss shdig
rst
- (s-nthcdr place rst))))))
+ (logtail-ns place rst))))))
+;; (defund logbitp-n2v (place digit n)
+;; (declare (xargs :guard (natp place)
+;; :hints (("goal" :in-theory (enable len)))
+;; ;; :guard-hints ('(:in-theory (e/d (ash) (floor))))
+;; :measure (len digit)))
+;; (b* (((mv first & end) (first/rest/end n)))
+;; (if (or (atom digit) end)
+;; first
+;; (if (car digit)
+;; (logbitp-n2v (* 2 place) (cdr digit) (logtail-ns place n))
+;; (logbitp-n2v (* 2 place) (cdr digit) n)))))
-(defund logbitp-n2v (place digit n)
+(defund bfr-logbitp-n2v (place digit n)
(declare (xargs :guard (natp place)
:hints (("goal" :in-theory (enable len)))
:guard-hints ('(:in-theory (enable ash)))
:measure (len digit)))
- (if (atom n)
- nil
- (if (or (atom digit) (atom (cdr n)))
- (car n)
+ (b* (((mv first & end) (first/rest/end n)))
+ (if (or (atom digit) end)
+ first
(bfr-ite (car digit)
- (logbitp-n2v (ash place 1) (cdr digit) (s-nthcdr place n))
- (logbitp-n2v (ash place 1) (cdr digit) n)))))
+ (bfr-logbitp-n2v (* 2 place) (cdr digit) (logtail-ns place n))
+ (bfr-logbitp-n2v (* 2 place) (cdr digit) n)))))
-(defund integer-length-s1 (offset x)
+
+;; (defund integer-length-s1 (offset x)
+;; (declare (xargs :guard (natp offset)
+;; :measure (len x)))
+;; (b* (((mv first rest end) (first/rest/end x)))
+;; (if end
+;; (mv nil nil)
+;; (mv-let (changed res)
+;; (integer-length-s1 (1+ offset) rest)
+;; (if (eq changed t)
+;; (mv t res)
+;; (let ((change (xor first (car rest))))
+;; (mv (or changed change)
+;; (if changed
+;; res
+;; (if change
+;; (i2v offset)
+;; nil)))))))))
+
+(defund bfr-integer-length-s1 (offset x)
(declare (xargs :guard (natp offset)
:measure (len x)))
- (if (or (atom x) (atom (cdr x)))
- (mv nil nil)
- (mv-let (changed res)
- (integer-length-s1 (1+ offset) (cdr x))
- (if (eq changed t)
- (mv t res)
- (let ((change (bfr-xor (car x) (cadr x))))
- (mv (bfr-or changed change)
- (bfr-ite-bss changed
- res
- (bfr-ite-bss change
- (i2v offset)
- nil))))))))
+ (b* (((mv first rest end) (first/rest/end x)))
+ (if end
+ (mv nil nil)
+ (mv-let (changed res)
+ (bfr-integer-length-s1 (1+ offset) rest)
+ (if (eq changed t)
+ (mv t res)
+ (let ((change (bfr-xor first (car rest))))
+ (mv (bfr-or changed change)
+ (bfr-ite-bss changed
+ res
+ (bfr-ite-bss change
+ (i2v offset)
+ nil)))))))))
+
+;; (defund integer-length-s (x)
+;; (declare (xargs :guard t))
+;; (mv-let (ign res)
+;; (integer-length-s1 1 x)
+;; (declare (ignore ign))
+;; res))
-(defund integer-length-s (x)
+(defund bfr-integer-length-s (x)
(declare (xargs :guard t))
(mv-let (ign res)
- (integer-length-s1 1 x)
+ (bfr-integer-length-s1 1 x)
(declare (ignore ign))
res))
-(defund logand-ss (a b)
+;; (defund logand-ss (a b)
+;; (declare (xargs :guard t
+;; :measure (+ (len a) (len b))))
+;; (b* (((mv af ar aend) (first/rest/end a))
+;; ((mv bf br bend) (first/rest/end b)))
+;; (if (and aend bend)
+;; (sterm (and af bf))
+;; (b* ((c (and af bf))
+;; (r (logand-ss ar br)))
+;; (scons c r)))))
+
+(defund bfr-logand-ss (a b)
(declare (xargs :guard t
:measure (+ (len a) (len b))))
- (b* (((mv af ar aend)
- (if (atom a)
- (mv nil nil t)
- (if (atom (cdr a))
- (mv (car a) a t)
- (mv (car a) (cdr a) nil))))
- ((mv bf br bend)
- (if (atom b)
- (mv nil nil t)
- (if (atom (cdr b))
- (mv (car b) b t)
- (mv (car b) (cdr b) nil)))))
+ (b* (((mv af ar aend) (first/rest/end a))
+ ((mv bf br bend) (first/rest/end b)))
(if (and aend bend)
- (list (bfr-and af bf))
+ (bfr-sterm (bfr-and af bf))
(b* ((c (bfr-and af bf))
- (r (logand-ss ar br)))
- (if (and (atom (cdr r))
- (hqual (car r) c))
- r
- (cons c r))))))
+ (r (bfr-logand-ss ar br)))
+ (bfr-scons c r)))))
-;; Symbolically computes the FLOOR and MOD for positive divisor B (when MINUS-B
-;; is the negation of B.)
-(defund floor-mod-ss (a b minus-b)
+;; ;; Symbolically computes the FLOOR and MOD for positive divisor B (when MINUS-B
+;; ;; is the negation of B.)
+;; (defund floor-mod-ss (a b minus-b)
+;; (declare (xargs :guard t
+;; :measure (len a)))
+;; (b* (((mv first rest endp) (first/rest/end a)))
+;; (if endp
+;; (mv (sterm first)
+;; (if first
+;; (+-ss nil '(t) b) ;; (mod -1 b) = b-1 with b > 0
+;; '(nil))) ;; (mod 0 b) = 0
+;; (b* (((mv rf rm)
+;; (floor-mod-ss rest b minus-b))
+;; (rm (scons first rm))
+;; (less (<-ss rm b))
+;; (rf (scons nil rf)))
+;; (mv (if less
+;; rf
+;; (+-ss t nil rf))
+;; (if less
+;; rm
+;; (+-ss nil minus-b rm)))))))
+
+(defund bfr-floor-mod-ss (a b minus-b)
(declare (xargs :guard t
:measure (len a)))
- (b* (((mv digit endp)
- (if (atom a)
- (mv nil t)
- (if (atom (cdr a))
- (mv (car a) t)
- (mv (car a) nil)))))
+ (b* (((mv first rest endp) (first/rest/end a)))
(if endp
- (mv (bfr-ite-bss
- digit
- '(t) ;; (floor -1 b) = -1 with b > 0
- '(nil)) ;; (floor 0 b) = 0
+ (mv (bfr-sterm first) ;; (floor 0 b) = 0
(bfr-ite-bss
- digit
- (+-ss nil '(t) b) ;; (mod -1 b) = b-1 with b > 0
+ first
+ (bfr-+-ss nil '(t) b) ;; (mod -1 b) = b-1 with b > 0
'(nil))) ;; (mod 0 b) = 0
(b* (((mv rf rm)
- (floor-mod-ss (cdr a) b minus-b))
- (rm (cons (car a) (if (atom rm) '(nil) rm)))
- (less (<-ss rm b))
- (rf (cons nil rf)))
+ (bfr-floor-mod-ss rest b minus-b))
+ (rm (bfr-scons first rm))
+ (less (bfr-<-ss rm b))
+ (rf (bfr-scons nil rf)))
(mv (bfr-ite-bss
less
rf
- (+-ss t nil rf))
+ (bfr-+-ss t nil rf))
(bfr-ite-bss
less rm
- (+-ss nil minus-b rm)))))))
+ (bfr-+-ss nil minus-b rm)))))))
+
-(defund floor-ss (a b)
+;; ;; (mv (sign b) (- b) (abs b) (- (abs b)))
+;; (defund sign-abs-neg-s (x)
+;; (declare (xargs :guard t))
+;; (b* ((sign (s-sign x))
+;; (minus (unary-minus-s x)))
+;; (if sign
+;; (mv sign minus minus x)
+;; (mv sign minus x minus))))
+
+
+(defund bfr-sign-abs-neg-s (x)
+ (declare (xargs :guard t))
+ (b* ((sign (s-sign x))
+ (minus (bfr-unary-minus-s x))
+ (abs (bfr-ite-bss sign minus x))
+ (neg (bfr-ite-bss sign x minus)))
+ (mv sign minus abs neg)))
+
+
+;; (defund floor-ss (a b)
+;; (declare (xargs :guard t))
+;; (if (=-ss b nil)
+;; nil
+;; (b* (((mv bsign & babs bneg) (sign-abs-neg-s b))
+;; (anorm (if bsign (unary-minus-s a) a))
+;; ((mv f &) (floor-mod-ss anorm babs bneg)))
+;; f)))
+
+(defund bfr-floor-ss (a b)
(declare (xargs :guard t))
- (bfr-ite-bss (=-ss b nil)
+ (bfr-ite-bss (bfr-=-ss b nil)
nil
- (b* ((bsign (s-sign b))
- (babs (bfr-ite-bss bsign (unary-minus-s b) b))
- (anorm (bfr-ite-bss bsign (unary-minus-s a) a))
- (bneg (unary-minus-s babs))
- ((mv f &) (floor-mod-ss anorm babs bneg)))
+ (b* (((mv bsign & babs bneg) (bfr-sign-abs-neg-s b))
+ (anorm (bfr-ite-bss bsign (bfr-unary-minus-s a) a))
+ ((mv f &) (bfr-floor-mod-ss anorm babs bneg)))
f)))
-(defund mod-ss (a b)
+;; (defund mod-ss (a b)
+;; (declare (xargs :guard t))
+;; (if (=-ss b nil)
+;; a
+;; (b* (((mv bsign & babs bneg) (sign-abs-neg-s b))
+;; (anorm (if bsign (unary-minus-s a) a))
+;; ((mv & m) (floor-mod-ss anorm babs bneg)))
+;; (if bsign (unary-minus-s m) m))))
+
+(defund bfr-mod-ss (a b)
(declare (xargs :guard t))
- (bfr-ite-bss (=-ss b nil)
+ (bfr-ite-bss (bfr-=-ss b nil)
a
- (b* ((bsign (s-sign b))
- (babs (bfr-ite-bss bsign (unary-minus-s b) b))
- (anorm (bfr-ite-bss bsign (unary-minus-s a) a))
- (bneg (unary-minus-s babs))
- ((mv & m) (floor-mod-ss anorm babs bneg)))
- (bfr-ite-bss bsign (unary-minus-s m) m))))
+ (b* (((mv bsign & babs bneg) (bfr-sign-abs-neg-s b))
+ (anorm (bfr-ite-bss bsign (bfr-unary-minus-s a) a))
+ ((mv & m) (bfr-floor-mod-ss anorm babs bneg)))
+ (bfr-ite-bss bsign (bfr-unary-minus-s m) m))))
+
+
+;; (defund truncate-ss (a b)
+;; (declare (xargs :guard t))
+;; (if (=-ss b nil)
+;; nil
+;; (b* (((mv bsign & babs bneg) (sign-abs-neg-s b))
+;; ((mv asign & aabs &) (sign-abs-neg-s a))
+;; ((mv f &) (floor-mod-ss aabs babs bneg)))
+;; (if (xor bsign asign)
+;; (unary-minus-s f)
+;; f))))
-(defund truncate-ss (a b)
+(defund bfr-truncate-ss (a b)
(declare (xargs :guard t))
- (bfr-ite-bss (=-ss b nil)
+ (bfr-ite-bss (bfr-=-ss b nil)
nil
- (b* ((bsign (s-sign b))
- (asign (s-sign a))
- (babs (bfr-ite-bss bsign (unary-minus-s b) b))
- (aabs (bfr-ite-bss asign (unary-minus-s a) a))
- (bneg (unary-minus-s babs))
- ((mv f &) (floor-mod-ss aabs babs bneg)))
+ (b* (((mv bsign & babs bneg) (bfr-sign-abs-neg-s b))
+ ((mv asign & aabs &) (bfr-sign-abs-neg-s a))
+ ((mv f &) (bfr-floor-mod-ss aabs babs bneg)))
(bfr-ite-bss (bfr-xor bsign asign)
- (unary-minus-s f) f))))
+ (bfr-unary-minus-s f) f))))
+
+;; (defund rem-ss (a b)
+;; (declare (xargs :guard t))
+;; (if (=-ss b nil)
+;; a
+;; (b* (((mv & & babs bneg) (sign-abs-neg-s b))
+;; ((mv asign & aabs &) (sign-abs-neg-s a))
+;; ((mv & m) (floor-mod-ss aabs babs bneg)))
+;; (if asign (unary-minus-s m) m))))
-(defund rem-ss (a b)
+(defund bfr-rem-ss (a b)
(declare (xargs :guard t))
- (bfr-ite-bss (=-ss b nil)
+ (bfr-ite-bss (bfr-=-ss b nil)
a
- (b* ((bsign (s-sign b))
- (asign (s-sign a))
- (babs (bfr-ite-bss bsign (unary-minus-s b) b))
- (aabs (bfr-ite-bss asign (unary-minus-s a) a))
- (bneg (unary-minus-s babs))
- ((mv & m) (floor-mod-ss aabs babs bneg)))
- (bfr-ite-bss asign (unary-minus-s m) m))))
+ (b* (((mv & & babs bneg) (bfr-sign-abs-neg-s b))
+ ((mv asign & aabs &) (bfr-sign-abs-neg-s a))
+ ((mv & m) (bfr-floor-mod-ss aabs babs bneg)))
+ (bfr-ite-bss asign (bfr-unary-minus-s m) m))))
+
+
+;; (defund logior-ss (a b)
+;; (declare (xargs :guard t
+;; :measure (+ (len a) (len b))))
+;; (b* (((mv af ar aend) (first/rest/end a))
+;; ((mv bf br bend) (first/rest/end b)))
+;; (if (and aend bend)
+;; (sterm (or af bf))
+;; (b* ((c (or af bf))
+;; (r (logior-ss ar br)))
+;; (scons c r)))))
-
-
-
-
-
-(defund lognot-s (a)
- (declare (xargs :guard t
- :measure (len a)))
- (b* (((mv a1 aend)
- (if (atom a)
- (mv nil t)
- (if (atom (cdr a))
- (mv (car a) t)
- (mv (car a) nil)))))
- (if aend
- (list (bfr-not a1))
- (cons (bfr-not a1) (lognot-s (cdr a))))))
-
-
-(defund logior-ss (a b)
+(defund bfr-logior-ss (a b)
(declare (xargs :guard t
:measure (+ (len a) (len b))))
- (b* (((mv af ar aend)
- (if (atom a)
- (mv nil nil t)
- (if (atom (cdr a))
- (mv (car a) a t)
- (mv (car a) (cdr a) nil))))
- ((mv bf br bend)
- (if (atom b)
- (mv nil nil t)
- (if (atom (cdr b))
- (mv (car b) b t)
- (mv (car b) (cdr b) nil)))))
+ (b* (((mv af ar aend) (first/rest/end a))
+ ((mv bf br bend) (first/rest/end b)))
(if (and aend bend)
- (list (bfr-or af bf))
+ (bfr-sterm (bfr-or af bf))
(b* ((c (bfr-or af bf))
- (r (logior-ss ar br)))
- (if (and (atom (cdr r))
- (hqual (car r) c))
- r
- (cons c r))))))
+ (r (bfr-logior-ss ar br)))
+ (bfr-scons c r)))))
+
+
diff -Nru acl2-6.2/books/centaur/gl/symbolic-arithmetic.lisp acl2-6.3/books/centaur/gl/symbolic-arithmetic.lisp
--- acl2-6.2/books/centaur/gl/symbolic-arithmetic.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/symbolic-arithmetic.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,13 +1,27 @@
-
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
(in-package "GL")
-
-
(include-book "symbolic-arithmetic-fns")
-
-;; (include-book "tools/with-arith5-help" :dir :system)
-;; (local (allow-arith5-help))
-
+(local (include-book "clause-processors/find-subterms" :dir :system))
+(local (include-book "centaur/bitops/ihs-extensions" :dir :system))
(local (include-book "arithmetic/top-with-meta" :dir :system))
@@ -21,949 +35,1295 @@
:hints (("goal" :use ((:instance realpart-imagpart-elim)))))
-(local (include-book "ihs/logops-lemmas" :dir :system))
-
-(local (in-theory (disable acl2::logapp acl2::logcar acl2::logcdr acl2::logtail
- acl2::logtail-identity
- acl2::logapp-0
- bfr-ite-bss-fn)))
-
-(local
- (progn
- (defthm logapp-0-n-m
- (implies (and (integerp m)
- (integerp n))
- (equal (acl2::logapp 0 m n)
- n))
- :hints(("Goal" :in-theory (enable acl2::logapp*))))
-
- (defthm logapp-1-0
- (implies (integerp n)
- (equal (acl2::logapp 1 0 n)
- (* 2 n)))
- :hints(("Goal" :in-theory (enable acl2::logapp-0))))
-
-
- (local (defthm minus-norm-to-*-minus-one
- (equal (- x) (* -1 x))))
-
- (local (in-theory (disable acl2::functional-commutativity-of-minus-*-left)))
-
- (defun ash*-ind (n sh)
- (if (zip sh)
- n
- (if (< sh 0)
- (ash*-ind (acl2::logcdr n) (1+ sh))
- (ash*-ind n (1- sh)))))
-
- (defthm logcar-possibilities
- (or (equal (acl2::logcar n) 0)
- (equal (acl2::logcar n) 1))
- :hints (("goal" :in-theory (e/d (acl2::logcar) (mod))
- :use ((:instance acl2::bitp-mod-2 (i (ifix n))))))
- :rule-classes nil)
-
- (defthm logcdr-logcar
- (equal (acl2::logcdr (acl2::logcar n)) 0)
- :hints(("Goal"
- :use logcar-possibilities)))
-
- (defthm acl2::logcdr-logapp
- (implies (and (integerp sz)
- (integerp n)
- (integerp m)
- (< 0 sz))
- (equal (acl2::logcdr (acl2::logapp sz n m))
- (acl2::logapp (1- sz) (acl2::logcdr n) m)))
- :hints(("Goal" :in-theory (enable acl2::logapp*))))
-
- (defthm ash-pos-to-logapp
- (implies (and (integerp n)
- (integerp sh)
- (<= 0 sh))
- (equal (ash n sh)
- (acl2::logapp sh 0 n)))
- :hints(("Goal" :in-theory (e/d (acl2::ash* acl2::logapp*)
- (ash acl2::logapp
- acl2::logcons
- acl2::logapp-0
- acl2::logcdr))
- :induct (ash*-ind n sh))))
-
- (defthm ash-neg-to-logtail
- (implies (and (integerp n)
- (integerp sh)
- (<= sh 0))
- (equal (ash n sh)
- (acl2::logtail (- sh) n)))
- :hints (("goal" :in-theory (e/d (acl2::ash* acl2::logtail*)
- (ash acl2::logtail
- acl2::logcdr))
- :expand ((:with acl2::ash* (ash n sh))
- (:with acl2::logtail* (acl2::logtail (- sh) n)))
- :induct (ash*-ind n sh))))
-
-
-
-
- (defthmd n2v-nonzero
- (implies (and (integerp x) (< 0 x))
- (n2v x))
- :hints(("Goal" :in-theory (enable (:induction n2v))
- :expand ((n2v x)))))
-
-
-
- (defthm n2v-when-nonzero
- (implies (and (integerp x)
- (< 0 x))
- (n2v x))
- :hints(("Goal" :in-theory (enable n2v))))
-
- (defthm right-shift-nonzero
- (implies (and (integerp x)
- (< 1 x))
- (< 0 (acl2::logtail 1 x)))
- :hints(("Goal" :in-theory (e/d (acl2::logtail*)))))))
-
-(defthm |equal-n2v-(t)|
- (equal (equal (n2v x) '(t))
- (equal x 1))
- :hints(("Goal" :induct (n2v x)
- :expand ((n2v x))
- :in-theory
- (e/d ((:induction n2v)
- n2v-nonzero)))))
-
-
-
-
-(defthm =-uu-correct
- (equal (bfr-eval (=-uu a b) env)
- (equal (v2n (bfr-eval-list a env))
- (v2n (bfr-eval-list b env))))
- :hints(("Goal" :in-theory (e/d (v2n bfr-eval-list =-uu)))))
-
-
-
-
-
-
-(defthm =-ss-correct
- (equal (bfr-eval (=-ss a b) env)
- (equal (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env))))
- :hints(("Goal" :in-theory (enable bfr-eval-list v2i
- =-ss))))
-
-
-
-
-
-
-(defthm rationalp-complex
- (equal (rationalp (complex a b))
- (equal (rfix b) 0)))
-
-
-(defthm realpart-rationalp
- (implies (rationalp x)
- (equal (realpart x) x)))
-
-(defthm realpart-complex-completion
- (equal (realpart (complex a b))
- (rfix a))
- :hints (("goal" :cases ((rationalp b)))))
-
-(defthm imagpart-complex-completion
- (equal (imagpart (complex a b))
- (rfix b))
- :hints (("goal" :cases ((rationalp a)))))
-
-
-
-
-(local
- (progn
- (in-theory (enable s-nthcdr))
-
- (defun logtail*-ind (pos i)
- (cond
- ((zp pos) i)
- (t (logtail*-ind (1- pos) (acl2::logcdr i)))))
-
- (defthm logtail-minus-one
- (implies (natp n)
- (equal (acl2::logtail n -1) -1))
- :hints(("Goal" :expand ((:with acl2::logtail* (acl2::logtail n -1)))
- :induct (logtail*-ind n -1))))))
-
-(defthm s-nthcdr-correct
- (implies (natp place)
- (equal (v2i (bfr-eval-list (s-nthcdr place n) env))
- (ash (v2i (bfr-eval-list n env)) (- place))))
- :hints(("Goal" :in-theory (e/d (bfr-eval-list v2i s-nthcdr)
- ((:definition s-nthcdr)))
- :induct (s-nthcdr place n)
- :expand ((:free (n) (s-nthcdr place n))
- (:free (place) (s-nthcdr place n))
- (:free (n) (acl2::logtail place n))))))
-
-
-
-(defthm s-nthcdr-0
- (equal (s-nthcdr 0 n) n))
-
-(local (in-theory (disable s-nthcdr)))
-
-
-(defthm s-sign-correct
- (equal (bfr-eval (s-sign x) env)
- (< (v2i (bfr-eval-list x env)) 0))
- :hints(("Goal" :in-theory (enable v2i bfr-eval-list last s-sign))))
-
-
-(defthm v2n-is-v2i-when-sign-nil
- (implies (not (bfr-eval (s-sign x) env))
- (equal (v2n (bfr-eval-list x env))
- (v2i (bfr-eval-list x env))))
- :hints(("Goal" :in-theory (enable v2i v2n bfr-eval-list s-sign last))))
-
-
-
-;; (defthm bfr-listp-bfr-p-car
-;; (implies (and (consp x)
-;; (bfr-listp x))
-;; (bfr-p (car x)))
-;; :rule-classes ((:rewrite :backchain-limit-lst 0)))
-
-
+(local (in-theory (disable bfr-ite-bss-fn)))
-;; ------------------ +-ss -------------------------------
-
-
-(local (bfr-reasoning-mode t))
-(local (in-theory (disable (force))))
-
-(defthm +-ss-correct
- (equal (v2i (bfr-eval-list (+-ss c v1 v2) env))
- (+ (if (bfr-eval c env) 1 0)
- (v2i (bfr-eval-list v1 env))
- (v2i (bfr-eval-list v2 env))))
- :hints (("Goal"
- :in-theory (enable (:induction +-ss))
- :induct (+-ss c v1 v2)
- :expand ((+-ss c v1 v2)
- (:free (a b) (v2i (cons a b)))
- (:free (a b) (bfr-eval-list (cons a b) env))
- (bfr-eval-list v1 env)
- (bfr-eval-list v2 env)))))
-
-(local (bfr-reasoning-mode nil))
-
-(defthm boolean-listp-+-ss-v2i-bind-env-car-env
- (implies (and (bind-free '((env . (car env))) (env))
-; (bfr-p c) (bfr-listp v1) (bfr-listp v2)
- (boolean-listp (+-ss c v1 v2)))
- (equal (v2i (+-ss c v1 v2))
- (+ (if (bfr-eval c env) 1 0)
- (v2i (bfr-eval-list v1 env))
- (v2i (bfr-eval-list v2 env)))))
- :hints (("goal" :use ((:instance bfr-eval-list-consts
- (x (+-ss c v1 v2)))
- +-ss-correct)
- :in-theory (disable +-ss +-ss-correct
- bfr-eval-list-consts))))
-
-;; ------------------ unary-minus-s ------------------------
-
-(local (in-theory (enable lognot-bv unary-minus-s)))
-
-(defthm v2i-lognot-bv
- (implies (consp x)
- (equal (v2i (bfr-eval-list (lognot-bv x) env))
- (+ -1 (- (v2i (bfr-eval-list x env))))))
- :hints(("Goal" :in-theory (enable bfr-eval-list v2i))))
-
-(local (in-theory (disable lognot-bv +-ss)))
-
-
-
-(defthm v2i-unary-minus-s
- (equal (v2i (bfr-eval-list (unary-minus-s x) env))
- (- (v2i (bfr-eval-list x env)))))
-
-(local (in-theory (disable unary-minus-s)))
-
-;; ------------------ *-ss ------------------------
-
-(local (in-theory (enable *-ss)))
-
-(encapsulate nil
- (local (in-theory (disable bfr-ite-bss-fn v2i
- (:definition *-ss))))
- (local (bfr-reasoning-mode t))
- (defthm *-ss-correct
- (equal (v2i (bfr-eval-list (*-ss v1 v2) env))
- (* (v2i (bfr-eval-list v1 env))
- (v2i (bfr-eval-list v2 env))))
- :hints(("Goal" :induct (*-ss v1 v2)
- :expand ((*-ss v1 v2)
- (*-ss nil v2)
- (:free (a b) (v2i (cons a b))))))))
-
-
-(defthm boolean-listp-*-ss-v2i-bind-env-car-env
- (implies (and (bind-free '((env . (car env))) (env))
- (boolean-listp (*-ss v1 v2)))
- (equal (v2i (*-ss v1 v2))
- (* (v2i (bfr-eval-list v1 env))
- (v2i (bfr-eval-list v2 env)))))
- :hints (("goal" :use ((:instance bfr-eval-list-consts
- (x (*-ss v1 v2)))
- *-ss-correct)
- :in-theory (disable *-ss *-ss-correct
- bfr-eval-list-consts))))
-
-(local (in-theory (disable *-ss)))
-
-
-
-
-
-;; ------------------- <-=-ss ----------------------------
-
-(local (in-theory (enable <-=-ss <-ss)))
-
-(defthm complex-<-1
- (equal (< (complex a b) c)
- (or (< (rfix a) (realpart c))
- (and (equal (rfix a) (realpart c))
- (< (rfix b) (imagpart c)))))
- :hints (("goal" :use ((:instance completion-of-<
- (x (complex a b)) (y c))))))
-
-(defthm complex-<-2
- (equal (< a (complex b c))
- (or (< (realpart a) (rfix b))
- (and (equal (realpart a) (rfix b))
- (< (imagpart a) (rfix c)))))
- :hints (("goal" :use ((:instance completion-of-<
- (x a) (y (complex b c)))))))
-
-
-(encapsulate nil
- (local (in-theory (disable v2i bfr-eval-list
- (:definition <-=-ss))))
- (defthm <-=-ss-correct
- (and (equal (bfr-eval (mv-nth 0 (<-=-ss a b)) env)
- (< (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env))))
- (equal (bfr-eval (mv-nth 1 (<-=-ss a b)) env)
- (equal (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env)))))
- :hints(("Goal"
- :induct (<-=-ss a b)
- :expand ((<-=-ss a b)
- (:free (a b) (v2i (cons a b)))
- (:free (a b) (bfr-eval-list (cons a b) env))
- (bfr-eval-list a env)
- (bfr-eval-list b env))))))
-
-(local (in-theory (disable <-=-ss)))
-
-
-
-(defthm <-ss-correct
- (equal (bfr-eval (<-ss a b) env)
- (< (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env))))
- :hints(("Goal" :in-theory (e/d ())
- :expand ((bfr-eval-list a env)
- (bfr-eval-list b env)
- (:free (a b) (v2i (cons a b))))
- :do-not-induct t)))
-
-(local (in-theory (disable <-ss)))
-
-
-;; ------------------ ash-ss ------------------------
-
-(local (in-theory (enable ash-ss)))
-
-
-
-(local
- (progn
- (defthm make-list-ac-nil-v2i-eval
- (equal (v2i (bfr-eval-list (make-list-ac n nil m) env))
- (acl2::logapp (nfix n) 0 (v2i (bfr-eval-list m env))))
- :hints(("Goal" :in-theory (enable bfr-eval-list v2i acl2::logapp-0))))
-
- (defthm make-list-ac-nil-v2i-eval
- (equal (v2i (bfr-eval-list (make-list-ac n nil m) env))
- (acl2::logapp (nfix n) 0 (v2i (bfr-eval-list m env))))
- :hints(("Goal" :in-theory (enable make-list-ac))))))
-
-
-(local
- (defthm reverse-distrib-1
- (and (equal (+ n n) (* 2 n))
- (implies (syntaxp (quotep k))
- (equal (+ n (* k n)) (* (+ 1 k) n)))
- (implies (syntaxp (and (quotep a) (quotep b)))
- (equal (+ (* a n) (* b n)) (* (+ a b) n)))
- (equal (+ n n m) (+ (* 2 n) m))
- (implies (syntaxp (quotep k))
- (equal (+ n (* k n) m) (+ (* (+ 1 k) n) m)))
- (implies (syntaxp (and (quotep a) (quotep b)))
- (equal (+ (* a n) (* b n) m) (+ (* (+ a b) n) m))))))
-
-
-
-
-(encapsulate nil
- (local (in-theory (disable acl2::logtail-identity
- bfr-ite-bss-fn
- equal-of-booleans-rewrite)))
- (local (bfr-reasoning-mode t))
- (defthm ash-ss-correct
- (implies (and
- (posp place))
- (equal (v2i (bfr-eval-list (ash-ss place n shamt) env))
- (ash (v2i (bfr-eval-list n env))
- (+ -1 place (* place (v2i (bfr-eval-list shamt env)))))))
- :hints (("goal" :induct (ash-ss place n shamt)
- :in-theory (e/d (logapp-1-0) ((:definition ash-ss)))
- :expand ((ash-ss place n shamt)
- (ash-ss place n nil)
- (bfr-eval-list shamt env)
- (:free (a b) (v2i (cons a b)))))
- (and stable-under-simplificationp
- '(:cases ((<= 0 (+ -1 PLACE
- (* 2 PLACE
- (V2I (BFR-EVAL-LIST (CDR SHAMT)
- ENV))))))))
- (and stable-under-simplificationp
- '(:cases ((<= 0 (+ -1 (* 2 PLACE)
- (* 2 PLACE
- (V2I (BFR-EVAL-LIST (CDR SHAMT) ENV)))))))))))
-
-(local (in-theory (disable ash-ss)))
-
-
-
-
-;; ------------------ logbitp-n2v -------------------------------
-
-(local (in-theory (enable logbitp-n2v)))
-
-(local
- (progn
- (defun logbitp*-ind (pos i)
- (cond ((zp pos) (equal (acl2::logcar i) 1))
- (t (logbitp*-ind (1- pos) (acl2::logcdr i)))))
-
- (encapsulate nil
- (local (defthm logbitp-0-natp
- (implies (natp n)
- (equal (logbitp n 0) nil))
- :hints(("Goal"
- :expand ((:with acl2::logbitp* (logbitp n 0)))
- :induct (logbitp*-ind n 0)))
- :rule-classes nil))
- (defthm logbitp-0
- (equal (logbitp n 0) nil)
- :hints (("goal" :use ((:instance logbitp-0-natp (n (nfix n))))
- :in-theory (enable logbitp))))
-
- (local (defthm logbitp-minus-1-natp
- (implies (natp n)
- (equal (logbitp n -1) t))
- :hints(("Goal"
- :expand ((:with acl2::logbitp* (logbitp n -1)))
- :induct (logbitp*-ind n -1)))))
-
- (defthm logbitp-minus-1
- (equal (logbitp n -1) t)
- :hints (("goal" :use ((:instance logbitp-minus-1-natp (n (nfix n))))
- :in-theory (enable logbitp)))))
-
- (defthm logbitp-to-logcar-logtail
- (implies (and (natp n) (integerp i))
- (equal (logbitp n i)
- (equal (acl2::logcar (acl2::logtail n i)) 1)))
- :hints (("goal" :induct (logtail*-ind n i)
- :expand ((:with acl2::logbitp* (:free (n) (logbitp n i)))
- (:with acl2::logtail* (acl2::logtail n i))))))))
-
-
-(defthm logbitp-n2v-correct
- (implies (and
- (posp place))
- (equal (bfr-eval (logbitp-n2v place digit n) env)
- (logbitp (* place (v2n (bfr-eval-list digit env)))
- (v2i (bfr-eval-list n env)))))
- :hints(("Goal" :in-theory (e/d (bfr-eval-list logapp-1-0)
- ((:definition logbitp-n2v) floor
+(local (defun cdr3-ind (a e b)
+ (declare (xargs :measure (+ (len a) (len e) (len b))))
+ (if (and (atom a) (atom e) (atom b))
+ (list a e b)
+ (cdr3-ind (cdr a) (cdr e) (cdr b)))))
+
+(local (defun scdr2-ind (a e)
+ (declare (xargs :measure (+ (len a) (len e))))
+ (if (and (s-endp a) (s-endp e))
+ (list a e)
+ (scdr2-ind (scdr a) (scdr e)))))
+
+(local (defun scdr3-ind (a e b)
+ (declare (xargs :measure (+ (len a) (len e) (len b))))
+ (if (and (s-endp a) (s-endp e) (s-endp b))
+ (list a e b)
+ (scdr3-ind (scdr a) (scdr e) (scdr b)))))
+
+
+
+(defsection =-uu
+
+ (local (in-theory (enable bfr-=-uu)))
+
+ ;; (defcong uv-equiv equal (=-uu a b) 1
+ ;; :hints(("Goal" :in-theory (e/d (uv-equiv-implies-cars-equiv)
+ ;; (uv-equiv))
+ ;; :induct (cdr3-ind a a-equiv b))))
+ ;; (defcong uv-equiv equal (=-uu a b) 2
+ ;; :hints(("Goal" :in-theory (e/d (uv-equiv-implies-cars-equiv)
+ ;; (uv-equiv))
+ ;; :induct (cdr3-ind a b b-equiv))))
+
+ (defthm bfr-=-uu-correct
+ (equal (bfr-eval (bfr-=-uu a b) env)
+ (= (bfr-list->u a env) (bfr-list->u b env))))
+
+ (defthm pbfr-depends-on-of-bfr-=-uu
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b)))
+ (not (pbfr-depends-on n p (bfr-=-uu a b))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on)))))
+
+(defsection =-ss
+
+ (local (in-theory (enable bfr-=-ss)))
+
+ ;; (defcong sv-equiv equal (=-ss a b) 1
+ ;; :hints(("Goal" :in-theory (e/d (scdr-when-equiv-to-endp)
+ ;; (sv-equiv))
+ ;; :induct (scdr3-ind a a-equiv b))))
+ ;; (defcong sv-equiv equal (=-ss a b) 2
+ ;; :hints(("Goal" :in-theory (e/d (scdr-when-equiv-to-endp)
+ ;; (sv-equiv))
+ ;; :induct (scdr3-ind a b b-equiv))))
+
+ (defthm bfr-=-ss-correct
+ (equal (bfr-eval (bfr-=-ss a b) env)
+ (= (bfr-list->s a env)
+ (bfr-list->s b env)))
+ :hints (("goal" :induct (scdr2-ind a b))))
+
+ (defthm pbfr-depends-on-of-bfr-=-ss
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b)))
+ (not (pbfr-depends-on n p (bfr-=-ss a b))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on)))))
+
+(defsection logtail-ns
+
+ (local (in-theory (enable logtail-ns)))
+
+ ;; (local (defun scdr2/count-ind (n x y)
+ ;; (declare (xargs :measure (nfix n)))
+ ;; (if (or (zp n) (s-endp x) (s-endp y))
+ ;; (list n x y)
+ ;; (scdr2/count-ind (1- (nfix n)) (scdr x) (scdr y)))))
+
+ ;; (local (defthm logtail-of-equiv-to-endp
+ ;; (IMPLIES (AND (S-ENDP X-EQUIV)
+ ;; (SV-EQUIV X X-EQUIV))
+ ;; (SV-EQUIV (LOGTAIL-NS N X)
+ ;; X))
+ ;; :hints (("goal" :induct (LOGTAIL-NS N X)
+ ;; :in-theory (e/d (scdr-when-equiv-to-endp)
+ ;; (sv-equiv))))))
+
+ ;; (defcong sv-equiv sv-equiv (logtail-ns n x) 2
+ ;; :hints(("Goal" :in-theory (e/d (scdr-when-equiv-to-endp)
+ ;; (sv-equiv))
+ ;; :induct (scdr2/count-ind n x x-equiv)
+ ;; :expand ((:free (x) (logtail-ns n x))))))
+
+ (defthm bfr-logtail-ns-correct
+ (equal (bfr-list->s (logtail-ns place n) env)
+ (logtail place (bfr-list->s n env)))
+ :hints(("Goal" :in-theory (enable acl2::logtail**))))
+
+ (defthm pbfr-list-depends-on-of-logtail-ns
+ (implies (not (pbfr-list-depends-on k p n))
+ (not (pbfr-list-depends-on k p (logtail-ns place n))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on)))))
+
+ ;; (defthm logtail-ns-correct
+ ;; (equal (v2i (logtail-ns place n))
+ ;; (logtail place (v2i n)))
+ ;; :hints(("Goal" :in-theory (e/d (bfr-eval-list v2i acl2::logtail**))))))
+
+
+(defsection s-sign
+ (local (in-theory (enable s-sign)))
+
+ ;; (defcong sv-equiv iff (s-sign x) 1
+ ;; :hints(("Goal" :in-theory (e/d (scdr-when-equiv-to-endp)
+ ;; (sv-equiv))
+ ;; :induct (scdr2-ind x x-equiv))))
+
+ (defthm bfr-s-sign-correct
+ (equal (bfr-eval (s-sign x) env)
+ (< (bfr-list->s x env) 0)))
+
+ (defthm pbfr-depends-on-of-s-sign
+ (implies (not (pbfr-list-depends-on k p n))
+ (not (pbfr-depends-on k p (s-sign n))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on)))))
+
+ ;; (defthm s-sign-correct
+ ;; (iff (s-sign x)
+ ;; (< (v2i x) 0))
+ ;; :hints(("Goal" :in-theory (enable v2i last s-sign)))))
+
+
+(defsection +-ss
+
+ ;; (local (defthm consp-cdr-sfix
+ ;; (implies (not (consp (cdr x)))
+ ;; (not (consp (cdr (sfix x)))))))
+
+ ;; (local (in-theory (enable car-of-sfix)))
+
+ (local (in-theory (enable bfr-+-ss)))
+
+ (defthm bfr-+-ss-correct
+ (equal (bfr-list->s (bfr-+-ss c v1 v2) env)
+ (+ (acl2::bool->bit (bfr-eval c env))
+ (bfr-list->s v1 env)
+ (bfr-list->s v2 env)))
+ :hints(("Goal" :in-theory (e/d (logcons)
+ ((:d bfr-+-ss)))
+ :induct (bfr-+-ss c v1 v2)
+ :expand ((bfr-+-ss c v1 v2)
+ ;; (:free (a b) (bfr-eval-list (cons a b) env))
+ ;; (bfr-eval-list nil env)
+ ))))
+
+
+ (defthm pbfr-list-depends-on-of-bfr-+-ss
+ (implies (and (not (pbfr-depends-on n p c))
+ (not (pbfr-list-depends-on n p v1))
+ (not (pbfr-list-depends-on n p v2)))
+ (not (pbfr-list-depends-on n p (bfr-+-ss c v1 v2))))
+ :hints(("Goal" :in-theory (e/d (pbfr-list-depends-on)
+ ((pbfr-list-depends-on)
+ (pbfr-depends-on)
+ (:d bfr-+-ss)))
+ :induct (bfr-+-ss c v1 v2)
+ :expand ((bfr-+-ss c v1 v2)))))
+)
+ ;; (and stable-under-simplificationp
+;; (let ((call (acl2::find-call '+-ss (caddr (car (last clause))))))
+;; (and call
+;; (let ((res `(:expand (,call
+;; (bfr-+-ss c v1 v2)
+;; (:free (a b) (sfix (cons a b)))
+;; ;; (:free (a b) (bfr-eval-list (cons a b) env))
+;; ;; (bfr-eval-list nil env)
+;; )
+;; :use ((:instance
+;; bfr-eval-list-when-not-s-endp
+;; (x v1))
+;; (:instance
+;; bfr-eval-list-when-not-s-endp
+;; (x v2))))))
+;; ; (or (cw "expand: ~x0~%" res)
+;; res))))
+;; (bfr-reasoning)))
+
+;; ;; (defcong iff sv-equiv (+-ss c a b) 1)
+
+
+;; ;; (defthm +-ss-correct
+;; ;; (equal (v2i (+-ss c v1 v2))
+;; ;; (+ (acl2::bool->bit c)
+;; ;; (v2i v1) (v2i v2)))
+;; ;; :hints(("Goal" :in-theory (enable v2i +-ss logcons xor (:t v2i)))))
+
+
+;; ;; (defcong sv-equiv sv-equiv (+-ss c a b) 2
+;; ;; :hints (("goal" :use ((:instance i2v-v2i
+;; ;; (v (+-ss c a b)))
+;; ;; (:instance i2v-v2i
+;; ;; (v (+-ss c a-equiv b))))
+;; ;; :in-theory (disable sv-equiv)
+;; ;; :do-not-induct t)
+;; ;; (and stable-under-simplificationp
+;; ;; '(:in-theory (enable sv-equiv)))))
+
+;; ;; (defcong sv-equiv sv-equiv (+-ss c a b) 3
+;; ;; :hints (("goal" :use ((:instance i2v-v2i
+;; ;; (v (+-ss c a b)))
+;; ;; (:instance i2v-v2i
+;; ;; (v (+-ss c a b-equiv))))
+;; ;; :in-theory (disable sv-equiv)
+;; ;; :do-not-induct t)
+;; ;; (and stable-under-simplificationp
+;; ;; '(:in-theory (enable sv-equiv)))))
+
+
+;; ;; (local (defthm sv-equiv-sterm
+;; ;; (implies (and (sv-equiv a b)
+;; ;; (s-endp b))
+;; ;; (and (equal (sv-equiv a (sterm c))
+;; ;; (iff (car b) c))
+;; ;; (equal (sv-equiv (sterm c) a)
+;; ;; (iff (car b) c))))
+;; ;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+;; ;; (local (defthmd sv-equiv-+-ss-endp
+;; ;; (implies (and (sv-equiv a a-equiv)
+;; ;; (s-endp a-equiv)
+;; ;; (s-endp b))
+;; ;; (sv-equiv (+-ss c a b)
+;; ;; ;; (scons (xor c (xor (car a-equiv) (car b)))
+;; ;; ;; (sterm (if (xor (car a-equiv) (car b))
+;; ;; ;; c
+;; ;; ;; (car a-equiv))))))
+;; ;; (+-ss c a-equiv b)))
+;; ;; :hints (("goal" :induct (+-ss c a b)
+;; ;; :expand ((:free (c b) (+-ss c a b))
+;; ;; (:free (c b) (+-ss c a-equiv b)))
+;; ;; :in-theory (e/d (sv-equiv-of-scons)
+;; ;; (sv-equiv (:d +-ss) (sterm)))))))
+
+;; ;; ;; (local (defthm sv-equiv-+-ss-endp2
+;; ;; ;; (implies (and (sv-equiv a a-equiv)
+;; ;; ;; (s-endp a-equiv)
+;; ;; ;; (s-endp b))
+;; ;; ;; (sv-equiv (+-ss c a b)
+;; ;; ;; (scons (xor c (xor (car a-equiv) (car b)))
+;; ;; ;; (sterm (if (xor (car a-equiv) (car b))
+;; ;; ;; (not c)
+;; ;; ;; (car a-equiv))))))
+;; ;; ;; :hints (("goal" :use sv-equiv-+-ss-endp
+;; ;; ;; :in-theory (disable sv-equiv)
+;; ;; ;; :do-not-induct t))))
+
+
+;; ;; ;; (local (defthm sv-equiv-sterm-2
+;; ;; ;; (implies (sv-equiv (scdr a) (sterm c))
+;; ;; ;; (and (equal (sv-equiv a (sterm c))
+;; ;; ;; (iff (car a) c))
+;; ;; ;; (equal (sv-equiv (sterm c) a)
+;; ;; ;; (iff (car a) c))))
+;; ;; ;; :hints(("Goal" :in-theory (e/d (scons sterm))))
+;; ;; ;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+;; ;; (local (defthm sv-equiv-of-scons-2
+;; ;; (equal (sv-equiv c (scons a b))
+;; ;; (and (iff (car c) a)
+;; ;; (sv-equiv (scdr c) b)))
+;; ;; :hints (("goal" :in-theory (disable sv-equiv-of-scons)
+;; ;; :use sv-equiv-of-scons))))
+
+;; ;; ;; (local (defthm sv-equiv-of-singleton-2
+;; ;; ;; (implies (and (sv-equiv a b)
+;; ;; ;; (s-endp b))
+;; ;; ;; (equal (sv-equiv (list c) a)
+;; ;; ;; (iff (car b) c)))
+;; ;; ;; :hints(("Goal" :in-theory (enable sfix s-endp)))
+;; ;; ;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+;; ;; (local (defun-nx +-ss-cong-ind (c a b e)
+;; ;; (declare (xargs :measure (+ (len a) (len b) (len e))))
+;; ;; (b* (((mv heada taila enda) (first/rest/end a))
+;; ;; ((mv headb tailb endb) (first/rest/end b))
+;; ;; ((mv ?heade taile ende) (first/rest/end e))
+;; ;; (axorb (xor heada headb)))
+;; ;; (if (and enda endb ende)
+;; ;; (list c a b e)
+;; ;; (+-ss-cong-ind (or (and c axorb)
+;; ;; (and heada headb))
+;; ;; taila tailb taile)))))
+
+
+;; ;; (defcong sv-equiv sv-equiv (+-ss c a b) 2
+;; ;; :hints (("goal" :induct (+-ss-cong-ind c a b a-equiv)
+;; ;; :expand ((:free (c) (+-ss c a b))
+;; ;; (:free (c) (+-ss c a-equiv b)))
+;; ;; :in-theory (e/d (scdr-when-equiv-to-endp
+;; ;; ;; sv-equiv-of-scons
+;; ;; )
+;; ;; (sv-equiv (sterm)
+;; ;; ; sterm-when-s-endp
+;; ;; ;; (:d +-ss)
+;; ;; )))
+;; ;; (and stable-under-simplificationp
+;; ;; '(:use ((:instance sv-equiv-+-ss-endp))))))
+
+;; ;; (defthmd +-ss-commutes
+;; ;; (sv-equiv (+-ss c a b)
+;; ;; (+-ss c b a))
+;; ;; :hints (("goal" :induct t :do-not-induct t
+;; ;; :in-theory (disable sv-equiv))))
+
+;; ;; (defcong sv-equiv sv-equiv (+-ss c a b) 3
+;; ;; :hints (("goal" :do-not-induct t
+;; ;; :in-theory (disable sv-equiv)
+;; ;; :use ((:instance +-ss-commutes)
+;; ;; (:instance +-ss-commutes (b b-equiv))))))
+
+;; ;; (defthmd bfr-eval-list-when-not-s-endp
+;; ;; (implies (not (s-endp x))
+;; ;; (sv-equiv (bfr-eval-list x env)
+;; ;; (scons (bfr-eval (car x) env)
+;; ;; (bfr-eval-list (scdr x) env))))
+;; ;; :hints(("Goal" :in-theory (enable s-endp scdr scons))))
+
+;; ;; ;; (local (defthm v2i-when-empty
+;; ;; ;; (implies (not (consp (cdr x)))
+;; ;; ;; (equal (v2i x)
+;; ;; ;; (if (car x) -1 0)))
+;; ;; ;; :hints(("Goal" :in-theory (enable v2i)))
+;; ;; ;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+;; ;; (local (in-theory (disable (:t acl2::logcons-negp)
+;; ;; (:t acl2::logcons-posp-2)
+;; ;; (:t acl2::logcons-natp)
+;; ;; (:t acl2::logcons-posp-1)
+;; ;; (:t natp)
+;; ;; (:t acl2::negp)
+;; ;; (:t posp)
+;; ;; (:t bfr-eval)
+;; ;; (:t bfr-+-ss)
+;; ;; (:t +-ss)
+;; ;; (:t v2i)
+;; ;; (:t acl2::logcons-type)
+;; ;; iff xor not
+;; ;; equal-of-booleans-rewrite
+;; ;; sets::double-containment
+;; ;; boolean-list-bfr-eval-list-const)))
+
+;; ;; (local (defthm open-+-ss-rec
+;; ;; (implies (or (consp (cdr v1))
+;; ;; (consp (cdr v2)))
+;; ;; (equal (+-ss c v1 v2)
+;; ;; (B* (((MV HEAD1 TAIL1 ?END1)
+;; ;; (FIRST/REST/END V1))
+;; ;; ((MV HEAD2 TAIL2 ?END2)
+;; ;; (FIRST/REST/END V2))
+;; ;; (AXORB (XOR HEAD1 HEAD2))
+;; ;; (S (XOR C AXORB)))
+;; ;; (LET* ((C (OR (AND C AXORB) (AND HEAD1 HEAD2)))
+;; ;; (RST (+-SS C TAIL1 TAIL2)))
+;; ;; (IF (AND (ATOM (CDR RST)) (IFF S (CAR RST)))
+;; ;; RST (CONS S RST))))))
+;; ;; :rule-classes ((:rewrite :backchain-limit-lst 1))))
+
+;; ;; (local (defthm consp-of-bfr-eval-list
+;; ;; (equal (consp (bfr-eval-list x env))
+;; ;; (consp x))
+;; ;; :hints(("Goal" :in-theory (enable bfr-eval-list)))))
+
+;; ;; (local (defthm open-+-ss-base
+;; ;; (implies (and (not (consp (cdr v1)))
+;; ;; (not (consp (cdr v2))))
+;; ;; (equal (+-ss c v1 v2)
+;; ;; (B* (((MV HEAD1 ?TAIL1 ?END1)
+;; ;; (FIRST/REST/END V1))
+;; ;; ((MV HEAD2 ?TAIL2 ?END2)
+;; ;; (FIRST/REST/END V2))
+;; ;; (AXORB (XOR HEAD1 HEAD2))
+;; ;; (S (XOR C AXORB)))
+;; ;; (LET ((LAST (IF AXORB (NOT C) HEAD1)))
+;; ;; (IF (IFF S LAST)
+;; ;; (LIST S)
+;; ;; (LIST S LAST))))))
+;; ;; :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+;; (local (in-theory (e/d (;; bfr-eval-list-when-not-s-endp
+;; )
+;; (bfr-eval-list-of-scdr))))
+
+;; (defthm s-endp-of-scons
+;; (equal (s-endp (scons b x))
+;; (and (s-endp x)
+;; (iff b (car x))))
+;; :hints(("Goal" :in-theory (enable s-endp scons))))
+
+;; ;; (defthm sterm-of-bfr-eval-of-car
+;; ;; (implies (s-endp x)
+;; ;; (equal (sterm (bfr-eval (car x) env))
+;; ;; (bfr-eval-list x env)))
+;; ;; :hints(("Goal" :in-theory (enable s-endp sterm)
+
+;; (defthm bfr-+-ss-correct
+;; (sv-equiv (bfr-eval-list (bfr-+-ss c v1 v2) env)
+;; (+-ss (bfr-eval c env)
+;; (bfr-eval-list v1 env)
+;; (bfr-eval-list v2 env)))
+;; :hints(("Goal" :in-theory (e/d ()
+;; ((:d bfr-+-ss) sv-equiv (sterm)))
+;; :induct (bfr-+-ss c v1 v2)
+;; :expand ((bfr-+-ss c v1 v2)
+;; (:free (a b) (sfix (cons a b)))
+;; ;; (:free (a b) (bfr-eval-list (cons a b) env))
+;; ;; (bfr-eval-list nil env)
+;; ))
+;; (and stable-under-simplificationp
+;; (let ((call (acl2::find-call '+-ss (caddr (car (last clause))))))
+;; (and call
+;; (let ((res `(:expand (,call
+;; (bfr-+-ss c v1 v2)
+;; (:free (a b) (sfix (cons a b)))
+;; ;; (:free (a b) (bfr-eval-list (cons a b) env))
+;; ;; (bfr-eval-list nil env)
+;; )
+;; :use ((:instance
+;; bfr-eval-list-when-not-s-endp
+;; (x v1))
+;; (:instance
+;; bfr-eval-list-when-not-s-endp
+;; (x v2))))))
+;; ; (or (cw "expand: ~x0~%" res)
+;; res))))
+;; (bfr-reasoning)))
+
+;; )
+
+
+(defsection lognot-s
+ (local (in-theory (enable bfr-lognot-s)))
+
+ (defthm bfr-lognot-s-correct
+ (equal (bfr-list->s (bfr-lognot-s x) env)
+ (lognot (bfr-list->s x env))))
+
+ (defthm pbfr-list-depends-on-of-bfr-lognot-s
+ (implies (not (pbfr-list-depends-on k p x))
+ (not (pbfr-list-depends-on k p (bfr-lognot-s x))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on)))))
+
+ ;; (defthm lognot-s-correct
+ ;; (equal (v2i (lognot-s x))
+ ;; (lognot (v2i x)))
+ ;; :hints(("Goal" :in-theory (enable v2i)))))
+
+
+(defsection unary-minus-s
+ (local (in-theory (enable bfr-unary-minus-s)))
+
+ (defthm bfr-unary-minus-s-correct
+ (equal (bfr-list->s (bfr-unary-minus-s x) env)
+ (- (bfr-list->s x env)))
+ :hints(("Goal" :in-theory (enable logcons lognot))))
+
+ (defthm pbfr-list-depends-on-of-bfr-unary-minus-s
+ (implies (not (pbfr-list-depends-on n p x))
+ (not (pbfr-list-depends-on n p (bfr-unary-minus-s x))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on)))))
+
+ ;; (defthm unary-minus-s-correct
+ ;; (equal (v2i (unary-minus-s x))
+ ;; (- (v2i x)))
+ ;; :hints(("Goal" :in-theory (enable v2i lognot)))))
+
+(defsection *-ss
+
+ (local (in-theory (enable bfr-*-ss)))
+
+ (defthm bfr-*-ss-correct
+ (equal (bfr-list->s (bfr-*-ss v1 v2) env)
+ (* (bfr-list->s v1 env)
+ (bfr-list->s v2 env)))
+ :hints(("Goal" :induct (bfr-*-ss v1 v2)
+ :in-theory (enable bfr-*-ss logcons)
+ :expand ((bfr-*-ss v1 v2)
+ (bfr-*-ss nil v2)))))
+
+ (defthm pbfr-list-depends-on-of-bfr-*-ss
+ (implies (and (not (pbfr-list-depends-on n p v1))
+ (not (pbfr-list-depends-on n p v2)))
+ (not (pbfr-list-depends-on n p (bfr-*-ss v1 v2))))
+ :hints(("Goal" :in-theory (e/d (pbfr-list-depends-on)
+ ((pbfr-list-depends-on)
+ (pbfr-depends-on)
+ (:d bfr-*-ss)))
+ :induct (bfr-*-ss v1 v2)
+ :expand ((bfr-*-ss v1 v2))))))
+
+ ;; (local (defthm +-double-minus
+ ;; (equal (+ x (- (* 2 x)))
+ ;; (- x))))
+
+ ;; (local (defthm +-double-minus-s
+ ;; (sv-equiv (+-ss nil v2 (scons nil (unary-minus-s v2)))
+ ;; (unary-minus-s v2))
+ ;; :hints (("goal" :use ((:instance i2v-v2i
+ ;; (v (+-ss nil v2 (scons nil (unary-minus-s
+ ;; v2)))))
+ ;; (:instance i2v-v2i
+ ;; (v (unary-minus-s v2))))
+ ;; :in-theory (enable logcons)))))
+
+ ;; (local (defthmd *-ss-equiv-when-end
+ ;; (implies (and (sv-equiv v1 v1-equiv)
+ ;; (s-endp v1-equiv))
+ ;; (sv-equiv (*-ss v1 v2)
+ ;; (*-ss v1-equiv v2)))
+ ;; :hints (("goal" :induct (*-ss v1 v2)
+ ;; :in-theory (disable sv-equiv)))))
+
+ ;; ;; (local (defun *-ss-cong-ind-1 (v1 v1e)
+ ;; ;; (b* (((mv dig1 rest1 end1) (first/rest/end v1))
+ ;; ;; ((mv ?dige reste ende) (first/rest/end v1e)))
+ ;; ;; (if (and end1 ende)
+ ;; ;; (list v1 v1e)
+ ;; ;; (*-ss-cong-ind-1 rest1 reste)))))
+
+ ;; (defcong sv-equiv sv-equiv (*-ss x y) 1
+ ;; :hints (("goal" :induct (scdr2-ind x x-equiv)
+ ;; :in-theory (disable sv-equiv)))))
+
+ ;; (local (in-theory (disable bfr-ite-bss-fn v2i
+ ;; (:definition bfr-*-ss))))
+
+ ;; (defthm bfr-*-ss-correct
+ ;; (
+
+
+
+ ;; (local (bfr-reasoning-mode t))
+
+
+
+ ;; )
+
+
+(defsection <-=-ss
+ (local (in-theory (enable bfr-<-=-ss)))
+
+ (defthm bfr-<-=-ss-correct
+ (b* (((mv less equal) (bfr-<-=-ss a b)))
+ (and (equal (bfr-eval less env)
+ (< (bfr-list->s a env)
+ (bfr-list->s b env)))
+ (equal (bfr-eval equal env)
+ (= (bfr-list->s a env)
+ (bfr-list->s b env)))))
+ :hints(("Goal" :in-theory (e/d () ((:d bfr-<-=-ss)))
+ :induct (bfr-<-=-ss a b)
+ :expand ((bfr-<-=-ss a b)))))
+
+ (defthm pbfr-depends-on-of-bfr-<-=-ss
+ (b* (((mv less equal) (bfr-<-=-ss a b)))
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b)))
+ (and (not (pbfr-depends-on n p less))
+ (not (pbfr-depends-on n p equal)))))))
+
+
+(defsection bfr-<-ss
+
+ (local (in-theory (enable bfr-<-ss)))
+
+ (defthm bfr-<-ss-correct
+ (equal (bfr-eval (bfr-<-ss a b) env)
+ (< (bfr-list->s a env)
+ (bfr-list->s b env))))
+
+ (defthm pbfr-depends-on-of-bfr-<-ss
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b)))
+ (not (pbfr-depends-on n p (bfr-<-ss a b))))))
+
+
+(defsection bfr-logapp-nss
+ (local (in-theory (enable bfr-logapp-nss)))
+
+ (defthm bfr-logapp-nss-correct
+ (equal (bfr-list->s (bfr-logapp-nss n a b) env)
+ (logapp n (bfr-list->s a env)
+ (bfr-list->s b env)))
+ :hints(("Goal" :in-theory (enable acl2::logapp** acl2::ash**))))
+
+ (defthm pbfr-list-depends-on-of-bfr-logapp-nss
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b)))
+ (not (pbfr-list-depends-on n p (bfr-logapp-nss m a b))))))
+
+(defsection bfr-logapp-nus
+ (local (in-theory (enable bfr-logapp-nus)))
+
+ (defthm bfr-logapp-nus-correct
+ (equal (bfr-list->s (bfr-logapp-nus n a b) env)
+ (logapp n (bfr-list->u a env)
+ (bfr-list->s b env)))
+ :hints(("Goal" :in-theory (enable acl2::logapp**
+ acl2::ash**
+ acl2::loghead**))))
+
+ (defthm pbfr-list-depends-on-of-bfr-logapp-nus
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b)))
+ (not (pbfr-list-depends-on n p (bfr-logapp-nus m a b))))))
+
+(defsection bfr-ash-ss
+
+ (local (in-theory (enable bfr-ash-ss)))
+
+ (local
+ (defthm reverse-distrib-1
+ (and (equal (+ n n) (* 2 n))
+ (implies (syntaxp (quotep k))
+ (equal (+ n (* k n)) (* (+ 1 k) n)))
+ (implies (syntaxp (quotep k))
+ (equal (+ (- n) (* k n)) (* (+ -1 k) n)))
+ (implies (syntaxp (quotep k))
+ (equal (+ (- n) (* k n) m) (+ (* (+ -1 k) n) m)))
+ (implies (syntaxp (and (quotep a) (quotep b)))
+ (equal (+ (* a n) (* b n)) (* (+ a b) n)))
+ (equal (+ n n m) (+ (* 2 n) m))
+ (implies (syntaxp (quotep k))
+ (equal (+ n (* k n) m) (+ (* (+ 1 k) n) m)))
+ (implies (syntaxp (and (quotep a) (quotep b)))
+ (equal (+ (* a n) (* b n) m) (+ (* (+ a b) n) m)))
+ (equal (+ n (- (* 2 n)) m)
+ (+ (- n) m))
+ )))
+
+ (defthm bfr-ash-ss-correct
+ (implies (posp place)
+ (equal (bfr-list->s (bfr-ash-ss place n shamt) env)
+ (ash (bfr-list->s n env)
+ (+ -1 place (* place (bfr-list->s shamt env))))))
+ :hints(("Goal" :in-theory (e/d (acl2::ash**) ((:d bfr-ash-ss)))
+ :induct (bfr-ash-ss place n shamt)
+ :expand ((bfr-ash-ss place n shamt)
+ (:free (b) (logcons b (bfr-list->s (scdr shamt) env)))))))
+
+ (defthm pbfr-list-depends-on-of-bfr-ash-ss
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b)))
+ (not (pbfr-list-depends-on n p (bfr-ash-ss place a b))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on)))))
+
+;; (encapsulate nil
+;; (local (defthm ash-of-logcons-0
+;; (implies (<= 0 (ifix m))
+;; (equal (ash (logcons 0 n) m)
+;; (logcons 0 (ash n m))))
+;; :hints(("Goal" :in-theory (enable* acl2::ihsext-inductions
+;; acl2::ihsext-recursive-redefs)))))
+
+;; (local
+;; (defthm make-list-ac-nil-v2i-eval
+;; (equal (v2i (bfr-eval-list (make-list-ac n nil m) env))
+;; (acl2::logapp (nfix n) 0 (v2i (bfr-eval-list m env))))
+;; :hints(("Goal" :in-theory (enable bfr-eval-list v2i acl2::ash**)))))
+
+;; (local (in-theory (disable acl2::logtail-identity
+;; bfr-ite-bss-fn
+;; equal-of-booleans-rewrite)))
+;; (local (in-theory (enable bfr-ash-ss logcons)))
+
+;; (local (defthm logtail-of-logtail-free
+;; (implies (equal y (logtail m z))
+;; (equal (logtail n y)
+;; (logtail (+ (nfix m) (nfix n)) z)))))
+
+
+;; ;; (local (bfr-reasoning-mode t))
+;; (defthm bfr-ash-ss-correct
+;; (implies (and
+;; (posp place))
+;; (equal (v2i (bfr-eval-list (bfr-ash-ss place n shamt) env))
+;; (ash (v2i (bfr-eval-list n env))
+;; (+ -1 place (* place (v2i (bfr-eval-list shamt env)))))))
+;; :hints (("goal" :induct (bfr-ash-ss place n shamt)
+;; :in-theory (e/d () ((:definition bfr-ash-ss)))
+;; :expand ((bfr-ash-ss place n shamt)
+;; (bfr-ash-ss place n nil)
+;; (bfr-eval-list shamt env)
+;; (:free (a b) (v2i (cons a b)))))
+;; (and stable-under-simplificationp
+;; '(:cases ((<= 0 (+ -1 PLACE
+;; (* 2 PLACE
+;; (V2I (BFR-EVAL-LIST (CDR SHAMT)
+;; ENV))))))))
+;; (and stable-under-simplificationp
+;; '(:cases ((<= 0 (+ -1 (* 2 PLACE)
+;; (* 2 PLACE
+;; (V2I (BFR-EVAL-LIST (CDR SHAMT)
+;; ENV)))))))))))
+
+(defsection bfr-logbitp-n2v
+ (local (in-theory (enable bfr-logbitp-n2v)))
+
+ (defthm bfr-logbitp-n2v-correct
+ (implies (posp place)
+ (equal (bfr-eval (bfr-logbitp-n2v place digit n) env)
+ (logbitp (* place (bfr-list->u digit env))
+ (bfr-list->s n env))))
+ :hints(("Goal" :in-theory (e/d (acl2::logbitp** logcons acl2::bool->bit)
+ ((:d bfr-logbitp-n2v) floor
boolean-listp))
- :induct (logbitp-n2v place digit n)
- :expand ((logbitp-n2v place digit n)
- (logbitp-n2v place nil n)
- (logbitp-n2v place digit nil)
- (:free (a b) (v2i (cons a b)))
- (:free (a b) (v2n (cons a b)))))))
-
-(local (in-theory (disable logbitp-n2v)))
-
+ :induct (bfr-logbitp-n2v place digit n)
+ :expand ((bfr-logbitp-n2v place digit n)))))
+ (defthm pbfr-list-depends-on-of-bfr-logbitp-n2v
+ (implies (and (not (pbfr-list-depends-on n p digit))
+ (not (pbfr-list-depends-on n p x)))
+ (not (pbfr-depends-on n p (bfr-logbitp-n2v place digit x))))))
+
+;; (encapsulate nil
+;; (local (in-theory (enable bfr-logbitp-n2v logcons acl2::ash**)))
+
+;; (defthm bfr-logbitp-n2v-correct
+;; (implies (and
+;; (posp place))
+;; (equal (bfr-eval (bfr-logbitp-n2v place digit n) env)
+;; (logbitp (* place (v2n (bfr-eval-list digit env)))
+;; (v2i (bfr-eval-list n env)))))
+;; :hints(("Goal" :in-theory (e/d (bfr-eval-list acl2::bool->bit)
+;; ((:definition bfr-logbitp-n2v) floor
+;; boolean-listp))
+;; :induct (bfr-logbitp-n2v place digit n)
+;; :expand ((bfr-logbitp-n2v place digit n)
+;; (bfr-logbitp-n2v place nil n)
+;; (bfr-logbitp-n2v place digit nil)
+;; (:free (n) (logbitp 0 n))
+;; (:free (a b) (v2i (cons a b)))
+;; (:free (a b) (v2n (cons a b))))))))
+
+(defsection bfr-integer-length
+ (local (defthm bfr-eval-of-car-when-bfr-list->s
+ (implies (and (equal (bfr-list->s x env) c)
+ (syntaxp (quotep c)))
+ (equal (bfr-eval (car x) env)
+ (equal 1 (logcar c))))))
+
+ (defthm bfr-integer-length-s1-correct1
+ (b* (((mv done ilen) (bfr-integer-length-s1 offset x))
+ (xval (bfr-list->s x env)))
+ (implies (posp offset)
+ (and (equal (bfr-eval done env)
+ (and (not (equal xval 0))
+ (not (equal xval -1))))
+ (equal (bfr-list->s ilen env)
+ (if (or (equal xval 0)
+ (equal xval -1))
+ 0
+ (+ -1 offset (integer-length xval)))))))
+ :hints(("Goal" :induct (bfr-integer-length-s1 offset x)
+ :in-theory (enable (:i bfr-integer-length-s1)
+ acl2::integer-length**)
+ ;; :in-theory (enable v2i-of-list-implies-car)
+ :expand ((bfr-integer-length-s1 offset x)))
+ (bfr-reasoning)))
+
+ (defthm pbfr-depends-on-of-bfr-integer-length-s1-rw
+ (b* (((mv done ilen) (bfr-integer-length-s1 offset x)))
+ (implies (not (pbfr-list-depends-on n p x))
+ (and (not (pbfr-depends-on n p done))
+ (not (pbfr-list-depends-on n p ilen)))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on
+ bfr-integer-length-s1))))
+
+ (defthm bfr-integer-length-s-correct
+ (equal (bfr-list->s (bfr-integer-length-s x) env)
+ (integer-length (bfr-list->s x env)))
+ :hints(("Goal" :in-theory (enable bfr-integer-length-s))))
+
+ (defthm pbfr-depends-on-of-bfr-integer-length-s
+ (implies (not (pbfr-list-depends-on n p x))
+ (not (pbfr-list-depends-on n p (bfr-integer-length-s x))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on
+ bfr-integer-length-s)))))
+
+
+
+;; (encapsulate nil
+;; (local (in-theory (enable bfr-integer-length-s1 bfr-integer-length-s)))
+;; (local (bfr-reasoning-mode t))
+;; (local (defthm bfr-integer-length-s1-correct1
+;; (implies (posp offset)
+;; (and (equal (bfr-eval (mv-nth 0 (bfr-integer-length-s1 offset x)) env)
+;; (not (or (equal (v2i (bfr-eval-list x env)) 0)
+;; (equal (v2i (bfr-eval-list x env)) -1))))
+;; (equal (v2i (bfr-eval-list (mv-nth 1 (bfr-integer-length-s1 offset
+;; x))
+;; env))
+;; (if (or (equal (v2i (bfr-eval-list x env)) 0)
+;; (equal (v2i (bfr-eval-list x env)) -1))
+;; 0
+;; (+ -1 offset (integer-length (v2i (bfr-eval-list x env))))))))
+;; :hints(("Goal" :induct (bfr-integer-length-s1 offset x)
+;; :in-theory (enable acl2::integer-length**)
+;; ;; :in-theory (enable v2i-of-list-implies-car)
+;; :expand ((bfr-integer-length-s1 offset x)
+;; (bfr-integer-length-s1 offset nil)
+;; (bfr-eval-list x env)
+;; (:free (a b) (v2i (cons a b)))
+;; (:free (a B) (bfr-eval-list (cons a b) env)))))))
+
+
+;; (defthm bfr-integer-length-s-correct
+;; (equal (v2i (bfr-eval-list (bfr-integer-length-s x) env))
+;; (integer-length (v2i (bfr-eval-list x env))))
+;; :hints(("Goal" :in-theory (disable bfr-integer-length-s1)))))
+
+(defsection bfr-logand-ss
+ (defthm bfr-logand-ss-correct
+ (equal (bfr-list->s (bfr-logand-ss a b) env)
+ (logand (bfr-list->s a env)
+ (bfr-list->s b env)))
+ :hints(("Goal"
+ :induct (scdr2-ind a b)
+ :in-theory (e/d (acl2::logand**))
+ :expand ((bfr-logand-ss a b)))))
+
+ (defthm pbfr-list-depends-on-of-bfr-logand-ss
+ (implies (and (not (pbfr-list-depends-on n p v1))
+ (not (pbfr-list-depends-on n p v2)))
+ (not (pbfr-list-depends-on n p (bfr-logand-ss v1 v2))))
+ :hints(("Goal" :in-theory (e/d (pbfr-list-depends-on bfr-logand-ss)
+ ((pbfr-list-depends-on)
+ (pbfr-depends-on)
+ (:d bfr-logand-ss)))
+ :induct (bfr-logand-ss v1 v2)
+ :expand ((bfr-logand-ss v1 v2))))))
+
+(defsection bfr-logior-ss
+ (defthm bfr-logior-ss-correct
+ (equal (bfr-list->s (bfr-logior-ss a b) env)
+ (logior (bfr-list->s a env)
+ (bfr-list->s b env)))
+ :hints(("Goal"
+ :induct (scdr2-ind a b)
+ :in-theory (e/d (acl2::logior**))
+ :expand ((bfr-logior-ss a b)))))
+
+ (defthm pbfr-list-depends-on-of-bfr-logior-ss
+ (implies (and (not (pbfr-list-depends-on n p v1))
+ (not (pbfr-list-depends-on n p v2)))
+ (not (pbfr-list-depends-on n p (bfr-logior-ss v1 v2))))
+ :hints(("Goal" :in-theory (e/d (pbfr-list-depends-on bfr-logior-ss)
+ ((pbfr-list-depends-on)
+ (pbfr-depends-on)
+ (:d bfr-logior-ss)))
+ :induct (bfr-logior-ss v1 v2)
+ :expand ((bfr-logior-ss v1 v2))))))
+
+
+;; ------
+
+
+
+
+;; (defthmd logtail-ns-0
+;; (equal (logtail-ns 0 n) n)
+;; :hints(("Goal" :in-theory (enable logtail-ns))))
+
+
+
+;; (defthmd boolean-listp-bfr-+-ss-v2i-bind-env-car-env
+;; (implies (and (bind-free '((env . (car env))) (env))
+;; ; (bfr-p c) (bfr-listp v1) (bfr-listp v2)
+;; (boolean-listp (bfr-+-ss c v1 v2)))
+;; (equal (v2i (bfr-+-ss c v1 v2))
+;; (+ (if (bfr-eval c env) 1 0)
+;; (v2i (bfr-eval-list v1 env))
+;; (v2i (bfr-eval-list v2 env)))))
+;; :hints (("goal" :use ((:instance bfr-eval-list-consts
+;; (x (bfr-+-ss c v1 v2)))
+;; bfr-+-ss-correct)
+;; :in-theory (disable bfr-+-ss bfr-+-ss-correct
+;; bfr-eval-list-consts))))
+
+
+;; (defthmd boolean-listp-bfr-*-ss-v2i-bind-env-car-env
+;; (implies (and (bind-free '((env . (car env))) (env))
+;; (boolean-listp (bfr-*-ss v1 v2)))
+;; (equal (v2i (bfr-*-ss v1 v2))
+;; (* (v2i (bfr-eval-list v1 env))
+;; (v2i (bfr-eval-list v2 env)))))
+;; :hints (("goal" :use ((:instance bfr-eval-list-consts
+;; (x (bfr-*-ss v1 v2)))
+;; bfr-*-ss-correct)
+;; :in-theory (disable bfr-*-ss bfr-*-ss-correct
+;; bfr-eval-list-consts))))
-;; ---------------- integer-length-s -----------------
-(local (in-theory (enable integer-length-s1 integer-length-s)))
-(local
- (progn
- (encapsulate nil
- (local (defthm equal-by-evenp
- (implies (not (equal (evenp x) (evenp y)))
- (not (equal x y)))))
-
- (defthmd v2i-of-list-implies-car
- (implies (and (equal (v2i (bfr-eval-list x env)) n)
- (syntaxp (quotep n)))
- (equal (bfr-eval (car x) env) (logbitp 0 n)))
- :hints (("goal" :expand ((bfr-eval-list x env)
- (:free (a b) (v2i (cons a b))))))))))
-
-(local (bfr-reasoning-mode t))
-(local (defthm integer-length-s1-correct1
- (implies (and
- (posp offset))
- (and (equal (bfr-eval (mv-nth 0 (integer-length-s1 offset x)) env)
- (not (or (equal (v2i (bfr-eval-list x env)) 0)
- (equal (v2i (bfr-eval-list x env)) -1))))
- (equal (v2i (bfr-eval-list (mv-nth 1 (integer-length-s1 offset
- x))
- env))
- (if (or (equal (v2i (bfr-eval-list x env)) 0)
- (equal (v2i (bfr-eval-list x env)) -1))
- 0
- (+ -1 offset (integer-length (v2i (bfr-eval-list x env))))))))
- :hints(("Goal" :induct (integer-length-s1 offset x)
- :in-theory (enable v2i-of-list-implies-car)
- :expand ((integer-length-s1 offset x)
- (integer-length-s1 offset nil)
- (bfr-eval-list x env)
- (:free (a b) (v2i (cons a b)))
- (:free (a B) (bfr-eval-list (cons a b) env))
- (:free (x) (:with acl2::integer-length* (integer-length (* 2 x))))
- (:free (x) (:with acl2::integer-length*
- (integer-length (+ 1 (* 2 x))))))))))
-
-
-(defthm integer-length-s-correct
- (equal (v2i (bfr-eval-list (integer-length-s x) env))
- (integer-length (v2i (bfr-eval-list x env))))
- :hints(("Goal" :in-theory (disable integer-length-s1))))
-
-
-(local
- (defthm not-integerp-integer-length-s1-1
- (not (integerp (mv-nth 1 (integer-length-s1 offs x))))
- :hints(("Goal" :in-theory (enable integer-length-s1)))))
-
-(local (in-theory (disable integer-length-s1)))
-
-
-(defthm not-integerp-integer-length-s
- (not (integerp (integer-length-s x)))
- :hints(("Goal" :in-theory (enable integer-length-s))))
-
-(local (in-theory (disable integer-length-s)))
+;; ---------------- bfr-floor-mod-ss ---------------------
+(defsection bfr-floor-mod-ss
+ (local (include-book "ihs/quotient-remainder-lemmas" :dir :system)) ;
+ (local
+ (encapsulate nil
+ (local
+ (progn
+ (defthm floor-between-b-and-2b
+ (implies (and (integerp a)
+ (integerp b)
+ (< 0 b)
+ (<= b a)
+ (< a (* 2 b)))
+ (equal (floor a b) 1))
+ :hints(("Goal" :in-theory (disable floor acl2::floor-bounds
+ acl2::<-*-/-left)
+ :use ((:instance acl2::floor-bounds
+ (x a) (y b))
+ (:theorem (implies (and (integerp a)
+ (integerp b)
+ (< 0 b)
+ (< a (* 2 b)))
+ (< (* a (/ b)) 2)))))
+ (and stable-under-simplificationp
+ '(:in-theory (disable floor)))))
+
+ (defthm floor-less-than-b
+ (implies (and (integerp a)
+ (integerp b)
+ (< 0 b)
+ (<= 0 a)
+ (< a b))
+ (equal (floor a b) 0))
+ :hints(("Goal" :in-theory (disable floor acl2::floor-bounds
+ acl2::<-*-/-left)
+ :use ((:instance acl2::floor-bounds
+ (x a) (y b))
+ (:theorem (implies (and (integerp a)
+ (integerp b)
+ (< 0 b)
+ (< a b))
+ (< (* a (/ b)) 1)))))
+ (and stable-under-simplificationp
+ '(:in-theory (disable floor)))))
+
+ (defthm mod-between-b-and-2-b
+ (implies (and (integerp a)
+ (integerp b)
+ (< 0 b)
+ (<= b a)
+ (< a (* 2 b)))
+ (equal (mod a b) (- a b)))
+ :hints(("Goal" :in-theory (e/d (mod)
+ (floor acl2::floor-bounds
+ acl2::<-*-/-left))
+ :use ((:instance acl2::floor-bounds
+ (x a) (y b))
+ (:theorem (implies (and (integerp a)
+ (integerp b)
+ (< 0 b)
+ (< a (* 2 b)))
+ (< (* a (/ b)) 2)))))
+ (and stable-under-simplificationp
+ '(:in-theory (disable floor)))))
+
+ (defthm mod-less-than-b
+ (implies (and (integerp a)
+ (integerp b)
+ (< 0 b)
+ (<= 0 a)
+ (< a b))
+ (equal (mod a b) a))
+ :hints(("Goal" :in-theory (disable floor acl2::floor-bounds
+ acl2::<-*-/-left)
+ :use ((:instance acl2::floor-bounds
+ (x a) (y b))
+ (:theorem (implies (and (integerp a)
+ (integerp b)
+ (< 0 b)
+ (< a (* 2 b)))
+ (< (* a (/ b)) 2)))))
+ (and stable-under-simplificationp
+ '(:in-theory (disable floor)))))))
+
+
+ ;; (defthm floor-rewrite-+-1-*-2-a
+ ;; (implies (and (integerp a) (integerp b)
+ ;; (< 0 b))
+ ;; (equal (floor (+ 1 (* 2 a)) b)
+ ;; (if (<= b (+ 1 (* 2 (mod a b))))
+ ;; (+ 1 (* 2 (floor a b)))
+ ;; (* 2 (floor a b)))))
+ ;; :hints(("Goal" :in-theory (disable floor))))
+
+ ;; (defthm floor-rewrite-*-2-a
+ ;; (implies (and (integerp a) (integerp b)
+ ;; (< 0 b))
+ ;; (equal (floor (* 2 a) b)
+ ;; (if (<= b (* 2 (mod a b)))
+ ;; (+ 1 (* 2 (floor a b)))
+ ;; (* 2 (floor a b)))))
+ ;; :hints(("Goal" :in-theory (disable floor))))
+
+ (defthm floor-rewrite-+-bit-*-2-a
+ (implies (and (integerp a) (integerp b)
+ (< 0 b))
+ (equal (floor (logcons c a) b)
+ (if (<= b (logcons c (mod a b)))
+ (logcons 1 (floor a b))
+ (logcons 0 (floor a b)))))
+ :hints(("Goal" :in-theory (e/d (logcons bfix) (floor)))))
+
+ ;; (defthm mod-rewrite-*-2-a
+ ;; (implies (and (integerp a) (integerp b)
+ ;; (< 0 b))
+ ;; (equal (mod (* 2 a) b)
+ ;; (if (<= b (* 2 (mod a b)))
+ ;; (+ (* -1 b)
+ ;; (* 2 (mod a b)))
+ ;; (* 2 (mod a b)))))
+ ;; :hints (("goal" :in-theory (disable mod))))
+
+ ;; (defthm mod-rewrite-+-1-*-2-a
+ ;; (implies (and (integerp a) (integerp b)
+ ;; (< 0 b))
+ ;; (equal (mod (+ 1 (* 2 a)) b)
+ ;; (if (<= b (+ 1 (* 2 (mod a b))))
+ ;; (+ 1 (* -1 b)
+ ;; (* 2 (mod a b)))
+ ;; (+ 1 (* 2 (mod a b))))))
+ ;; :hints (("goal" :in-theory (e/d (mod) (floor)))))
+
+ (defthm mod-rewrite-+-bit-*-2-a
+ (implies (and (integerp a) (integerp b)
+ (< 0 b))
+ (equal (mod (logcons c a) b)
+ (if (<= b (logcons c (mod a b)))
+ (+ (- b)
+ (logcons c (mod a b)))
+ (logcons c (mod a b)))))
+ :hints (("goal" :in-theory (e/d (logcons bfix mod) (floor)))))
+
+
+
+ ;; (in-theory (disable mod-between-b-and-2-b
+ ;; mod-less-than-b
+ ;; floor-between-b-and-2b
+ ;; floor-less-than-b))
+
+ (defthm denominator-of-unary-/
+ (implies (and (integerp n) (< 0 n))
+ (equal (denominator (/ n)) n))
+ :hints (("goal" :use ((:instance rational-implies2
+ (x (/ n)))))))
+
+ (defthm <-1-not-integer-recip
+ (implies (and (integerp n)
+ (< 1 n))
+ (not (integerp (/ n))))
+ :hints (("goal"
+ :use ((:instance denominator-of-unary-/))
+ :in-theory (disable denominator-of-unary-/))))
+
+ (defthm integer-and-integer-recip
+ (implies (and (integerp n)
+ (< 0 n))
+ (equal (integerp (/ n))
+ (equal n 1))))))
+
+ (local (add-bfr-pat (bfr-<-ss . &)))
+
+ (local (defthm +-1-logcons-0
+ (equal (+ 1 (logcons 0 a))
+ (logcons 1 a))
+ :hints(("Goal" :in-theory (enable logcons)))))
+
+ (defthm bfr-floor-mod-ss-correct
+ (b* (((mv floor mod) (bfr-floor-mod-ss a b bminus))
+ (a (bfr-list->s a env))
+ (b (bfr-list->s b env))
+ (bminus (bfr-list->s bminus env)))
+ (implies
+ (and (< 0 b)
+ (equal bminus (- b)))
+ (and (equal (bfr-list->s floor env)
+ (floor a b))
+ (equal (bfr-list->s mod env)
+ (mod a b)))))
+ :hints (("goal" :induct (bfr-floor-mod-ss a b bminus)
+ :in-theory (e/d* ((:i bfr-floor-mod-ss))
+ (floor mod
+ bfr-eval-list
+ equal-of-booleans-rewrite
+ (:definition bfr-floor-mod-ss)
+ acl2::mod-type
+ acl2::floor-type-3 acl2::floor-type-1
+ acl2::logcons-posp-1 acl2::logcons-posp-2
+ acl2::logcons-negp
+ acl2::rationalp-mod (:t floor) (:t mod)))
+ :do-not-induct t
+ :expand ((bfr-floor-mod-ss a b bminus)
+ (bfr-floor-mod-ss nil b bminus)))
+ (bfr-reasoning)))
+
+ (defthm pbfr-list-depends-on-of-bfr-floor-mod-ss
+ (b* (((mv floor mod) (bfr-floor-mod-ss a b bminus)))
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b))
+ (not (pbfr-list-depends-on n p bminus)))
+ (and (not (pbfr-list-depends-on n p floor))
+ (not (pbfr-list-depends-on n p mod)))))
+ :hints(("Goal" :in-theory (enable bfr-floor-mod-ss pbfr-list-depends-on)))))
+
+(defsection bfr-sign-abs-neg-s
+
+ (local (in-theory (enable bfr-sign-abs-neg-s)))
+ (local (add-bfr-pat (s-sign . &)))
+
+ (defthm bfr-sign-abs-neg-s-correct
+ (b* (((mv sign minus abs neg) (bfr-sign-abs-neg-s x))
+ (x (bfr-list->s x env)))
+ (and (equal (bfr-eval sign env)
+ (< x 0))
+ (equal (bfr-list->s minus env)
+ (- x))
+ (equal (bfr-list->s abs env)
+ (abs x))
+ (equal (bfr-list->s neg env)
+ (- (abs x)))))
+ :hints ((bfr-reasoning)))
+
+ (defthm pbfr-list-depends-on-of-bfr-sign-abs-neg-s-rw
+ (b* (((mv sign minus abs neg) (bfr-sign-abs-neg-s x)))
+ (implies (not (pbfr-list-depends-on n p x))
+ (and (not (pbfr-depends-on n p sign))
+ (not (pbfr-list-depends-on n p minus))
+ (not (pbfr-list-depends-on n p abs))
+ (not (pbfr-list-depends-on n p neg)))))))
+
+
+(defsection bfr-floor-ss
+
+ (local (add-bfr-pat (bfr-=-ss . &)))
+ (local (add-bfr-pat (mv-nth 0 (bfr-sign-abs-neg-s . &))))
+
+ (local (defthm floor-negative
+ (equal (floor x (- y))
+ (floor (- x) y))
+ :hints(("Goal" :in-theory (enable floor)))))
+
+ (defthm bfr-floor-ss-correct
+ (equal (bfr-list->s (bfr-floor-ss a b) env)
+ (floor (bfr-list->s a env)
+ (bfr-list->s b env)))
+ :hints (("goal" :do-not-induct t
+ :in-theory (enable bfr-floor-ss))
+ (bfr-reasoning)))
+
+ (defthm pbfr-list-depends-on-of-bfr-floor-ss
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b)))
+ (not (pbfr-list-depends-on n p (bfr-floor-ss a b))))
+ :hints(("Goal" :in-theory (enable bfr-floor-ss
+ pbfr-list-depends-on)))))
+
+(defsection bfr-mod-ss
+
+ (local (add-bfr-pat (bfr-=-ss . &)))
+ (local (add-bfr-pat (mv-nth 0 (bfr-sign-abs-neg-s . &))))
+
+ (local (defthm floor-negative
+ (equal (floor x (- y))
+ (floor (- x) y))
+ :hints(("Goal" :in-theory (enable floor)))))
+
+ (local (defthm mod-negative
+ (equal (mod x (- y))
+ (- (mod (- x) y)))
+ :hints(("Goal" :in-theory (enable mod)))))
+
+ (defthm bfr-mod-ss-correct
+ (equal (bfr-list->s (bfr-mod-ss a b) env)
+ (mod (bfr-list->s a env)
+ (bfr-list->s b env)))
+ :hints (("goal" :do-not-induct t
+ :in-theory (enable bfr-mod-ss))
+ (bfr-reasoning)))
+
+ (defthm pbfr-list-depends-on-of-bfr-mod-ss
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b)))
+ (not (pbfr-list-depends-on n p (bfr-mod-ss a b))))
+ :hints(("Goal" :in-theory (enable bfr-mod-ss
+ pbfr-list-depends-on)))))
-;; ---------------- logand-ss ------------------------
-
-(local (in-theory (enable logand-ss)))
-
-(local (in-theory (disable acl2::logmaskp integer-length)))
-
-(defthm logand-ss-correct
- (equal (v2i (bfr-eval-list (logand-ss a b) env))
- (logand (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env))))
- :hints(("Goal"
- :in-theory (disable binary-logand)
- :expand ((logand-ss a b)
- (:free (a b) (v2i (cons a b)))
- (bfr-eval-list a env)
- (bfr-eval-list b env)
- (bfr-eval-list nil env)
- (:free (a b) (bfr-eval-list (cons a b) env))
- (:with acl2::logand*
- (:free (x y) (logand (* 2 x) (* 2 y))))
- (:with acl2::logand*
- (:free (x y) (logand (* 2 x) (+ 1 (* 2 y)))))
- (:with acl2::logand*
- (:free (x y) (logand (+ 1 (* 2 x)) (* 2 y))))
- (:with acl2::logand*
- (:free (x y) (logand (+ 1 (* 2 x)) (+ 1 (* 2 y))))))
- :induct (logand-ss a b))
- (and stable-under-simplificationp
- '(:in-theory (e/d (bfr-eval-list) (binary-logand))))))
-
-
-(local (in-theory (disable logand-ss)))
+(defsection bfr-truncate-ss
+ (local (add-bfr-pat (bfr-=-ss . &)))
+ (local (add-bfr-pat (mv-nth 0 (bfr-sign-abs-neg-s . &))))
+ (local
+ (defthm truncate-is-floor
+ (implies (and (integerp a) (integerp b)
+ (not (equal b 0)))
+ (equal (truncate a b)
+ (if (acl2::xor (< a 0) (< b 0))
+ (- (floor (abs a) (abs b)))
+ (floor (abs a) (abs b)))))
+ :hints(("Goal" :in-theory (enable truncate floor)))))
+ (local (defthm truncate-0
+ (equal (truncate x 0) 0)
+ :hints(("Goal" :in-theory (enable truncate)))))
-;; ---------------- floor-mod-ss ---------------------
-
-(local (in-theory (enable floor-mod-ss floor-ss mod-ss truncate-ss rem-ss)))
+ (local (in-theory (disable truncate)))
+ (defthm bfr-truncate-ss-correct
+ (equal (bfr-list->s (bfr-truncate-ss a b) env)
+ (truncate (bfr-list->s a env)
+ (bfr-list->s b env)))
+ :hints (("goal" :do-not-induct t
+ :in-theory (enable bfr-truncate-ss))
+ (bfr-reasoning))
+ :otf-flg t)
+ (defthm pbfr-list-depends-on-of-bfr-truncate-ss
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b)))
+ (not (pbfr-list-depends-on n p (bfr-truncate-ss a b))))
+ :hints(("Goal" :in-theory (enable bfr-truncate-ss
+ pbfr-list-depends-on)))))
+(defsection bfr-rem-ss
-(local
- (defthm car-last-when-nonnegative
- (equal (bfr-eval (car (last b)) env)
- (< (v2i (bfr-eval-list b env)) 0))
- :hints(("Goal" :in-theory (enable v2i)))))
-
-
-
-(local (include-book "ihs/quotient-remainder-lemmas" :dir :system))
-
-(local
- (progn
- (defthm floor-between-b-and-2b
- (implies (and (integerp a)
- (integerp b)
- (< 0 b)
- (<= b a)
- (< a (* 2 b)))
- (equal (floor a b) 1))
- :hints(("Goal" :in-theory (disable floor acl2::floor-bounds
- acl2::<-*-/-left)
- :use ((:instance acl2::floor-bounds
- (x a) (y b))
- (:theorem (implies (and (integerp a)
- (integerp b)
- (< 0 b)
- (< a (* 2 b)))
- (< (* a (/ b)) 2)))))
- (and stable-under-simplificationp
- '(:in-theory (disable floor)))))
-
- (defthm floor-less-than-b
- (implies (and (integerp a)
- (integerp b)
- (< 0 b)
- (<= 0 a)
- (< a b))
- (equal (floor a b) 0))
- :hints(("Goal" :in-theory (disable floor acl2::floor-bounds
- acl2::<-*-/-left)
- :use ((:instance acl2::floor-bounds
- (x a) (y b))
- (:theorem (implies (and (integerp a)
- (integerp b)
- (< 0 b)
- (< a b))
- (< (* a (/ b)) 1)))))
- (and stable-under-simplificationp
- '(:in-theory (disable floor)))))
-
- (defthm mod-between-b-and-2-b
- (implies (and (integerp a)
- (integerp b)
- (< 0 b)
- (<= b a)
- (< a (* 2 b)))
- (equal (mod a b) (- a b)))
- :hints(("Goal" :in-theory (disable floor acl2::floor-bounds
- acl2::<-*-/-left)
- :use ((:instance acl2::floor-bounds
- (x a) (y b))
- (:theorem (implies (and (integerp a)
- (integerp b)
- (< 0 b)
- (< a (* 2 b)))
- (< (* a (/ b)) 2)))))
- (and stable-under-simplificationp
- '(:in-theory (disable floor)))))
-
- (defthm mod-less-than-b
- (implies (and (integerp a)
- (integerp b)
- (< 0 b)
- (<= 0 a)
- (< a b))
- (equal (mod a b) a))
- :hints(("Goal" :in-theory (disable floor acl2::floor-bounds
- acl2::<-*-/-left)
- :use ((:instance acl2::floor-bounds
- (x a) (y b))
- (:theorem (implies (and (integerp a)
- (integerp b)
- (< 0 b)
- (< a (* 2 b)))
- (< (* a (/ b)) 2)))))
- (and stable-under-simplificationp
- '(:in-theory (disable floor)))))
+ (local (add-bfr-pat (bfr-=-ss . &)))
+ (local (add-bfr-pat (mv-nth 0 (bfr-sign-abs-neg-s . &))))
- (defthm mod-rewrite-+-1-*-2-a
- (implies (and (integerp a) (integerp b)
- (< 0 b))
- (equal (mod (+ 1 (* 2 a)) b)
- (if (<= b (+ 1 (* 2 (mod a b))))
- (+ 1 (* -1 b)
- (* 2 (mod a b)))
- (+ 1 (* 2 (mod a b))))))
- :hints (("goal" :in-theory (disable mod))))
+ (local (defthm rem-0
+ (equal (rem x 0) (fix x))))
- (defthm mod-rewrite-*-2-a
- (implies (and (integerp a) (integerp b)
- (< 0 b))
- (equal (mod (* 2 a) b)
- (if (<= b (* 2 (mod a b)))
- (+ (* -1 b)
- (* 2 (mod a b)))
- (* 2 (mod a b)))))
- :hints (("goal" :in-theory (disable mod))))
- (defthm floor-rewrite-+-1-*-2-a
+ (local
+ (defthm truncate-is-floor
(implies (and (integerp a) (integerp b)
- (< 0 b))
- (equal (floor (+ 1 (* 2 a)) b)
- (if (<= b (+ 1 (* 2 (mod a b))))
- (+ 1 (* 2 (floor a b)))
- (* 2 (floor a b)))))
- :hints(("Goal" :in-theory (disable floor))))
+ (not (equal b 0)))
+ (equal (truncate a b)
+ (if (acl2::xor (< a 0) (< b 0))
+ (- (floor (abs a) (abs b)))
+ (floor (abs a) (abs b)))))
+ :hints(("Goal" :in-theory (enable truncate floor)))))
- (defthm floor-rewrite-*-2-a
+ (local
+ (defthm rem-is-mod
(implies (and (integerp a) (integerp b)
- (< 0 b))
- (equal (floor (* 2 a) b)
- (if (<= b (* 2 (mod a b)))
- (+ 1 (* 2 (floor a b)))
- (* 2 (floor a b)))))
- :hints(("Goal" :in-theory (disable floor))))
-
- (in-theory (disable mod-between-b-and-2-b
- mod-less-than-b
- floor-between-b-and-2b
- floor-less-than-b))
-
- (defthm denominator-of-unary-/
- (implies (and (integerp n) (< 0 n))
- (equal (denominator (/ n)) n))
- :hints (("goal" :use ((:instance rational-implies2
- (x (/ n)))))))
-
- (defthm <-1-not-integer-recip
- (implies (and (integerp n)
- (< 1 n))
- (not (integerp (/ n))))
- :hints (("goal"
- :use ((:instance denominator-of-unary-/))
- :in-theory (disable denominator-of-unary-/))))
-
- (defthm integer-and-integer-recip
- (implies (and (integerp n)
- (< 0 n))
- (equal (integerp (/ n))
- (equal n 1))))))
-
-(local (bfr-reasoning-mode t))
-(local (add-bfr-pat (<-ss . &)))
-(local (add-bfr-pat (bfr-fix . &)))
-
-(local
- (defthm floor-mod-ss-correct
- (implies
- (and
- (< 0 (v2i (bfr-eval-list b env))))
- (and (equal (v2i (bfr-eval-list
- (mv-nth 0 (floor-mod-ss
- a b (unary-minus-s b)))
- env))
- (floor (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env))))
- (equal (v2i (bfr-eval-list
- (mv-nth 1 (floor-mod-ss a b (unary-minus-s b)))
- env))
- (mod (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env))))))
- :hints (("goal" :induct (floor-mod-ss a b (unary-minus-s b))
- :in-theory (disable floor mod
- equal-of-booleans-rewrite
- (:definition floor-mod-ss)
- (:type-prescription acl2::floor-type-3 . 2))
- :do-not-induct t
- :expand ((floor-mod-ss a b (unary-minus-s b))
- (floor-mod-ss nil b (unary-minus-s b))
- (:free (a b) (v2i (cons a b)))
- (:free (a b) (bfr-eval-list (cons a b) env))
- (bfr-eval-list a env))))))
-
-(local (bfr-reasoning-mode nil))
-
-
-(local (in-theory (disable floor-mod-ss)))
-
-(local (bfr-reasoning-mode t))
-(local (add-bfr-pat (=-ss . &)))
-(local (add-bfr-pat (s-sign . &)))
-
-(local (in-theory (disable floor mod truncate rem)))
-
-(local (defthm floor-0
- (equal (floor i 0) 0)
- :hints(("Goal" :in-theory (enable floor)))))
-
-(defthm floor-ss-correct
- (equal (v2i (bfr-eval-list (floor-ss a b) env))
- (floor (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env))))
- :hints (("goal" :do-not-induct t)))
-
-
-
-(defthm mod-ss-correct
- (equal (v2i (bfr-eval-list (mod-ss a b) env))
- (mod (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env))))
- :hints (("goal" :do-not-induct t)))
-
-(local (in-theory (disable floor-ss mod-ss)))
-
-(local (bfr-reasoning-mode nil))
-
-
-
-(local
- (defthm truncate-is-floor
- (implies (and (integerp a) (integerp b)
- (not (equal b 0)))
- (equal (truncate a b)
- (if (acl2::xor (< a 0) (< b 0))
- (- (floor (abs a) (abs b)))
- (floor (abs a) (abs b)))))
- :hints(("Goal" :in-theory (disable truncate floor)))))
-
-(local (bfr-reasoning-mode t))
-
-(local (defthm truncate-0
- (equal (truncate x 0) 0)
- :hints(("Goal" :in-theory (enable truncate)))))
-
-(local (Defthm truncate-0-x
- (equal (truncate 0 x) 0)
- :hints(("Goal" :in-theory (enable truncate)))))
-
-(defthm truncate-ss-correct
- (equal (v2i (bfr-eval-list (truncate-ss a b) env))
- (truncate (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env))))
- :hints (("goal" :do-not-induct t
- :in-theory (disable floor truncate bfr-eval-list))))
-
-
-
-(local
- (defthm rem-is-mod
- (implies (and (integerp a) (integerp b)
- (not (equal b 0)))
- (equal (rem a b)
- (if (< a 0)
- (- (mod (abs a) (abs b)))
- (mod (abs a) (abs b)))))
- :hints(("Goal" :in-theory (e/d (rem mod) (floor truncate))))))
-
-
-(local (bfr-reasoning-mode t))
-(local (defthm rem-0
- (implies (acl2-numberp x) (equal (rem x 0) x))
- :hints(("Goal" :in-theory (enable rem)))))
-(local (defthm rem-0-x
- (equal (rem 0 x) 0)
- :hints(("Goal" :in-theory (enable rem)))))
-
-(defthm rem-ss-correct
- (equal (v2i (bfr-eval-list (rem-ss a b) env))
- (rem (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env))))
- :hints (("goal" :do-not-induct t
- :in-theory (disable mod rem))))
-
-(local (in-theory (disable truncate-ss rem-ss)))
-
-
-
-
-;; ---------------- lognot-s -------------------------
-
-(local (in-theory (enable lognot-s)))
-
-(defthm lognot-s-correct
- (equal (v2i (bfr-eval-list (lognot-s a) env))
- (lognot (v2i (bfr-eval-list a env))))
- :hints (("goal" :in-theory (e/d (v2i bfr-eval-list lognot)
- (boolean-list-bfr-eval-list
- (:definition lognot-s)))
- :induct (lognot-s a)
- :expand ((lognot-s a)))))
-
-
-(local (in-theory (disable lognot-s)))
-
-;; ---------------- logior-ss ------------------------
-
-(local (in-theory (enable logior-ss)))
-
-(local (add-bfr-pat (car (logior-ss . &) . &)))
-
-(local
- (defthm bfr-eval-list-not-consp-cdr
- (implies (and (not (consp (cdr lst)))
- (consp lst))
- (equal (bfr-eval-list lst env)
- (list (bfr-eval (car lst) env))))
- :hints(("Goal" :expand ((bfr-eval-list lst env))))
- :rule-classes ((:rewrite :backchain-limit-lst 0))))
-
-(defthm logior-ss-correct
- (equal (v2i (bfr-eval-list (logior-ss a b) env))
- (logior (v2i (bfr-eval-list a env))
- (v2i (bfr-eval-list b env))))
- :hints(("Goal" :in-theory (e/d () (logior (:definition logior-ss)))
- :induct (logior-ss a b)
- :expand ((logior-ss a b)
- (:free (a b) (v2i (cons a b)))
- (bfr-eval-list a env)
- (bfr-eval-list b env)
- (bfr-eval-list nil env)
- (:free (x y) (:with acl2::logior*
- (logior (* 2 x) (* 2 y))))
- (:free (x y) (:with acl2::logior*
- (logior (* 2 x) (+ 1 (* 2 y)))))
- (:free (x y) (:with acl2::logior*
- (logior (+ 1 (* 2 x)) (* 2 y))))
- (:free (x y) (:with acl2::logior*
- (logior (+ 1 (* 2 x)) (+ 1 (* 2 y)))))))))
-
-
-(local (in-theory (disable logior-ss)))
-
+ (not (equal b 0)))
+ (equal (rem a b)
+ (if (< a 0)
+ (- (mod (abs a) (abs b)))
+ (mod (abs a) (abs b)))))
+ :hints(("Goal" :in-theory (e/d (rem mod) (floor truncate))))))
+
+ (local (in-theory (disable rem)))
+
+ (defthm bfr-rem-ss-correct
+ (equal (bfr-list->s (bfr-rem-ss a b) env)
+ (rem (bfr-list->s a env)
+ (bfr-list->s b env)))
+ :hints (("goal" :do-not-induct t
+ :in-theory (enable bfr-rem-ss))
+ (bfr-reasoning)))
+
+ (defthm pbfr-list-depends-on-of-bfr-rem-ss
+ (implies (and (not (pbfr-list-depends-on n p a))
+ (not (pbfr-list-depends-on n p b)))
+ (not (pbfr-list-depends-on n p (bfr-rem-ss a b))))
+ :hints(("Goal" :in-theory (enable bfr-rem-ss
+ pbfr-list-depends-on)))))
diff -Nru acl2-6.2/books/centaur/gl/try-gl.lisp acl2-6.3/books/centaur/gl/try-gl.lisp
--- acl2-6.2/books/centaur/gl/try-gl.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/gl/try-gl.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,4 +1,5 @@
-; Copyright (C) 2013 Centaur Technology
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
;
; Contact:
; Centaur Technology Formal Verification Group
@@ -102,31 +103,88 @@
(include-book "gl-generic-clause-proc")
(include-book "centaur/misc/numlist" :dir :system)
(include-book "shape-spec")
-
-(defun uniquify-nat-list (x next-idx)
- (declare (xargs :guard (natp next-idx)))
- (mv (numlist next-idx 1 (len x))
- (+ (lnfix next-idx) (len x))))
+(include-book "str/natstr" :dir :system)
+(include-book "str/strnatless" :dir :system)
+(include-book "defsort/duplicated-members" :dir :system)
+
+(defun uniquify-nat-list (x next-idx used-idxs)
+ (declare (xargs :guard (and (nat-listp x)
+ (natp next-idx))
+ :guard-hints ('(:in-theory (enable nat-listp)))))
+ (if (atom x)
+ (mv nil (lnfix next-idx))
+ (b* ((xx (lnfix (car x)))
+ (usedp (hons-get xx used-idxs))
+ ((mv rest-lst rest-next)
+ (uniquify-nat-list
+ (cdr x) (if usedp (+ 1 (lnfix next-idx)) next-idx) used-idxs)))
+ (mv (cons (if usedp (lnfix next-idx) xx) rest-lst)
+ rest-next))))
(defthm natp-next-idx-of-uniquify-nat-list
- (natp (mv-nth 1 (uniquify-nat-list x next-idx))))
+ (natp (mv-nth 1 (uniquify-nat-list x next-idx used-idxs))))
-(defun uniquify-number-spec (x next-idx)
- (declare (xargs :guard (natp next-idx)))
+(defun nat-list-listp (x)
+ (declare (xargs :guard t))
+ (if (atom x)
+ (eq x nil)
+ (and (nat-listp (car x))
+ (nat-list-listp (cdr x)))))
+
+(local (defthm nat-list-listp-when-number-specp
+ (implies (number-specp x)
+ (nat-list-listp x))
+ :hints(("Goal" :in-theory (enable nat-list-listp
+ number-specp)))))
+
+(defun uniquify-number-spec (x next-idx used-idxs)
+ (declare (xargs :guard (and (nat-list-listp x)
+ (natp next-idx))))
(if (atom x)
(mv nil (lnfix next-idx))
(b* (((mv field next-idx)
- (uniquify-nat-list (car x) next-idx))
+ (uniquify-nat-list (car x) next-idx used-idxs))
((mv rest next-idx)
- (uniquify-number-spec (cdr X) next-idx)))
+ (uniquify-number-spec (cdr X) next-idx used-idxs)))
(mv (cons field rest) next-idx))))
(defthm natp-next-idx-of-uniquify-number-spec
- (natp (mv-nth 1 (uniquify-number-spec x next-idx))))
+ (natp (mv-nth 1 (uniquify-number-spec x next-idx used-idxs))))
+
+(defun to-symb (n)
+ (declare (xargs :guard (natp n)))
+ (intern$
+ (concatenate 'string "X" (str::natstr n))
+ "ACL2"))
+
+(defun max-xn-sym (syms)
+ (declare (xargs :guard t
+ :verify-guards nil))
+ (b* (((when (atom syms))
+ 0)
+ (sym (car syms))
+ ((unless (symbolp sym)) (max-xn-sym (cdr syms)))
+ (str (symbol-name sym))
+ (len (length str))
+ ((unless (and (< 1 len)
+ (eql (char str 0) #\X)
+ (str::digit-string-p-aux str 1 len)
+ ;; not generally correct but there arent any XN symbols in
+ ;; ACL2's package imports
+ (equal (symbol-package-name sym) "ACL2")))
+ (max-xn-sym (cdr syms)))
+ ((mv val &) (str::parse-nat-from-string str 0 0 1 len)))
+ (max (+ 1 val) (max-xn-sym (cdr syms)))))
+
+(defthm natp-max-xn-sym
+ (natp (max-xn-sym syms))
+ :rule-classes :type-prescription)
+
+(verify-guards max-xn-sym)
;; Transforms a shape spec so that all bit indices and var names are unique;
;; they'll just be sequentially numbered.
-(defun uniquify-shape-spec (x next-idx next-var)
+(defun uniquify-shape-spec (x next-idx next-var used-idxs used-vars)
(declare (xargs :guard (and (shape-specp x)
(natp next-idx)
(natp next-var))
@@ -135,41 +193,82 @@
(mv x (lnfix next-idx) (lnfix next-var))
(case (tag x)
(:g-number (mv-let (numspec next-idx)
- (uniquify-number-spec (g-number->num x) next-idx)
+ (uniquify-number-spec (g-number->num x) next-idx used-idxs)
(mv (g-number numspec) next-idx (lnfix next-var))))
- (:g-boolean (mv (g-boolean next-idx) (+ 1 (lnfix next-idx)) (lnfix next-var)))
+ (:g-integer (b* ((sign next-idx)
+ ((mv bits next-idx)
+ (uniquify-nat-list (g-integer->bits x)
+ (+ 1 (lnfix next-idx))
+ used-idxs))
+ (var next-var))
+ (mv (g-integer sign bits var)
+ next-idx (+ 1 (lnfix next-var)))))
+ (:g-integer? (b* ((intp next-idx)
+ (sign (+ 1 (lnfix next-idx)))
+ ((mv bits next-idx)
+ (uniquify-nat-list (g-integer?->bits x)
+ (+ 2 (lnfix next-idx))
+ used-idxs))
+ (var next-var))
+ (mv (g-integer? sign bits var intp)
+ next-idx (+ 1 (lnfix next-var)))))
+ (:g-boolean (if (hons-get (g-boolean->bool x) used-idxs)
+ (mv (g-boolean next-idx) (+ 1 (lnfix next-idx)) (lnfix next-var))
+ (mv x (lnfix next-idx) (lnfix next-var))))
(:g-concrete (mv x (lnfix next-idx) (lnfix next-var)))
- (:g-var (mv (g-var next-var) (lnfix next-idx) (1+ (lnfix next-var))))
+ (:g-var (b* ((v (g-var->name x)))
+ (if (and (symbolp v)
+ (not (hons-get v used-vars)))
+ (mv x (lnfix next-idx) (lnfix next-var))
+ (mv (g-var (to-symb next-var)) (lnfix next-idx) (1+ (lnfix next-var))))))
(:g-ite
(b* (((mv test next-idx next-var)
- (uniquify-shape-spec (g-ite->test x) next-idx next-var))
+ (uniquify-shape-spec (g-ite->test x) next-idx next-var used-idxs used-vars))
((mv then next-idx next-var)
- (uniquify-shape-spec (g-ite->then x) next-idx next-var))
+ (uniquify-shape-spec (g-ite->then x) next-idx next-var used-idxs used-vars))
((mv else next-idx next-var)
- (uniquify-shape-spec (g-ite->else x) next-idx next-var)))
+ (uniquify-shape-spec (g-ite->else x) next-idx next-var used-idxs used-vars)))
(mv (g-ite test then else) next-idx next-var)))
+ (:g-call
+ (b* (((mv args next-idx next-var)
+ (uniquify-shape-spec (g-call->args x) next-idx next-var used-idxs used-vars)))
+ (mv (g-call (g-call->fn x) args
+ (g-call->inverse x))
+ next-idx next-var)))
(otherwise
(b* (((mv car next-idx next-var)
- (uniquify-shape-spec (car x) next-idx next-var))
+ (uniquify-shape-spec (car x) next-idx next-var used-idxs used-vars))
((mv cdr next-idx next-var)
- (uniquify-shape-spec (cdr x) next-idx next-var)))
+ (uniquify-shape-spec (cdr x) next-idx next-var used-idxs used-vars)))
(mv (cons car cdr) next-idx next-var))))))
(defthm natp-next-idx-of-uniquify-shape-spec
- (natp (mv-nth 1 (uniquify-shape-spec x next-idx next-var)))
+ (natp (mv-nth 1 (uniquify-shape-spec x next-idx next-var used-idxs used-vars)))
:rule-classes (:rewrite :type-prescription))
(defthm natp-next-var-of-uniquify-shape-spec
- (natp (mv-nth 2 (uniquify-shape-spec x next-idx next-var)))
+ (natp (mv-nth 2 (uniquify-shape-spec x next-idx next-var used-idxs used-vars)))
:rule-classes (:rewrite :type-prescription))
(verify-guards uniquify-shape-spec
:hints(("Goal" :in-theory (enable shape-specp))))
+(defun integer-with-nbitsp (n x)
+ (declare (xargs :guard t)
+ (ignore n))
+ (integerp x))
+
+(defun integer?-with-nbitsp (n x)
+ (declare (xargs :guard t)
+ (ignore n x))
+ t)
+
(defconst *default-symobj-generators*
'(((booleanp x) (g-boolean 0))
((unsigned-byte-p n x) (g-number (list (numlist 0 1 (+ 1 n)))))
- ((signed-byte-p n x) (g-number (list (numlist 0 1 n))))))
+ ((signed-byte-p n x) (g-number (list (numlist 0 1 n))))
+ ((integer-with-nbitsp n x) (g-integer 0 (numlist 0 1 n) 0))
+ ((integer?-with-nbitsp n x) (g-integer? 0 (numlist 0 1 n) 0 0))))
(defun translate-term-alist (gens wrld state-vars)
(declare (xargs :mode :program))
@@ -381,7 +480,7 @@
(defthm disjoin-of-intersection
(implies (not (add-hyps-ev (disjoin clause) a))
(not (add-hyps-ev (disjoin (intersection-equal x clause)) a)))
- :hints(("Goal" :in-theory (enable intersection-equal))))
+ :hints(("Goal" :in-theory (enable member-equal intersection-equal))))
(defthm group-list-cp-rec-correct
(implies (not (add-hyps-ev (disjoin clause) a))
@@ -411,11 +510,20 @@
(acl2::term-vars-list clause)))))))
-(defun gl-auto-hint-step2 (clause g-bindings state)
+(defun maybe-print-clause-fn (print pr-name message clause state)
+ (declare (xargs :mode :program :stobjs state))
+ (and (or (eq print :all)
+ (member :all print)
+ (member pr-name print))
+ (cw message (acl2::prettyify-clause clause t (w state)))))
+
+(defmacro maybe-print-clause (pr-name message)
+ `(maybe-print-clause-fn print ,pr-name ,message clause state))
+
+(defun gl-auto-hint-step2 (clause g-bindings print state)
(declare (xargs :mode :program :stobjs state))
(b* ((gl-clause-proc (latest-gl-clause-proc))
- (- (cw "using GL on clause: ~x0~%"
- (acl2::prettyify-clause clause nil (w state))))
+ (- (maybe-print-clause :final-clause "using GL on clause: ~x0~%"))
(config (make-glcp-config))
(cov-hints (glcp-coverage-hints nil nil nil nil))
(hyp (car clause))
@@ -431,21 +539,32 @@
(glcp-combine-hints call cov-hints nil nil nil)))
-(defun gl-auto-hint-fn (clause type-gens bad-subterms state)
+(defun gl-auto-hint-fn (clause type-gens bad-subterms print state)
(declare (xargs :mode :program :stobjs state))
- (b* ((- (cw "before filtering: ~x0~%"
- (acl2::prettyify-clause clause nil (w state))))
+ (b* ((- (maybe-print-clause :before-filtering "before filtering: ~x0~%"))
(clause (filter-bad-subterms clause bad-subterms))
((mv bindings hyp-lits nonhyp-lits)
(type-gen-collect-bindings clause type-gens state))
(bindings (fast-alist-free (hons-shrink-alist bindings nil)))
- ((mv g-bindings & &) (uniquify-shape-spec bindings 0 0))
+ (indices (shape-spec-indices bindings))
+ (vars (shape-spec-vars bindings))
+ (next-idx (+ 1 (max-list indices)))
+ (next-var (max-xn-sym vars))
+ (used-idxs (pairlis$ (acl2::duplicated-members indices) nil))
+ (used-vars (pairlis$ (acl2::duplicated-members vars) nil))
+ ((acl2::with-fast used-idxs used-vars))
+ ((mv g-bindings & &)
+ (uniquify-shape-spec bindings next-idx next-var used-idxs used-vars))
(vars (strip-cars g-bindings))
(concl-lits (filter-nonhyp-lits nonhyp-lits vars)))
`(:computed-hint-replacement
((run-let-abstraction-cp clause)
- (gl-auto-hint-step2 clause ',g-bindings state))
- :clause-processor (group-lits-cp clause ',(list hyp-lits concl-lits)))))
+ (gl-auto-hint-step2 clause ',g-bindings ',print state))
+ :clause-processor (group-lits-cp clause ',(list (append hyp-lits (butlast concl-lits 1))
+ (last concl-lits))))))
+
+
+
(defun get-fixup-alist (clause fixups)
@@ -480,14 +599,21 @@
:rule-classes :clause-processor)
-
+(defun remove-variables (x)
+ (if (atom x)
+ nil
+ (if (and (symbolp (car x))
+ (car x))
+ (remove-variables (cdr x))
+ (cons (car x) (remove-variables (cdr x))))))
+
-(defun try-gl-hint-fn (clause stablep fixups subterms-types type-gens bad-subterms state)
+(defun try-gl-hint-fn (clause stablep fixups subterms-types type-gens
+ bad-subterms print state)
(declare (xargs :mode :program :stobjs state))
(b* (((unless stablep) nil)
- (- (cw "original clause: ~x0~%"
- (acl2::prettyify-clause clause nil (w state))))
+ (- (maybe-print-clause :original-clause "original clause: ~x0~%"))
;; translate all the terms in the various arguments
(state-vars (acl2::default-state-vars t))
@@ -513,13 +639,12 @@
clause))
(- (and fixup-subst
- (cw "fixed-up clause: ~x0~%"
- (acl2::prettyify-clause fixup-clause nil (w state)))))
+ (maybe-print-clause :fixed-up-clause "fixed-up clause: ~x0~%")))
;; collect the subterms that we'll generalize away and their type hyps
((mv subterms type-hyps)
(collect-subterm-types fixup-clause subterms-types))
- (subterms (remove-duplicates-equal subterms))
+ (subterms (remove-variables (remove-duplicates-equal subterms)))
(type-hyps (remove-duplicates-equal type-hyps))
(clause-vars (acl2::term-vars-list fixup-clause))
(fresh-vars (make-n-vars (len subterms) 'x 0 clause-vars))
@@ -530,12 +655,14 @@
(try-gl-add-hyps-cp
clause '(,type-hyps
((progn$
- (cw "before generalization: ~x0~%"
- (acl2::prettyify-clause clause nil (w state)))
+ (let ((print ',print))
+ (maybe-print-clause :before-generalization
+ "before generalization: ~x0~%"))
(cw "Variable mapping: ~x0~%"
',(pairlis$ fresh-vars (pairlis$ subterms nil)))
'(:computed-hint-replacement
- ((gl-auto-hint-fn clause ',type-gens ',bad-subterms state))
+ ((gl-auto-hint-fn clause ',type-gens ',bad-subterms
+ ',print state))
:clause-processor
(acl2::simple-generalize-cp
clause ',(pairlis$ subterms fresh-vars))))))))))
@@ -550,10 +677,11 @@
add-hyps-hint)))
-(defmacro try-gl (&key fixes subterms-types type-gens bad-subterms)
+(defmacro try-gl (&key fixes subterms-types type-gens bad-subterms
+ print)
`(try-gl-hint-fn
clause stable-under-simplificationp
- ',fixes ',subterms-types ',type-gens ',bad-subterms state))
+ ',fixes ',subterms-types ',type-gens ',bad-subterms ',print state))
;; (include-book "gl")
diff -Nru acl2-6.2/books/centaur/gl/tutorial.lisp acl2-6.3/books/centaur/gl/tutorial.lisp
--- acl2-6.2/books/centaur/gl/tutorial.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/tutorial.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,676 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; tutorial.lisp
+;
+; Original authors: Sol Swords
+; Jared Davis
+
+(in-package "GL")
+(include-book "xdoc/top" :dir :system)
+
+(defxdoc basic-tutorial
+ :parents (gl)
+ :short "An introductory guide, recommended for new users of @(see GL)."
+
+ :long "This is a tutorial introduction to using GL to prove ACL2 theorems.
+We recommend going through the entire tutorial before beginning to use GL.
+
+You can think of this tutorial as a quick-start guide. By the time you're
+done with it, you should have a good understanding of how GL works, and be able
+to use GL to easily prove many theorems.
+
+We don't try to cover more advanced topics, like @(see optimization) and
+@(see term-level-reasoning). You'll probably want to get some practice using
+GL before exploring these topics.
")
+
+
+(defxdoc |1. An Example GL Proof|
+ :parents (basic-tutorial)
+ :long "
+
+The usual way to load GL is to start with
+@({
+ (include-book \"centaur/gl/gl\" :dir :system)
+})
+
+Let's use GL to prove a theorem. The following C code, from Sean
+Anderson Bit
+Twiddling Hacks page, is a fast way to count how many bits are set in a
+32-bit integer.
+
+@({
+ v = v - ((v >> 1) & 0x55555555);
+ v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
+ c = ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
+})
+
+We can model this in ACL2 as follows. It turns out that using
+arbitrary-precision addition and subtraction does not affect the result, but we
+must take care to use a 32-bit multiply to match the C code.
+
+@({
+ (defun 32* (x y)
+ (logand (* x y) (1- (expt 2 32))))
+
+ (defun fast-logcount-32 (v)
+ (let* ((v (- v (logand (ash v -1) #x55555555)))
+ (v (+ (logand v #x33333333)
+ (logand (ash v -2) #x33333333))))
+ (ash (32* (logand (+ v (ash v -4)) #xF0F0F0F)
+ #x1010101)
+ -24)))
+})
+
+We can then use GL to prove @('fast-logcount-32') computes the same
+result as ACL2's built-in @('logcount') function for all unsigned 32-bit
+inputs.
+
+@({
+ (def-gl-thm fast-logcount-32-correct
+ :hyp (unsigned-byte-p 32 x)
+ :concl (equal (fast-logcount-32 x)
+ (logcount x))
+ :g-bindings `((x ,(g-int 0 1 33))))
+})
+
+The @(':g-bindings') form is the only help GL needs from the user. It tells
+GL how to construct a symbolic object that can represent every value for @('x')
+that satisfies the hypothesis (we'll cover this shortly). No arithmetic books
+or lemmas are required—we actually don't even know why this algorithm
+works. The proof completes in 0.09 seconds and results in the following ACL2
+theorem.
+
+@({
+ (defthm fast-logcount-32-correct
+ (implies (unsigned-byte-p 32 x)
+ (equal (fast-logcount-32 x)
+ (logcount x)))
+ :hints ((gl-hint ...)))
+})
+
+GL can generate counterexamples to non-theorems. At first, we didn't
+realize we needed to use a 32-bit multiply in @('fast-logcount-32'), and we
+just used an arbitrary-precision multiply instead. The function still worked
+for test cases like @('0'), @('1') @('#b111'), and @('#b10111'), but when we
+tried to prove its correctness, GL showed us three counterexamples:
+@('#x80000000'), @('#xFFFFFFFF'), and @('#x9448C263'). By default, GL
+generates a first counterexample by setting bits to 0 wherever possible, a
+second by setting bits to 1, and a third with random bit settings.
")
+
+(defxdoc |2. Symbolic Objects|
+ :parents (basic-tutorial)
+ :long "
+
+At its heart, GL works by manipulating Boolean expressions. There are
+many ways to represent Boolean expressions. GL currently supports a hons-based
+BDD package and also has support for using a
+hons-based @(see aig) representation.
+
+For any particular proof, you can choose which representation to use by
+picking one of the available proof @(see modes). Each representation has
+strengths and weaknesses, and the choice of representation can significantly
+impact performance. We give some advice about choosing these modes in @(see
+modes).
+
+The GL user does not need to know how BDDs and AIGs are represented; in this
+documentation we will just adopt a conventional syntax to describe Boolean
+expressions, e.g., @('true'), @('false'), @('A & B'), @('~C'), etc.
+
+GL groups Boolean expressions into symbolic objects . Much like a
+Boolean expression can be evaluated to obtain a Boolean value, a symbolic
+object can be evaluated to produce an ACL2 object. There are several kinds of
+symbolic objects, but numbers are a good start. GL represents symbolic, signed
+integers as
+
+@({
+ (:g-number )
+})
+
+Where @('lsb-bits') is a list of Boolean expressions that represent the
+two's complement bits of the number. The bits are in lsb-first order, and the
+last, most significant bit is the sign bit. For instance, if @('p') is the
+following @(':g-number'),
+
+@({
+ p = (:g-number (true false A & B false))
+})
+
+Then @('p') represents a 4-bit, signed integer whose value is either 1 or 5,
+depending on the value of @('A & B').
+
+GL uses another kind of symbolic object to represent ACL2 Booleans.
+In particular,
+
+@({
+ (:g-boolean . )
+})
+
+represents @('t') or @('nil'), depending on the Boolean expression
+@(''). For example,
+
+@({
+ (:g-boolean . ~(A & B))
+})
+
+is a symbolic object whose value is @('t') when @('p') has value 1, and
+@('nil') when @('p') has value 5.
+
+GL has a few other kinds of symbolic objects that are also tagged with
+keywords, such as @(':g-var') and @(':g-apply'). But an ACL2 object
+that does not have any of these special keywords within it is also
+considered to be a symbolic object, and just represents itself. Furthermore, a
+cons of two symbolic objects represents the cons of the two objects they
+represent. For instance,
+
+@({
+ (1 . (:g-boolean . A & B))
+})
+
+represents either @('(1 . t)') or @('(1 . nil)'). Together, these
+conventions allow GL to avoid lots of tagging as symbolic objects are
+manipulated.
+
+One last kind of symbolic object we will mention represents an if-then-else
+among other symbolic objects. Its syntax is:
+
+@({
+ (:g-ite . )
+})
+
+where @(''), @(''), and @('') are themselves symbolic
+objects. The value of a @(':g-ite') is either the value of @('') or
+of @(''), depending on the value of @(''). For example,
+
+@({
+ (:g-ite (:g-boolean . A)
+ (:g-number (B A false))
+ . #\\C)
+})
+
+represents either 2, 3, or the character @('C').
+
+GL doesn't have a special symbolic object format for ACL2 objects other than
+numbers and Booleans. But it is still possible to create symbolic objects that
+take any finite range of values among ACL2 objects, by using a nesting of
+@(':g-ite')s where the tests are @(':g-boolean')s.
")
+
+
+(defxdoc |3. Computing with Symbolic Objects|
+ :parents (basic-tutorial)
+ :long "
+
+Once we have a representation for symbolic objects, we can perform symbolic
+executions on those objects. For instance, recall the symbolic number @('p')
+which can have value 1 or 5,
+
+@({
+ p = (:g-number (true false A & B false))
+})
+
+We might symbolically add 1 to @('p') to obtain a new symbolic number, say
+@('q'),
+
+@({
+ q = (:g-number (false true A & B false))
+})
+
+which represents either 2 or 6. Suppose @('r') is another symbolic number,
+
+@({
+ r = (:g-number (A false true false))
+})
+
+which represents either 4 or 5. We might add @('q') and @('r') to obtain
+@('s'),
+
+@({
+ s = (:g-number (A true ~(A & B) (A & B) false))
+})
+
+whose value can be 6, 7, or 11.
+
+Why can't @('s') be 10 if @('q') can be 6 and @('r') can be 4? This
+combination isn't possible because @('q') and @('r') involve the same
+expression, @('A'). The only way for @('r') to be 4 is for @('A') to be false,
+but then @('q') must be 2.
+
+The underlying algorithm GL uses for symbolic additions is just a
+ripple-carry addition on the Boolean expressions making up the bits of the two
+numbers. Performing a symbolic addition, then, means constructing new @(see
+ubdds) or @(see aig)s, depending on which mode is being used.
+
+GL has built-in support for symbolically executing most ACL2 primitives.
+Generally, this is done by cases on the types of the symbolic objects being
+passed in as arguments. For instance, if we want to symbolically execute @(see
+consp) on @('s'), then we are asking whether a @(':g-number') may ever
+represent a cons, so the answer is simply @('nil'). Similarly, if we ever try
+to add a @(':g-boolean') to a @(':g-number'), by the ACL2 axioms the
+@(':g-boolean') is simply treated as 0.
+
+Beyond these primitives, GL provides what is essentially a McCarthy-style
+interpreter for symbolically executing terms. By default, it expands
+function definitions until it reaches primitives, with some special handling
+for @(see if). For better performance, its interpretation scheme can be
+customized with more efficient definitions and other @(see optimization)s.
+")
+
+(defxdoc |4. Proving Theorems by Symbolic Execution|
+ :parents (basic-tutorial)
+ :long "
+
+To see how symbolic execution can be used to prove theorems, let's return to
+the bit-counting example, where our goal was to prove
+
+@({
+ (implies (unsigned-byte-p 32 x)
+ (equal (fast-logcount-32 x)
+ (logcount x)))
+})
+
+The basic idea is to first symbolically execute the above formula, and then
+check whether it can ever evaluate to @('nil'). But to do this symbolic
+execution, we need some symbolic object to represent @('x').
+
+We want our symbolic execution to cover all the cases necessary for proving
+the theorem, namely all @('x') for which the hypothesis @('(unsigned-byte-p 32
+x)') holds. In other words, the symbolic object we choose needs to be able to
+represent any integer from 0 to @('2^32 - 1').
+
+Many symbolic objects cover this range. As notation, let @('b0, b1, ...')
+represent independent Boolean variables in our Boolean expression
+representation. Then, one suitable object is:
+
+@({
+ Xinit = (:g-number (b0 b1 ... b31 b32)).
+})
+
+Why does this have 33 variables? The final bit, @('b32'), represents the
+sign, so this object covers the integers from @('-2^32') to @('2^32 - 1'). We
+could instead use a 34-bit integer, or a 35-bit integer, or some esoteric
+creation involving @(':g-ite') forms. But perhaps the best object to use would
+be:
+
+@({
+ Xbest = (:g-number (b0 b1 ... b31 false)).
+})
+
+since it covers exactly the desired range using the simplest possible
+Boolean expressions.
+
+Suppose we choose @('Xbest') to stand for @('x') We can now symbolically
+execute the goal formula on that object.
+
+What does this involve? First, @('(unsigned-byte-p 32 x)') produces the
+symbolic result @('t'), since it is always true of the possible values of
+@('Xbest'). It would have been equally valid for this to produce
+@('(:g-boolean . true)'), but GL prefers to produce constants when
+possible.
+
+Next, the @('(fast-logcount-32 x)') and @('(logcount x)') forms each yield
+@(':g-number') objects whose bits are Boolean expressions in the variables
+@('b0, ..., b31'). For example, the least significant bit will be an
+expression representing the XOR of all these variables.
+
+Finally, we symbolically execute @(see equal) on these two results. This
+compares the Boolean expressions for their bits to determine if they are
+equivalent, and produces a symbolic object representing the answer.
+
+So far we have basically ignored the differences between using @(see ubdds)
+or @(see aig)s as our Boolean expression representation. But here, the two
+approaches produce very different answers:
+
+
+Since UBDDs are canonical, the expressions for the bits of the two numbers
+ are syntactically equal, and the result from @(see equal) is simply @('t').
+
+With AIGs, the expressions for the bits are semantically equivalent but not
+ syntactically equal. The result is therefore @('(:g-boolean . phi)'), where
+ @('phi') is a large Boolean expression in the variables @('b0, ..., b31').
+ The fact that @('phi') always evaluates to @('t') is not obvious just from
+ its syntax.
+
+
+At this point we have completed the symbolic execution of our goal formula,
+obtaining either @('t') in BDD mode, or this @(':g-boolean') object in AIG
+mode. Recall that to prove theorems using symbolic execution, the idea is to
+symbolically execute the goal formula and then check whether its symbolic
+result can represent @('nil'). If we are using BDDs, it is obvious that @('t')
+cannot represent @('nil'). With AIGs, we simply ask a SAT solver whether
+@('phi') can evaluate to @('false'), and find that it cannot. This completes
+the proof.
+
+GL automates this proof strategy, taking care of many of the details
+relating to creating symbolic objects, ensuring that they cover all the
+possible cases, and ensuring that @('nil') cannot be represented by the
+symbolic result. When GL is asked to prove a non-theorem, it can generate
+counterexamples by finding assignments to the Boolean variables that cause the
+result to become @('nil').
")
+
+
+(defxdoc |5. Using def-gl-thm|
+ :parents (basic-tutorial)
+ :long "
+
+The @(see def-gl-thm) command is the main interface for using GL to prove
+theorems. Here is the command we used in the bit-counting example from @(csee
+|1. An Example GL Proof|):
+
+@({
+ (def-gl-thm fast-logcount-32-correct
+ :hyp (unsigned-byte-p 32 x)
+ :concl (equal (fast-logcount-32 x)
+ (logcount x))
+ :g-bindings `((x ,(g-int 0 1 33))))
+})
+
+Unlike an ordinary @(see defthm) command, @(see def-gl-thm) takes separate
+hypothesis and conclusion terms (its @('hyp') and @(':concl') arguments). This
+separation allows GL to use the hypothesis to limit the scope of the symbolic
+execution it will perform. You also have to provide GL with @(':g-bindings')
+that describe the symbolic objects to use for each free variable in the
+theorem.
+
+What are these bindings? In the @('fast-logcount-32-correct') theorem, we
+used a convenient function, @('g-int'), to construct the @(':g-bindings').
+Expanding this away, here are the actual bindings:
+
+@({
+ ((x (:g-number (0 1 2 ... 32))))
+})
+
+The @(':g-bindings') argument uses a slight modification of the symbolic
+object format where the Boolean expressions are replaced by distinct natural
+numbers, each representing a Boolean variable. In this case, our binding for
+@('x') stands for the following symbolic object:
+
+@({
+ Xinit = (:g-number (b0 b1 ... b31 b32))
+})
+
+Note that @('Xinit') is not the same object as @('Xbest') from @(see
+|4. Proving Theorems by Symbolic Execution|)—its sign bit is @('b32')
+instead of @('false'), so @('Xinit') can represent any 33-bit signed integer
+whereas @('Xbest') only represents 32-bit unsigned values. In fact, the
+@(':g-bindings') syntax does not even allow us to describe objects like
+@('Xbest'), which has the constant @('false') instead of a variable as one of
+its bits.
+
+There is a good reason for this restriction. One of the steps in our proof
+strategy is to prove coverage : we need to show the symbolic objects we
+are starting out with have a sufficient range of values to cover all cases for
+which the hypothesis holds; more on this in @(see |7. Proving Coverage|). The
+restricted syntax permitted by @(':g-bindings') ensures that the range of
+values represented by each symbolic object is easy to determine. Because of
+this, coverage proofs are usually automatic.
+
+Despite these restrictions, GL will still end up using @('Xbest') to carry
+out the symbolic execution. GL optimizes the original symbolic objects
+inferred from the @(':g-bindings') by using the hypothesis to reduce the space
+of objects that are represented. In BDD mode this optimization uses BDD parametrization , which
+restricts the symbolic objects so they cover exactly the inputs recognized by
+the hypothesis. In AIG mode we use a lighter-weight transformation that
+replaces variables with constants when the hypothesis sufficiently restricts
+them. In this example, either optimization transforms @('Xinit') into
+@('Xbest').
")
+
+(defxdoc |6. Writing :g-bindings forms|
+ :parents (basic-tutorial)
+ :long "
+
+In a typical @(see def-gl-thm) command, the @(':g-bindings') should have an
+entry for every free variable in the theorem. Here is an example that shows
+some typical bindings.
+
+@({
+ :g-bindings '((flag (:g-boolean . 0))
+ (a-bus (:g-number (1 3 5 7 9)))
+ (b-bus (:g-number (2 4 6 8 10)))
+ (mode (:g-ite (:g-boolean . 11) exact . fast))
+ (opcode #b0010100))
+})
+
+These bindings allow @('flag') to take an arbitrary Boolean value,
+@('a-bus') and @('b-bus') any five-bit signed integer values, @('mode') either
+the symbol @('exact') or @('fast'), and @('opcode') only the value 20.
+
+(Aside: Note that since @('#b0010100') is not within a @(':g-boolean') or
+@(':g-number') form, it is not the index of a Boolean variable.
+Instead, like the symbols @('exact') and @('fast'), it is just an ordinary ACL2
+constant that stands for itself, i.e., 20.)
+
+These @(':g-boolean') and @(':g-number') are called @(see shape-specs).
+They are similar to the symbolic objects GL uses to compute with, except that
+natural number indices take the places of Boolean expressions. The indices
+used throughout all of the bindings must be distinct, and represent free,
+independent Boolean variables.
+
+In BDD mode, these indices have additional meaning: they specify the BDD
+variable ordering, with smaller indices coming first in the order. This
+ordering can greatly affect performance. In AIG mode the choice of indices has
+no particular bearing on efficiency.
+
+How do you choose a good BDD ordering? It is often good to interleave the
+bits of data buses that are going to be combined in some way. It is also
+typically a good idea to put any important control signals such as opcodes and
+mode settings before the data buses.
+
+Often the same @(':g-bindings') can be used throughout several theorems,
+either verbatim or with only small changes. In practice, we almost always
+generate the @(':g-bindings') forms by calling functions or macros. One
+convenient function is
+
+@({(g-int start by n)})
+
+which generates a @(':g-number') form with @('n') bits, using
+indices that start at @('start') and increment by @('by'). This is
+particularly useful for interleaving the bits of numbers, as we did for the
+@('a-bus') and @('b-bus') bindings above:
+
+@({
+ (g-int 1 2 5) ---> (:g-number (1 3 5 7 9))
+ (g-int 2 2 5) ---> (:g-number (2 4 6 8 10))
+})
+
+Writing out @(':g-bindings') and getting all the indices can be tedious.
+See @(see auto-bindings) for a convenient macro that helps ensure that all the
+indices are different.
")
+
+
+(defxdoc |7. Proving Coverage|
+ :parents (basic-tutorial)
+ :long "
+
+There are really two parts to any GL theorem. First, we need to
+symbolically execute the goal formula and ensure it cannot evaluate to
+@('nil'). But in addition to this, we must ensure that the objects we use to
+represent the variables of the theorem cover all the cases that satisfy the
+hypothesis. This part of the proof is called the coverage
+obligation .
+
+For @('fast-logcount-32-correct'), the coverage obligation is to show that
+our binding for @('x') is able to represent every integer from 0 to @('2^32 -
+1'). This is true of @('Xinit'), and the coverage proof goes through
+automatically.
+
+But suppose we forget that @(':g-number')s use a signed representation, and
+attempt to prove @('fast-logcount-32-correct') using the following (incorrect)
+g-bindings.
+
+@({
+ :g-bindings `((x ,(g-int 0 1 32)))
+})
+
+This looks like a 32-bit integer, but because of the sign bit it does not cover
+the intended unsigned range. If we submit the @(see def-gl-thm) command
+with these bindings, the symbolic execution part of the proof is still successful.
+But this execution has only really shown the goal holds for 31-bit unsigned
+integers, so @(see def-gl-thm) prints the message
+
+@({
+ ERROR: Coverage proof appears to have failed.
+})
+
+and leaves us with a failed subgoal,
+
+@({
+ (implies (and (integerp x)
+ (<= 0 x)
+ (< x 4294967296))
+ (< x 2147483648))
+})
+
+This goal is clearly not provable: we are trying to show @('x') must be less
+than @('2^31') (from our @(':g-bindings')) whenever it is less than
+@('2^32') (from the hypothesis).
+
+Usually when the @(':g-bindings') are correct, the coverage proof will be
+automatic, so if you see that a coverage proof has failed, the first thing to
+do is check whether your bindings are really sufficient.
+
+On the other hand, proving coverage is undecidable in principle, so
+sometimes GL will fail to prove coverage even though the bindings are
+appropriate. For these cases, there are some keyword arguments to @(see
+def-gl-thm) that may help coverage proofs succeed.
+
+First, as a practical matter, GL does the symbolic execution part of the
+proof before trying to prove coverage. This can get in the way of
+debugging coverage proofs when the symbolic execution takes a long time. You
+can use @(':test-side-goals t') to have GL skip the symbolic execution and go
+straight to the coverage proof. Of course, no @(see defthm) is produced when
+this option is used.
+
+By default, our coverage proof strategy uses a restricted set of rules and
+ignores the current theory. It heuristically expands functions in the
+hypothesis and throws away terms that seem irrelevant. When this strategy
+fails, it is usually for one of two reasons.
+
+
+
+The heuristics expand too many terms and overwhelm ACL2. GL tries to avoid
+this by throwing away irrelevant terms, but sometimes this approach is
+insufficient. It may be helpful to disable the expansion of functions that are
+not important for proving coverage. The @(':do-not-expand') argument allows
+you to list functions that should not be expanded.
+
+The heuristics throw away a necessary hypothesis, leading to unprovable
+goals. GL's coverage proof strategy tries to show that the binding for each
+variable is sufficient, one variable at a time. During this process it throws
+away hypotheses that do not mention the variable, but in some cases this can be
+inappropriate. For instance, suppose the following is a coverage goal for
+@('b'):
+
+@({
+ (implies (and (natp a)
+ (natp b)
+ (< a (expt 2 15))
+ (< b a))
+ (< b (expt 2 15)))
+})
+
+Here, throwing away the terms that don't mention @('b') will cause the proof to
+fail. A good way to avoid this problem is to separate type and size hypotheses
+from more complicated assumptions that are not important for proving coverage,
+along these lines:
+
+@({
+ (def-gl-thm my-theorem
+ :hyp (and (type-assms-1 x)
+ (type-assms-2 y)
+ (type-assms-3 z)
+ (complicated-non-type-assms x y z))
+ :concl ...
+ :g-bindings ...
+ :do-not-expand '(complicated-non-type-assms))
+})
+
+
+
+
+For more control, you can also use the @(':cov-theory-add') argument to
+enable additional rules during the coverage proof, e.g., @(':cov-theory-add
+'(type-rule1 type-rule2)').
")
+
+
+(defxdoc |8. Exercises|
+ :parents (basic-tutorial)
+ :long "Here are some exercises you can use to get some experience with
+using GL.
+
+These exercises will get you into some rough spots, so that you can learn
+how to get out. If you get stuck, you can see our solutions in the file
+@('centaur/gl/solutions.lisp').
+
+We recommend trying to carry out these exercises in a new file. You will
+probably want to start your file with:
+
+@({
+ (in-package \"ACL2\")
+ (include-book \"centaur/gl/gl\" :dir :system)
+})
+
+At certain points in the exercises, we assume your computer has at least
+8 GB of memory.
+
+
+Arithmetic Exercises
+
+1a. Use GL to prove that addition commutes for 4-bit unsigned
+numbers:
+
+@({
+ (implies (and (unsigned-byte-p 4 x)
+ (unsigned-byte-p 4 y))
+ (equal (+ x y) (+ y x)))
+})
+
+1b. Carry out the same proof as in 1a, but construct your
+G-bindings:
+
+
+ Using @(see auto-bindings)
+ Using @(see g-int)
+ \"Manually\", without using either of these.
+
+
+Hints: you may want to consult @(see |6. Writing :g-bindings forms|) and
+@(see shape-specs).
+
+
+1c. Extend your proof from 1a to 20-bit numbers. How long does the
+proof take? How much memory did it use? Try the @(see hons-summary) command
+get a sense of the memory usage.
+
+
+1d. In the same ACL2 session, unto your proof of 1c and submit it
+again. How long did it take this time? Can you explain what happened?
+
+
+1e. Figure out how to optimize your G-bindings to make the proof in
+1c go through quickly. For reliable timings, use @(see clear-memoize-tables)
+and @(see hons-clear) before each proof attempt. Implement your solution using
+both @(see g-int) and @(see auto-bindings).
+
+
+1f. Use GL to prove that addition commutes up to 3,000 bits.
+Hint: the @(see debugging) section might be able to help you.
+
+
+")
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/gl/var-bounds.lisp acl2-6.3/books/centaur/gl/var-bounds.lisp
--- acl2-6.2/books/centaur/gl/var-bounds.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/gl/var-bounds.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,791 @@
+; GL - A Symbolic Simulation Framework for ACL2
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; tutorial.lisp
+;
+; Original authors: Sol Swords
+; Jared Davis
+
+(in-package "GL")
+(include-book "gtypes")
+(include-book "bvar-db")
+(include-book "param")
+(local (include-book "centaur/misc/arith-equivs" :dir :system))
+
+(defsection bfr-vars-bounded
+ (defun-sk bfr-vars-bounded (n x)
+ (forall m
+ (implies (<= (nfix n) (nfix m))
+ (not (bfr-depends-on m x))))
+ :rewrite :direct)
+
+ (in-theory (disable bfr-vars-bounded))
+
+ (defthm bfr-vars-bounded-incr
+ (implies (and (bfr-vars-bounded m x)
+ (<= (nfix m) (nfix n)))
+ (bfr-vars-bounded n x))
+ :hints ((and stable-under-simplificationp
+ `(:expand (,(car (last clause)))))))
+
+ (local (in-theory (enable* acl2::arith-equiv-forwarding)))
+
+ (local (defthm bfr-eval-of-set-non-dep-cong
+ (implies (and (not (bfr-depends-on k x))
+ (acl2::nat-equiv k k-equiv))
+ (equal (bfr-eval x (bfr-set-var k-equiv v env))
+ (bfr-eval x env)))))
+
+ (encapsulate nil
+ (local (defthm bfr-semantic-depends-on-of-set-var-equiv
+ (implies (and (not (bfr-semantic-depends-on k1 x))
+ (acl2::nat-equiv k1 k2))
+ (equal (bfr-eval x (bfr-set-var k2 v env))
+ (bfr-eval x env)))))
+
+ (defcong acl2::nat-equiv equal (bfr-semantic-depends-on k x) 1
+ :hints(("Goal" :cases ((bfr-semantic-depends-on k x))
+ :in-theory (e/d (bfr-depends-on)
+ (acl2::nat-equiv)))
+ (and stable-under-simplificationp
+ (if (eq (caar clause) 'not)
+ `(:expand (,(cadar clause)))
+ `(:expand (,(cadar (last clause)))))))))
+
+ (defcong acl2::nat-equiv equal (bfr-depends-on k x) 1
+ :hints(("Goal" :cases ((bfr-depends-on k x))
+ :in-theory (enable bfr-depends-on))))
+
+ (defcong acl2::nat-equiv equal (bfr-vars-bounded n x) 1
+ :hints(("Goal"
+ :use ((:instance bfr-vars-bounded-necc
+ (m (bfr-vars-bounded-witness acl2::n-equiv x)))
+ (:instance bfr-vars-bounded-necc
+ (n acl2::n-equiv)
+ (m (bfr-vars-bounded-witness n x))))
+ :in-theory (e/d (bfr-vars-bounded)
+ (bfr-vars-bounded-necc)))))
+
+ (defthm bfr-vars-bounded-of-consts
+ (and (bfr-vars-bounded k t)
+ (bfr-vars-bounded k nil))
+ :hints(("Goal" :in-theory (enable bfr-vars-bounded)))))
+
+(defsection bfr-list-vars-bounded
+ (defund bfr-list-vars-bounded (n x)
+ (if (atom x)
+ t
+ (and (bfr-vars-bounded n (car x))
+ (bfr-list-vars-bounded n (cdr x)))))
+
+ (local (in-theory (enable bfr-list-vars-bounded)))
+
+ (defthm bfr-list-vars-bounded-incr
+ (implies (and (bfr-list-vars-bounded m x)
+ (<= (nfix m) (nfix n)))
+ (bfr-list-vars-bounded n x))
+ :hints ((and stable-under-simplificationp
+ `(:expand (,(car (last clause)))))))
+
+ (defcong acl2::nat-equiv equal (bfr-list-vars-bounded n x) 1)
+
+ (defthm bfr-list-vars-bounded-of-cons
+ (equal (bfr-list-vars-bounded n (cons x y))
+ (and (bfr-vars-bounded n x)
+ (bfr-list-vars-bounded n y))))
+
+ (defthm bfr-list-vars-bounded-of-atom
+ (implies (not (consp x))
+ (equal (bfr-list-vars-bounded n x) t))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+
+(defsection pbfr-vars-bounded
+
+ (defun-sk pbfr-vars-bounded (n p x)
+ (forall m
+ (implies (<= (nfix n) (nfix m))
+ (not (pbfr-depends-on m p x))))
+ :rewrite :direct)
+
+ (in-theory (disable pbfr-vars-bounded))
+
+ (defthm pbfr-vars-bounded-incr
+ (implies (and (pbfr-vars-bounded m p x)
+ (<= (nfix m) (nfix n)))
+ (pbfr-vars-bounded n p x))
+ :hints ((and stable-under-simplificationp
+ `(:expand (,(car (last clause)))))))
+
+ (local (in-theory (enable* acl2::arith-equiv-forwarding)))
+
+ (local (defthm pbfr-eval-of-set-non-dep-cong
+ (implies (and (not (pbfr-depends-on k p x))
+ (acl2::nat-equiv k k-equiv)
+ (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k-equiv v env)))
+ (equal (bfr-eval x (bfr-param-env p (bfr-set-var k-equiv v env)))
+ (bfr-eval x (bfr-param-env p env))))))
+
+ (encapsulate nil
+ (local (defthm pbfr-semantic-depends-on-of-set-var-equiv
+ (implies (and (not (pbfr-semantic-depends-on k1 p x))
+ (acl2::nat-equiv k1 k2)
+ (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k2 v env)))
+ (equal (bfr-eval x
+ (bfr-param-env p (bfr-set-var k2 v env)))
+ (bfr-eval x (bfr-param-env p env))))))
+
+
+ (defcong acl2::nat-equiv equal (pbfr-semantic-depends-on k p x) 1
+ :hints(("Goal" :cases ((pbfr-semantic-depends-on k p x))
+ :in-theory (disable acl2::nat-equiv))
+ (and stable-under-simplificationp
+ (if (eq (caar clause) 'not)
+ `(:expand (,(cadar clause)))
+ `(:expand (,(cadar (last clause)))))))))
+
+ (defcong acl2::nat-equiv equal (pbfr-depends-on k p x) 1
+ :hints(("Goal" :in-theory (enable pbfr-depends-on))))
+
+ (defcong acl2::nat-equiv equal (pbfr-vars-bounded n p x) 1
+ :hints(("Goal"
+ :use ((:instance pbfr-vars-bounded-necc
+ (m (pbfr-vars-bounded-witness acl2::n-equiv p x)))
+ (:instance pbfr-vars-bounded-necc
+ (n acl2::n-equiv)
+ (m (pbfr-vars-bounded-witness n p x))))
+ :in-theory (e/d (pbfr-vars-bounded)
+ (pbfr-vars-bounded-necc)))))
+
+ (defthm pbfr-vars-bounded-of-consts
+ (and (pbfr-vars-bounded k p t)
+ (pbfr-vars-bounded k p nil))
+ :hints(("Goal" :in-theory (enable pbfr-vars-bounded))))
+
+ (defthm bfr-param-env-t
+ (equal (bfr-param-env t env)
+ env)
+ :hints(("Goal" :in-theory (enable bfr-param-env bfr-lookup))))
+
+ (defthm bfr-unparam-env-t
+ (equal (bfr-unparam-env t env) env)
+ :hints(("Goal" :in-theory (enable bfr-unparam-env))))
+
+
+ (defthm pbfr-semantic-depends-on-t
+ (implies (not (pbfr-semantic-depends-on k t x))
+ (not (bfr-semantic-depends-on k x)))
+ :hints (("goal" :expand ((bfr-semantic-depends-on k x))
+ :use ((:instance pbfr-semantic-depends-on-suff
+ (p t)
+ (v (mv-nth 1 (bfr-semantic-depends-on-witness k x)))
+ (env (mv-nth 0 (bfr-semantic-depends-on-witness k x)))))
+ :in-theory (disable pbfr-semantic-depends-on-suff))))
+
+ (defthm pbfr-depends-on-t
+ (implies (not (pbfr-depends-on k t x))
+ (not (bfr-depends-on k x)))
+ :hints(("Goal" :in-theory (enable pbfr-depends-on bfr-depends-on
+ bfr-from-param-space))))
+
+ (defthm pbfr-semantic-depends-on-of-bfr-to-param-space
+ (implies (not (pbfr-semantic-depends-on k t x))
+ (not (pbfr-semantic-depends-on k p (bfr-to-param-space p x))))
+ :hints (("goal" :expand ((pbfr-semantic-depends-on k p (bfr-to-param-space p x)))
+ :use ((:instance pbfr-semantic-depends-on-suff
+ (p t)
+ (env (mv-nth 0 (pbfr-semantic-depends-on-witness k p (bfr-to-param-space p x))))
+ (v (mv-nth 1 (pbfr-semantic-depends-on-witness k p (bfr-to-param-space p x))))))
+ :in-theory (disable pbfr-semantic-depends-on-suff
+ pbfr-eval-of-set-non-dep))))
+
+ (defthm pbfr-depends-on-of-bfr-to-param-space
+ (implies (not (pbfr-depends-on k t x))
+ (not (pbfr-depends-on k p (bfr-to-param-space p x))))
+ :hints(("Goal" :in-theory (enable pbfr-depends-on))
+ (and stable-under-simplificationp
+ '(:in-theory (enable bfr-to-param-space bfr-from-param-space
+ bfr-depends-on)))))
+
+ (defthm pbfr-vars-bounded-t
+ (implies (pbfr-vars-bounded k t x)
+ (bfr-vars-bounded k x))
+ :hints (("goal" :expand ((bfr-vars-bounded k x))
+ :use ((:instance pbfr-vars-bounded-necc
+ (n k)
+ (p t) (m (bfr-vars-bounded-witness k x))))
+ :in-theory (disable pbfr-vars-bounded-necc))))
+
+ (defthm pbfr-vars-bounded-of-bfr-to-param-space
+ (implies (pbfr-vars-bounded k t x)
+ (pbfr-vars-bounded k p (bfr-to-param-space p x)))
+ :hints (("goal" :expand ((pbfr-vars-bounded k p (bfr-to-param-space p x)))))))
+
+(defsection pbfr-list-depends-on
+ (local (in-theory (enable pbfr-list-depends-on)))
+
+ (defthm pbfr-list-depends-on-of-cons
+ (equal (pbfr-list-depends-on k p (cons x y))
+ (or (pbfr-depends-on k p x)
+ (pbfr-list-depends-on k p y))))
+
+ (defthm pbfr-list-depends-on-of-atom
+ (implies (not (consp x))
+ (equal (pbfr-list-depends-on k p x)
+ nil))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+
+(defsection pbfr-list-vars-bounded
+ (defund pbfr-list-vars-bounded (n p x)
+ (if (atom x)
+ t
+ (and (pbfr-vars-bounded n p (car x))
+ (pbfr-list-vars-bounded n p (cdr x)))))
+
+ (defun pbfr-list-vars-bounded-witness (n p x)
+ (if (atom x)
+ nil
+ (or (and (not (pbfr-vars-bounded n p (car x)))
+ (nfix (pbfr-vars-bounded-witness n p (car x))))
+ (pbfr-list-vars-bounded-witness n p (cdr x)))))
+
+ (local (in-theory (enable pbfr-list-vars-bounded)))
+
+
+
+ (defthm pbfr-list-vars-bounded-implies-not-depends-on
+ (implies (and (pbfr-list-vars-bounded n p x)
+ (<= (nfix n) (nfix m)))
+ (not (pbfr-list-depends-on m p x)))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on))))
+
+ (defthm pbfr-list-vars-bounded-incr
+ (implies (and (pbfr-list-vars-bounded m p x)
+ (<= (nfix m) (nfix n)))
+ (pbfr-list-vars-bounded n p x))
+ :hints ((and stable-under-simplificationp
+ `(:expand (,(car (last clause)))))))
+
+ (defcong acl2::nat-equiv equal (pbfr-list-vars-bounded n p x) 1)
+
+ (defthmd pbfr-list-vars-bounded-in-terms-of-witness
+ (implies (acl2::rewriting-positive-literal
+ `(pbfr-list-vars-bounded ,n ,p ,x))
+ (equal (pbfr-list-vars-bounded n p x)
+ (let ((m (pbfr-list-vars-bounded-witness n p x)))
+ (or (< (nfix m) (nfix n))
+ (not (pbfr-list-depends-on m p x))))))
+ :hints(("Goal" :in-theory (enable pbfr-list-depends-on)
+ :induct t)
+ (and stable-under-simplificationp
+ '(:expand ((pbfr-vars-bounded n p (car x))
+ (:free (n) (pbfr-list-depends-on n p x)))))))
+
+ (defthmd pbfr-list-vars-bounded-witness-under-iff
+ (iff (pbfr-list-vars-bounded-witness n p x)
+ (not (pbfr-list-vars-bounded n p x))))
+
+ (defthm pbfr-list-vars-bounded-of-cons
+ (equal (pbfr-list-vars-bounded n p (cons x y))
+ (and (pbfr-vars-bounded n p x)
+ (pbfr-list-vars-bounded n p y))))
+
+ (defthm pbfr-list-vars-bounded-of-atom
+ (implies (not (consp x))
+ (equal (pbfr-list-vars-bounded n p x) t))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm pbfr-list-vars-bounded-t
+ (implies (pbfr-list-vars-bounded k t x)
+ (bfr-list-vars-bounded k x)))
+
+ (defthm pbfr-list-vars-bounded-of-bfr-to-param-space
+ (implies (pbfr-list-vars-bounded k t x)
+ (pbfr-list-vars-bounded k p (bfr-list-to-param-space p x)))
+ :hints(("Goal" :in-theory (enable bfr-list-to-param-space)))))
+
+
+
+
+
+
+(defsection gobj-alist-depends-on
+
+ (defun gobj-alist-depends-on (k p x)
+ (if (atom x)
+ nil
+ (or (and (consp (car x))
+ (gobj-depends-on k p (cdar x)))
+ (gobj-alist-depends-on k p (cdr x)))))
+
+
+ (defthm gobj-alist-depends-on-of-pairlis$
+ (implies (not (gobj-list-depends-on k p x))
+ (not (gobj-alist-depends-on k p (pairlis$ keys x)))))
+
+ (defthm gobj-depends-on-of-alist-lookup
+ (implies (not (gobj-alist-depends-on k p alist))
+ (not (gobj-depends-on k p (cdr (hons-assoc-equal x alist)))))))
+
+
+
+(defsection gobj-vars-bounded
+
+ (mutual-recursion
+ (defun gobj-vars-bounded (k p x)
+ (if (atom x)
+ t
+ (pattern-match x
+ ((g-boolean b) (pbfr-vars-bounded k p b))
+ ((g-number n)
+ (b* (((mv rn rd in id) (break-g-number n)))
+ (and (pbfr-list-vars-bounded k p rn)
+ (pbfr-list-vars-bounded k p rd)
+ (pbfr-list-vars-bounded k p in)
+ (pbfr-list-vars-bounded k p id))))
+ ((g-ite test then else)
+ (and (gobj-vars-bounded k p test)
+ (gobj-vars-bounded k p then)
+ (gobj-vars-bounded k p else)))
+ ((g-concrete &) t)
+ ((g-var &) t)
+ ((g-apply & args) (gobj-list-vars-bounded k p args))
+ (& (and (gobj-vars-bounded k p (car x))
+ (gobj-vars-bounded k p (cdr x)))))))
+ (defun gobj-list-vars-bounded (k p x)
+ (if (atom x)
+ t
+ (and (gobj-vars-bounded k p (car x))
+ (gobj-list-vars-bounded k p (cdr x))))))
+
+ (mutual-recursion
+ (defun gobj-vars-bounded-witness (k p x)
+ (if (atom x)
+ nil
+ (pattern-match x
+ ((g-boolean b) (and (not (pbfr-vars-bounded k p b))
+ (nfix (pbfr-vars-bounded-witness k p b))))
+ ((g-number n)
+ (b* (((mv rn rd in id) (break-g-number n)))
+ (or (pbfr-list-vars-bounded-witness k p rn)
+ (pbfr-list-vars-bounded-witness k p rd)
+ (pbfr-list-vars-bounded-witness k p in)
+ (pbfr-list-vars-bounded-witness k p id))))
+ ((g-ite test then else)
+ (or (gobj-vars-bounded-witness k p test)
+ (gobj-vars-bounded-witness k p then)
+ (gobj-vars-bounded-witness k p else)))
+ ((g-concrete &) nil)
+ ((g-var &) nil)
+ ((g-apply & args) (gobj-list-vars-bounded-witness k p args))
+ (& (or (gobj-vars-bounded-witness k p (car x))
+ (gobj-vars-bounded-witness k p (cdr x)))))))
+ (defun gobj-list-vars-bounded-witness (k p x)
+ (if (atom x)
+ nil
+ (or (gobj-vars-bounded-witness k p (car x))
+ (gobj-list-vars-bounded-witness k p (cdr x))))))
+
+ (in-theory (disable gobj-vars-bounded gobj-list-vars-bounded))
+ (local (in-theory (enable gobj-vars-bounded gobj-list-vars-bounded)))
+
+ (defthm-gobj-flag
+ (defthm gobj-vars-bounded-implies-not-depends-on
+ (implies (and (gobj-vars-bounded k p x)
+ (<= (nfix k) (nfix n)))
+ (not (gobj-depends-on n p x)))
+ :flag gobj)
+ (defthm gobj-list-vars-bounded-implies-not-depends-on
+ (implies (and (gobj-list-vars-bounded k p x)
+ (<= (nfix k) (nfix n)))
+ (not (gobj-list-depends-on n p x)))
+ :flag list))
+
+
+ (defthm-gobj-flag
+ (defthm gobj-vars-bounded-incr
+ (implies (and (gobj-vars-bounded k p x)
+ (<= (nfix k) (nfix n)))
+ (gobj-vars-bounded n p x))
+ :flag gobj)
+ (defthm gobj-list-vars-bounded-incr
+ (implies (and (gobj-list-vars-bounded k p x)
+ (<= (nfix k) (nfix n)))
+ (gobj-list-vars-bounded n p x))
+ :flag list))
+
+ (defthm-gobj-flag
+ (defthm gobj-vars-bounded-witness-under-iff
+ (iff (gobj-vars-bounded-witness k p x)
+ (not (gobj-vars-bounded k p x)))
+ :hints('(:in-theory (enable pbfr-list-vars-bounded-witness-under-iff)))
+ :flag gobj)
+ (defthm gobj-list-vars-bounded-witness-under-iff
+ (iff (gobj-list-vars-bounded-witness k p x)
+ (not (gobj-list-vars-bounded k p x)))
+ :flag list))
+
+ (defthm-gobj-flag
+ (defthm gobj-vars-bounded-in-terms-of-witness
+ (implies (acl2::rewriting-positive-literal
+ `(gobj-vars-bounded ,k ,p ,x))
+ (equal (gobj-vars-bounded k p x)
+ (let ((n (gobj-vars-bounded-witness k p x)))
+ (or (< (nfix n) (nfix k))
+ (not (gobj-depends-on n p x))))))
+ :hints ('(:expand ((gobj-vars-bounded k p x)
+ (gobj-vars-bounded-witness k p x)))
+ (and stable-under-simplificationp
+ `(:expand ((PBFR-VARS-BOUNDED K P (G-BOOLEAN->BOOL X))))))
+ :flag gobj)
+ (defthm gobj-list-vars-bounded-in-terms-of-witness
+ (implies (acl2::rewriting-positive-literal
+ `(gobj-list-vars-bounded ,k ,p ,x))
+ (equal (gobj-list-vars-bounded k p x)
+ (let ((n (gobj-list-vars-bounded-witness k p x)))
+ (or (< (nfix n) (nfix k))
+ (not (gobj-list-depends-on n p x))))))
+ :flag list)
+ :hints (("goal" :in-theory (e/d (pbfr-list-vars-bounded-in-terms-of-witness
+ pbfr-list-vars-bounded-witness-under-iff)
+ (gobj-vars-bounded gobj-vars-bounded-witness)))))
+
+ (in-theory (disable gobj-vars-bounded-in-terms-of-witness
+ gobj-list-vars-bounded-in-terms-of-witness))
+
+ (defthm gobj-list-vars-bounded-of-g-apply->args
+ (implies (and (gobj-vars-bounded k p x)
+ (eq (tag x) :g-apply))
+ (gobj-list-vars-bounded k p (g-apply->args x))))
+
+ (defthm gobj-vars-bounded-of-g-ite->test
+ (implies (and (gobj-vars-bounded k p x)
+ (eq (tag x) :g-ite))
+ (gobj-vars-bounded k p (g-ite->test x))))
+
+ (defthm gobj-vars-bounded-of-g-ite->then
+ (implies (and (gobj-vars-bounded k p x)
+ (eq (tag x) :g-ite))
+ (gobj-vars-bounded k p (g-ite->then x))))
+
+ (defthm gobj-vars-bounded-of-g-ite->else
+ (implies (and (gobj-vars-bounded k p x)
+ (eq (tag x) :g-ite))
+ (gobj-vars-bounded k p (g-ite->else x))))
+
+ (defthm gobj-vars-bounded-car-of-gobj-list
+ (implies (gobj-list-vars-bounded k p x)
+ (gobj-vars-bounded k p (car x))))
+
+ (defthm gobj-list-vars-bounded-cdr-of-gobj-list
+ (implies (gobj-list-vars-bounded k p x)
+ (gobj-list-vars-bounded k p (cdr x))))
+
+ (defthm gobj-list-vars-bounded-of-cons
+ (equal (gobj-list-vars-bounded k p (cons a b))
+ (and (gobj-vars-bounded k p a)
+ (gobj-list-vars-bounded k p b))))
+
+ (defthm gobj-list-vars-bounded-of-atom
+ (implies (not (consp x))
+ (equal (gobj-list-vars-bounded k p x) t))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm gobj-vars-bounded-car-of-gobj
+ (implies (and (gobj-vars-bounded k p x)
+ (NOT (EQUAL (TAG X) :G-CONCRETE))
+ (NOT (EQUAL (TAG X) :G-BOOLEAN))
+ (NOT (EQUAL (TAG X) :G-NUMBER))
+ (NOT (EQUAL (TAG X) :G-ITE))
+ (NOT (EQUAL (TAG X) :G-VAR))
+ (NOT (EQUAL (TAG X) :G-APPLY)))
+ (gobj-vars-bounded k p (car x))))
+
+ (defthm gobj-vars-bounded-cdr-of-gobj
+ (implies (and (gobj-vars-bounded k p x)
+ (NOT (EQUAL (TAG X) :G-CONCRETE))
+ (NOT (EQUAL (TAG X) :G-BOOLEAN))
+ (NOT (EQUAL (TAG X) :G-NUMBER))
+ (NOT (EQUAL (TAG X) :G-ITE))
+ (NOT (EQUAL (TAG X) :G-VAR))
+ (NOT (EQUAL (TAG X) :G-APPLY)))
+ (gobj-vars-bounded k p (cdr x))))
+
+ (defthm gobj-vars-bounded-of-g-boolean->bool
+ (implies (and (gobj-vars-bounded k p x)
+ (eq (tag x) :g-boolean))
+ (pbfr-vars-bounded k p (g-boolean->bool x))))
+
+ (defthm gobj-vars-bounded-of-g-number->num-0
+ (implies (and (gobj-vars-bounded k p x)
+ (eq (tag x) :g-number))
+ (pbfr-list-vars-bounded k p (mv-nth 0 (break-g-number (g-number->num x))))))
+
+ (defthm gobj-vars-bounded-of-g-number->num-1
+ (implies (and (gobj-vars-bounded k p x)
+ (eq (tag x) :g-number))
+ (pbfr-list-vars-bounded k p (mv-nth 1 (break-g-number (g-number->num x))))))
+
+ (defthm gobj-vars-bounded-of-g-number->num-2
+ (implies (and (gobj-vars-bounded k p x)
+ (eq (tag x) :g-number))
+ (pbfr-list-vars-bounded k p (mv-nth 2 (break-g-number (g-number->num x))))))
+
+ (defthm gobj-vars-bounded-of-g-number->num-3
+ (implies (and (gobj-vars-bounded k p x)
+ (eq (tag x) :g-number))
+ (pbfr-list-vars-bounded k p (mv-nth 3 (break-g-number (g-number->num x))))))
+
+ (defthm-gobj-flag
+ (defthm generic-geval-of-set-var-when-gobj-vars-bounded
+ (implies (and (gobj-vars-bounded m p x)
+ (<= (nfix m) (nfix k))
+ (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k v env)))
+ (equal (generic-geval x (cons (bfr-param-env p (bfr-set-var k v env))
+ var-env))
+ (generic-geval x (cons (bfr-param-env p env)
+ var-env))))
+ :hints ('(:expand ((:free (env) (:with generic-geval (generic-geval x env))))))
+ :flag gobj)
+ (defthm generic-geval-list-of-set-var-when-gobj-vars-bounded
+ (implies (and (gobj-list-vars-bounded m p x)
+ (<= (nfix m) (nfix k))
+ (bfr-eval p env)
+ (bfr-eval p (bfr-set-var k v env)))
+ (equal (generic-geval-list x (cons (bfr-param-env p (bfr-set-var k v env))
+ var-env))
+ (generic-geval-list x (cons (bfr-param-env p env)
+ var-env))))
+ :hints ('(:expand ((:free (env) (generic-geval-list x env)))))
+ :flag list))
+
+ (defthm gobj-vars-bounded-of-atom
+ (implies (not (consp x))
+ (gobj-vars-bounded k p x))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm gobj-vars-bounded-of-gl-cons
+ (equal (gobj-vars-bounded k p (gl-cons a b))
+ (and (gobj-vars-bounded k p a)
+ (gobj-vars-bounded k p b)))
+ :hints(("Goal" :in-theory (enable gl-cons g-keyword-symbolp))))
+
+ (defthm gobj-vars-bounded-of-cons
+ (implies (not (g-keyword-symbolp x))
+ (equal (gobj-vars-bounded k p (cons x y))
+ (and (gobj-vars-bounded k p x)
+ (gobj-vars-bounded k p y))))
+ :hints(("Goal" :in-theory (enable g-keyword-symbolp))))
+
+
+
+ (defthm gobj-vars-bounded-of-g-apply
+ (equal (gobj-vars-bounded k p (g-apply fn args))
+ (gobj-list-vars-bounded k p args)))
+
+ (defthm gobj-vars-bounded-of-g-ite
+ (equal (gobj-vars-bounded k p (g-ite test then else))
+ (and (gobj-vars-bounded k p test)
+ (gobj-vars-bounded k p then)
+ (gobj-vars-bounded k p else))))
+
+ (defthm gobj-vars-bounded-of-g-number
+ (equal (gobj-vars-bounded k p (g-number num))
+ (b* (((mv rn rd in id) (break-g-number num)))
+ (and (pbfr-list-vars-bounded k p rn)
+ (pbfr-list-vars-bounded k p rd)
+ (pbfr-list-vars-bounded k p in)
+ (pbfr-list-vars-bounded k p id)))))
+
+ (defthm gobj-vars-bounded-of-g-boolean
+ (equal (gobj-vars-bounded k p (g-boolean bool))
+ (pbfr-vars-bounded k p bool)))
+
+ (defthm gobj-vars-bounded-of-g-concrete
+ (equal (gobj-vars-bounded k p (g-concrete val)) t))
+
+ (defthm gobj-vars-bounded-of-g-var
+ (equal (gobj-vars-bounded k p (g-var val)) t))
+
+
+ (defthm gobj-vars-bounded-when-g-concrete
+ (implies (equal (tag x) :g-concrete)
+ (equal (gobj-vars-bounded k p x) t))
+ :hints (("goal" :expand ((gobj-vars-bounded k p x))))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm gobj-vars-bounded-when-g-var
+ (implies (equal (tag x) :g-var)
+ (equal (gobj-vars-bounded k p x) t))
+ :hints (("goal" :expand ((gobj-vars-bounded k p x))))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+(defsection gobj-vars-bounded-of-gobj-to-param-space
+
+ (defthmd pbfr-list-vars-bounded-of-boolean-list
+ (implies (boolean-listp x)
+ (pbfr-list-vars-bounded k p x))
+ :hints(("Goal" :in-theory (enable bfr-list-vars-bounded boolean-listp))))
+
+ (local (in-theory (enable pbfr-list-vars-bounded-of-boolean-list)))
+
+ (local (defthm boolean-listp-i2v
+ (boolean-listp (i2v n))
+ :hints(("Goal" :in-theory (e/d (bfr-scons) (logcar logcdr))))))
+
+ (local (defthm boolean-listp-n2v
+ (boolean-listp (n2v n))
+ :hints(("Goal" :in-theory (e/d (bfr-ucons) (logcar logcdr))))))
+
+ (defthm gobj-vars-bounded-of-mk-g-number
+ (implies (and (pbfr-list-vars-bounded k p rn)
+ (pbfr-list-vars-bounded k p rd)
+ (pbfr-list-vars-bounded k p in)
+ (pbfr-list-vars-bounded k p id))
+ (gobj-vars-bounded k p (mk-g-number rn rd in id)))
+ :hints(("Goal" :in-theory (e/d (mk-g-number-fn)
+ (i2v n2v
+ equal-of-booleans-rewrite
+ sets::double-containment)))))
+
+ (defthm-gobj-flag
+ (defthm gobj-vars-bounded-of-gobj-to-param-space
+ (implies (gobj-vars-bounded k t x)
+ (gobj-vars-bounded
+ k p (gobj-to-param-space x p)))
+ :hints ('(:expand ((gobj-to-param-space x p)
+ (gobj-vars-bounded k t x))
+ :in-theory (enable mk-g-ite
+ mk-g-boolean
+ ; mk-g-number
+ gnumber-to-param-space)))
+ :flag gobj)
+ (defthm gobj-list-vars-bounded-of-gobj-list-to-param-space
+ (implies (gobj-list-vars-bounded k t x)
+ (gobj-list-vars-bounded
+ k p (gobj-list-to-param-space x p)))
+ :hints ('(:expand ((gobj-list-to-param-space x p))))
+ :flag list)))
+
+
+(defsection gobj-alist-vars-bounded
+ (defund gobj-alist-vars-bounded (k p x)
+ (if (atom x)
+ t
+ (and (or (atom (car x))
+ (gobj-vars-bounded k p (cdar x)))
+ (gobj-alist-vars-bounded k p (cdr x)))))
+
+ (defund gobj-alist-vars-bounded-witness (k p x)
+ (if (atom x)
+ nil
+ (or (and (consp (car x))
+ (gobj-vars-bounded-witness k p (cdar x)))
+ (gobj-alist-vars-bounded-witness k p (cdr x)))))
+
+ (local (in-theory (enable gobj-alist-vars-bounded
+ gobj-alist-vars-bounded-witness)))
+
+ (defthm gobj-alist-vars-bounded-implies-not-depends-on
+ (implies (and (gobj-alist-vars-bounded k p x)
+ (<= (nfix k) (nfix n)))
+ (not (gobj-alist-depends-on n p x)))
+ :hints(("Goal" :in-theory (enable gobj-alist-depends-on))))
+
+ (defthm gobj-alist-vars-bounded-of-pairlis$
+ (implies (gobj-list-vars-bounded k p x)
+ (gobj-alist-vars-bounded k p (pairlis$ keys x))))
+
+ (defthm gobj-vars-bounded-of-alist-lookup
+ (implies (gobj-alist-vars-bounded k p alist)
+ (gobj-vars-bounded k p (cdr (hons-assoc-equal x alist)))))
+
+ (defthm gobj-alist-vars-bounded-incr
+ (implies (and (gobj-alist-vars-bounded m p x)
+ (<= (nfix m) (nfix n)))
+ (gobj-alist-vars-bounded n p x))
+ :hints ((and stable-under-simplificationp
+ `(:expand (,(car (last clause)))))))
+
+ (defthm gobj-alist-vars-bounded-witness-under-iff
+ (iff (gobj-alist-vars-bounded-witness k p x)
+ (not (gobj-alist-vars-bounded k p x))))
+
+ (defthmd gobj-alist-vars-bounded-in-terms-of-witness
+ (implies (acl2::rewriting-positive-literal
+ `(gobj-alist-vars-bounded ,k ,p ,x))
+ (equal (gobj-alist-vars-bounded k p x)
+ (let ((n (gobj-alist-vars-bounded-witness k p x)))
+ (or (< (nfix n) (nfix k))
+ (not (gobj-alist-depends-on n p x))))))
+ :hints(("Goal" :in-theory (enable gobj-alist-depends-on
+ gobj-vars-bounded-in-terms-of-witness))))
+
+ (defthm gobj-alist-vars-bounded-of-cons
+ (equal (gobj-alist-vars-bounded k p (cons a b))
+ (and (or (atom a)
+ (gobj-vars-bounded k p (cdr a)))
+ (gobj-alist-vars-bounded k p b))))
+
+ (defthm gobj-alist-vars-bounded-of-atom
+ (implies (not (consp x))
+ (equal (gobj-alist-vars-bounded k p x) t))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+ (defthm gobj-alist-vars-bounded-of-gobj-alist-to-param-space
+ (implies (gobj-alist-vars-bounded k t x)
+ (gobj-alist-vars-bounded
+ k p (gobj-alist-to-param-space x p)))))
+
+
+(defsection bvar-db-orderedp
+
+ (defun-sk bvar-db-orderedp (p bvar-db)
+ (forall n
+ (implies (and (natp n)
+ (<= (base-bvar$a bvar-db) n)
+ (< n (next-bvar$a bvar-db)))
+ (gobj-vars-bounded n p (get-bvar->term$a n bvar-db))))
+ :rewrite :direct)
+
+ (in-theory (disable bvar-db-orderedp))
+
+ (defthm gobj-vars-bounded-of-get-bvar->term-when-bvar-db-orderedp
+ (implies (and (bvar-db-orderedp p bvar-db)
+ (<= (base-bvar$a bvar-db) (nfix m))
+ (<= (nfix m) (nfix n))
+ (< (nfix m) (next-bvar$a bvar-db)))
+ (gobj-vars-bounded n p (get-bvar->term$a m bvar-db)))
+ :hints (("goal" :use ((:instance bvar-db-orderedp-necc
+ (n (nfix m))))
+ :in-theory (disable bvar-db-orderedp-necc))))
+
+ (defthm bvar-db-orderedp-of-parametrize-bvar-db
+ (implies (bvar-db-orderedp t bvar-db)
+ (bvar-db-orderedp p (parametrize-bvar-db p bvar-db bvar-db1)))
+ :hints (("goal" :expand ((bvar-db-orderedp p (parametrize-bvar-db p bvar-db nil)))
+ :in-theory (disable parametrize-bvar-db))))
+
+ (defthm bvar-db-orderedp-of-init-bvar-db
+ (bvar-db-orderedp p (init-bvar-db$a base bvar-db))
+ :hints(("Goal" :in-theory (enable bvar-db-orderedp)))))
+
diff -Nru acl2-6.2/books/centaur/jared-customization.lsp acl2-6.3/books/centaur/jared-customization.lsp
--- acl2-6.2/books/centaur/jared-customization.lsp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/jared-customization.lsp 2013-09-30 17:53:15.000000000 +0000
@@ -108,8 +108,6 @@
#!ACL2
(progn
- (add-untranslate-pattern (coerce ?x 'list)
- (chars ?x))
(add-untranslate-pattern (car ?x)
(first ?x))
@@ -223,6 +221,10 @@
(if (not (boundp-global :suppress-preload-xdoc state))
`(progn
(include-book "xdoc/top" :dir :system)
+ (include-book "xdoc/debug" :dir :system)
(xdoc::colon-xdoc-init))
`(value-triple nil)))
+
+; maybe actually report correct times
+(assign get-internal-time-as-realtime t)
diff -Nru acl2-6.2/books/centaur/misc/1d-arr.lisp acl2-6.3/books/centaur/misc/1d-arr.lisp
--- acl2-6.2/books/centaur/misc/1d-arr.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/1d-arr.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -40,6 +40,8 @@
(progn
(include-book "data-structures/list-defthms" :dir :system)
(in-theory (enable nth update-nth resize-list))
+ (local (in-theory (disable RESIZE-LIST-WHEN-EMPTY)))
+
(:@ :fix
(def-universal-equiv 1d-arr-tmp-equiv
:equiv-terms ((equal (_fix_ x)))))
@@ -47,15 +49,15 @@
(def-universal-equiv 1d-arr-tmp-list-equiv
:qvars (i)
:equiv-terms ((1d-arr-tmp-equiv (nth i x))))
-
+
(defcong 1d-arr-tmp-list-equiv 1d-arr-tmp-equiv (nth i x) 2
:hints(("Goal" :in-theory (e/d (1d-arr-tmp-list-equiv-necc)
(1d-arr-tmp-equiv)))))
-
+
(defcong 1d-arr-tmp-list-equiv 1d-arr-tmp-list-equiv (update-nth i v x) 3
:hints((and stable-under-simplificationp
`(:expand (,(car (last clause)))))))
-
+
(defcong 1d-arr-tmp-equiv 1d-arr-tmp-list-equiv (update-nth i v x) 2
:hints((and stable-under-simplificationp
`(:expand (,(car (last clause)))))))
@@ -81,7 +83,8 @@
(defthm 1d-arr-tmp-listp-of-resize-list
(implies (and (1d-arr-tmp-listp x)
(_pred_ default))
- (1d-arr-tmp-listp (resize-list x n default)))))))
+ (1d-arr-tmp-listp (resize-list x n default))))
+ )))
(defstobj _arrname_$c
(_slotname_s$c :type (array _type-decl_
@@ -200,12 +203,13 @@
:short "Defines a stobj containing an array of objects of a certain type, and
a convenient abstraction so that logically operations on it are just list
manipulations"
- :long "
- Def-1d-arr produces an abstract stobj whose accessors/updaters are
+
+ :long "
Def-1d-arr produces an abstract stobj whose accessors/updaters are
list operations in the logic, but use fast array accesses to execute.
Usage
-Example:
+
+
Example:
@({
(def-1d-arr :arrname swidgarr
:slotname swidg
@@ -216,11 +220,13 @@
:pkg-sym xdoc::asdfs)
})
-The possible arguments are as follows:
+The possible arguments are as follows:
+
@(':arrname') is the name of the abstract stobj that will be produced. It
defaults to @('arr'), and @(':slotname') must be provided if
@(':arrname') is not.
+
@(':slotname') is the base for the names of the accessor functions. It
defaults to @('val'). In this case, with slotname @('swidg'), the
accessor functions will be:
@@ -230,25 +236,27 @@
@('set-swidg')
@('resize-swidgs')
+
@(':pred') is a predicate recognizing elements of the desired type. It
defaults to @('nil'), in which case any object is accepted.
+
@(':fix') is a fixing function of the desired type. This may only be
supplied if @(':pred') is also given. When the fixing function is supplied,
the logical definition of e.g. @('get-swidg') is @('(swidg-fix (nth i
swidgarr))'), which makes it trivial to show that array accesses always produce
elements of the correct type.
+
@(':type-decl') is the type declaration that will be put on the base
stobj, primarily affecting performance.
+
@(':default-val') gives the default array element for resizing (the
@(':initially') argument to the stobj).
+
@(':pkg-sym'), if given, determines the package in which any newly
created symbols will be interned. If not given, @(':arrname') or
@(':slotname') are used instead.
-
-
-
-")
+")
(deffunmac def-1d-arr (&key arrname
@@ -292,7 +300,7 @@
tmpl)))
-
+
diff -Nru acl2-6.2/books/centaur/misc/2d-arr.lisp acl2-6.3/books/centaur/misc/2d-arr.lisp
--- acl2-6.2/books/centaur/misc/2d-arr.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/2d-arr.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -120,7 +120,8 @@
arith-equiv-forwarding)
(nth-with-large-index
len-update-nth
- nth update-nth))))
+ nth update-nth
+ ))))
(defstobj _prefix_e-arr2
(_prefix_e-nrows :type (unsigned-byte 60) :initially 0)
diff -Nru acl2-6.2/books/centaur/misc/arith-equiv-defs.lisp acl2-6.3/books/centaur/misc/arith-equiv-defs.lisp
--- acl2-6.2/books/centaur/misc/arith-equiv-defs.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/misc/arith-equiv-defs.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,104 @@
+; Centaur Miscellaneous Books
+; Copyright (C) 2008-2011 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original authors: Jared Davis , Sol Swords
+
+; arith-equivs.lisp -- congruence reasoning about integers/naturals/bits
+
+
+;; Note: To use this book at full strength, do:
+;; (local (in-theory (enable* arith-equiv-forwarding)))
+
+(in-package "ACL2")
+(include-book "ihs/basic-definitions" :dir :system)
+(include-book "tools/rulesets" :dir :system)
+
+(defthm bitp-compound-recognizer
+ ;; Questionable given the bitp-forward rule. But I think we may still want
+ ;; this.
+ (implies (bitp x)
+ (natp x))
+ :rule-classes :compound-recognizer)
+
+;; (defthm bitp-when-under-2
+;; ;; questionable to bring arithmetic into it
+;; (implies (< x 2)
+;; (equal (bitp x)
+;; (natp x))))
+
+;; (defthm bitp-when-over-1
+;; (implies (< 1 x)
+;; (not (bitp x))))
+
+(defun int-equiv (a b)
+ (declare (xargs :guard t))
+ (equal (ifix a) (ifix b)))
+
+(defun nat-equiv (a b)
+ (declare (xargs :guard t))
+ (equal (nfix a) (nfix b)))
+
+(defun bit-equiv (x y)
+ (declare (xargs :guard t))
+ (equal (bfix x) (bfix y)))
+
+(local (in-theory (enable int-equiv nat-equiv bit-equiv)))
+
+(defequiv int-equiv)
+(defequiv nat-equiv)
+(defequiv bit-equiv)
+
+(defrefinement int-equiv nat-equiv)
+(defrefinement nat-equiv bit-equiv)
+;; (defrefinement int-equiv bit-equiv) ;; already known
+
+(defcong int-equiv equal (ifix a) 1)
+(defcong nat-equiv equal (nfix a) 1)
+(defcong bit-equiv equal (bfix a) 1)
+
+(defthm ifix-under-int-equiv
+ (int-equiv (ifix a) a))
+
+(defthm nfix-under-nat-equiv
+ (nat-equiv (nfix a) a))
+
+(defthm bfix-under-bit-equiv
+ (bit-equiv (bfix a) a))
+
+(defcong int-equiv equal (zip a) 1)
+(defcong nat-equiv equal (zp a) 1)
+(defcong bit-equiv equal (zbp a) 1)
+
+(defund-inline bool->bit (x)
+ (declare (xargs :guard t))
+ (if x 1 0))
+
+(defund negp (x)
+ (declare (xargs :guard t))
+ (and (integerp x)
+ (< x 0)))
+
+(defthm negp-compound-recognizer
+ (equal (negp x)
+ (and (integerp x)
+ (< x 0)))
+ :hints(("Goal" :in-theory (enable negp)))
+ :rule-classes :compound-recognizer)
+
+
+
diff -Nru acl2-6.2/books/centaur/misc/arith-equivs.lisp acl2-6.3/books/centaur/misc/arith-equivs.lisp
--- acl2-6.2/books/centaur/misc/arith-equivs.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/arith-equivs.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -25,65 +25,9 @@
;; (local (in-theory (enable* arith-equiv-forwarding)))
(in-package "ACL2")
-(include-book "ihs/basic-definitions" :dir :system)
-(include-book "tools/rulesets" :dir :system)
+(include-book "arith-equiv-defs")
(include-book "std/lists/mfc-utils" :dir :system)
-(defthm bitp-compound-recognizer
- ;; Questionable given the bitp-forward rule. But I think we may still want
- ;; this.
- (implies (bitp x)
- (natp x))
- :rule-classes :compound-recognizer)
-
-;; (defthm bitp-when-under-2
-;; ;; questionable to bring arithmetic into it
-;; (implies (< x 2)
-;; (equal (bitp x)
-;; (natp x))))
-
-;; (defthm bitp-when-over-1
-;; (implies (< 1 x)
-;; (not (bitp x))))
-
-(defun int-equiv (a b)
- (declare (xargs :guard t))
- (equal (ifix a) (ifix b)))
-
-(defun nat-equiv (a b)
- (declare (xargs :guard t))
- (equal (nfix a) (nfix b)))
-
-(defun bit-equiv (x y)
- (declare (xargs :guard t))
- (equal (bfix x) (bfix y)))
-
-(local (in-theory (enable int-equiv nat-equiv bit-equiv)))
-
-(defequiv int-equiv)
-(defequiv nat-equiv)
-(defequiv bit-equiv)
-
-(defrefinement int-equiv nat-equiv)
-(defrefinement nat-equiv bit-equiv)
-;; (defrefinement int-equiv bit-equiv) ;; already known
-
-(defcong int-equiv equal (ifix a) 1)
-(defcong nat-equiv equal (nfix a) 1)
-(defcong bit-equiv equal (bfix a) 1)
-
-(defthm ifix-under-int-equiv
- (int-equiv (ifix a) a))
-
-(defthm nfix-under-nat-equiv
- (nat-equiv (nfix a) a))
-
-(defthm bfix-under-bit-equiv
- (bit-equiv (bfix a) a))
-
-(defcong int-equiv equal (zip a) 1)
-(defcong nat-equiv equal (zp a) 1)
-(defcong bit-equiv equal (zbp a) 1)
(defthm posp-redefinition
(equal (posp x) (not (zp x))))
@@ -201,19 +145,8 @@
-(defund negp (x)
- (declare (xargs :guard t))
- (and (integerp x)
- (< x 0)))
-
(local (in-theory (enable negp)))
-(defthm negp-compound-recognizer
- (equal (negp x)
- (and (integerp x)
- (< x 0)))
- :rule-classes :compound-recognizer)
-
(defthm negp-when-integerp
(implies (integerp x)
(equal (negp x)
@@ -661,10 +594,6 @@
(encapsulate
()
- (defund-inline bool->bit (x)
- (declare (xargs :guard t))
- (if x 1 0))
-
(local (in-theory (enable bool->bit)))
;; (bit->bool x) would just be the same as (equal x 1). So we just use this
diff -Nru acl2-6.2/books/centaur/misc/beta-reduce-full.acl2 acl2-6.3/books/centaur/misc/beta-reduce-full.acl2
--- acl2-6.2/books/centaur/misc/beta-reduce-full.acl2 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/misc/beta-reduce-full.acl2 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,2 @@
+
+(ld "tools/flag-package.lsp" :dir :system)
diff -Nru acl2-6.2/books/centaur/misc/beta-reduce-full.lisp acl2-6.3/books/centaur/misc/beta-reduce-full.lisp
--- acl2-6.2/books/centaur/misc/beta-reduce-full.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/misc/beta-reduce-full.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,171 @@
+; Centaur Miscellaneous Books
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; beta-reduce-full.lisp
+;
+; Original authors: Sol Swords
+
+(in-package "ACL2")
+
+(include-book "tools/bstar" :dir :system)
+(include-book "tools/flag" :dir :system)
+
+
+;; note: intended to be compatible (redundant) with misc/beta-reduce.lisp
+(defevaluator beta-eval beta-eval-list nil)
+
+(mutual-recursion
+ (defun beta-reduce-full-rec (x alist)
+ (declare (xargs :guard (and (pseudo-termp x)
+ (symbol-alistp alist))
+ :verify-guards nil))
+ (b* (((when (null x)) nil)
+ ((when (variablep x)) (cdr (assoc x alist)))
+ ((when (fquotep x)) x)
+ (args (beta-reduce-full-rec-list (fargs x) alist))
+ (fn (ffn-symb x))
+ ((when (atom fn)) (cons fn args))
+ (formals (lambda-formals fn))
+ (body (lambda-body fn)))
+ (beta-reduce-full-rec body (pairlis$ formals args))))
+ (defun beta-reduce-full-rec-list (x alist)
+ (declare (xargs :guard (and (pseudo-term-listp x)
+ (symbol-alistp alist))))
+ (if (endp x)
+ nil
+ (cons (beta-reduce-full-rec (car x) alist)
+ (beta-reduce-full-rec-list (cdr x) alist)))))
+
+(flag::make-flag beta-reduce-flg beta-reduce-full-rec
+ :flag-mapping ((beta-reduce-full-rec . term)
+ (beta-reduce-full-rec-list . list)))
+
+(defthm len-of-beta-reduce-full-rec-list
+ (equal (len (beta-reduce-full-rec-list x alist))
+ (len x)))
+
+(defthm true-listp-of-beta-reduce-full-rec-list
+ (true-listp (beta-reduce-full-rec-list x alist))
+ :hints (("goal" :induct (len x))))
+
+(defthm symbol-alistp-pairlis
+ (implies (symbol-listp keys)
+ (symbol-alistp (pairlis$ keys vals))))
+
+(verify-guards beta-reduce-full-rec)
+
+(defun beta-eval-alist (x a)
+ (if (atom x)
+ nil
+ (cons (cons (caar x) (beta-eval (cdar x) a))
+ (beta-eval-alist (cdr x) a))))
+
+(defthm beta-eval-alist-of-pairlis
+ (equal (beta-eval-alist (pairlis$ keys vals) a)
+ (pairlis$ keys (beta-eval-list vals a))))
+
+(defthm lookup-in-beta-eval-alist
+ (implies k
+ (equal (assoc k (beta-eval-alist x a))
+ (and (assoc k x)
+ (cons k (beta-eval (cdr (assoc k x)) a))))))
+
+(local
+ (defthm strip-cdrs-of-pairlis
+ (implies (and (true-listp vals)
+ (equal (len keys) (len vals)))
+ (equal (strip-cdrs (pairlis$ keys valS))
+ vals))))
+
+(defthm-beta-reduce-flg
+ (defthm pseudo-termp-of-beta-reduce-full-rec
+ (implies (and (pseudo-termp x)
+ (pseudo-term-listp (strip-cdrs alist)))
+ (pseudo-termp (beta-reduce-full-rec x alist)))
+ :flag term)
+ (defthm pseudo-term-listp-of-beta-reduce-full-rec-list
+ (implies (and (pseudo-term-listp x)
+ (pseudo-term-listp (strip-cdrs alist)))
+ (pseudo-term-listp (beta-reduce-full-rec-list x alist)))
+ :flag list))
+
+(defthm-beta-reduce-flg
+ (defthm beta-reduce-full-rec-correct
+ (implies (pseudo-termp x)
+ (equal (beta-eval (beta-reduce-full-rec x alist) a)
+ (beta-eval x (beta-eval-alist alist a))))
+ :hints ('(:in-theory (enable beta-eval-constraint-0)))
+ :flag term)
+ (defthm beta-reduce-full-rec-list-correct
+ (implies (pseudo-term-listp x)
+ (equal (beta-eval-list (beta-reduce-full-rec-list x alist) a)
+ (beta-eval-list x (beta-eval-alist alist a))))
+ :flag list))
+
+
+(mutual-recursion
+ (defun beta-reduce-full (x)
+ (declare (xargs :guard (pseudo-termp x)))
+ (b* (((when (or (variablep x)
+ (fquotep x))) x)
+ (args (beta-reduce-full-list (fargs x)))
+ (fn (ffn-symb x))
+ ((when (atom fn)) (cons fn args))
+ (formals (lambda-formals fn))
+ (body (lambda-body fn)))
+ (beta-reduce-full-rec body (pairlis$ formals args))))
+ (defun beta-reduce-full-list (x)
+ (declare (xargs :guard (pseudo-term-listp x)))
+ (if (endp x)
+ nil
+ (cons (beta-reduce-full (car x))
+ (beta-reduce-full-list (cdr x))))))
+
+(defthm len-of-beta-reduce-full-list
+ (equal (len (beta-reduce-full-list x))
+ (len x)))
+
+(defthm true-listp-of-beta-reduce-full-list
+ (true-listp (beta-reduce-full-list x))
+ :hints (("goal" :induct (len x))))
+
+
+(defthm-beta-reduce-flg
+ (defthm pseudo-termp-of-beta-reduce-full
+ (implies (pseudo-termp x)
+ (pseudo-termp (beta-reduce-full x)))
+ :flag term)
+ (defthm pseudo-term-listp-of-beta-reduce-full-list
+ (implies (pseudo-term-listp x)
+ (pseudo-term-listp (beta-reduce-full-list x)))
+ :flag list))
+
+(defthm-beta-reduce-flg
+ (defthm beta-reduce-full-correct
+ (implies (pseudo-termp x)
+ (equal (beta-eval (beta-reduce-full x) a)
+ (beta-eval x a)))
+ :hints ('(:in-theory (enable beta-eval-constraint-0)))
+ :flag term)
+ (defthm beta-reduce-full-list-correct
+ (implies (pseudo-term-listp x)
+ (equal (beta-eval-list (beta-reduce-full-list x) a)
+ (beta-eval-list x a)))
+ :flag list))
+
+
diff -Nru acl2-6.2/books/centaur/misc/context-rw.lisp acl2-6.3/books/centaur/misc/context-rw.lisp
--- acl2-6.2/books/centaur/misc/context-rw.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/context-rw.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -34,6 +34,7 @@
all-keys-bound)))
(defxdoc contextual-rewriting
+ :parents (proof-automation)
:short "A meta-rule system that lets the ACL2 rewriter pass around contextual
information. Similar to Dave Greve's NARY. This extends ACL2's notion of
congruence-based rewriting."
diff -Nru acl2-6.2/books/centaur/misc/defapply.lisp acl2-6.3/books/centaur/misc/defapply.lisp
--- acl2-6.2/books/centaur/misc/defapply.lisp 2013-06-07 03:12:14.000000000 +0000
+++ acl2-6.3/books/centaur/misc/defapply.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -337,7 +337,8 @@
(defun reduce-identities (term fn)
(case-match term
- ((!fn . &) term)
+ ((!fn) term)
+ ((!fn ('nth . &) . &) term)
(('mv-list & sub . &) (reduce-identities sub fn))
(('return-last & & sub) (reduce-identities sub fn))
(& term)))
@@ -718,7 +719,8 @@
:off :all :on (error)
(make-event
`(defevaluator-fast _name_-ev _name_-ev-lst
- ,(mk-defeval-entries '_fnsyms_ (w state)))))
+ ,(mk-defeval-entries '_fnsyms_ (w state))
+ :namedp t)))
(def-ruleset _name_-ev-rules
(set-difference-theories
(current-theory :here)
@@ -841,7 +843,7 @@
car-to-nth-meta-correct
;; _name_-ev-rules
kwote nfix
- _name_-ev-constraint-0
+ _name_-ev-of-fncall-args
(cons) (equal) (member-equal) (eql)
car-cons cdr-cons _name_-eval-nth-kwote-lst
list-fix-when-true-listp
diff -Nru acl2-6.2/books/centaur/misc/equal-by-nths.lisp acl2-6.3/books/centaur/misc/equal-by-nths.lisp
--- acl2-6.2/books/centaur/misc/equal-by-nths.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/equal-by-nths.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -20,87 +20,6 @@
(in-package "ACL2")
-(include-book "tools/bstar" :dir :system)
-
-(encapsulate
- (((equal-by-nths-hyp) => *)
- ((equal-by-nths-lhs) => *)
- ((equal-by-nths-rhs) => *))
- (local (defun equal-by-nths-hyp () nil))
- (local (defun equal-by-nths-lhs () nil))
- (local (defun equal-by-nths-rhs () nil))
- (defthmd equal-by-nths-constraint
- (implies (and (equal-by-nths-hyp)
- (natp n)
- (< n (len (equal-by-nths-lhs))))
- (equal (nth n (equal-by-nths-lhs))
- (nth n (equal-by-nths-rhs))))))
-
-
-(local (defun nth-badguy (x y)
- (cond ((or (not (consp x))
- (not (consp y)))
- 0)
- ((equal (car x) (car y))
- (+ 1 (nth-badguy (cdr x) (cdr y))))
- (t
- 0))))
-
-(local (defthm nth-badguy-bounded
- (<= (nth-badguy x y) (len x))
- :rule-classes :linear))
-
-(local (defthm nth-badguy-is-bad
- (implies (and (equal (len x) (len y))
- (not (equal (nth-badguy x y) (len x))))
- (not (equal (nth (nth-badguy x y) x)
- (nth (nth-badguy x y) y))))))
-
-(local (defthm nth-badguy-is-equality
- (implies (and (equal (len x) (len y))
- (true-listp x)
- (true-listp y))
- (equal (equal (nth-badguy x y) (len x))
- (equal x y)))))
-
-(local (in-theory (disable nth-badguy-is-equality
- nth-badguy-is-bad
- nth-badguy)))
-
-(defthm equal-by-nths
- (implies (and (equal-by-nths-hyp)
- (true-listp (equal-by-nths-lhs))
- (true-listp (equal-by-nths-rhs)))
- (equal (equal (equal-by-nths-lhs) (equal-by-nths-rhs))
- (equal (len (equal-by-nths-lhs)) (len (equal-by-nths-rhs)))))
- :hints(("Goal"
- :use ((:instance nth-badguy-is-equality
- (x (equal-by-nths-lhs))
- (y (equal-by-nths-rhs)))
- (:instance nth-badguy-is-bad
- (x (equal-by-nths-lhs))
- (y (equal-by-nths-rhs)))
- (:instance equal-by-nths-constraint
- (n (nth-badguy (equal-by-nths-lhs) (equal-by-nths-rhs))))))))
-
-
-;; Computed hint. For now we'll assume that we're trying to prove an equality
-;; which is the conclusion of the goal, and that the rest of the goal is hyps
-;; that we might need.
-(defun equal-by-nths-hint-fn (clause)
- (declare (xargs :mode :program))
- (b* ((lit (car (last clause)))
- ((unless (and (consp lit)
- (eq (car lit) 'equal)))
- nil)
- (hyps (dumb-negate-lit-lst (butlast clause 1)))
- ((list x y) (cdr lit)))
- `(:use ((:functional-instance
- equal-by-nths
- (equal-by-nths-lhs (lambda () ,x))
- (equal-by-nths-rhs (lambda () ,y))
- (equal-by-nths-hyp (lambda () (and . ,hyps))))))))
-
-(defmacro equal-by-nths-hint ()
- '(equal-by-nths-hint-fn clause))
+; cert_param: (reloc_stub)
+(include-book "std/lists/nth" :dir :system)
diff -Nru acl2-6.2/books/centaur/misc/equal-sets.acl2 acl2-6.3/books/centaur/misc/equal-sets.acl2
--- acl2-6.2/books/centaur/misc/equal-sets.acl2 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/equal-sets.acl2 2013-09-30 17:53:11.000000000 +0000
@@ -19,6 +19,6 @@
; Original author: Sol Swords
(in-package "ACL2")
-(ld "finite-set-theory/osets/sets.defpkg" :dir :system)
+(include-book "std/osets/portcullis" :dir :system)
; cert-flags: ? t :ttags :all
-(certify-book "equal-sets" ? t :ttags :all)
+
diff -Nru acl2-6.2/books/centaur/misc/equal-sets.lisp acl2-6.3/books/centaur/misc/equal-sets.lisp
--- acl2-6.2/books/centaur/misc/equal-sets.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/equal-sets.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -21,7 +21,7 @@
(in-package "ACL2")
;; BOZO we could consider removing osets now...
-(include-book "finite-set-theory/osets/sets" :dir :system)
+(include-book "std/osets/top" :dir :system)
(include-book "std/lists/sets" :dir :system)
(include-book "witness-cp")
diff -Nru acl2-6.2/books/centaur/misc/fast-alists.lisp acl2-6.3/books/centaur/misc/fast-alists.lisp
--- acl2-6.2/books/centaur/misc/fast-alists.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/fast-alists.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -106,7 +106,7 @@
(defthm alist-keys-hons-put-list
(set-equiv (alist-keys (hons-put-list vars vals rest))
(union-equal vars (alist-keys rest)))
- :hints (("goal" :in-theory (enable alist-keys))
+ :hints (("goal" :in-theory (enable alist-keys append))
(set-reasoning)))
diff -Nru acl2-6.2/books/centaur/misc/hons-alphorder-merge.lisp acl2-6.3/books/centaur/misc/hons-alphorder-merge.lisp
--- acl2-6.2/books/centaur/misc/hons-alphorder-merge.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/hons-alphorder-merge.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -22,6 +22,7 @@
(in-package "ACL2")
(include-book "misc/total-order" :dir :system)
(include-book "equal-sets")
+(local (include-book "std/typed-lists/atom-listp" :dir :system))
; Abuse of atom-listp on ordered sets
@@ -37,8 +38,9 @@
:hints(("Goal" :in-theory (enable* (:ruleset sets::primitive-rules)))))
(defthm atom-listp-of-sfix
- (implies (atom-listp x)
- (atom-listp (sets::sfix x)))
+ (implies (atom-listp (double-rewrite x))
+ (equal (atom-listp (sets::sfix x))
+ t))
:hints(("Goal" :in-theory (enable* (:ruleset sets::primitive-rules)))))
(defthm atom-listp-of-insert
@@ -48,9 +50,9 @@
:hints(("Goal" :in-theory (enable* (:ruleset sets::primitive-rules) sets::insert))))
(defthm atom-listp-of-union
- (implies (and (atom-listp x)
- (atom-listp y))
- (atom-listp (sets::union x y))))
+ (equal (atom-listp (sets::union x y))
+ (and (atom-listp (sets::sfix x))
+ (atom-listp (sets::sfix y)))))
diff -Nru acl2-6.2/books/centaur/misc/intern-debugging-raw.lsp acl2-6.3/books/centaur/misc/intern-debugging-raw.lsp
--- acl2-6.2/books/centaur/misc/intern-debugging-raw.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/misc/intern-debugging-raw.lsp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,75 @@
+; Intern Debugging
+; Copyright (C) 2010 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+#+Clozure
+(progn
+
+; Accessors for symbol hash tables.
+; Per nfasload.lisp, symbol hash tables are (htvec . (htcount . hlimit))
+
+ (defmacro ccl-htvec (tbl)
+ `(the simple-vector (car ,tbl)))
+
+ (defmacro ccl-htcount (tbl)
+ `(the fixnum (cadr ,tbl)))
+
+ (defmacro ccl-htlimit (tbl)
+ `(the fixnum (cddr ,tbl)))
+
+; Basic way to inspect packages, which we make available to the logic.
+
+ (defun inspect-package (name)
+ (let* ((pkg (or (find-package name)
+ (er hard? 'inspect-package "package ~x0 not found." name)))
+ (tab (ccl::pkg.itab pkg)))
+ (format t "; - Current count: ~:D~%" (ccl-htcount tab))
+ (format t "; - Current limit: ~:D~%" (ccl-htlimit tab))
+ nil))
+
+ (setq ccl::*warn-if-redefine-kernel* nil)
+
+ (defun intern (str &optional (package *package*))
+ ;; (format t "Debugging intern is being called.~%")
+ (let* ((pkg (ccl::pkg-arg package))
+ (tab (ccl::pkg.itab pkg)))
+ (when (and (= (ccl-htcount tab)
+ (the fixnum (1- (ccl-htlimit tab))))
+ ;; Don't bother reporting on very small packages resizing.
+ ;; This helps avoid package-size messages when including
+ ;; books, for instance.
+ (< 10000 (ccl-htcount tab)))
+ (let ((name (package-name pkg)))
+ (format t "~%; Note: we may be about to resize the ~a package.~%" name)
+ (format t "; Before interning ~a:~%" str)
+ (inspect-package name)
+ (let ((ret (time (ccl::%intern str pkg))))
+ (format t "; After interning ~a:~%" str)
+ (inspect-package name))
+ (format t "~%")
+ ret))
+ (ccl::%intern str pkg)))
+
+ (defun ccl::%pkg-ref-intern (str ref)
+ ;; It seems necessary to also redefine this to get compiled functions with
+ ;; interns in them to call our new intern.
+ (intern str (or (ccl::package-ref.pkg ref)
+ (ccl::%kernel-restart ccl::$xnopkg (ccl::package-ref.name ref)))))
+
+ (setq ccl::*warn-if-redefine-kernel* t))
diff -Nru acl2-6.2/books/centaur/misc/intern-debugging.lisp acl2-6.3/books/centaur/misc/intern-debugging.lisp
--- acl2-6.2/books/centaur/misc/intern-debugging.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/misc/intern-debugging.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,161 @@
+; Intern Debugging
+; Copyright (C) 2010 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "ACL2")
+(include-book "tools/include-raw" :dir :system)
+; (depends-on "intern-debugging-raw.lsp")
+
+
+(defxdoc intern-debugging
+ :parents (intern-in-package-of-symbol intern$)
+ :short "A debugger that can warn you about slow @('intern')ing. (CCL only)"
+
+ :long "Jared once spent many hours trying to figure out why some
+computation was slow, only to discover that he was getting bitten by repeatedly
+growing a package by small amounts. This performance problem is hard to debug
+because it is hard to reproduce (once the package has been grown, the same
+computation you are debugging suddenly runs much faster), and also because it
+is unusual: you would generally expect @('intern') to be a constant-time, cheap
+operation.
+
+The book @('centaur/misc/intern-debugging') is a debugger that can notice
+and report on slow calls of @('intern') due to package growth. It only works
+on CCL.
+
+The book redefines the primitive Common Lisp function @('intern') so that
+some debugging messages are printed when the package is resized. Obviously
+this requires a ttag. Redefining core Common Lisp functions like @('intern')
+is slightly insane, and we might run into trouble if CCL is changed. But this
+is a really valuable debugging message to have, so it seems worthwhile.
+
+Note that the debugger slows down interning by some small amount (on the
+order of 1.5 to 5%).
+
+If you find out that slow interning is the cause of your problems, consider
+tweaking the @('ACL2_SIZE') parameter you use when you build ACL2 (which can
+help for symbols interned in the ACL2 package only).
")
+
+
+(defsection inspect-package
+ :parents (intern-debugging)
+ :short "Print some basic information about a package. (CCL only)"
+ :long "@(call ccl-inspect-package) is given the name of a package, e.g.,
+@('\"ACL2\"') or @('\"VL\"'). It prints out some low-level information about
+the current number of symbols that are in the package and how many will fit
+before it needs to be resized. This is occasionally useful for figuring out
+whether your packages are large enough, but usually the passive @(see
+intern-debugging) monitoring is more useful.
"
+
+ (defun inspect-package (name)
+ (declare (xargs :guard (stringp name))
+ (ignorable name))
+ (cw "inspect-package not yet redefined.~%")))
+
+(defttag intern-debugging)
+
+(include-raw "intern-debugging-raw.lsp")
+
+
+
+#|
+; These tests were with ACL2_SIZE = 3,000,000.
+
+(include-book
+ "intern-debugging")
+
+(include-book
+ "str/top" :dir :system)
+
+
+
+; Performance test. The extra expensive of debugging should be most severe
+; when we're interning an already-interned symbol (and hence don't need to
+; actually insert anything into the hash table).
+
+(time (loop for i from 1 to 10000000 do ;; test 1: repeated symbols
+ (intern "FOO" "ACL2")))
+
+(defconst *strs*
+ (loop for i from 1 to 1000000 collect (str::cat "foo_" (str::natstr i))))
+
+(time (loop for str in *strs* do (intern str "ACL2"))) ;; test 2: fresh symbols
+
+
+; TEST1: about 5% slowdown
+; - Without intern-debugging: 3.140 seconds
+; - With intern-debugging: 3.303 seconds
+;
+; TEST2: about 1.5% slowdown
+; - Without intern-debugging, .879 seconds
+; - With intern-debugging: .893 seconds
+
+
+; Functionality test. Okay, so does it work? I set ACL2_SIZE to 3 million,
+; but actually its size seems to be around 2.65 million. Since the following
+; loop requires the interning of 3 million new symbols, it will need at least a
+; resize.
+
+(defconst *strs*
+ (loop for i from 1 to 3000000 collect (str::cat "foo_" (str::natstr i))))
+
+(time (loop for str in *strs* do (intern str "ACL2")))
+
+
+; Without intern-debugging, in a fresh session, this loop takes 64 seconds (246
+; MB) and doesn't give you any idea that the reason this is taking so long is
+; that the package is being resized.
+
+; With intern-debugging, in a fresh session, the loop again takes 64 seconds
+; and 246 MB, so the performance hasn't really changed, but it prints several
+; useful messages that warn you the package is being resized. You can see that
+; there are two resizes which collectively cost 17 seconds of execution time.
+
+; Note: we may be about to resize the ACL2 package.
+; Before interning foo_2611853:
+; - Current count: 2,625,000
+; - Current limit: 2,625,001
+(CCL::%INTERN STR
+ PKG) took 10,066,616 microseconds (10.066616 seconds) to run
+ with 8 available CPU cores.
+During that period, 10,036,474 microseconds (10.036474 seconds) were spent in user mode
+ 26,996 microseconds (0.026996 seconds) were spent in system mode
+ 26,249,968 bytes of memory allocated.
+ 12,878 minor page faults, 0 major page faults, 0 swaps.
+; After interning foo_2611853:
+; - Current count: 2,624,987
+; - Current limit: 2,871,083
+
+
+; Note: we may be about to resize the ACL2 package.
+; Before interning foo_2857949:
+; - Current count: 2,871,082
+; - Current limit: 2,871,083
+(CCL::%INTERN STR
+ PKG) took 7,238,270 microseconds (7.238270 seconds) to run
+ with 8 available CPU cores.
+During that period, 7,223,902 microseconds (7.223902 seconds) were spent in user mode
+ 13,998 microseconds (0.013998 seconds) were spent in system mode
+ 28,710,928 bytes of memory allocated.
+ 14,019 minor page faults, 0 major page faults, 0 swaps.
+; After interning foo_2857949:
+; - Current count: 2,871,083
+; - Current limit: 3,140,250
+
+|#
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/misc/introduce-var.lisp acl2-6.3/books/centaur/misc/introduce-var.lisp
--- acl2-6.2/books/centaur/misc/introduce-var.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/introduce-var.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -25,7 +25,7 @@
(in-package "ACL2")
(include-book "clause-processors/generalize" :dir :system)
(include-book "centaur/vl/util/namedb" :dir :system)
-
+(include-book "beta-reduce-full")
; We introduce the INTRODUCE-VARS clause processor. To use this clause
; processor you should just do this:
@@ -74,12 +74,88 @@
; And will replace it with something like IDX, IDX_1, etc., as appropriate to
; avoid name clashes.
+
+
+(local
+ (defthm beta-reduce-full-correct-for-gen-eval
+ (implies (pseudo-termp x)
+ (equal (gen-eval (beta-reduce-full x) a)
+ (gen-eval x a)))
+ :hints (("goal" :use ((:functional-instance
+ beta-reduce-full-correct
+ (beta-eval gen-eval)
+ (beta-eval-list gen-eval-lst)))
+ :in-theory (enable gen-eval-constraint-0)))))
+
+(local
+ (defthm beta-reduce-full-list-correct-for-gen-eval
+ (implies (pseudo-term-listp x)
+ (equal (gen-eval-lst (beta-reduce-full-list x) a)
+ (gen-eval-lst x a)))
+ :hints (("goal" :use ((:functional-instance
+ beta-reduce-full-list-correct
+ (beta-eval gen-eval)
+ (beta-eval-list gen-eval-lst)))
+ :in-theory (enable gen-eval-constraint-0)))))
+
+
+
(defund introduce-var (name term)
(declare (xargs :guard t)
(ignore name))
term)
+;; Note: We've seen problems where sometimes two apparently-identical terms get
+;; generalized to two different variables because they differ in something like
+;; the order of lambda formals, e.g. one is
+;; (hide ((lambda (a b) (list a b)) aa bb))
+;; and the other is
+;; (hide ((lambda (b a) (list a b)) bb aa)).
+;; So we normalize these (and also differences in bound variable names)
+;; by fully beta-reducing introduce-var terms.
+(mutual-recursion
+ (defun beta-reduce-introduce-vars (x)
+ (declare (xargs :guard (pseudo-termp x)))
+ (b* (((when (or (variablep x) (fquotep x))) x)
+ (fn (ffn-symb x))
+ ((when (eq fn 'introduce-var))
+ (beta-reduce-full x)))
+ (cons fn (beta-reduce-introduce-vars-list (fargs x)))))
+ (defun beta-reduce-introduce-vars-list (x)
+ (declare (xargs :guard (pseudo-term-listp x)))
+ (if (atom x)
+ nil
+ (cons (beta-reduce-introduce-vars (car x))
+ (beta-reduce-introduce-vars-list (cdr x))))))
+
+(defthm len-of-beta-reduce-introduce-vars-list
+ (equal (len (beta-reduce-introduce-vars-list x))
+ (len x)))
+
+(defthm-beta-reduce-flg
+ (defthm beta-reduce-introduce-vars-correct
+ (implies (pseudo-termp x)
+ (equal (gen-eval (beta-reduce-introduce-vars x) a)
+ (gen-eval x a)))
+ :hints ('(:in-theory (enable gen-eval-constraint-0)))
+ :flag term)
+ (defthm beta-reduce-introduce-vars-list-correct
+ (implies (pseudo-term-listp x)
+ (equal (gen-eval-lst (beta-reduce-introduce-vars-list x) a)
+ (gen-eval-lst x a)))
+ :flag list))
+
+(defthm-beta-reduce-flg
+ (defthm pseudo-termp-beta-reduce-introduce-vars
+ (implies (pseudo-termp x)
+ (pseudo-termp (beta-reduce-introduce-vars x)))
+ :flag term)
+ (defthm pseudo-term-listp-beta-reduce-introduce-vars-list
+ (implies (pseudo-term-listp x)
+ (pseudo-term-listp (beta-reduce-introduce-vars-list x)))
+ :flag list))
+
(mutual-recursion
; These scanning functions look for occurrences of (INTRODUCE-VAR 'VAR TERM)
@@ -202,12 +278,52 @@
(vl::vl-free-namedb namedb)
fresh-alist))
+(defun introduce-vars-cp (clause pkg)
+ (declare (xargs :guard (pseudo-term-listp clause)))
+ (let* ((clause (beta-reduce-introduce-vars-list clause))
+ (al (mbe :logic (scan-for-introduce-var pkg clause)
+ :exec (if (and (stringp pkg)
+ (not (equal pkg "")))
+ (scan-for-introduce-var pkg clause)
+ (ec-call (scan-for-introduce-var pkg clause))))))
+ (ec-call (simple-generalize-cp clause al))))
+
+(defthm eval-disjoin-of-beta-reduce-introduce-vars-list
+ (implies (pseudo-term-listp clause)
+ (iff (gen-eval (disjoin (beta-reduce-introduce-vars-list clause)) a)
+ (gen-eval (disjoin clause) a)))
+ :hints (("goal" :induct (len clause)
+ :in-theory (enable gen-eval-disjoin-when-consp))))
+
+(defthm introduce-vars-cp-correct
+ (implies (and (pseudo-term-listp clause)
+ (alistp a)
+ (gen-eval (conjoin-clauses (introduce-vars-cp clause pkg))
+ (alist-for-simple-generalize-cp
+ (beta-reduce-introduce-vars-list clause)
+ (scan-for-introduce-var
+ pkg (beta-reduce-introduce-vars-list clause))
+ a)))
+ (gen-eval (disjoin clause) a))
+ :hints (("goal" :use ((:instance simple-generalize-cp-correct
+ (clause (beta-reduce-introduce-vars-list clause))
+ (env a)
+ (alist (scan-for-introduce-var
+ pkg (beta-reduce-introduce-vars-list clause)))))
+ :in-theory (disable simple-generalize-cp
+ alist-for-simple-generalize-cp)))
+ :rule-classes :clause-processor)
+
(defmacro introduce-vars ()
- '(let ((al (scan-for-introduce-var (current-package state) clause)))
- (and al
+ '(let* ((pkg (current-package state))
+ (al (scan-for-introduce-var pkg clause)))
+ (and al ;; this just tells us whether we have any before we go ahead and
+ ;; run the clause-processor
`(:computed-hint-replacement
t
- :clause-processor (simple-generalize-cp clause ',al)))))
+ :clause-processor (introduce-vars-cp clause ',pkg)))))
+
+
#||
diff -Nru acl2-6.2/books/centaur/misc/iter.lisp acl2-6.3/books/centaur/misc/iter.lisp
--- acl2-6.2/books/centaur/misc/iter.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/iter.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -408,6 +408,7 @@
;; are the same
:guard-hints ... ;; for defining the step function
:package foo) ;; package witness symbol, default is function-name
+~ev[]
~/~/
"
;; args contains:
@@ -687,6 +688,7 @@
:length (bar x y) ;; final index
:index idx-var ;; counter variable, default N
... defiteration args ...)
+~ev[]
~/~/
"
;; args contains:
diff -Nru acl2-6.2/books/centaur/misc/load-stobj.lisp acl2-6.3/books/centaur/misc/load-stobj.lisp
--- acl2-6.2/books/centaur/misc/load-stobj.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/load-stobj.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -25,7 +25,7 @@
(local (include-book "data-structures/list-defthms" :dir :system))
;;(local (include-book "unicode/take" :dir :system))
;;(local (include-book "unicode/nthcdr" :dir :system))
-(local (include-book "equal-by-nths"))
+(local (include-book "std/lists/nth" :dir :system))
(local (include-book "tools/do-not" :dir :system))
(local (do-not generalize fertilize))
@@ -108,10 +108,11 @@
nil))
:hints(("Goal" :in-theory (enable xfirstn)))))
-(local (defthm nth-of-list-fix
- (equal (nth n (list-fix a))
- (nth n a))
- :hints(("Goal" :in-theory (enable nth list-fix)))))
+;; part of std/lists now
+;; (local (defthm nth-of-list-fix
+;; (equal (nth n (list-fix a))
+;; (nth n a))
+;; :hints(("Goal" :in-theory (enable nth list-fix)))))
diff -Nru acl2-6.2/books/centaur/misc/memory-mgmt-raw.lisp acl2-6.3/books/centaur/misc/memory-mgmt-raw.lisp
--- acl2-6.2/books/centaur/misc/memory-mgmt-raw.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/memory-mgmt-raw.lisp 1970-01-01 00:00:00.000000000 +0000
@@ -1,5 +0,0 @@
-(in-package "ACL2")
-
-;; cert_param: (reloc_stub)
-
-(include-book "memory-mgmt")
diff -Nru acl2-6.2/books/centaur/misc/nat-list-duplicates.lisp acl2-6.3/books/centaur/misc/nat-list-duplicates.lisp
--- acl2-6.2/books/centaur/misc/nat-list-duplicates.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/nat-list-duplicates.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -28,6 +28,7 @@
(include-book "arithmetic/nat-listp" :dir :system)
(local (include-book "arithmetic/top-with-meta" :dir :system))
(local (include-book "tools/mv-nth" :dir :system))
+(local (include-book "std/lists/resize-list" :dir :system))
(defsection nat-list-remove-duplicates
@@ -114,16 +115,7 @@
(defthm acl2-numberp-when-integerp
(implies (integerp x)
- (acl2-numberp x)))
-
- (defthm len-zero
- (equal (equal 0 (len x))
- (atom x)))
-
- (defthm len-of-resize-list
- (equal (len (resize-list lst n default-value))
- (nfix n)))))
-
+ (acl2-numberp x)))))
(local (in-theory (enable nat-listp)))
@@ -349,21 +341,6 @@
(equal (nat-remove-dups-arr-length (create-nat-remove-dups-stobj))
0))
- (local (defun my-induct (key n lst)
- (if (zp n)
- (list key n lst)
- (my-induct (- key 1) (- n 1) (if (atom lst) lst (cdr lst))))))
-
- (local (defthm nth-of-resize-list
- (implies (and (natp key)
- (natp n)
- (< key n))
- (equal (nth key (resize-list lst n default-value))
- (if (< key (len lst))
- (nth key lst)
- default-value)))
- :hints(("Goal" :induct (my-induct key n lst)))))
-
(defthm nat-remove-dups-arri-of-resize-nat-remove-dups-arr
(implies (and (force (natp key))
(force (natp max))
diff -Nru acl2-6.2/books/centaur/misc/nth-equiv.lisp acl2-6.3/books/centaur/misc/nth-equiv.lisp
--- acl2-6.2/books/centaur/misc/nth-equiv.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/nth-equiv.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -37,3 +37,50 @@
(nth-equiv (update-nth n (nth n x) x)
x)
:hints(("Goal" :in-theory (enable nth-equiv))))
+
+(local (defthm +-cancel-consts
+ (implies (syntaxp (and (quotep x) (quotep y)))
+ (equal (+ x y z) (+ (+ x y) z)))))
+
+(defcong nth-equiv equal (car x) 1
+ :hints (("goal" :use ((:instance nth-equiv-necc
+ (n 0) (y x-equiv)))
+ :in-theory (e/d (nth) (nth-equiv-implies-equal-nth-2)))))
+
+(defcong nth-equiv nth-equiv (cdr x) 1
+ :hints (("goal" :use ((:instance nth-equiv-necc
+ (n (+ 1 (nfix (nth-equiv-witness (cdr x) (cdr
+ x-equiv)))))
+ (y x-equiv)))
+ :expand ((nth-equiv (cdr x) (cdr x-equiv))
+ (nth-equiv (cdr x) nil)
+ (nth-equiv nil (cdr x-equiv)))
+ :in-theory (disable nth-equiv-implies-equal-nth-2))))
+
+(defthmd nth-equiv-recursive
+ (equal (nth-equiv x y)
+ (or (and (atom x) (atom y))
+ (and (equal (car x) (car y))
+ (nth-equiv (cdr x) (cdr y)))))
+ :hints ((and stable-under-simplificationp
+ '(:cases ((nth-equiv x y))))
+ (and stable-under-simplificationp
+ (cond ((equal (car clause) '(nth-equiv x y))
+ '(:expand ((nth-equiv x y)
+ (:free (n) (nth n x))
+ (:free (n) (nth n y))))))))
+ :rule-classes ((:definition :install-body nil
+ :clique (nth-equiv)
+ :controller-alist ((nth-equiv t t)))))
+
+(defun cdr2-ind (x y)
+ (declare (xargs :measure (+ (acl2-count x) (acl2-count y))))
+ (if (and (atom x) (atom y))
+ nil
+ (cdr2-ind (cdr x) (cdr y))))
+
+(defthmd nth-equiv-ind
+ t
+ :rule-classes ((:induction
+ :pattern (nth-equiv x y)
+ :scheme (cdr2-ind x y))))
diff -Nru acl2-6.2/books/centaur/misc/osets-witnessing.acl2 acl2-6.3/books/centaur/misc/osets-witnessing.acl2
--- acl2-6.2/books/centaur/misc/osets-witnessing.acl2 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/osets-witnessing.acl2 2013-09-30 17:53:11.000000000 +0000
@@ -1,5 +1,5 @@
(in-package "ACL2")
-(include-book "finite-set-theory/osets/portcullis" :dir :system)
+(include-book "std/osets/portcullis" :dir :system)
; cert-flags: ? t :ttags :all
(certify-book "osets-witnessing" ? t :ttags :all)
diff -Nru acl2-6.2/books/centaur/misc/osets-witnessing.lisp acl2-6.3/books/centaur/misc/osets-witnessing.lisp
--- acl2-6.2/books/centaur/misc/osets-witnessing.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/osets-witnessing.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -153,7 +153,7 @@
;; prove.
-(include-book "finite-set-theory/osets/sets" :dir :system)
+(include-book "std/osets/top" :dir :system)
(include-book "witness-cp")
(include-book "tools/rulesets" :dir :system)
diff -Nru acl2-6.2/books/centaur/misc/resize-list.lisp acl2-6.3/books/centaur/misc/resize-list.lisp
--- acl2-6.2/books/centaur/misc/resize-list.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/resize-list.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -20,30 +20,5 @@
(in-package "ACL2")
-; Basic lemmas about resize-list.
-
-(local (defun my-induct (n m lst)
- (if (zp n)
- (list lst)
- (if (zp m)
- nil
- (my-induct (- n 1) (- m 1)
- (if (atom lst)
- lst
- (cdr lst)))))))
-
-(defthm nth-of-resize-list
- (equal (nth n (resize-list lst m default-value))
- (let ((n (nfix n))
- (m (nfix m)))
- (and (< n m)
- (if (< n (len lst))
- (nth n lst)
- default-value))))
- :hints(("Goal"
- :expand (resize-list lst m default-value)
- :induct (my-induct n m lst))))
-
-(defthm len-of-resize-list
- (equal (len (resize-list lst m default))
- (nfix m)))
+; cert_param: (reloc_stub)
+(include-book "std/lists/resize-list" :dir :system)
diff -Nru acl2-6.2/books/centaur/misc/rewrite-rule.lisp acl2-6.3/books/centaur/misc/rewrite-rule.lisp
--- acl2-6.2/books/centaur/misc/rewrite-rule.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/misc/rewrite-rule.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,133 @@
+; Dumb Rewriter
+; Copyright (C) 2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original authors: Jared Davis
+; Sol Swords
+
+(in-package "ACL2")
+(include-book "cutil/define" :dir :system)
+
+;; Accessors for rewrite rules, since otherwise the proof obligations become
+;; giant cadaddrpillars.
+
+(define rewrite-rule->rune ((rule weak-rewrite-rule-p))
+ :inline t
+ (access rewrite-rule rule :rune))
+
+(define rewrite-rule->hyps ((rule weak-rewrite-rule-p))
+ :inline t
+ (access rewrite-rule rule :hyps))
+
+(define rewrite-rule->lhs ((rule weak-rewrite-rule-p))
+ :inline t
+ (access rewrite-rule rule :lhs))
+
+(define rewrite-rule->rhs ((rule weak-rewrite-rule-p))
+ :inline t
+ (access rewrite-rule rule :rhs))
+
+(define rewrite-rule->equiv ((rule weak-rewrite-rule-p))
+ :inline t
+ (access rewrite-rule rule :equiv))
+
+(define rewrite-rule->subclass ((rule weak-rewrite-rule-p))
+ :inline t
+ (access rewrite-rule rule :subclass))
+
+(define rewrite-rule->heuristic-info ((rule weak-rewrite-rule-p))
+ :inline t
+ (access rewrite-rule rule :heuristic-info))
+
+
+(define drw-get-rules ((fn symbolp)
+ (world plist-worldp))
+ :returns rules
+ (fgetprop fn 'lemmas nil world))
+
+
+(defmacro make-rewrite-rule (&key rune nume hyps equiv lhs rhs subclass
+ heuristic-info backchain-limit-lst
+ var-info match-free)
+ `(make-rewrite-rule-fn ,rune ,nume ,hyps ,equiv ,lhs ,rhs ,subclass
+ ,heuristic-info ,backchain-limit-lst
+ ,var-info ,match-free))
+
+(define make-rewrite-rule-fn (rune nume hyps equiv lhs rhs subclass
+ heuristic-info backchain-limit-lst
+ var-info match-free)
+ :inline t
+ (make rewrite-rule :rune rune :nume nume :hyps hyps :equiv equiv :lhs lhs
+ :rhs rhs :subclass subclass :heuristic-info heuristic-info
+ :backchain-limit-lst backchain-limit-lst :var-info var-info :match-free
+ match-free)
+ ///
+ (defthm weak-rewrite-rule-p-of-make-rewrite-rule-fn
+ (weak-rewrite-rule-p (make-rewrite-rule-fn
+ rune nume hyps equiv lhs rhs subclass
+ heuristic-info backchain-limit-lst
+ var-info match-free)))
+ (defthm rewrite-rule->hyps-of-make-rewrite-rule-fn
+ (equal (rewrite-rule->hyps (make-rewrite-rule-fn
+ rune nume hyps equiv lhs rhs subclass
+ heuristic-info backchain-limit-lst
+ var-info match-free))
+ hyps)
+ :hints(("Goal" :in-theory (enable rewrite-rule->hyps))))
+ (defthm rewrite-rule->lhs-of-make-rewrite-rule-fn
+ (equal (rewrite-rule->lhs (make-rewrite-rule-fn
+ rune nume hyps equiv lhs rhs subclass
+ heuristic-info backchain-limit-lst
+ var-info match-free))
+ lhs)
+ :hints(("Goal" :in-theory (enable rewrite-rule->lhs))))
+ (defthm rewrite-rule->rhs-of-make-rewrite-rule-fn
+ (equal (rewrite-rule->rhs (make-rewrite-rule-fn
+ rune nume hyps equiv lhs rhs subclass
+ heuristic-info backchain-limit-lst
+ var-info match-free))
+ rhs)
+ :hints(("Goal" :in-theory (enable rewrite-rule->rhs))))
+ (defthm rewrite-rule->equiv-of-make-rewrite-rule-fn
+ (equal (rewrite-rule->equiv (make-rewrite-rule-fn
+ rune nume hyps equiv lhs rhs subclass
+ heuristic-info backchain-limit-lst
+ var-info match-free))
+ equiv)
+ :hints(("Goal" :in-theory (enable rewrite-rule->equiv))))
+ (defthm rewrite-rule->subclass-of-make-rewrite-rule-fn
+ (equal (rewrite-rule->subclass (make-rewrite-rule-fn
+ rune nume hyps equiv lhs rhs subclass
+ heuristic-info backchain-limit-lst
+ var-info match-free))
+ subclass)
+ :hints(("Goal" :in-theory (enable rewrite-rule->subclass))))
+ (defthm rewrite-rule->heuristic-info-of-make-rewrite-rule-fn
+ (equal (rewrite-rule->heuristic-info (make-rewrite-rule-fn
+ rune nume hyps equiv lhs rhs subclass
+ heuristic-info backchain-limit-lst
+ var-info match-free))
+ heuristic-info)
+ :hints(("Goal" :in-theory (enable rewrite-rule->heuristic-info))))
+ (defthm rewrite-rule->rune-of-make-rewrite-rule-fn
+ (equal (rewrite-rule->rune (make-rewrite-rule-fn
+ rune nume hyps equiv lhs rhs subclass
+ heuristic-info backchain-limit-lst
+ var-info match-free))
+ rune)
+ :hints(("Goal" :in-theory (enable rewrite-rule->rune)))))
+
diff -Nru acl2-6.2/books/centaur/misc/seed-random.lisp acl2-6.3/books/centaur/misc/seed-random.lisp
--- acl2-6.2/books/centaur/misc/seed-random.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/seed-random.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -26,7 +26,7 @@
nil)
(defmacro seed-random$ (name &key (freshp 't))
- ":Doc-Section Programming
+ ":Doc-Section random$
Influence the random numbers produced by ~ilc[random$]~/
General form:
diff -Nru acl2-6.2/books/centaur/misc/sneaky-load.lisp acl2-6.3/books/centaur/misc/sneaky-load.lisp
--- acl2-6.2/books/centaur/misc/sneaky-load.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/sneaky-load.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -22,7 +22,7 @@
(in-package "ACL2")
(include-book "tools/bstar" :dir :system)
-
+(include-book "tools/include-raw" :dir :system)
(defttag sneaky-load)
(remove-untouchable 'read-acl2-oracle t)
@@ -144,67 +144,8 @@
(mv (cons val rest)
state)))))
-(progn!
- (set-raw-mode t)
-
- (defvar *sneaky-state*
- (make-hash-table))
-
- ;; (defun sneaky-save (name what)
- ;; (setf (gethash name *sneaky-load-table*) what)
- ;; nil)
-
- ;; (defun sneaky-push (name what)
- ;; (let ((val (gethash name *sneaky-load-table*)))
- ;; (setf (gethash name *sneaky-load-table*)
- ;; (cons what val)))
- ;; nil)
-
- ;; (defun sneaky-incf-fn (name amount)
- ;; (setf (gethash name *sneaky-load-table*)
- ;; (+ (fix (gethash name *sneaky-load-table*))
- ;; amount))
- ;; nil)
-
- (defun sneaky-load (name state)
- (unless (live-state-p state)
- (er hard? 'sneaky-load "sneaky-load should only be used on live states"))
- (let ((val (gethash name *sneaky-state*)))
- (mv val state)))
-
- (defun sneaky-alist (state)
- (unless (live-state-p state)
- (er hard? 'sneaky-load "sneaky-load should only be used on live states"))
- (let (al)
- (maphash (lambda (k v)
- (push (cons k v) al))
- *sneaky-state*)
- (mv al state)))
-
-
- (defun sneaky-mutate (fnname get-keys user-arg)
- (b* ((st *the-live-state*)
- (world (w st))
- (stobjs-in (fgetprop fnname 'stobjs-in :none world))
- (stobjs-out (fgetprop fnname 'stobjs-out :none world))
- ((when (not (equal stobjs-in '(nil nil))))
- (er hard 'sneaky-mutate
- "FNNAME must be an ACL2 function symbol of 2 non-stobj args; ~x0 is not~%"
- fnname))
- ((when (not (equal stobjs-out '(nil))))
- (er hard 'sneaky-mutate
- "FNNAME must be an ACL2 function symbol that returns a single value; ~x0 is not~%"
- fnname))
- (get-ins (loop for key in get-keys collect
- (gethash key *sneaky-state*)))
- (starfn (*1*-symbol fnname))
- (result (funcall starfn get-ins user-arg)))
- (loop while (consp result) do
- (b* ((head (car result)))
- (when (consp head)
- (setf (gethash (car head) *sneaky-state*) (cdr head)))
- (setq result (cdr result))))
- nil)))
+; (depends-on "sneaky-raw.lsp")
+(include-raw "sneaky-raw.lsp")
diff -Nru acl2-6.2/books/centaur/misc/sneaky-raw.lsp acl2-6.3/books/centaur/misc/sneaky-raw.lsp
--- acl2-6.2/books/centaur/misc/sneaky-raw.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/misc/sneaky-raw.lsp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,58 @@
+(defvar *sneaky-state*
+ (make-hash-table))
+
+;; (defun sneaky-save (name what)
+;; (setf (gethash name *sneaky-load-table*) what)
+;; nil)
+
+;; (defun sneaky-push (name what)
+;; (let ((val (gethash name *sneaky-load-table*)))
+;; (setf (gethash name *sneaky-load-table*)
+;; (cons what val)))
+;; nil)
+
+;; (defun sneaky-incf-fn (name amount)
+;; (setf (gethash name *sneaky-load-table*)
+;; (+ (fix (gethash name *sneaky-load-table*))
+;; amount))
+;; nil)
+
+(defun sneaky-load (name state)
+ (unless (live-state-p state)
+ (er hard? 'sneaky-load "sneaky-load should only be used on live states"))
+ (let ((val (gethash name *sneaky-state*)))
+ (mv val state)))
+
+(defun sneaky-alist (state)
+ (unless (live-state-p state)
+ (er hard? 'sneaky-load "sneaky-load should only be used on live states"))
+ (let (al)
+ (maphash (lambda (k v)
+ (push (cons k v) al))
+ *sneaky-state*)
+ (mv al state)))
+
+
+(defun sneaky-mutate (fnname get-keys user-arg)
+ (b* ((st *the-live-state*)
+ (world (w st))
+ (stobjs-in (fgetprop fnname 'stobjs-in :none world))
+ (stobjs-out (fgetprop fnname 'stobjs-out :none world))
+ ((when (not (equal stobjs-in '(nil nil))))
+ (er hard 'sneaky-mutate
+ "FNNAME must be an ACL2 function symbol of 2 non-stobj args; ~x0 is not~%"
+ fnname))
+ ((when (not (equal stobjs-out '(nil))))
+ (er hard 'sneaky-mutate
+ "FNNAME must be an ACL2 function symbol that returns a single value; ~x0 is not~%"
+ fnname))
+ (get-ins (loop for key in get-keys collect
+ (gethash key *sneaky-state*)))
+ (starfn (*1*-symbol fnname))
+ (result (funcall starfn get-ins user-arg)))
+ (loop while (consp result) do
+ (b* ((head (car result)))
+ (when (consp head)
+ (setf (gethash (car head) *sneaky-state*) (cdr head)))
+ (setq result (cdr result))))
+ nil))
diff -Nru acl2-6.2/books/centaur/misc/sparsemap-impl.lisp acl2-6.3/books/centaur/misc/sparsemap-impl.lisp
--- acl2-6.2/books/centaur/misc/sparsemap-impl.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/sparsemap-impl.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -19,7 +19,7 @@
; Original author: Sol Swords
(in-package "ACL2")
-(include-book "resize-list")
+(include-book "std/lists/resize-list" :dir :system)
(include-book "count-up")
(include-book "remove-assoc")
(include-book "arith-equivs")
diff -Nru acl2-6.2/books/centaur/misc/top.lisp acl2-6.3/books/centaur/misc/top.lisp
--- acl2-6.2/books/centaur/misc/top.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/top.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -29,7 +29,7 @@
(include-book "ap")
(include-book "defapply")
(include-book "dfs-measure")
-(include-book "equal-by-nths")
+(include-book "std/lists/nth" :dir :system)
(include-book "equal-sets")
(include-book "evaluator-metatheorems")
(include-book "fal-graphs")
diff -Nru acl2-6.2/books/centaur/misc/tshell-raw.lsp acl2-6.3/books/centaur/misc/tshell-raw.lsp
--- acl2-6.2/books/centaur/misc/tshell-raw.lsp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/tshell-raw.lsp 2013-09-30 17:53:11.000000000 +0000
@@ -19,12 +19,11 @@
; Tshell
; Original author: Jared Davis
-
(in-package "ACL2")
; NOTE: This file requires that str/strprefixp has been loaded.
-(defparameter *tshell-debug*
+(defvar *tshell-debug*
;; Change this to T for verbose debugging information.
nil)
@@ -35,31 +34,35 @@
; We look for certain strings to know when the program's output ends. This is
; gross, but in practice it should work.
-(defparameter *tshell-exit-line* "HORRIBLE_STRING_TO_DETECT_END_OF_TSHELL_COMMAND")
-(defparameter *tshell-status-line* "HORRIBLE_STRING_TO_DETECT_TSHELL_EXIT_STATUS")
-(defparameter *tshell-pid-line* "TSHELL_PID")
+(defvar *tshell-exit-line* "HORRIBLE_STRING_TO_DETECT_END_OF_TSHELL_COMMAND")
+(defvar *tshell-status-line* "HORRIBLE_STRING_TO_DETECT_TSHELL_EXIT_STATUS")
+(defvar *tshell-pid-line* "TSHELL_PID")
; We actually use two bash processes. *tshell* runs the programs.
; *tshell-killer* is only used to kill programs that *tshell* is running.
-(defvar *tshell*)
-(defvar *tshell-killer*)
+; Bug fix 2013-09-17: these were formerly uninitialized defvars, but Matt
+; pointed out that tshell-ensure is assuming they are initialized, so set
+; them to nil.
+
+(defvar *tshell* nil)
+(defvar *tshell-killer* nil)
; I added another bash process for background jobs. This seems easier than
; running them with *tshell*.
-(defvar *tshell-bg*)
+(defvar *tshell-bg* nil)
(defun tshell-stop ()
;; Stops any tshell processes that are running.
- #-Clozure
+ #-(and Clozure (not mswindows))
;; BOZO maybe eventually add support for other Lisps
nil
- #+Clozure
+ #+(and Clozure (not mswindows))
(progn (ignore-errors
(when *tshell*
(tshell-debug "TSHELL-STOP: stopping *tshell*~%")
@@ -80,11 +83,11 @@
(defun tshell-start ()
;; Stops any tshell processes and starts new ones.
- #-Clozure
+ #-(and Clozure (not mswindows))
;; BOZO maybe eventually add support for other Lisps
nil
- #+Clozure
+ #+(and Clozure (not mswindows))
(progn (tshell-debug "TSHELL-START: killing old processes~%")
(tshell-stop)
(tshell-debug "TSHELL-START: starting *tshell*~%")
@@ -108,9 +111,9 @@
nil))
(defun tshell-check ()
- #-Clozure
+ #-(and Clozure (not mswindows))
t
- #+Clozure
+ #+(and Clozure (not mswindows))
(and (ccl::external-process-p *tshell*)
(ccl::external-process-p *tshell-killer*)
(ccl::external-process-p *tshell-bg*)
@@ -120,10 +123,10 @@
(defun tshell-ensure ()
;; Stops any tshell processes and starts new ones.
- #-Clozure
+ #-(and Clozure (not mswindows))
;; BOZO eventually add support for other Lisps
nil
- #+Clozure
+ #+(and Clozure (not mswindows))
(unless (tshell-check)
(tshell-debug "TSHELL-START: starting *tshell*~%")
(setf *tshell* (ccl::run-program "/bin/bash" nil
@@ -164,7 +167,7 @@
(declare (ignore pos))
val))
-#+Clozure
+#+(and Clozure (not mswindows))
(defun tshell-kill (pid)
;; Use the tshell-killer process to try to kill process PID.
(tshell-debug "TSHELL-KILL: killing ~a.~%" pid)
@@ -203,46 +206,16 @@
-(defun tshell (cmd &key (print 't) (save 't))
-
-; (TSHELL CMD :PRINT [t/nil] :SAVE [t/nil]) --> (FINISHEDP STATUS LINES)
-;
-; Inputs:
-;
-; CMD should be an ordinary shell command that takes no input and does not
-; attempt to do any I/O redirection. It can have arguments, e.g., you can
-; write something like "echo hello" here.
-;
-; :PRINT says whether to print the lines produced by CMD as they are
-; produced. The default is T.
-;
-; :SAVE says whether to buffer the lines produced by CMD and return them as
-; LINES. The default is T. You can set :SAVE NIL if you want to use less
-; memory and don't care about inspecting the lines programmatically.
-;
-; Note that :SAVE and :PRINT are independent from one another. You can
-; print without saving, save without printing, or do both.
-;
-; Outputs:
-;
-; FINISHEDP is T if the command completed execution normally, or is NIL if
-; the command was aborted via interrupting.
-;
-; STATUS is the exit status code of the command (e.g., typically 0 means
-; success and some non-0 value means failure). It is only meaningful if
-; FINISHEDP is T.
-;
-; LINES are a list of strings which represent the output of the command,
-; (both to standard output and standard error.) Note that LINES will just
-; be NIL when you set :SAVE NIL.
+(defun tshell-call-fn (cmd print save)
+ ;; See the documentation in tshell.lisp.
(unless (tshell-check)
(error "Invalid *tshell*, *tshell-killer*, or *tshell-bg* -- did you call (tshell-start)?"))
- #-Clozure
+ #-(and Clozure (not mswindows))
(error "Oops, TSHELL isn't implemented for this Lisp.")
- #+Clozure
+ #+(and Clozure (not mswindows))
(let* ((tshell-in (ccl::external-process-input-stream *tshell*))
(tshell-out (ccl::external-process-output-stream *tshell*))
(tshell-err (ccl::external-process-error-stream *tshell*))
@@ -359,10 +332,10 @@
(unless (tshell-check)
(error "Invalid *tshell*, *tshell-killer*, or *tshell-bg* -- did you call (tshell-start)?"))
- #-Clozure
+ #-(and Clozure (not mswindows))
(error "Oops, TSHELL isn't implemented on this Lisp.")
- #+Clozure
+ #+(and Clozure (not mswindows))
(let* ((tshell-bg-in (ccl::external-process-input-stream *tshell*))
(nl (coerce (list #\Newline) 'string))
(cmd (concatenate 'string "(" cmd ") &" nl)))
diff -Nru acl2-6.2/books/centaur/misc/tshell-tests.lisp acl2-6.3/books/centaur/misc/tshell-tests.lisp
--- acl2-6.2/books/centaur/misc/tshell-tests.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/misc/tshell-tests.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -0,0 +1,90 @@
+; Centaur Miscellaneous Books
+; Copyright (C) 2008-2011 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "ACL2")
+(include-book "tshell")
+
+; Well, this is pretty pathetic. But it's hard to test much here, e.g., how
+; can we emulate interrupts, etc.?
+
+(value-triple (tshell-ensure))
+
+(defmacro test-tshell (&key cmd save print okp lines)
+ (declare (ignorable cmd save print okp lines))
+ #-(and Clozure (not mswindows))
+ `(value-triple :invisible)
+ #+(and Clozure (not mswindows))
+ `(make-event
+ (b* (((mv $finishedp $status $lines)
+ (tshell-call ,cmd :save ,save :print ,print)))
+ (and (or (equal $finishedp t)
+ (er hard? 'test-tshell "Error: finished was ~x0~%" $finishedp))
+ (or (equal (equal $status 0) ,okp)
+ (er hard? 'test-tshell "Error: status was ~x0~%" $status))
+ (or (equal ,lines :skip)
+ (equal $lines ,lines)
+ (er hard? 'test-tshell "Error: lines were ~x0~%" $lines)))
+ '(value-triple :success))))
+
+(test-tshell :cmd "echo hello"
+ :save t
+ :print t
+ :okp t
+ :lines '("hello"))
+
+(test-tshell :cmd "echo hello"
+ :save t
+ :print nil
+ :okp t
+ :lines '("hello"))
+
+(test-tshell :cmd "echo hello"
+ :save nil
+ :print nil
+ :okp t
+ :lines nil)
+
+(test-tshell :cmd "ls -1 tshell-tests.lisp"
+ :save t
+ :print t
+ :okp t
+ :lines '("tshell-tests.lisp"))
+
+; Matt K., 8/11/2013: Commenting out the following test, at Jared's suggestion,
+; since it is failing on a Mac.
+#||
+(test-tshell :cmd "ls -1 tshell.lisp tshell-tests.lisp"
+ :save t
+ :print t
+ :okp t
+ :lines '("tshell.lisp" "tshell-tests.lisp"))
+||#
+
+(test-tshell :cmd "ls file-that-should-not-exist.txt"
+ :save t
+ :print t
+ :okp nil
+ :lines :skip)
+
+(test-tshell :cmd "ls file-that-should-not-exist.txt"
+ :save nil
+ :print t
+ :okp nil
+ :lines nil)
diff -Nru acl2-6.2/books/centaur/misc/tshell.lisp acl2-6.3/books/centaur/misc/tshell.lisp
--- acl2-6.2/books/centaur/misc/tshell.lisp 2013-06-06 17:11:45.000000000 +0000
+++ acl2-6.3/books/centaur/misc/tshell.lisp 2013-09-30 17:53:11.000000000 +0000
@@ -19,84 +19,230 @@
; Tshell
; Original author: Jared Davis
+(in-package "ACL2")
+(include-book "tools/include-raw" :dir :system)
+(include-book "cutil/define" :dir :system)
+(include-book "str/strprefixp" :dir :system) ;; used in the raw code
+;; (depends-on "tshell-raw.lsp")
-; TSHELL is an alternative to things like sys-call and run-program. It is
-; similar to the CSH and SH commands in hons-raw.lisp, and like CSH and SH it
-; does not require a "fork" for every external program invocation. Instead, we
-; start up a single BASH process with (TSHELL-START) ahead of time, then use
-; this process to issue every command. Forking is often problematic when many
-; gigabytes of memory are allocated, so the basic idea is to call TSHELL-START
-; The basic idea is to call TSHELL-START early in the life of the Lisp image,
-; before much memory allocation is done.
-;
-; Here are TSHELL's features that are not in CSH or SH:
-;
-; (1) You can have the program's output printed at runtime, but still capture
-; its output as a list of strings.
-;
-; (2) You can get the exit code from the program.
-;
-; (3) If you interrupt, :continue will let you keep running the program, but
-; if you :q then a KILL signal will be sent.
-;
-; The third feature was particularly important to me for AIGPU, because we
-; don't want some runaway AIGPU process on prime getting in the way and
-; stopping us from doing other tautology checking.
+(defxdoc tshell
+ :parents (interfacing-tools sys-call)
+ :short "A fancy alternative to @(see sys-call) that features output streaming
+and capture, exit-code capture, interruption, and better control over when
+forking occurs. (CCL only)"
+ :long "Tshell is an alternative to things like ACL2's @(see
+sys-call) or Lisp-specific tools like CCL's @('run-program') that offers
+some nice features:
-; This file defines the ACL2 interface for tshell; see tshell-raw.lsp for the
-; implementation.
+
-(in-package "ACL2")
+Output streaming and capture . You can (optionally) have the
+program's output printed at runtime, but still (optionally) capture its output
+as a strings list. This makes it easy to show a user a long-running
+sub-program's output as it's being created, but also parse and analyze the
+program's output with your ACL2 code.
-(include-book "tools/include-raw" :dir :system)
-(include-book "str/strprefixp" :dir :system)
+Exit code. Yep, you get it.
+
+Interruption. Interrupts are handled gracefully. After you
+interrupt (e.g., Control C), you can @(':continue') to keep running the
+program, or @(':q') to send the sub-program a KILL signal.
+
+Forking. Sub-programs are launched with a separate shell, so you can
+avoid forking
+your ACL2 image when you have dozens of GB allocated. (Trying to do so
+typically results in ACL2 being killed, despite the wonders of copy-on-write
+pages.)
+
+Background jobs. You can optionally launch programs in the
+background. We use this, e.g., to launch waveform viewers which the user can
+then interact with independently from ACL2.
+
+
+
+Usage
+
+Note that Tshell requires a trust tag because its implementation requires
+some raw Lisp code. The book to load is:
+
+@({
+ (include-book \"centaur/misc/tshell\" :dir :system)
+})
+
+After loading this book, the first step is then to launch a tshell,
+e.g.,
+
+@({
+ (value-triple (tshell-ensure))
+})
+
+This will launch the subsidiary bash shell that tshell will use to run
+programs (actually three bash shells: one to launch programs, one to kill them,
+and one for background jobs). This step requires forking ACL2 itself, so you
+typically want to do this early in your ACL2 session, before you have allocated
+tons of memory.
+
+After that, you can start launching programs using @(see tshell-call) or
+@(see tshell-run-background). For instance,
+
+@({
+ ACL2 !>(tshell-call \"echo hello\")
+ (tshell-call \"echo hello\")
+ hello ;; <-- output from subprogram, streamed
+ (T 0 (\"hello\")) ;; <-- finished ok, exit code 0, output lines
+})")
+
+
+(define tshell-stop ()
+ :parents (tshell)
+ :short "Stop any subsidiary bash processes that tshell is running."
+ :returns (nil)
+ :long "You could call this when you're done using tshell. We typically
+don't bother, since the shells get closed when ACL2 exits anyway.
"
+
+ (cw "Warning: under-the-hood definition of ~s0 not installed?"
+ __function__))
+
+
+(define tshell-start ()
+ :parents (tshell)
+ :short "Stop any subsidiary bash processes that tshell is running, then
+start new ones. (always forks ACL2)"
+ :returns (nil)
+ :long "We usually instead use @(see tshell-ensure), which only starts up
+new bash processes if they aren't already running.
+
+If you want to use this in a book, you can wrap it in a @(see value-triple),
+e.g.,
+
+@({ (value-triple (tshell-start)) })"
+
+ (cw "Warning: under-the-hood definition of ~s0 not installed?"
+ __function__))
+
+
+(define tshell-ensure ()
+ :parents (tshell)
+ :short "Starts up the subsidiary bash processes for tshell, but only if they
+are not already running. (sometimes forks ACL2)"
+ :returns (nil)
+ :long "If you want to use this in a book, you can wrap it in a @(see
+value-triple), e.g.,
+
+@({ (value-triple (tshell-ensure)) })
+
+It's also typically useful to put this before calls of @(see tshell-call) or
+@(see tshell-run-background), to start up the shells if the user hadn't already
+gotten them started earlier.
"
+
+ (cw "Warning: under-the-hood definition of ~s0 not installed?"
+ __function__))
-;; (depends-on "tshell-raw.lsp")
-(defun tshell-start ()
- (declare (xargs :guard t))
- (cw "Warning: tshell-start not redefined."))
-
-(defun tshell-stop ()
- (declare (xargs :guard t))
- (cw "Warning: tshell-stop not redefined."))
-
-(defun tshell-ensure ()
- (declare (xargs :guard t))
- (cw "Warning: tshell-ensure not redefined."))
-
-(defun tshell-run-background (cmd)
- (declare (xargs :guard t)
- (ignorable cmd))
- (cw "Warning: tshell-run-background not redefined."))
(defun tshell-useless-clauseproc (clause)
(list clause))
(defttag tshell)
-(acl2::define-trusted-clause-processor
- tshell-useless-clauseproc
- (tshell-call-fn1)
- :partial-theory
- (encapsulate
- (((tshell-call-fn1 * * *) => (mv * * *)))
-
- (local (defun tshell-call-fn1 (x y z)
- (declare (ignorable x y z))
- (mv nil nil nil)))))
-
-(defun tshell-call-fn (cmd print save)
- (declare (xargs :guard t))
- (tshell-call-fn1 cmd print save))
-
-(defmacro tshell-call (cmd &key (print 't) (save 't))
- `(tshell-call-fn ,cmd ,print ,save))
-
-(acl2::include-raw "tshell-raw.lsp")
-
-(acl2::progn!
- (set-raw-mode t)
- (defun tshell-call-fn (cmd print save)
- (tshell cmd :print print :save save)))
+(defsection tshell-call-fn1
+ :parents (tshell)
+ :short "Logical story for @(see tshell-call)."
+ :long "We use the @(':partial-theory') feature of @(see
+define-trusted-clause-processor) to introduce a function, @('tshell-call-fn1'),
+about which we assume nothing.
+
+BOZO this probably isn't sound. Don't we get the equality axioms for
+tshell-call-fn1? But those aren't necessarily satisfied by command-line
+programs. We should probably be using oracle reads instead, but then we'll
+need to involve state.
"
+
+ (acl2::define-trusted-clause-processor
+ tshell-useless-clauseproc
+ (tshell-call-fn1)
+ :partial-theory
+ (encapsulate
+ (((tshell-call-fn1 * * *) => (mv * * *)))
+
+ (local (defun tshell-call-fn1 (x y z)
+ (declare (ignorable x y z))
+ (mv nil 0 nil)))
+
+ (defthm return-type-of-tshell-call-fn1
+ (b* (((mv finishedp status lines)
+ (tshell-call-fn1 cmd print save)))
+ (and (booleanp finishedp)
+ (natp status)
+ (string-listp lines)))))))
+
+(define tshell-call
+ :parents (tshell)
+ :short "Use tshell to run a sub-program and wait for it to finish. (never
+forks ACL2)."
+
+ ((cmd stringp
+ "This should be an ordinary shell command that takes no input and does
+ not attempt to do any I/O redirection. It can have arguments, e.g.,
+ you can write something like @('\"echo hello\"') here. But it won't
+ work to do something like @('\"echo < foo.txt\"').")
+ &key
+
+ ((print booleanp
+ "This says whether we should print the lines produced by @('cmd') as
+ they are produced.")
+ 't)
+
+ ((save booleanp
+ "This says whether we should capture the output lines produced by
+ @('cmd') and return them as the @('lines') output. If you aren't
+ going to analyze the program's output, you might want to set this
+ to @('nil') to cut down on memory usage.")
+ 't))
+
+ :returns
+ (mv (finishedp booleanp :rule-classes :type-prescription
+ "This will be @('t') if the command completed normally, or
+ @('nil') if the command was interrupted.")
+
+ (exit-status natp :rule-classes :type-prescription
+ "The exit code from the command. Typically 0 means success
+ and any non-zero value means failure. This is only
+ sensible if @('finishedp') is @('t').")
+
+ (lines string-listp
+ "The output from the command (from both standard output and
+ standard error.) Note that @('lines') will always just be
+ @('nil') if you're using @(':save nil')."))
+
+ :long "Before using @('tshell-call') you need to make sure that the bash
+processes for tshell have been started; see @(see tshell-start) and @(see
+tshell-ensure).
+
+Note that @(':save') and @(':print') are independent from one-another; you
+can print without saving, save without printing, save and print, or do neither
+and just get the exit code.
"
+
+ (progn$
+ (cw "Warning: under-the-hood definition of ~s0 not installed?"
+ __function__)
+ (tshell-call-fn1 cmd print save)))
+
+(define tshell-run-background
+ :parents (tshell)
+ :short "Use tshell to run a sub-program in the background; don't wait for it
+to finish and don't get any output from it. (never forks ACL2)."
+
+ ((cmd stringp "The command to give to the shell. It had better be
+ well-formed. It can probably use input/output redirection
+ without problems. We're basically going to run: @('(cmd) &')."))
+ :returns (nil)
+ :ignore-ok t
+ (cw "Warning: under-the-hood definition of ~s0 not installed?"
+ __function__))
+
+(include-raw "tshell-raw.lsp")
+
+
+
diff -Nru acl2-6.2/books/centaur/quicklisp/Makefile acl2-6.3/books/centaur/quicklisp/Makefile
--- acl2-6.2/books/centaur/quicklisp/Makefile 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/quicklisp/Makefile 1970-01-01 00:00:00.000000000 +0000
@@ -1,38 +0,0 @@
-# Quicklisp setup for Centaur books
-# Copyright (C) 2008-2012 Centaur Technology
-#
-# Contact:
-# Centaur Technology Formal Verification Group
-# 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
-# http://www.centtech.com/
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation; either version 2 of the License, or (at your option) any later
-# version. This program is distributed in the hope that it will be useful but
-# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
-# more details. You should have received a copy of the GNU General Public
-# License along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
-#
-# Original author: Jared Davis
-
-STARTJOB ?= $(SHELL)
-ACL2 ?= acl2
-
-all: top.cert
-
-quicklisp.lisp:
- curl -O http://beta.quicklisp.org/quicklisp.lisp
-
-setup.lisp: quicklisp.lisp install.lsp
- $(STARTJOB) -c "$(ACL2) < install.lsp &> install.out"
-
-clean:
- rm -rf setup.lisp quicklisp.lisp asdf.lisp cache dists local-projects \
- tmp install.out quicklisp *.cert.out *.cert.time *.lx64fsl \
- Makefile-tmp *.cert
-
-top.cert: setup.lisp
- cert.pl top.cert
diff -Nru acl2-6.2/books/centaur/quicklisp/README acl2-6.3/books/centaur/quicklisp/README
--- acl2-6.2/books/centaur/quicklisp/README 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/quicklisp/README 2013-09-30 17:53:14.000000000 +0000
@@ -1,3 +1,8 @@
-Note: you need to run "make" in this directory before you can certify top.cert.
+Note: You can't just certify these books with cert.pl. The proper way to
+build them is, e.g.,:
-See books/centaur/README.html for detailed instructions about building the Centaur books.
+ cd acl2-sources/books
+ make USE_QUICKLISP=1
+
+Or similar. See books/centaur/README.html for detailed instructions about
+building the Centaur books.
diff -Nru acl2-6.2/books/centaur/quicklisp/cert.acl2 acl2-6.3/books/centaur/quicklisp/cert.acl2
--- acl2-6.2/books/centaur/quicklisp/cert.acl2 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/quicklisp/cert.acl2 2013-09-30 17:53:14.000000000 +0000
@@ -1 +1,23 @@
+; Quicklisp setup for Centaur books
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "ACL2")
+(include-book "xdoc/portcullis" :dir :system)
; cert-flags: ? t :ttags :all
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/quicklisp/top.lisp acl2-6.3/books/centaur/quicklisp/top.lisp
--- acl2-6.2/books/centaur/quicklisp/top.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/quicklisp/top.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1,5 +1,5 @@
; Quicklisp setup for Centaur books
-; Copyright (C) 2008-2012 Centaur Technology
+; Copyright (C) 2008-2013 Centaur Technology
;
; Contact:
; Centaur Technology Formal Verification Group
@@ -22,18 +22,114 @@
(include-book "tools/include-raw" :dir :system)
; (depends-on "setup.lisp")
+(defsection quicklisp
+ :parents (acl2::interfacing-tools)
+ :short "An ACL2 wrapper for the Quicklisp system for installing Lisp
+libraries."
-; Quicklisp (www.quicklisp.org) is a tool for installing Common Lisp libraries,
-; somewhat like CPAN for Perl, GEMS for Ruby.
-;
-; This file is a way to get Quicklisp loaded in an ACL2 session. It doesn't
-; load anything beyond Quicklisp itself, so, e.g., to load an actual Quicklisp
-; package, you'll need to do something like:
-;
-; (ql:quickload "cl-json")
-;
-; In your own ACL2 book. Obviously doing this will require a ttag. For that
-; matter, even loading this Quicklisp book requires a ttag.
+ :long "About Quicklisp
+
+Quicklisp is a Common Lisp equivalent to tools like CPAN for Perl , or RubyGems for Ruby . It lets you to easily install and
+load the latest versions of Common Lisp libraries (and their dependencies).
+
+If you don't know much about Quicklisp and are wanting to find out about the
+available libraries, the following may be useful:
+
+
+
+
+The ACL2 Quicklisp Book
+
+To make it easy to use Quicklisp from ACL2, we have wrapper book, which of
+course requires a trust tag :
+
+@({
+ (include-book \"centaur/quicklisp/top\" :dir :system)
+})
+
+NOTE: this book isn't automatically certified when you just run
+@('make') in the acl2-books directory. You have to explicitly tell @('make')
+that you want to use Quicklisp—e.g.,
+
+@({
+ cd [...]/acl2-sources/books
+ make USE_QUICKLISP=1
+})
+
+The Quicklisp book really is just a way to get Quicklisp itself loaded into
+an ACL2 session. It doesn't load anything libraries.
+
+
+Practical Howto
+
+So how do you actually use the Quicklisp book to gain access to a Common
+Lisp library? For instance, say we want to make use of the CL-JSON library.
+
+Normally you would do something like this:
+
+@({
+ ; ** my-book.lisp
+ (in-package \"MY-PKG\")
+
+ ; ** Load Quicklisp, tell cert.pl this book needs Quicklisp support
+ (include-book \"centaur/quicklisp/top\" :dir :system)
+ ;; cert_param: (uses-quicklisp)
+
+ ; ** [OPTIONAL] develop a logical story so you can use the
+ ; ** library from proper ACL2 functions...
+ (defun foo (x y z)
+ (declare (xargs :guard ...))
+ (progn$
+ (er hard? 'foo \"Raw lisp definition not installed?\")
+ (logical-story-of-foo x y z)))
+
+ ; ** Add a ttag since we're going to use include-raw
+ (defttag :my-book)
+
+ ; ** Tell cert.pl that we're going to be loading raw Lisp code
+ ;; (depends-on \"my-book-raw.lsp\")
+
+ ; ** Actually include the raw Lisp code for our book
+ (include-raw \"my-book-raw.lsp\"
+ :do-not-compile t
+ :host-readtable t)
+})
+
+You usually need to use the @(':host-readtable') option because real Common
+Lisp libraries will use things (packages, floats, etc.) that ACL2's reader will
+reject. You usually need to use @(':do-not-compile') because BOZO why? I
+don't know, but it never *!@$! works if you try to compile it.
+
+The corresponding raw file, then would look something like this:
+
+@({
+ ; ** my-book-raw.lsp
+ (in-package \"MY-PKG\")
+
+ ; ** Tell Quicklisp we want to use the CL-JSON library
+ (ql:quickload \"cl-json\")
+
+ ; ** Redefine our interface functions, freely using cl-json
+ ; ** functionality
+ (defun foo (x y z)
+ ...)
+})")
(defttag :quicklisp)
@@ -52,4 +148,6 @@
***********************************************************************~%~
~%"))
-(include-raw "setup.lisp" :do-not-compile t :host-readtable t)
\ No newline at end of file
+(include-raw "setup.lisp"
+ :do-not-compile t
+ :host-readtable t)
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/regression/add.lisp acl2-6.3/books/centaur/regression/add.lisp
--- acl2-6.2/books/centaur/regression/add.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/add.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,92 @@
+; Copyright David Rager, 2013
+
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+
+;; cert_param: (uses-glucose)
+
+(in-package "ACL2")
+
+(include-book "common")
+
+(defmodules *add-modules*
+ (vl::make-vl-loadconfig
+ :start-files (list "add.v")))
+
+(defmacro add-thm (n)
+ (let* ((n-str (str::natstr n))
+
+ (constant-name ;;; defining a constant is a bit silly, but having this
+ ;;; intermediate artifact to view
+ (intern$ (str::cat "*ADD-" n-str "-MODULE*")
+ "ACL2"))
+
+ (thm-name
+ (intern$ (str::cat "ADD-" n-str "-CORRECT")
+ "ACL2"))
+
+ (module-name (str::cat "add" n-str))
+
+ (test-vector-name
+ (intern$ (str::cat "ADD-" n-str "-TEST-VECTOR")
+ "ACL2"))
+
+ (test-vector-autohyps-name
+ (intern$ (str::cat (symbol-name test-vector-name)
+ "-AUTOHYPS")
+
+ "ACL2"))
+
+ (test-vector-autoins-name
+ (intern$ (str::cat (symbol-name test-vector-name)
+ "-AUTOINS")
+
+ "ACL2"))
+
+ (g-bindings
+ `(gl::auto-bindings (:mix (:nat a ,n)
+ (:nat b ,n)))))
+
+ `(progn
+ (defconst ,constant-name
+ (vl::vl-module->esim
+ (vl::vl-find-module ,module-name (vl::vl-translation->mods *add-modules*))))
+
+
+
+ (defstv ,test-vector-name
+ :mod ,constant-name
+ :inputs
+ '(("abus" a)
+ ("bbus" b))
+ :outputs
+ '(("out" res)))
+
+ (def-gl-thm ,thm-name
+ :hyp (,test-vector-autohyps-name)
+ :concl (equal (let* ((in-alist (,test-vector-autoins-name))
+ (out-alist (stv-run (,test-vector-name) in-alist))
+ (res (cdr (assoc 'res out-alist))))
+ res)
+ (mod (+ a b) (expt 2 ,n)))
+ :g-bindings ,g-bindings))))
+
+
+(add-thm 1)
+(add-thm 2)
+(add-thm 3)
+(add-thm 4)
+(add-thm 8)
+(add-thm 16)
+(add-thm 32)
+(add-thm 64)
+(add-thm 128)
+(add-thm 256) ; took 6.98 seconds (with glucose 2.2)
+; (add-thm 512) ; took 26.33 seconds (with glucose 2.2)
diff -Nru acl2-6.2/books/centaur/regression/add.v acl2-6.3/books/centaur/regression/add.v
--- acl2-6.2/books/centaur/regression/add.v 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/add.v 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,109 @@
+/*
+
+
+Copyright (C) 2013 David L. Rager
+
+*/
+
+
+
+// add.v
+//
+// These are simple adders.
+
+module add1 (
+ output [0:0] out,
+ input [0:0] abus,
+ input [0:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
+module add2 (
+ output [1:0] out,
+ input [1:0] abus,
+ input [1:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
+module add3 (
+ output [2:0] out,
+ input [2:0] abus,
+ input [2:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
+module add4 (
+ output [3:0] out,
+ input [3:0] abus,
+ input [3:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
+module add8 (
+ output [7:0] out,
+ input [7:0] abus,
+ input [7:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
+module add16 (
+ output [15:0] out,
+ input [15:0] abus,
+ input [15:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
+module add32 (
+ output [31:0] out,
+ input [31:0] abus,
+ input [31:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
+module add64 (
+ output [63:0] out,
+ input [63:0] abus,
+ input [63:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
+module add128 (
+ output [127:0] out,
+ input [127:0] abus,
+ input [127:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
+module add256 (
+ output [255:0] out,
+ input [255:0] abus,
+ input [255:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
+module add512 (
+ output [511:0] out,
+ input [511:0] abus,
+ input [511:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
+module add1024 (
+ output [1023:0] out,
+ input [1023:0] abus,
+ input [1023:0] bbus
+);
+assign out = abus + bbus;
+endmodule
+
diff -Nru acl2-6.2/books/centaur/regression/cert.acl2 acl2-6.3/books/centaur/regression/cert.acl2
--- acl2-6.2/books/centaur/regression/cert.acl2 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/cert.acl2 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,9 @@
+; cert.acl2
+; Just loads relevant packages
+
+(in-package "ACL2")
+(include-book "centaur/vl/portcullis" :dir :system)
+(include-book "centaur/gl/portcullis" :dir :system)
+(include-book "centaur/esim/portcullis" :dir :system)
+(include-book "centaur/aig/portcullis" :dir :system)
+; cert-flags: ? t :ttags :all
diff -Nru acl2-6.2/books/centaur/regression/common.lisp acl2-6.3/books/centaur/regression/common.lisp
--- acl2-6.2/books/centaur/regression/common.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/common.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,62 @@
+; Copyright David Rager, 2013
+
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+
+(in-package "ACL2")
+
+(include-book "centaur/vl/top" :dir :system)
+(include-book "centaur/gl/gl" :dir :system)
+(include-book "centaur/aig/g-aig-eval" :dir :system)
+(include-book "centaur/esim/stv/stv-top" :dir :system)
+(include-book "centaur/esim/stv/stv-debug" :dir :system)
+(include-book "centaur/4v-sexpr/top" :dir :system)
+(include-book "tools/plev-ccl" :dir :system)
+(include-book "centaur/misc/memory-mgmt" :dir :system)
+(include-book "str/top" :dir :system)
+
+(set-waterfall-parallelism nil) ; for below call of def-gl-clause-processor
+
+; I'm unsure why the below is critical, but the "GL Clock" runs out without it.
+; It introduces a GL clause processor that can natively execute at least the
+; functions from the above books that get marked with add-clause-proc-exec-fns.
+
+(def-gl-clause-processor my-glcp)
+
+(include-book "centaur/gl/bfr-satlink" :dir :system)
+
+(make-event (prog2$ (tshell-ensure)
+ '(value-triple :invisible))
+ :check-expansion t)
+
+(gl::gl-satlink-mode)
+
+(defun my-glucose-config ()
+ (declare (xargs :guard t))
+ (satlink::make-config :cmdline "glucose"
+ :verbose t
+ :mintime 1/2
+ :remove-temps t))
+
+(defattach gl::gl-satlink-config my-glucose-config)
+
+(local (defthm unsigned-byte-p-re-redef
+ (equal (unsigned-byte-p bits x)
+ (AND (INTEGERP BITS)
+ (<= 0 BITS)
+ (INTEGER-RANGE-P 0 (EXPT 2 BITS) X)))
+ :hints(("Goal" :in-theory (enable unsigned-byte-p)))
+ :rule-classes :definition))
+
+(defxdoc verilog-regression-tests
+ :parents (ACL2::VL)
+ :short "Regression tests for @(see vl) and @(see esim)."
+ :long "Regression tests for the ACL2 verilog system can be found in
+ books/centaur/regression.")
diff -Nru acl2-6.2/books/centaur/regression/divide.lisp acl2-6.3/books/centaur/regression/divide.lisp
--- acl2-6.2/books/centaur/regression/divide.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/divide.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,99 @@
+; Copyright David Rager, 2013
+
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+
+;; cert_param: (uses-glucose)
+
+(in-package "ACL2")
+
+(include-book "common")
+
+(defmodules *divide-modules*
+ (vl::make-vl-loadconfig
+ :start-files (list "divide.v")))
+
+(defmacro divide-thm (n)
+ (let* ((n-str (str::natstr n))
+
+ (constant-name ;;; defining a constant is a bit silly, but having this
+ ;;; intermediate artifact to view
+ (intern$ (str::cat "*DIVIDE-" n-str "-MODULE*")
+ "ACL2"))
+
+ (thm-name
+ (intern$ (str::cat "DIVIDE-" n-str "-CORRECT")
+ "ACL2"))
+
+ (module-name (str::cat "divide" n-str))
+
+ (test-vector-name
+ (intern$ (str::cat "DIVIDE-" n-str "-TEST-VECTOR")
+ "ACL2"))
+
+
+ (test-vector-autohyps-name
+ (intern$ (str::cat (symbol-name test-vector-name)
+ "-AUTOHYPS")
+ "ACL2"))
+
+ (test-vector-autoins-name
+ (intern$ (str::cat (symbol-name test-vector-name)
+ "-AUTOINS")
+ "ACL2"))
+
+ (g-bindings
+ `(gl::auto-bindings (:mix (:nat a ,n)
+ (:nat b ,n)))))
+
+ `(progn
+ (defconst ,constant-name
+ (vl::vl-module->esim
+ (vl::vl-find-module ,module-name (vl::vl-translation->mods *divide-modules*))))
+
+
+
+ (defstv ,test-vector-name
+ :mod ,constant-name
+ :inputs
+ '(("abus" a)
+ ("bbus" b))
+ :outputs
+ '(("out" res)))
+
+ (def-gl-thm ,thm-name
+ :hyp (and (,test-vector-autohyps-name))
+ :concl (equal (let* ((in-alist (,test-vector-autoins-name))
+ (out-alist (stv-run (,test-vector-name) in-alist))
+ (res (cdr (assoc 'res out-alist))))
+ res)
+ (if (equal b 0) 'X (floor a b)))
+ :g-bindings ,g-bindings))))
+
+
+(divide-thm 1)
+(divide-thm 2)
+(divide-thm 3)
+(divide-thm 4)
+(divide-thm 8)
+(divide-thm 10) ; took 2.79 seconds with glucose 2.2 on modern, yet slow, laptop
+; (divide-thm 12) ; ; took 14.59 seconds with glucose 2.2 on modern, yet slow, laptop
+
+#|
+
+; These are left as benchmarks for the future
+
+(divide-thm 16)
+(divide-thm 32)
+(divide-thm 64)
+(divide-thm 128)
+(divide-thm 256)
+(divide-thm 512)
+|#
diff -Nru acl2-6.2/books/centaur/regression/divide.v acl2-6.3/books/centaur/regression/divide.v
--- acl2-6.2/books/centaur/regression/divide.v 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/divide.v 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,127 @@
+/*
+
+
+Copyright (C) 2013 David L. Rager
+
+*/
+
+
+
+// divide.v
+//
+// These are simple dividers.
+
+module divide1 (
+ output [0:0] out,
+ input [0:0] abus,
+ input [0:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide2 (
+ output [1:0] out,
+ input [1:0] abus,
+ input [1:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide3 (
+ output [2:0] out,
+ input [2:0] abus,
+ input [2:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide4 (
+ output [3:0] out,
+ input [3:0] abus,
+ input [3:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide8 (
+ output [7:0] out,
+ input [7:0] abus,
+ input [7:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide10 (
+ output [9:0] out,
+ input [9:0] abus,
+ input [9:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide12 (
+ output [11:0] out,
+ input [11:0] abus,
+ input [11:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide16 (
+ output [15:0] out,
+ input [15:0] abus,
+ input [15:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide32 (
+ output [31:0] out,
+ input [31:0] abus,
+ input [31:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide64 (
+ output [63:0] out,
+ input [63:0] abus,
+ input [63:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+/*
+ module divide128 (
+ output [127:0] out,
+ input [127:0] abus,
+ input [127:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide256 (
+ output [255:0] out,
+ input [255:0] abus,
+ input [255:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide512 (
+ output [511:0] out,
+ input [511:0] abus,
+ input [511:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+module divide1024 (
+ output [1023:0] out,
+ input [1023:0] abus,
+ input [1023:0] bbus
+);
+assign out = abus / bbus;
+endmodule
+
+*/
diff -Nru acl2-6.2/books/centaur/regression/idiv.lisp acl2-6.3/books/centaur/regression/idiv.lisp
--- acl2-6.2/books/centaur/regression/idiv.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/idiv.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,72 @@
+; Copyright David Rager, 2013
+
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+
+; cert_param: (uses-glucose)
+
+(in-package "ACL2")
+
+(include-book "common")
+
+(defmodules *divide-modules*
+ (vl::make-vl-loadconfig
+ :start-files (list "idiv.v")))
+
+(defconst *divide-translation*
+ (VL::VL-TRANSLATION->MODS *DIVIDE-MODULES*))
+
+; (vl::vl-modulelist-flat-warnings
+; (vl::vl-translation->failmods *divide-modules*))
+
+(defconst *divide-module*
+ (vl::vl-module->esim
+ (vl::vl-find-module "udivider_v5"
+ *divide-translation*)))
+
+(defstv divide-test-vector
+ :mod *divide-module*
+ :inputs '(("iDIVIDEND" dividend) ("iDIVISOR" divisor) ("iDIVVLD" divvld)
+ ("iRESET" reset) ("CLK" clk))
+ :outputs '(("oQUOTIENT" quot) ("oREMAINDER" rem) ("oDONE" done)))
+
+(def-gl-thm divide-resets-quotient
+ :hyp (and (divide-test-vector-autohyps)
+ (equal reset -1))
+ :concl (equal (let* ((in-alist (divide-test-vector-autoins))
+ (out-alist (stv-run (divide-test-vector)
+ in-alist))
+ (quot (cdr (assoc 'quot out-alist))))
+ quot)
+ 0)
+ :g-bindings '((dividend (:g-number (11 12 13 14 15 16 17 18 19)))
+ (divisor (:g-number (6 7 8 9 10)))
+ (divvld (:g-number (0 1)))
+ (clk (:g-number (2 3)))
+ (reset (:g-number (4 5)))))
+
+(def-gl-thm divide-resets-everything
+ :hyp (and (divide-test-vector-autohyps)
+ (equal reset -1))
+ :concl (let* ((in-alist (divide-test-vector-autoins))
+ (out-alist (stv-run (divide-test-vector) in-alist))
+ (quot (cdr (assoc 'quot out-alist)))
+ (rem (cdr (assoc 'rem out-alist)))
+ (done (cdr (assoc 'done out-alist))))
+ (and (equal quot 0)
+ (equal rem 0)
+ (equal done 0)))
+
+ :g-bindings '((dividend (:g-number (11 12 13 14 15 16 17 18 19)))
+ (divisor (:g-number (6 7 8 9 10)))
+ (divvld (:g-number (0 1)))
+ (clk (:g-number (2 3)))
+ (reset (:g-number (4 5)))))
+
diff -Nru acl2-6.2/books/centaur/regression/idiv.v acl2-6.3/books/centaur/regression/idiv.v
--- acl2-6.2/books/centaur/regression/idiv.v 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/idiv.v 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,417 @@
+/*
+
+Copyright (C) 2013 David L. Rager
+
+A derived work from the following, which has no specific license:
+ http://commdspfpga.blogspot.com/2012/09/unsiged-integer-divider-in-verilog.html
+
+
+The module below divides an eight bit number by a four bit number. We
+use both "output"s and "reg"s for the outputs, because VL doesn't yet
+support "output reg"s.
+
+As of August 6, 2013, I have proved that resetting the divider resets
+the outputs. Correctness of the output under non-reset conditions
+remains to be done.
+
+Something else I'd like to do is reinstate the parameters, as opposed
+to hard coded "8" and "4" values. This may require further improving
+VL.
+
+*/
+
+//=================================================
+//`timescale 1ns / 1ps
+
+/*********************************************************************************/
+/* Unsigned Integer Divider Module */
+/*********************************************************************************/
+module udivider_v5
+(
+ input [8-1:0] iDIVIDEND, // 0 ~ 2**(8)-1
+ input [4-1:0] iDIVISOR, // 1 ~ 2**(4)-1
+ input iDIVVLD,
+ input iRESET,
+ input CLK,
+ output /*reg*/ [8-1:0] oQUOTIENT,
+ output /*reg*/ [4-1:0] oREMAINDER,
+ output /*reg*/ oDONE
+);
+/*********************************************************************************/
+/* Derived Parameters */
+/*********************************************************************************/
+// parameter EXT_8 = 4 + 8;
+/*********************************************************************************/
+/* Generate rVIVVLD_D1, rDIVVLD_D2, rSTART_D1, rSTART_D1, based on iDIVVLD */
+/*********************************************************************************/
+wire wSTART;
+reg rSTART_D1;
+reg rDIVVLD_D1;
+reg rDIVVLD_D2;
+reg [8-1:0] oQUOTIENT;
+reg [4-1:0] oREMAINDER;
+reg oDONE;
+
+
+always @ (posedge CLK)
+begin
+ if (iRESET)
+ begin
+ rDIVVLD_D1 <= 0;
+ end else
+ begin
+ rDIVVLD_D1 <= iDIVVLD;
+ end
+end
+
+always @ (posedge CLK)
+begin
+ if (iRESET)
+ begin
+ rDIVVLD_D2 <= 0;
+ end else
+ begin
+ rDIVVLD_D2 <= rDIVVLD_D1;
+ end
+end
+
+always @ (posedge CLK)
+begin
+ if (iRESET)
+ begin
+ rSTART_D1 <= 0;
+ end else
+ begin
+ rSTART_D1 <= wSTART;
+ end
+end
+
+assign wSTART = rDIVVLD_D1 && ~rDIVVLD_D2;
+/*********************************************************************************/
+/* Latch iDIVISOR and iDIVIDEND on rSTART_D1 */
+/*********************************************************************************/
+reg [4:0] rDIVISOR_POS;
+reg [4:0] rDIVISOR_NEG;
+always @ (posedge CLK)
+begin
+ if (iRESET)
+ begin
+ rDIVISOR_POS <= 0;
+ end else if (wSTART)
+ begin
+ rDIVISOR_POS <= {1'b0, iDIVISOR};
+ end
+end
+
+always @ (posedge CLK)
+begin
+ if (iRESET)
+ begin
+ rDIVISOR_NEG <= 0;
+ end else if (wSTART)
+ begin
+ rDIVISOR_NEG <= {1'b1, ~iDIVISOR + 1};
+ end
+end
+
+wire [4:0] wEXTZEROS;
+assign wEXTZEROS = 0;
+/*********************************************************************************/
+/* Select between rDIVISOR_POS and rDIVISOR_NEG */
+/* based on subtract result */
+/*********************************************************************************/
+reg [4:0] rDIVISOR_TC;
+reg [4:0] rREMAINDER;
+wire [4:0] wREMAINDER_1;
+always @ (posedge CLK)
+ begin
+ if (iRESET || wSTART)
+ begin
+ rDIVISOR_TC <= 0;
+ //rDIVISOR_TC <= rDIVISOR_NEG;
+ end else if (wREMAINDER_1[4])
+ begin
+ rDIVISOR_TC <= rDIVISOR_POS;
+ end else if (~wREMAINDER_1[4])
+ begin
+ rDIVISOR_TC <= rDIVISOR_NEG;
+ end
+end
+/*********************************************************************************/
+/* Initialize rREMAINDER at rSTART_D1 */
+/* Load and Left Shift rREMAINDER at each rLSHIFT cycle */
+/*********************************************************************************/
+reg rLSHIFT;
+reg [8-1:0] rQUOTIENT;
+reg [7:0] rCOUNT; // 8
+always @ (posedge CLK)
+begin
+ if (iRESET || wSTART)
+ begin
+ rREMAINDER <= 0;
+ end else if (rSTART_D1)
+ begin
+ // rREMAINDER <= { wEXTZEROS[4-1:1], iDIVIDEND[8-1] };
+ rREMAINDER <= { { (4-1){1'b0}}, iDIVIDEND[8-1] };
+ // Extend 4 zeros to iDIVIDEND, so that iDIVISOR > rREMAINDER
+ end else if (rLSHIFT)
+ begin
+ rREMAINDER <= { wREMAINDER_1[4-1:0], rQUOTIENT[8-1] };
+ // Left shift rREMAINDER by 1 bit, shift rQUOTIENT[8-1] to
+ // rREMAINDER[0]
+ end
+end
+/*********************************************************************************/
+/* Compute wREMAINDER_1 as rDIVISOR_TC + rREMAINDER */
+/*********************************************************************************/
+assign wREMAINDER_1 = rDIVISOR_TC + rREMAINDER;
+/*********************************************************************************/
+/* Iniitalize rQUOTIENT at rSTART_D1 */
+/* Left Shift rQUOTIENT at rLSHIFT cycle */
+/*********************************************************************************/
+always @ (posedge CLK)
+begin
+ if (iRESET || wSTART )
+ begin
+ rQUOTIENT <= 0;
+ end else if (rSTART_D1 )
+ begin
+ rQUOTIENT <= {iDIVIDEND[8-2:0], 1'b0};
+ // Initialize rQUOTIENT
+ end else if (rLSHIFT)
+ begin
+ rQUOTIENT <= { rQUOTIENT[8-2:0], ~wREMAINDER_1[4] };
+ // Left shift rQUOTIENT by 1 bit, shift ~wREMAINDER_1[4] to
+ // rQUOTIENT[0]
+ end
+end
+/*********************************************************************************/
+/* Restore the remainder at last iteration by adding rDIVISOR_POS if a 0 Quotient*/
+/*********************************************************************************/
+reg [4-1:0] rRESTORE;
+always @ (posedge CLK)
+begin
+ if (iRESET || wSTART)
+ begin
+ rRESTORE <= 0;
+ end else if (rCOUNT == 8-1 && wREMAINDER_1[4])
+ begin
+ rRESTORE <= wREMAINDER_1 + rDIVISOR_POS;
+ end else if (rCOUNT == 8-1 && ~wREMAINDER_1[4])
+ begin
+ rRESTORE <= wREMAINDER_1;
+ end
+end
+/*********************************************************************************/
+/* rLSHIFT and DONE signals generation based on iDONE */
+/*********************************************************************************/
+//reg rLSHIFT;
+reg rDONE;
+always @ ( posedge CLK)
+begin
+ if (iRESET || rCOUNT == 8-1)
+ begin
+ rLSHIFT <= 0;
+ end else if (rSTART_D1)
+ begin
+ rLSHIFT <= 1;
+ end
+end
+
+always @ ( posedge CLK)
+begin
+ if (iRESET || rSTART_D1 || rCOUNT == 8-1)
+ begin
+ rCOUNT <= 0;
+ end else if (rLSHIFT)
+ begin
+ rCOUNT <= rCOUNT + 1;
+ end
+end
+
+always @ ( posedge CLK)
+begin
+ if (iRESET || rSTART_D1 || rDONE)
+ begin
+ rDONE <= 0;
+ end else if ( rCOUNT == 8-1)
+ begin
+ rDONE <= 1;
+ end
+end
+/*********************************************************************************/
+/* output registers */
+/*********************************************************************************/
+always @ (posedge CLK)
+begin
+ if (iRESET || rSTART_D1)
+ begin
+ oQUOTIENT <= 0;
+ end else if (rDONE)
+ begin
+ oQUOTIENT <= rQUOTIENT;
+ end
+end
+
+always @ (posedge CLK)
+begin
+ if (iRESET || rSTART_D1)
+ begin
+ oREMAINDER <= 0;
+ end else if (rDONE)
+ begin
+ oREMAINDER <= rRESTORE;
+ end
+end
+
+
+always @ (posedge CLK)
+begin
+ if (iRESET || rSTART_D1)
+ begin
+ oDONE <= 0;
+ end else
+ begin
+ oDONE <= rDONE;
+ end
+end
+endmodule
+
+/*********************************************************************************/
+/* End of Unsigned Divider Module */
+/*********************************************************************************/
+
+/*
+Running Results:
+
+#
+# X = 254, D = 1, Q = 254 R= 0
+# X =11111110, D =0001, Q =11111110 R=0000
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 2, Q = 127 R= 0
+# X =11111110, D =0010, Q =01111111 R=0000
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 3, Q = 84 R= 2
+# X =11111110, D =0011, Q =01010100 R=0010
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 4, Q = 63 R= 2
+# X =11111110, D =0100, Q =00111111 R=0010
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 5, Q = 50 R= 4
+# X =11111110, D =0101, Q =00110010 R=0100
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 6, Q = 42 R= 2
+# X =11111110, D =0110, Q =00101010 R=0010
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 7, Q = 36 R= 2
+# X =11111110, D =0111, Q =00100100 R=0010
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 8, Q = 31 R= 6
+# X =11111110, D =1000, Q =00011111 R=0110
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 9, Q = 28 R= 2
+# X =11111110, D =1001, Q =00011100 R=0010
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 10, Q = 25 R= 4
+# X =11111110, D =1010, Q =00011001 R=0100
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 11, Q = 23 R= 1
+# X =11111110, D =1011, Q =00010111 R=0001
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 12, Q = 21 R= 2
+# X =11111110, D =1100, Q =00010101 R=0010
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 13, Q = 19 R= 7
+# X =11111110, D =1101, Q =00010011 R=0111
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 14, Q = 18 R= 2
+# X =11111110, D =1110, Q =00010010 R=0010
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+# X = 254, D = 15, Q = 16 R= 14
+# X =11111110, D =1111, Q =00010000 R=1110
+# rPRODUCT=11111110, rPASS=1 rERRCOUNT= 0
+#
+#
+#
+# X = 255, D = 1, Q = 255 R= 0
+# X =11111111, D =0001, Q =11111111 R=0000
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 2, Q = 127 R= 1
+# X =11111111, D =0010, Q =01111111 R=0001
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 3, Q = 85 R= 0
+# X =11111111, D =0011, Q =01010101 R=0000
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 4, Q = 63 R= 3
+# X =11111111, D =0100, Q =00111111 R=0011
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 5, Q = 51 R= 0
+# X =11111111, D =0101, Q =00110011 R=0000
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 6, Q = 42 R= 3
+# X =11111111, D =0110, Q =00101010 R=0011
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 7, Q = 36 R= 3
+# X =11111111, D =0111, Q =00100100 R=0011
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 8, Q = 31 R= 7
+# X =11111111, D =1000, Q =00011111 R=0111
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 9, Q = 28 R= 3
+# X =11111111, D =1001, Q =00011100 R=0011
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 10, Q = 25 R= 5
+# X =11111111, D =1010, Q =00011001 R=0101
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 11, Q = 23 R= 2
+# X =11111111, D =1011, Q =00010111 R=0010
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 12, Q = 21 R= 3
+# X =11111111, D =1100, Q =00010101 R=0011
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 13, Q = 19 R= 8
+# X =11111111, D =1101, Q =00010011 R=1000
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 14, Q = 18 R= 3
+# X =11111111, D =1110, Q =00010010 R=0011
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+# X = 255, D = 15, Q = 17 R= 0
+# X =11111111, D =1111, Q =00010001 R=0000
+# rPRODUCT=11111111, rPASS=1 rERRCOUNT= 0
+#
+#
+#
+# X ranges from 0 to 255.
+# D ranges from 1 to 15.
+# 0
+# Expected Number of Cases: (2**8)*( (2**4) - 1) = 3840.
+# Total 3840 cases examined. Number of Erros: 0
+*/
diff -Nru acl2-6.2/books/centaur/regression/multiply.lisp acl2-6.3/books/centaur/regression/multiply.lisp
--- acl2-6.2/books/centaur/regression/multiply.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/multiply.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,99 @@
+; Copyright David Rager, 2013
+
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+
+;; cert_param: (uses-glucose)
+
+(in-package "ACL2")
+
+(include-book "common")
+
+(defmodules *multiply-modules*
+ (vl::make-vl-loadconfig
+ :start-files (list "multiply.v")))
+
+(defmacro multiply-thm (n)
+ (let* ((n-str (str::natstr n))
+
+ (constant-name ;;; defining a constant is a bit silly, but having this
+ ;;; intermediate artifact to view
+ (intern$ (str::cat "*MULTIPLY-" n-str "-MODULE*")
+ "ACL2"))
+
+ (thm-name
+ (intern$ (str::cat "MULTIPLY-" n-str "-CORRECT")
+ "ACL2"))
+
+ (module-name (str::cat "multiply" n-str))
+
+ (test-vector-name
+ (intern$ (str::cat "MULTIPLY-" n-str "-TEST-VECTOR")
+ "ACL2"))
+
+
+ (test-vector-autohyps-name
+ (intern$ (str::cat (symbol-name test-vector-name)
+ "-AUTOHYPS")
+ "ACL2"))
+
+ (test-vector-autoins-name
+ (intern$ (str::cat (symbol-name test-vector-name)
+ "-AUTOINS")
+ "ACL2"))
+
+ (g-bindings
+ `(gl::auto-bindings (:mix (:nat a ,n)
+ (:nat b ,n)))))
+
+ `(progn
+ (defconst ,constant-name
+ (vl::vl-module->esim
+ (vl::vl-find-module ,module-name (vl::vl-translation->mods *multiply-modules*))))
+
+
+
+ (defstv ,test-vector-name
+ :mod ,constant-name
+ :inputs
+ '(("abus" a)
+ ("bbus" b))
+ :outputs
+ '(("out" res)))
+
+ (def-gl-thm ,thm-name
+ :hyp (,test-vector-autohyps-name)
+ :concl (equal (let* ((in-alist (,test-vector-autoins-name))
+ (out-alist (stv-run (,test-vector-name) in-alist))
+ (res (cdr (assoc 'res out-alist))))
+ res)
+ (mod (* a b) (expt 2 ,n)))
+ :g-bindings ,g-bindings))))
+
+
+(multiply-thm 1)
+(multiply-thm 2)
+(multiply-thm 3)
+(multiply-thm 4)
+(multiply-thm 8) ; took 1.57 seconds with glucose 2.2 on modern, yet slow, laptop
+; (multiply-thm 10) ; took 86.11 seconds with glucose 2.2 on modern, yet slow, laptop
+
+#|
+
+; These are left as benchmarks for the future
+
+(multiply-thm 12)
+(multiply-thm 16)
+(multiply-thm 32)
+(multiply-thm 64)
+(multiply-thm 128)
+(multiply-thm 256)
+(multiply-thm 512)
+|#
diff -Nru acl2-6.2/books/centaur/regression/multiply.v acl2-6.3/books/centaur/regression/multiply.v
--- acl2-6.2/books/centaur/regression/multiply.v 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/multiply.v 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,127 @@
+/*
+
+
+Copyright (C) 2013 David L. Rager
+
+*/
+
+
+
+// multiply.v
+//
+// These are simple multipliers.
+
+module multiply1 (
+ output [0:0] out,
+ input [0:0] abus,
+ input [0:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply2 (
+ output [1:0] out,
+ input [1:0] abus,
+ input [1:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply3 (
+ output [2:0] out,
+ input [2:0] abus,
+ input [2:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply4 (
+ output [3:0] out,
+ input [3:0] abus,
+ input [3:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply8 (
+ output [7:0] out,
+ input [7:0] abus,
+ input [7:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply10 (
+ output [9:0] out,
+ input [9:0] abus,
+ input [9:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply12 (
+ output [11:0] out,
+ input [11:0] abus,
+ input [11:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply16 (
+ output [15:0] out,
+ input [15:0] abus,
+ input [15:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply32 (
+ output [31:0] out,
+ input [31:0] abus,
+ input [31:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply64 (
+ output [63:0] out,
+ input [63:0] abus,
+ input [63:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+/*
+ module multiply128 (
+ output [127:0] out,
+ input [127:0] abus,
+ input [127:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply256 (
+ output [255:0] out,
+ input [255:0] abus,
+ input [255:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply512 (
+ output [511:0] out,
+ input [511:0] abus,
+ input [511:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+module multiply1024 (
+ output [1023:0] out,
+ input [1023:0] abus,
+ input [1023:0] bbus
+);
+assign out = abus * bbus;
+endmodule
+
+*/
diff -Nru acl2-6.2/books/centaur/regression/subtract.lisp acl2-6.3/books/centaur/regression/subtract.lisp
--- acl2-6.2/books/centaur/regression/subtract.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/subtract.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,94 @@
+; Copyright David Rager, 2013
+
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+
+;; cert_param: (uses-glucose)
+
+(in-package "ACL2")
+
+(include-book "common")
+
+(defmodules *subtract-modules*
+ (vl::make-vl-loadconfig
+ :start-files (list "subtract.v")))
+
+(defmacro subtract-thm (n)
+ (let* ((n-str (str::natstr n))
+
+ (constant-name ;;; defining a constant is a bit silly, but having this
+ ;;; intermediate artifact to view
+ (intern$ (str::cat "*SUBTRACT-" n-str "-MODULE*")
+
+ "ACL2"))
+
+ (thm-name
+ (intern$ (str::cat "SUBTRACT-" n-str "-CORRECT")
+
+ "ACL2"))
+
+ (module-name (str::cat "subtract" n-str))
+
+ (test-vector-name
+ (intern$ (str::cat "SUBTRACT-" n-str "-TEST-VECTOR")
+ "ACL2"))
+
+ (test-vector-autohyps-name
+ (intern$ (str::cat (symbol-name test-vector-name)
+ "-AUTOHYPS")
+
+ "ACL2"))
+
+ (test-vector-autoins-name
+ (intern$ (str::cat (symbol-name test-vector-name)
+ "-AUTOINS")
+
+ "ACL2"))
+
+ (g-bindings
+ `(gl::auto-bindings (:mix (:nat a ,n)
+ (:nat b ,n)))))
+
+ `(progn
+ (defconst ,constant-name
+ (vl::vl-module->esim
+ (vl::vl-find-module ,module-name (vl::vl-translation->mods *subtract-modules*))))
+
+
+
+ (defstv ,test-vector-name
+ :mod ,constant-name
+ :inputs
+ '(("abus" a)
+ ("bbus" b))
+ :outputs
+ '(("out" res)))
+
+ (def-gl-thm ,thm-name
+ :hyp (,test-vector-autohyps-name)
+ :concl (equal (let* ((in-alist (,test-vector-autoins-name))
+ (out-alist (stv-run (,test-vector-name) in-alist))
+ (res (cdr (assoc 'res out-alist))))
+ res)
+ (mod (- a b) (expt 2 ,n)))
+ :g-bindings ,g-bindings))))
+
+
+(subtract-thm 1)
+(subtract-thm 2)
+(subtract-thm 3)
+(subtract-thm 4)
+(subtract-thm 8)
+(subtract-thm 16)
+(subtract-thm 32)
+(subtract-thm 64)
+(subtract-thm 128)
+(subtract-thm 256) ; took 7.82 seconds (with glucose 2.2)
+; (subtract-thm 512) ; took 29.34 seconds (with glucose 2.2)
diff -Nru acl2-6.2/books/centaur/regression/subtract.v acl2-6.3/books/centaur/regression/subtract.v
--- acl2-6.2/books/centaur/regression/subtract.v 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/regression/subtract.v 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,109 @@
+/*
+
+
+Copyright (C) 2013 David L. Rager
+
+*/
+
+
+
+// subtract.v
+//
+// These are simple subtracters.
+
+module subtract1 (
+ output [0:0] out,
+ input [0:0] abus,
+ input [0:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
+module subtract2 (
+ output [1:0] out,
+ input [1:0] abus,
+ input [1:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
+module subtract3 (
+ output [2:0] out,
+ input [2:0] abus,
+ input [2:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
+module subtract4 (
+ output [3:0] out,
+ input [3:0] abus,
+ input [3:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
+module subtract8 (
+ output [7:0] out,
+ input [7:0] abus,
+ input [7:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
+module subtract16 (
+ output [15:0] out,
+ input [15:0] abus,
+ input [15:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
+module subtract32 (
+ output [31:0] out,
+ input [31:0] abus,
+ input [31:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
+module subtract64 (
+ output [63:0] out,
+ input [63:0] abus,
+ input [63:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
+module subtract128 (
+ output [127:0] out,
+ input [127:0] abus,
+ input [127:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
+module subtract256 (
+ output [255:0] out,
+ input [255:0] abus,
+ input [255:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
+module subtract512 (
+ output [511:0] out,
+ input [511:0] abus,
+ input [511:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
+module subtract1024 (
+ output [1023:0] out,
+ input [1023:0] abus,
+ input [1023:0] bbus
+);
+assign out = abus - bbus;
+endmodule
+
diff -Nru acl2-6.2/books/centaur/satlink/cnf.lisp acl2-6.3/books/centaur/satlink/cnf.lisp
--- acl2-6.2/books/centaur/satlink/cnf.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/satlink/cnf.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -29,8 +29,13 @@
(include-book "centaur/misc/bitarr" :dir :system)
(local (include-book "data-structures/list-defthms" :dir :system))
-(defstobj-clone env$ bitarr
- :exports (env$-length env$-get env$-set env$-resize))
+
+(defsection env$
+ :parents (cnf)
+ :short "A bit array that serves as the environment for @(see eval-formula)."
+
+ (defstobj-clone env$ bitarr
+ :exports (env$-length env$-get env$-set env$-resize)))
(local (defthm equal-1-when-bitp
(implies (bitp x)
@@ -40,26 +45,33 @@
(defxdoc cnf
:parents (satlink)
- :short "Representation of CNF formulas."
+ :short "Our representation (syntax and semantics) for conjunctive normal
+form formulas."
+
+ :long "To express what it means to call a SAT solver, we need a
+representation and a semantics for Boolean formulas in conjunctive normal form.
+Our syntax is as follows:
- :long "
+
-A VARIABLE is a natural number. To help keep variables separate
+ A variable is a natural number. To help keep variables separate
from literals, we represent them @(see varp)s, instead of @(see natp)s.
-A LITERAL represents either a variable or a negated variable. We
+ A literal represents either a variable or a negated variable. We
represent these using a typical numeric encoding: the least significant bit is
the negated bit, and the remaining bits are the variable. See @(see
litp).
-A CLAUSE is a disjunction of literals. We represent these as
+ A clause is a disjunction of literals. We represent these as
ordinary lists of literals. See @(see lit-listp).
-A FORMULA is a conjunction of clauses. We represent these using
+ A formula is a conjunction of clauses. We represent these using
@(see lit-list-listp).
- ")
+
+The semantics of these formulas are given by @(see eval-formula).
")
(defsection eval-formula
:parents (cnf)
@@ -68,9 +80,10 @@
:long "We define a simple evaluator for CNF formulas that uses an
environment to assign values to the identifiers.
-The environment is represented as a bit array. Our evaluators produce a
-BIT (i.e., 0 or 1) instead of a BOOL (i.e., T or NIL) to make it
-directly compatible with the bitarr stobj.
"
+The environment, @(see env$), is an abstract stobj that implements a simple
+bit array. Our evaluators produce a BIT (i.e., 0 or 1) instead of a
+BOOL (i.e., T or NIL) to make it directly compatible with the bitarr
+stobj.
"
(define eval-var ((var varp) env$)
:returns (bit bitp)
diff -Nru acl2-6.2/books/centaur/satlink/dimacs.lisp acl2-6.3/books/centaur/satlink/dimacs.lisp
--- acl2-6.2/books/centaur/satlink/dimacs.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/satlink/dimacs.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -26,6 +26,7 @@
(include-book "str/natstr" :dir :system)
(include-book "str/strnatless" :dir :system)
(include-book "std/io/base" :dir :system)
+(include-book "std/typed-lists/character-listp" :dir :system)
(defsection dimacs
:parents (satlink)
@@ -99,11 +100,17 @@
that conform to these more stringent requirements, since otherwise a SAT solver
that believes it can make these assumptions may make a mistake. We may
eventually add a cleaning phase to our SAT integration, to ensure that we only
-call the SAT solver on \"clean\" formulas."
+call the SAT solver on \"clean\" formulas.")
-; Basic idea: ACC is a character list with the output we have "printed" in
-; reverse order. This means (cons char acc) is the same as printing a char,
-; (str::revappend-chars str acc) is the same as printing str, etc.
+(defsection dimacs-export
+ :parents (dimacs)
+ :short "Writer to translate @(see cnf) formulas into DIMACS files."
+
+ :long "The basic idea here is that @('acc') is a character list with the
+output we have printed in reverse order. This means @('(cons char acc)') is
+the same as printing a char, @('(str::revappend-chars str acc)') is the same as
+printing @('str'), etc. See @(see str::revappend-chars) for more background
+about this basic approach.
"
(define dimacs-write-lit ((lit litp) (acc character-listp))
:returns (acc character-listp :hyp :guard)
diff -Nru acl2-6.2/books/centaur/satlink/package.lsp acl2-6.3/books/centaur/satlink/package.lsp
--- acl2-6.2/books/centaur/satlink/package.lsp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/satlink/package.lsp 2013-09-30 17:53:14.000000000 +0000
@@ -21,9 +21,9 @@
(in-package "ACL2")
-(ld "cutil/package.lsp" :dir :system)
+(include-book "cutil/portcullis" :dir :system)
(ld "tools/flag-package.lsp" :dir :system)
-(ld "oslib/package.lsp" :dir :system)
+(include-book "oslib/portcullis" :dir :system)
(defpkg "SATLINK"
(union-eq *acl2-exports*
@@ -60,5 +60,6 @@
bitarr get-bit set-bit bits-length resize-bits bits-equiv
natarr get-nat set-nat nats-length resize-nats nats-equiv
tshell-call tshell-start tshell-stop tshell-ensure
+ satlink boolean-reasoning
)))
diff -Nru acl2-6.2/books/centaur/satlink/top.lisp acl2-6.3/books/centaur/satlink/top.lisp
--- acl2-6.2/books/centaur/satlink/top.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/satlink/top.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -29,40 +29,113 @@
(include-book "oslib/tempfile" :dir :system)
(include-book "centaur/misc/tshell" :dir :system)
(include-book "config")
+(local (include-book "std/lists/nthcdr" :dir :system))
(defxdoc satlink
- :short "A way to call SAT solvers from within ACL2, and trust what they say."
-
- :long "SATLINK is a basic connection to SAT solvers from within ACL2. At
-a high level, it provides:
+ :parents (acl2::boolean-reasoning)
+ :short "A simple representation for Boolean formulas in conjunctive normal form , and a mechanism for calling SAT solvers
+from within ACL2 and trusting what they say. (CCL Only)"
+
+ :long "SAT solvers are programs that can solve the Boolean
+satisfiability problem . Modern solvers implement clever algorithms in fast
+languages like C and C++, so they can quickly solve many large problems.
+Developing faster SAT solvers is an active area of research with frequent competitions .
+
+SAT solvers are useful because many problems can be recast as SAT problems.
+For instance, the @(see gl::gl) framework can translate many ACL2 proof goals,
+e.g., bounded arithmetic problems, into SAT problems. This allows for a large
+class of theorems to be solved quickly and automatically by the SAT solver.
+This is especially useful in @(see acl2::hardware-verification).
+
+Satlink is an interfacing library that allows ACL2 to make use of
+off-the-shelf SAT solvers like lingeling , glucose , and so on. It
+provides:
-A (trivial) representation and semantics for Boolean formulas in conjunctive normal
-form ; see @(see cnf).
+A (trivial) representation and semantics for Boolean formulas in
+conjunctive normal form; see @(see cnf).
+
+A function, @(see sat), that can invoke a SAT solver on a formula and
+interpret its output. This is done via @(see acl2::tshell), so the integration
+is very smooth, e.g., you can interrupt the SAT solver.
+
+A @(see logical-story) that allows us to assume,
+using a trust tag , that when the
+SAT solver claims the formula is unsatisfiable, it's correct.
+
+
+
+We don't have to assume anything when the SAT solver claims that a formula
+is satisfiable, since we can just check the alleged satisfying assignment it
+produces.
+
+
+Loading the Library
+
+Satlink is a low-level library. It would be a bit weird to want to use it
+directly. Instead, it is typically used indirectly through other tools, such
+as the @(see gl::gl) framework, or @(see acl2::aig-sat), or the @(see
+aignet::aignet-cnf) translation. These other approaches are likely to be more
+convenient than using Satlink directly.
+
+If you want to include Satlink directly for some reason, the book to include
+is:
+
+@({
+ (include-book \"centaur/satlink/top\" :dir :system)
+})
+
+Once you load this book, you generally need to construct your input @(see
+cnf) formula in some way, and then call @(see sat).
+
+
+
-A function, @(see sat), that can call an off-the-shelf SAT solver (e.g., lingeling ) on a formula, and interpret
-its output.
+Copyright Information
-A logical story that allows us to assume, using a trust tag , that the SAT solver only claims that formulas are
-unsatisfiable when this is indeed the case. (When the SAT solver claims that a
-formula is satisfiable, we can just check the alleged satisfying assignment it
-produces.)
+Satlink — Link from ACL2 to SAT Solvers
+Copyright (C) 2013 Centaur Technology .
-")
+Contact:
+@({
+Centaur Technology Formal Verification Group
+7600-C N. Capital of Texas Highway, Suite 300
+Austin, TX 78731, USA.
+})
+Satlink is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
-; Parser for reading DIMACS output from the SAT solver...
+This program is distributed in the hope that it will be useful but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+details.
-(define satlink-skip-ws ((x stringp)
- (n natp)
- (xl (equal xl (length x))))
+You should have received a copy of the GNU General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
+Street, Suite 500, Boston, MA 02110-1335, USA.
")
+
+
+(defsection dimacs-interp
+ :parents (dimacs)
+ :short "How we interpret the DIMACS formatted output from the SAT solver.")
+
+(define satlink-skip-ws
+ :parents (dimacs-interp)
+ ((x stringp "String we're processing")
+ (n natp "Current position in @('x').")
+ (xl (equal xl (length x)) "Pre-computed length of @('x')."))
:guard (<= n xl)
+ :returns (new-n natp "New position after skipping whitespace.")
:measure (nfix (- (nfix xl) (nfix n)))
- :returns (new-n natp)
(b* (((when (mbe :logic (zp (- (nfix xl) (nfix n)))
:exec (int= xl n) ;; It's *really* fast
))
@@ -88,15 +161,17 @@
:rule-classes ((:rewrite) (:linear))))
(define satlink-parse-variable-line
- ((x stringp)
- (n natp "current position")
- (xl (equal xl (length x)))
- saw-zero-p
- env$)
+ :parents (dimacs-interp)
+ ((x stringp "String we're processing.")
+ (n natp "Current position in @('x').")
+ (xl (equal xl (length x)) "Pre-computed length of @('x').")
+ (saw-zero-p booleanp "Have we seen a 0 yet?")
+ (env$ "Satisfying assignment we're populating."))
:guard (<= n xl)
- :returns (mv error saw-zero-p env$)
+ :returns (mv (error "True if there is an error parsing this line.")
+ (saw-zero-p "Did we ever see 0? (checked later).")
+ (env$ "Updated satisfying assignment."))
:measure (nfix (- (nfix xl) (nfix n)))
-
(b* ((n (satlink-skip-ws x n xl))
((when (mbe :logic (zp (- (nfix xl) n))
:exec (int= xl n)))
@@ -125,17 +200,17 @@
(set-bit index (if minus-p 0 1) env$))
(t
(prog2$
- (er hard? __function__ "Assignment to out-of-bounds variable: ~x0" index)
+ (raise "Assignment to out-of-bounds variable: ~x0" index)
env$)))))
(satlink-parse-variable-line x (+ n len) xl saw-zero-p env$)))
(define satlink-handle-line
+ :parents (dimacs-interp)
((line "one line of sat solver output" stringp)
(saw-unsat-p "have we seen an 's UNSATISFIABLE' line?")
(saw-sat-p "have we seen an 's SATISFIABLE' line?")
(saw-zero-p "have we seen a 0 in a 'v' line?")
(env$ "evolving variable bindings"))
-
:returns
(mv (error-p "did we see something we don't understand?")
saw-unsat-p
@@ -162,6 +237,9 @@
(prog2$
(cw "SATLINK: Don't recognize this line: ~s0~%" line)
(mv t saw-unsat-p saw-sat-p saw-zero-p env$)))))
+ ((when (str::strprefixp "Solved by" line))
+ ;; Ignore glucose 2.2 feature
+ (mv nil saw-unsat-p saw-sat-p saw-zero-p env$))
((unless (eql char #\v))
(cw "SATLINK: Don't recognize this line: ~s0~%" line)
(mv t saw-unsat-p saw-sat-p saw-zero-p env$))
@@ -174,6 +252,7 @@
(mv error saw-unsat-p saw-sat-p saw-zero-p env$)))
(define satlink-handle-lines
+ :parents (dimacs-interp)
((lines string-listp)
(saw-unsat-p "have we seen an 's UNSATISFIABLE' line?")
(saw-sat-p "have we seen an 's SATISFIABLE' line?")
@@ -194,8 +273,9 @@
(satlink-handle-lines (cdr lines) saw-unsat-p saw-sat-p saw-zero-p env$)))
(define satlink-parse-output
- ((out string-listp)
- (env$ "empty env to populate, should be sized already."))
+ :parents (dimacs-interp)
+ ((out string-listp "output lines from the SAT solver.")
+ (env$ "empty env to populate, should be sized already."))
:returns (mv (status "Either :failed, :sat, or :unsat")
(env$ "Variable assignment, in the :sat case."))
(b* (((mv error-p saw-unsat-p saw-sat-p saw-zero-p env$)
@@ -218,16 +298,22 @@
(mv :sat env$)))
-; Core function to use to run the SAT solver.
-
-(define satlink-run-impl ((config config-p)
- (cnf lit-list-listp)
- (env$ "empty env to populate, will usually be resized")
- &key
- (state 'state))
- :returns (mv status
+(define satlink-run-impl
+ :parents (logical-story)
+ :short "Core function used to run the SAT solver."
+ ((config config-p "Which solver to call, etc.")
+ (cnf lit-list-listp "The formula to solve.")
+ (env$ "Empty env to populate, will usually be resized")
+ &key
+ (state 'state))
+ :returns (mv (status ":sat, :unsat, or :failed")
(env$ "Variable assignment, in the :sat case.")
(state state-p1 :hyp (state-p1 state)))
+ :long "This function actually runs the SAT solver: it exports the formula
+into a @(see dimacs) file, invokes the SAT solver on it, and interprets the
+answer. This function is typically never used directly; instead see @(see
+satlink-run).
"
+
(b* (((config config) config)
((mv filename state) (oslib::tempfile "satlink"))
@@ -274,7 +360,90 @@
(mv status env$ state)))
-; Logical Story
+(defsection logical-story
+ :parents (satlink)
+ :short "How we logically assume that the SAT solver's claims of unsat are
+correct."
+
+ :long "The whole point of Satlink is to be able to call an external SAT
+solver, written in C or C++, and trust its results. Here, we explain exactly
+how we do that.
+
+Our assumptions about the SAT solver will be expressed as constraints about
+a new function, @('satlink-run-fn'). Informally, the idea behind this function
+is that it will have the following signature:
+
+
+ (satlink-run-fn config formula env$) → (status env$)
+
+
+
+
+Inputs
+
+@('config') is a @(see config-p) that says which SAT solver to run and how
+to run it.
+
+@('formula') is the @(see cnf) formula to solve.
+
+@('env$') is @(see env$), a bit array that will be used to store the
+satisfying assignment from the SAT solver, in the SAT case.
+
+Outputs
+
+@('status') is the answer we get back from the SAT solver; in practice it
+will either be @(':sat') or @(':unsat'), or perhaps @(':failed') if we run into
+some kind of gross error—for instance, perhaps the SAT solver produces
+output that we weren't expecting, like \"Segmentation fault\" or
+\"Killed\".
+
+@('env$') is the updated @(see env$) bit array; in the @(':sat') case it
+should contain the satisfying assignment.
+
+
+
+Axiomatization
+
+We use ACL2's @(see define-trusted-clause-processor) @(':partial-theory')
+feature to assume that the function satisfies certain constraints.
+
+To make our story as tight as possible, we would like to assume very little
+about @('satlink-run-fn'). It turns out we only need three constraints, with
+the first two constraints just saying that the function returns two values:
+
+@(thm true-listp-of-satlink-run-fn)
+@(thm len-of-satlink-run-fn)
+
+The final constraint is the real one. The idea here is to express:
+
+
+ if @('satlink-run-fn') returns @(':unsat'),
+ then the formula evaluates to false under every environment.
+
+
+But the quantification here isn't quite right for a rewrite rule, so
+instead we assume the contrapositive:
+
+
+ if NOT(the formula evaluates to false under every environment),
+ then NOT( @('satlink-run-fn') returns @(':unsat') )
+
+
+Which simplifies down to:
+
+
+ if the formula evaluates to true under any environment,
+ then @('satlink-run-fn') does not return @(':unsat')
+
+
+So the real constraint looks like this:
+
+@(thm satlink-run-fn-unsat-claim)
+
+
+And that's it. We don't need to assume anything about what happens in the
+@(':sat') case, because our top-level @(see sat) wrapper can just check any
+@(':sat') answers.
")
(defun satlink-useless-clauseproc (clause)
(list clause))
@@ -307,33 +476,51 @@
(not (equal (mv-nth 0 (satlink-run-fn config formula env$))
:unsat))))))
-(defun satlink-run (config formula env$)
- "Returns (MV STATUS ENV$)"
- (declare (xargs :stobjs env$
- :guard (and (config-p config)
- (lit-list-listp formula))))
- (satlink-run-fn config formula env$))
-
-(progn!
- (set-raw-mode t)
- (defun satlink-run (config formula env$)
- (b* ((state acl2::*the-live-state*)
- (prev-okp (f-get-global 'acl2::writes-okp state))
- (state (f-put-global 'acl2::writes-okp t state))
- ((mv res env$ state) (satlink-run-impl config formula env$))
- (?state (f-put-global 'acl2::writes-okp prev-okp state)))
- (mv res env$))))
-
-(define sat ((formula "A CNF formula to solve." lit-list-listp)
- (env$ "Environment to populate with a satisfying assignment,
- in the case of SAT. Will be emptied, in any case.")
- &key
- ((config "Configuration for running a SAT solver." config-p)
- '*default-config*))
+(defsection satlink-run
+ :parents (logical-story)
+ :short "Connection between the implementation and the logical story."
+
+ :long "In the logic, this function does nothing more than call
+@('satlink-run-fn'), the constrained function that is the basis of our @(see
+logical-story).
+
+Under the hood, through a trust tag, we smash its definition and have it
+invoke @(see satlink-run-impl), which actually calls the SAT solver.
"
+
+ (defun satlink-run (config formula env$)
+ "Returns (MV STATUS ENV$)"
+ (declare (xargs :stobjs env$
+ :guard (and (config-p config)
+ (lit-list-listp formula))))
+ (satlink-run-fn config formula env$))
+
+ (progn!
+ (set-raw-mode t)
+ (defun satlink-run (config formula env$)
+ (b* ((state acl2::*the-live-state*)
+ (prev-okp (f-get-global 'acl2::writes-okp state))
+ (state (f-put-global 'acl2::writes-okp t state))
+ ((mv res env$ state) (satlink-run-impl config formula env$))
+ (?state (f-put-global 'acl2::writes-okp prev-okp state)))
+ (mv res env$)))))
+
+(define sat
:parents (satlink)
:short "Top-level function for running a SAT solver."
+
+ ((formula "A @(see cnf) formula to solve." lit-list-listp)
+ (env$ "Environment to populate with a satisfying assignment, in the case
+ of SAT. Will be emptied, in any case.")
+ &key
+ ((config "Configuration for running a SAT solver." config-p)
+ '*default-config*))
:returns (mv (status "@(':sat'), @(':unsat'), or @(':failed').")
(env$ "Satisfying assignment, in the case of @(':sat')."))
+
+ :long "This is the top-level wrapper for calling SAT. It handles the
+details of clearing out the @(see env$) and checking the SAT solver's answers
+in the SAT case.
"
+
(b* (((config config) config)
(env$ (mbe :logic (non-exec nil) :exec (resize-bits 0 env$)))
((mv status env$)
@@ -353,12 +540,16 @@
(implies (syntaxp (not (equal env$ ''nil)))
(equal (sat formula env$ :config config)
(sat formula nil :config config))))
+
(defthm sat-when-sat
- (implies (eq (mv-nth 0 (sat formula env$ :config config)) :sat)
- (equal (eval-formula formula (mv-nth 1 (sat formula env$ :config config))) 1)))
+ (b* (((mv status new-env$) (sat formula env$ :config config)))
+ (implies (equal status :sat)
+ (equal (eval-formula formula new-env$) 1))))
+
(defthm sat-when-unsat
- (implies (equal (eval-formula formula env) 1)
- (not (equal (mv-nth 0 (sat formula env$ :config config)) :unsat)))
+ (b* (((mv status &) (sat formula env$ :config config)))
+ (implies (equal (eval-formula formula env) 1)
+ (not (equal status :unsat))))
:hints (("goal" :use ((:instance satlink-run-fn-unsat-claim
(env$ nil)))))))
@@ -374,4 +565,4 @@
(b* (((mv ans env$) (sat '((1 2)) env$)))
(mv nil `(value-triple ,ans) state env$)))
-||#
\ No newline at end of file
+||#
diff -Nru acl2-6.2/books/centaur/tutorial/booth-support.lisp acl2-6.3/books/centaur/tutorial/booth-support.lisp
--- acl2-6.2/books/centaur/tutorial/booth-support.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/tutorial/booth-support.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,268 @@
+; Centaur Hardware Verification Tutorial
+; Copyright (C) 2012 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+; Jared Davis
+
+
+(in-package "ACL2")
+
+(local (include-book "centaur/bitops/ihs-extensions" :dir :System))
+(local (include-book "arithmetic/top-with-meta" :dir :system))
+(include-book "ihs/basic-definitions" :dir :system)
+(include-book "tools/bstar" :dir :system)
+
+(defun booth-enc-one (a b)
+ (+ (if (logbitp 0 a) b 0)
+ (if (logbitp 1 a) b 0)
+ (if (logbitp 2 a) (* -2 b) 0)))
+
+(local
+ (progn
+ (defund booth-enc-coeff (a)
+ (+ (logcar a)
+ (logext 2 (logcdr a))))
+
+ (defthm booth-enc-one-redef
+ (equal (booth-enc-one a b)
+ (* (booth-enc-coeff a)
+ b))
+ :hints(("Goal" :expand ((:free (n a) (logext n a))
+ (:free (n a) (logbitp n a)))
+ :in-theory (enable booth-enc-coeff))))
+
+
+
+
+ (defthmd booth-enc-one-impl
+ (implies (integerp b)
+ (equal (booth-enc-one a b)
+ (b* ((bsign (if (logbitp 2 a) (- b) b))
+ (shft (iff (logbitp 0 a) (logbitp 1 a)))
+ (zro (and shft (iff (logbitp 1 a) (logbitp 2 a))))
+ (res1 (if zro 0 bsign)))
+ (if shft (* 2 res1) res1))))
+ :hints(("Goal" :in-theory (disable booth-enc-one-redef))))
+
+
+ (local (in-theory (disable booth-enc-one)))
+
+ (defun booth-sum (n a b)
+ (if (zp n)
+ 0
+ (+ (booth-enc-one a b)
+ (* 4 (booth-sum (1- n) (logtail 2 a) b)))))
+
+
+ (local
+ (progn
+ (encapsulate nil
+ (local (defthm floor-1
+ (implies (integerp x)
+ (equal (floor x 1) x))
+ :hints(("Goal" :in-theory (enable floor)))))
+ (local (defthm logcar-of-ash-2
+ (equal (logcar (ash n 2)) 0)
+ :hints(("Goal" :in-theory (enable ash**)))))
+ (defthm logcar-of-*-4
+ (implies (integerp n)
+ (equal (logcar (* 4 n)) 0))
+ :hints (("goal" :use logcar-of-ash-2
+ :in-theory (enable ash))))
+
+ (local (defthm logcdr-of-ash-2
+ (equal (logcdr (ash n 2)) (ash n 1))
+ :hints(("Goal" :in-theory (enable ash**)))))
+ (defthm logcdr-of-*-4
+ (implies (integerp n)
+ (equal (logcdr (* 4 n))
+ (* 2 n)))
+ :hints (("goal" :use logcdr-of-ash-2
+ :in-theory (enable ash)))))
+
+ (defthm logcar-of-logext
+ (equal (logcar (logext n a))
+ (logcar a))
+ :hints(("Goal" :in-theory (enable* ihsext-inductions
+ ihsext-recursive-redefs))))
+
+ (defthm sum-negative-prods
+ (implies (syntaxp (and (quotep a) (quotep b)))
+ (equal (+ (- (* a n)) (* b n) c)
+ (+ (* (- b a) n) c))))))
+
+ (local (in-theory (disable logext-identity
+ logtail-identity)))
+
+ (defthm booth-sum-is-multiply
+ (implies (integerp b)
+ (equal (booth-sum n a b)
+ (let ((m (logext (+ 1 (* 2 (nfix n))) a)))
+ (* (+ (logcdr m) (logcar m)) b))))
+ :hints(("Goal" :in-theory (e/d* (logcons booth-enc-coeff)
+ ((:d booth-sum)))
+ :induct (booth-sum n a b)
+ :expand ((booth-sum n a b)
+ (:free (a) (logext 1 a))
+ (:free (a) (logext 2 a))
+ (:free (a) (logext (* 2 n) a))
+ (:free (a) (logext (+ 1 (* 2 n)) a))
+ (:free (a) (logbitp 0 a))
+ (:free (a) (logbitp 1 a))
+ (:free (a) (logbitp 2 a))
+ (:free (a) (logtail 0 a))
+ (:free (a) (logtail 1 a))
+ (:free (a) (logtail 2 a))))
+ (and stable-under-simplificationp
+ `(:use ((:instance logcar-logcdr-elim
+ (i (logext (+ -1 (* 2 n)) (logcdr (logcdr a))))))))))
+
+
+
+ (defund booth-sum-impl1 (n i a b)
+ (if (zp n)
+ 0
+ (+ (ash (booth-enc-one (ash a (- 1 (* 2 i))) b) (* 2 i))
+ (booth-sum-impl1 (1- n) (+ 1 i) a b))))
+
+ (local (defthm integerp-expt-when-not-negp
+ (implies (and (not (negp i))
+ (integerp b))
+ (integerp (expt b i)))
+ :hints(("Goal" :in-theory (enable expt)))
+ :rule-classes :type-prescription))
+
+ (local (defthm floor-1-when-integer
+ (implies (integerp i)
+ (equal (floor i 1) i))
+ :hints(("Goal" :in-theory (enable floor)))))
+
+ (local (defthmd left-shift-to-expt
+ (implies (not (negp shift))
+ (equal (ash i shift)
+ (* (ifix i) (expt 2 shift))))
+ :hints(("Goal" :in-theory (enable ash)))))
+
+ (defthm booth-enc-one-integerp
+ (implies (integerp b)
+ (integerp (booth-enc-one a b)))
+ :hints(("Goal" :in-theory (enable booth-enc-one)))
+ :rule-classes :type-prescription)
+
+ (defthm booth-sum-integerp
+ (implies (integerp b)
+ (integerp (booth-sum n a b)))
+ :hints(("Goal" :in-theory (enable booth-sum)))
+ :rule-classes :type-prescription)
+
+ (defthm booth-sum-impl1-is-booth-sum
+ (implies (and (natp i)
+ (integerp b))
+ (equal (booth-sum-impl1 n i a b)
+ (ash (booth-sum n (ash a (- 1 (* 2 i))) b) (* 2 i))))
+ :hints(("Goal" :in-theory (e/d (booth-sum booth-sum-impl1 logcons)
+ (booth-enc-one-redef
+ booth-sum-is-multiply))
+ :induct (booth-sum-impl1 n i a b)
+ :expand ((:free (a) (booth-sum n a b))))
+ (and stable-under-simplificationp
+ '(:in-theory (e/d (left-shift-to-expt)
+ (booth-enc-one-redef
+ booth-sum-is-multiply))))))
+
+
+
+ (defthm logext-of-loghead-when-signed-byte-p
+ (implies (signed-byte-p n x)
+ (equal (logext n (loghead n x))
+ x))
+ :hints(("Goal" :in-theory (e/d* (ihsext-recursive-redefs
+ ihsext-inductions)
+ (signed-byte-p)))))
+
+ (defthm booth-enc-coeff-lower-bound
+ (<= -2 (booth-enc-coeff a))
+ :hints(("Goal" :in-theory (enable booth-enc-coeff logcons)
+ :expand ((:free (a) (logext 2 a))
+ (:free (a) (logext 1 a))
+ (:free (a) (logext 0 a)))))
+ :rule-classes :linear)
+
+ (defthm booth-enc-coeff-upper-bound
+ (<= (booth-enc-coeff a) 2)
+ :hints(("Goal" :in-theory (enable booth-enc-coeff logcons)
+ :expand ((:free (a) (logext 2 a))
+ (:free (a) (logext 1 a))
+ (:free (a) (logext 0 a)))))
+ :rule-classes :linear)
+
+
+
+ (local (defthmd minus-of-*
+ (implies (syntaxp (quotep a))
+ (equal (- (* a b))
+ (* (- a) b)))))
+
+ (defthm signed-byte-p-of-booth-enc-one
+ (implies (signed-byte-p (+ -2 n) b)
+ (signed-byte-p n (booth-enc-one a b)))
+ :hints(("Goal" :in-theory (e/d (booth-enc-one-redef)
+ (booth-enc-one
+ exponents-add))
+ :expand ((expt 2 (+ -1 n))
+ (expt 2 (+ -2 n)))
+ :do-not-induct t)
+ (and stable-under-simplificationp
+ '(:cases ((equal (booth-enc-coeff a) -2)
+ (equal (booth-enc-coeff a) -1)
+ (equal (booth-enc-coeff a) 0)
+ (equal (booth-enc-coeff a) 1)
+ (equal (booth-enc-coeff a) 2))))))
+
+ ))
+
+(defund boothmul-pp-spec (sz i a b)
+ (loghead (+ 2 sz) (booth-enc-one (ash a (- 1 (* 2 i)))
+ (logext sz b))))
+
+(defund booth-sum-impl (n i a b sz)
+ (if (zp n)
+ 0
+ (+ (ash (logext (+ 2 sz) (boothmul-pp-spec sz i a b)) (* 2 i))
+ (booth-sum-impl (1- n) (+ 1 i) a b sz))))
+
+(local
+ (defthm booth-sum-impl-is-booth-sum-impl1
+ (implies (posp sz)
+ (equal (booth-sum-impl n i a b sz)
+ (booth-sum-impl1 n i a (logext sz b))))
+ :hints(("Goal" :in-theory (e/d* (booth-sum-impl
+ boothmul-pp-spec
+ booth-sum-impl1)
+ (booth-sum-impl1-is-booth-sum
+ booth-enc-one-redef
+ booth-enc-one
+ signed-byte-p))))))
+
+(defthm booth-sum-impl-is-multiply
+ (implies (and (integerp b)
+ (posp sz)
+ (posp n))
+ (equal (booth-sum-impl n 0 a b sz)
+ (* (logext sz b) (logext (* 2 n) a))))
+ :hints (("goal" :expand ((LOGEXT (+ 1 (* 2 N)) (ASH A 1))))))
diff -Nru acl2-6.2/books/centaur/tutorial/boothmul.lisp acl2-6.3/books/centaur/tutorial/boothmul.lisp
--- acl2-6.2/books/centaur/tutorial/boothmul.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/tutorial/boothmul.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,255 @@
+; Centaur Hardware Verification Tutorial
+; Copyright (C) 2012 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Sol Swords
+; Jared Davis
+
+(in-package "ACL2")
+(include-book "intro")
+(include-book "centaur/gl/bfr-satlink" :dir :system)
+(include-book "booth-support")
+(value-triple (set-max-mem (* 3 (expt 2 30))))
+(value-triple (tshell-ensure))
+; cert_param: (hons-only)
+
+(make-event
+
+; Disabling waterfall parallelism for unknown reasons other than that
+; certification stalls out with it enabled.
+
+ (if (and (hons-enabledp state)
+ (f-get-global 'parallel-execution-enabled state))
+ (er-progn (set-waterfall-parallelism nil)
+ (value '(value-triple nil)))
+ (value '(value-triple nil))))
+
+; (depends-on "boothmul.v")
+(defmodules *boothmul-translation*
+ (vl::make-vl-loadconfig
+ :start-files (list "boothmul.v")))
+
+(defconst *boothmul*
+ (b* ((mods (vl::vl-translation->mods *boothmul-translation*))
+ (boothmul (vl::vl-find-module "boothmul" mods))
+ ((unless boothmul)
+ (er hard? '*boothmul* "Failed to translate boothmul?"))
+ (esim (vl::vl-module->esim boothmul))
+ ((unless (good-esim-modulep esim))
+ (er hard? '*boothmul* "Failed to produce a good esim module")))
+ esim))
+
+(defstv boothmul-direct
+ :mod *boothmul*
+ :inputs '(("a" a)
+ ("b" b))
+ :outputs '(("o" o))
+ :parents (esim-tutorial) ;; xdoc stuff, not needed
+ )
+
+;; This is becoming UNTENABLE
+;; (def-gl-thm boothmul-correct-direct
+;; :hyp (boothmul-direct-autohyps)
+;; :concl (b* ((in-alist (boothmul-direct-autoins))
+;; (out-alist (stv-run (boothmul-direct) in-alist))
+;; (o (cdr (assoc 'o out-alist))))
+;; (equal o (* a b)))
+;; :g-bindings (boothmul-direct-autobinds)
+;; :rule-classes nil)
+
+;; (stv-run (boothmul-direct) (list (cons 'a 3)
+;; (cons 'b 5)))
+
+
+(gl::gl-satlink-mode)
+
+(defstv boothmul-decomp
+ :mod *boothmul*
+ :inputs '(("a" a)
+ ("b" b))
+ :outputs '(("o" o))
+ :internals '(("minusb" minusb)
+ ("temp_1" temp1))
+ :overrides '(("pp0" pp0)
+ ("pp1" pp1)
+ ("pp2" pp2)
+ ("pp3" pp3)
+ ("pp4" pp4)
+ ("pp5" pp5)
+ ("pp6" pp6)
+ ("pp7" pp7))
+ :parents (esim-tutorial) ;; xdoc stuff, not needed
+ )
+
+
+(defun hexify-nums (x)
+ (if (atom x)
+ (if (natp x)
+ (str::hexify x)
+ x)
+ (cons (hexify-nums (car x))
+ (hexify-nums (cdr x)))))
+
+
+(local
+ (progn
+ (defun my-glucose-config ()
+ (declare (xargs :guard t))
+ (satlink::make-config :cmdline "glucose"
+ :verbose t
+ :mintime 1/2
+ :remove-temps t))
+
+ (defattach gl::gl-satlink-config my-glucose-config)))
+; cert_param: (uses-glucose)
+
+
+(def-gl-thm boothmul-pp-correct
+ :hyp (boothmul-decomp-autohyps)
+ :concl (b* ((in-alist (boothmul-decomp-autoins))
+ (out-alist (stv-run (boothmul-decomp) in-alist)))
+ (and (equal (cdr (assoc 'pp0 out-alist)) (boothmul-pp-spec 16 #x0 a b))
+ (equal (cdr (assoc 'pp1 out-alist)) (boothmul-pp-spec 16 #x1 a b))
+ (equal (cdr (assoc 'pp2 out-alist)) (boothmul-pp-spec 16 #x2 a b))
+ (equal (cdr (assoc 'pp3 out-alist)) (boothmul-pp-spec 16 #x3 a b))
+ (equal (cdr (assoc 'pp4 out-alist)) (boothmul-pp-spec 16 #x4 a b))
+ (equal (cdr (assoc 'pp5 out-alist)) (boothmul-pp-spec 16 #x5 a b))
+ (equal (cdr (assoc 'pp6 out-alist)) (boothmul-pp-spec 16 #x6 a b))
+ (equal (cdr (assoc 'pp7 out-alist)) (boothmul-pp-spec 16 #x7 a b))
+ ))
+ :g-bindings (boothmul-decomp-autobinds))
+
+(def-gl-thm boothmul-sum-correct
+ :hyp (boothmul-decomp-autohyps)
+ :concl (b* ((in-alist (boothmul-decomp-autoins))
+ (out-alist (stv-run (boothmul-decomp) in-alist))
+ (o (cdr (assoc 'o out-alist)))
+ (- (cw "o: ~s0~%" (str::hexify o)))
+ (res (loghead 32
+ (+ (ash (logext 18 pp0) #x0)
+ (ash (logext 18 pp1) #x2)
+ (ash (logext 18 pp2) #x4)
+ (ash (logext 18 pp3) #x6)
+ (ash (logext 18 pp4) #x8)
+ (ash (logext 18 pp5) #xa)
+ (ash (logext 18 pp6) #xc)
+ (ash (logext 18 pp7) #xe))))
+ (- (cw "res: ~s0~%" (str::hexify res))))
+ (equal o res))
+ :g-bindings (boothmul-decomp-autobinds))
+
+
+;; these actually slow down the proof below, but cause it to show explicitly
+;; how booth-sum-impl is expanded into the sum of partial-products that we need
+;; below in booth-sum-of-products-correct.
+(local (defund unhide (x) x))
+(local (defthm unhide-hide
+ (equal (unhide (hide x)) x)
+ :hints (("goal" :in-theory (enable unhide)
+ :expand ((:free (x) (hide x)))))))
+(local (defthm booth-sum-impl-redef
+ (equal (booth-sum-impl n i a b sz)
+ (IF (ZP N)
+ 0
+ (+ (ASH (LOGEXT (+ 2 SZ)
+ (BOOTHMUL-PP-SPEC SZ I A B))
+ (* 2 I))
+ (unhide (hide (BOOTH-SUM-IMPL (1- N)
+ (+ 1 I)
+ A B SZ))))))
+ :hints(("Goal" :in-theory (enable booth-sum-impl)))))
+
+;; this wouldn't be a GL theorem, typically, at least for large N
+;; left as a fun arithmetical exercise
+(defthm booth-sum-of-products-correct
+ (implies (boothmul-direct-autohyps)
+ (let ((pp0 (boothmul-pp-spec 16 #x0 a b))
+ (pp1 (boothmul-pp-spec 16 #x1 a b))
+ (pp2 (boothmul-pp-spec 16 #x2 a b))
+ (pp3 (boothmul-pp-spec 16 #x3 a b))
+ (pp4 (boothmul-pp-spec 16 #x4 a b))
+ (pp5 (boothmul-pp-spec 16 #x5 a b))
+ (pp6 (boothmul-pp-spec 16 #x6 a b))
+ (pp7 (boothmul-pp-spec 16 #x7 a b)))
+ (equal (+ (ash (logext 18 pp0) #x0)
+ (ash (logext 18 pp1) #x2)
+ (ash (logext 18 pp2) #x4)
+ (ash (logext 18 pp3) #x6)
+ (ash (logext 18 pp4) #x8)
+ (ash (logext 18 pp5) #xa)
+ (ash (logext 18 pp6) #xc)
+ (ash (logext 18 pp7) #xe))
+ (* (logext 16 a)
+ (logext 16 b)))))
+ :hints (("goal" :use ((:instance booth-sum-impl-is-multiply
+ (n 8) (sz 16)))
+ :in-theory (e/d ()
+ (booth-sum-impl-is-multiply
+ ash
+ signed-byte-p
+ boothmul-pp-spec)))))
+
+
+;; ideally we'd do this as a theorem solely about sexpr composition, but AIG
+;; mode works pretty well too and is easier
+(def-gl-thm boothmul-decomp-is-boothmul
+ :hyp (boothmul-decomp-autohyps)
+ :concl (b* ((in-alist1 (boothmul-decomp-autoins))
+ (out-alist1 (stv-run (boothmul-decomp) in-alist1))
+ ((assocs pp0
+ pp1
+ pp2
+ pp3
+ pp4
+ pp5
+ pp6
+ pp7) out-alist1)
+ (in-alist2 (boothmul-decomp-autoins))
+ (out-alist2 (stv-run (boothmul-decomp) in-alist2))
+ (orig-in-alist (boothmul-direct-autoins))
+ (orig-out-alist (stv-run (boothmul-direct) orig-in-alist)))
+ (equal (cdr (assoc 'o out-alist2))
+ (cdr (assoc 'o orig-out-alist))))
+ :g-bindings (boothmul-decomp-autobinds))
+
+
+(defthm boothmul-pp-spec-bound
+ (< (boothmul-pp-spec 16 i a b) (expt 2 18))
+ :hints(("Goal" :in-theory (enable boothmul-pp-spec)))
+ :rule-classes :linear)
+
+(defthm boothmul-correct
+ (implies (boothmul-direct-autohyps)
+ (b* ((in-alist (boothmul-direct-autoins))
+ (out-alist (stv-run (boothmul-direct) in-alist))
+ (o (cdr (assoc 'o out-alist))))
+ (equal o (loghead 32 (* (logext 16 a) (logext 16 b))))))
+ :hints (("goal" :in-theory (disable stv-run
+ (boothmul-direct) boothmul-direct
+ (boothmul-decomp) boothmul-decomp
+ boothmul-decomp-is-boothmul
+ ash-of-n-0
+ right-shift-to-logtail)
+ :use ((:instance boothmul-decomp-is-boothmul
+ (pp0 0)
+ (pp1 0)
+ (pp2 0)
+ (pp3 0)
+ (pp4 0)
+ (pp5 0)
+ (pp6 0)
+ (pp7 0))))))
diff -Nru acl2-6.2/books/centaur/tutorial/boothmul.v acl2-6.3/books/centaur/tutorial/boothmul.v
--- acl2-6.2/books/centaur/tutorial/boothmul.v 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/tutorial/boothmul.v 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,89 @@
+/*
+
+Centaur Hardware Verification Tutorial
+Copyright (C) 2012-2013 Centaur Technology
+
+Contact:
+ Centaur Technology Formal Verification Group
+ 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+ http://www.centtech.com/
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version. This program is distributed in the hope that it will be useful but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+details. You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+
+Original authors: Sol Swords
+ Jared Davis
+
+*/
+
+
+// assumes minusb = - b.
+// computes pp = b * (signed(abits[2:1]) + abits[0]).
+module boothenc (pp, abits, b, minusb);
+ output [17:0] pp;
+ input [2:0] abits;
+ input [15:0] b;
+ input [16:0] minusb;
+
+ wire [16:0] bsign = abits[2] ? minusb : { b[15], b };
+
+ // is it shifted?
+ wire shft = abits[0] ~^ abits[1];
+
+ // is it zero? (all abits same)
+ wire zro = shft & (abits[2] ~^ abits[1]);
+
+ // result without the shift
+ wire [16:0] res1 = zro ? 16'b0 : bsign;
+
+ // final shift
+ wire [17:0] pp = shft ? { res1, 1'b0 } : { res1[16], res1 };
+
+endmodule
+
+
+
+module boothmul (o, a, b);
+
+ output [31:0] o;
+ input [15:0] a, b;
+
+ wire [16:0] minusb = 17'b1 + ~{ b[15], b };
+
+ wire [17:0] pp0;
+ wire [17:0] pp1;
+ wire [17:0] pp2;
+ wire [17:0] pp3;
+ wire [17:0] pp4;
+ wire [17:0] pp5;
+ wire [17:0] pp6;
+ wire [17:0] pp7;
+
+ boothenc booth0 (pp0, { a[1:0], 1'b0 }, b, minusb);
+ boothenc booth1 (pp1, a[3:1], b, minusb);
+ boothenc booth2 (pp2, a[5:3], b, minusb);
+ boothenc booth3 (pp3, a[7:5], b, minusb);
+ boothenc booth4 (pp4, a[9:7], b, minusb);
+ boothenc booth5 (pp5, a[11:9], b, minusb);
+ boothenc booth6 (pp6, a[13:11], b, minusb);
+ boothenc booth7 (pp7, a[15:13], b, minusb);
+
+ assign o = { {14{pp0[17]}}, pp0 }
+ + { {12{pp1[17]}}, pp1, 2'b0 }
+ + { {10{pp2[17]}}, pp2, 4'b0 }
+ + { {8{pp3[17]}}, pp3, 6'b0 }
+ + { {6{pp4[17]}}, pp4, 8'b0 }
+ + { {4{pp5[17]}}, pp5, 10'b0 }
+ + { {2{pp6[17]}}, pp6, 12'b0 }
+ + { pp7, 14'b0 };
+
+endmodule
+
+
diff -Nru acl2-6.2/books/centaur/tutorial/counter.lisp acl2-6.3/books/centaur/tutorial/counter.lisp
--- acl2-6.2/books/centaur/tutorial/counter.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/tutorial/counter.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -61,13 +61,9 @@
(vl::vl-module->esim *counter-vl*))
-
(defstv counter-run ;; name for this test vector
:mod *counter* ;; the module this vector pertains to
- :initial
- '(("out" init)) ; initial value for the counter
-
:inputs
'(("clk" 0 ~) ; clk will toggle
@@ -88,8 +84,12 @@
; v . v . v . v . v
'(("out" o0 _ o1 _ o2 _ o3 _ o4 _)) ; extract out before each posedge
+ :overrides
+ '(("out" init _)) ; initial value for the counter
+
+
;; I'll use this as a chance to also show off the documentation features.
- :labels '(c0 c1 c1 c2 c2 c3 c3 c4 c4)
+ :labels '(c0 c1 c1 c2 c2 c3 c3 c4 c4 c5)
:parents (esim-tutorial)
:short "Running the counter module"
:long "This is a demo of the defstv documentation stuff. You can see what
@@ -97,8 +97,6 @@
centaur/README.html if you don't know where to look.
")
-
-
; Some basic examples of running the counter.
#||
diff -Nru acl2-6.2/books/centaur/tutorial/sat.lsp acl2-6.3/books/centaur/tutorial/sat.lsp
--- acl2-6.2/books/centaur/tutorial/sat.lsp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/tutorial/sat.lsp 2013-09-30 17:53:14.000000000 +0000
@@ -109,6 +109,8 @@
;
; Glucose version 2.1
; https://www.lri.fr/~simon/?page=glucose
+; Some packages Rager needed in order to build glocuse included:
+; g++ and libc6-dev-i386
;
; But probably most any solver that is part of the SAT Competition should work,
; modulo a few concerns about the input format (see :xdoc satlink::dimacs).
@@ -121,10 +123,10 @@
; The particular SAT solver that SATLINK will call, and other options about,
-; e.g., what kind of debugging information will printed, whether temporary
+; e.g., what kind of debugging information will be printed, whether temporary
; files should be removed, etc., are governed by a configuration object. For
-; details, see :XDOC satlink::config-p. GL will use whatever configuration
-; is returned by:
+; details, see :XDOC satlink::config-p. GL will use whatever configuration is
+; returned by:
(gl::gl-satlink-config)
@@ -186,7 +188,9 @@
'(("opcode" op) ;; verilog name --> inputs we are going to supply
("abus" a) ;; at each phase
("bbus" b)) ;; we only have one phase, so we'll just supply a
- ;; variable for each vector.
+ ;; variable for each vector (note that we do not
+ ;; yet need to specify anything related to the
+ ;; length of the vectors).
:outputs ;; verilog name --> variable names we will use
'(("out" res)))
diff -Nru acl2-6.2/books/centaur/ubdds/core.lisp acl2-6.3/books/centaur/ubdds/core.lisp
--- acl2-6.2/books/centaur/ubdds/core.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/ubdds/core.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -28,7 +28,10 @@
(include-book "xdoc/top" :dir :system)
(defxdoc ubdds
- :short "A BDD package implemented with @(see hons-and-memoization)."
+ :parents (boolean-reasoning)
+ :short "A @(see hons)-based, unlabeled Binary Decision
+Diagram (bdd) representation of Boolean functions."
:long "UBDDs (\"unlabeled bdds\") are a concise and efficient
implementation of binary decision diagrams. Unlike most BDD packages, our
diff -Nru acl2-6.2/books/centaur/ubdds/deps.lisp acl2-6.3/books/centaur/ubdds/deps.lisp
--- acl2-6.2/books/centaur/ubdds/deps.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/ubdds/deps.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -0,0 +1,220 @@
+; UBDD Library
+; Copyright (C) 2008-2011 Warren Hunt and Bob Boyer
+; Significantly revised in 2008 by Jared Davis and Sol Swords.
+; Now maintained by Centaur Technology.
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+
+; deps.lisp - tracking variable dependencies of BDDs
+
+(in-package "ACL2")
+(include-book "extra-operations")
+
+
+;; UBDD-DEPS: Produce a list of Ts and NILs indicating which variables the input
+;; BDD depends on.
+
+(defn or-lists (x y)
+ (if (atom x)
+ y
+ (if (atom y) x
+ (cons (or (car x) (car y))
+ (or-lists (cdr x) (cdr y))))))
+
+(defthm nth-of-or-lists
+ (equal (nth n (or-lists x y))
+ (or (nth n x) (nth n y))))
+
+(in-theory (disable or-lists))
+
+
+(defn ubdd-deps (x)
+ (if (atom x)
+ nil
+ (cons (not (hons-equal (car x) (cdr x)))
+ (or-lists (ubdd-deps (car x)) (ubdd-deps (cdr x))))))
+
+(memoize 'ubdd-deps :condition '(consp x))
+
+(in-theory (disable ubdd-deps))
+
+(local (defun eval-ubdd-deps-ind (x n env)
+ (if (atom x)
+ (list n env)
+ (if (car env)
+ (eval-ubdd-deps-ind (car x) (1- n) (cdr env))
+ (eval-ubdd-deps-ind (cdr x) (1- n) (cdr env))))))
+
+(defthm eval-bdd-of-update-when-not-dependent
+ (implies (not (nth n (ubdd-deps x)))
+ (equal (eval-bdd x (update-nth n v env))
+ (eval-bdd x env)))
+ :hints (("goal" :induct (eval-ubdd-deps-ind x n env)
+ :in-theory (enable (:i eval-bdd))
+ :expand ((:free (env) (eval-bdd x env))
+ (ubdd-deps x)
+ (:free (a b) (nth n (cons a b)))))))
+
+(local (defun bdd-deps-ind (x n)
+ (if (zp n)
+ x
+ (list (bdd-deps-ind (car x) (1- n))
+ (bdd-deps-ind (cdr x) (1- n))))))
+
+(local (defun 2bdd-deps-ind (x y n)
+ (if (zp n)
+ (list x y)
+ (list (2bdd-deps-ind (car x) (car y) (1- n))
+ (2bdd-deps-ind (cdr x) (cdr y) (1- n))))))
+
+(local (defun q-ite-deps-ind (x y z n)
+ (declare (xargs :measure (nfix n)))
+ (if (zp n)
+ (list x y z)
+ (list (q-ite-deps-ind (car x)
+ (if (hons-equal x y) t (qcar y))
+ (if (hons-equal x z) nil (qcar z))
+ (1- n))
+ (q-ite-deps-ind (cdr x)
+ (if (hons-equal x y) t (qcdr y))
+ (if (hons-equal x z) nil (qcdr z))
+ (1- n))))))
+
+
+(local (in-theory (disable equal-of-booleans-rewrite)))
+
+(local (defthm nth-ubdd-deps-of-qcons
+ (equal (nth n (ubdd-deps (qcons x y)))
+ (if (zp n)
+ (not (equal x y))
+ (nth (1- n) (or-lists (ubdd-deps x) (ubdd-deps y)))))
+ :hints(("Goal" :in-theory (enable ubdd-deps)))))
+
+(local (defthm nth-ubdd-deps-of-cons
+ (equal (nth n (ubdd-deps (cons x y)))
+ (if (zp n)
+ (not (equal x y))
+ (nth (1- n) (or-lists (ubdd-deps x) (ubdd-deps y)))))
+ :hints(("Goal" :in-theory (enable ubdd-deps)))))
+
+(local (defthm nth-of-ubdd-deps-when-zp
+ (implies (and (syntaxp (symbolp x))
+ (zp n))
+ (equal (nth n (ubdd-deps x))
+ (not (equal (car x) (cdr x)))))
+ :hints(("Goal" :in-theory (enable ubdd-deps)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+(local (defthm nth-of-ubdd-deps-when-not-zp
+ (implies (and (syntaxp (symbolp x))
+ (not (zp n)))
+ (equal (nth n (ubdd-deps x))
+ (nth (1- n) (or-lists
+ (ubdd-deps (car x))
+ (ubdd-deps (cdr x))))))
+ :hints(("Goal" :in-theory (enable ubdd-deps)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0))))
+
+
+(local (in-theory (disable qcons nth)))
+
+(local (defthm nth-of-nil
+ (not (nth n nil))
+ :hints(("Goal" :in-theory (enable nth)))))
+
+(local (defthm or-lists-identical
+ (equal (or-lists x x)
+ x)
+ :hints(("Goal" :in-theory (enable or-lists)))))
+
+(defthm ubdd-deps-of-qv
+ (equal (ubdd-deps (qv n))
+ (update-nth n t nil))
+ :hints(("Goal" :in-theory (enable (:i qv))
+ :induct (qv n)
+ :expand ((qv n)
+ (:free (x y) (ubdd-deps (cons x y)))))))
+
+;; BOZO may also prove that if (nth n (ubdd-deps x)) and (ubddp x), then there
+;; exists some env, v under which
+;; (eval-bdd x env) != (eval-bdd x (update-nth n v env)).
+
+;; Stronger theorems may be proved provided X is ubddp. At the moment I'll
+;; just prove simple conservative stuff.
+
+(defthm q-not-no-new-deps
+ (implies (not (nth n (ubdd-deps x)))
+ (not (nth n (ubdd-deps (q-not x)))))
+ :hints (("goal" :induct (bdd-deps-ind x n))))
+
+
+(defthm q-and-no-new-deps
+ (implies (and (not (nth n (ubdd-deps x)))
+ (not (nth n (ubdd-deps y))))
+ (not (nth n (ubdd-deps (q-binary-and x y)))))
+ :hints (("goal" :induct (2bdd-deps-ind x y n)
+ :in-theory (disable (force))
+ :expand ((q-binary-and x y)))))
+
+(defthm q-or-no-new-deps
+ (implies (and (not (nth n (ubdd-deps x)))
+ (not (nth n (ubdd-deps y))))
+ (not (nth n (ubdd-deps (q-binary-or x y)))))
+ :hints (("goal" :induct (2bdd-deps-ind x y n)
+ :in-theory (disable (force))
+ :expand ((q-binary-or x y)))))
+
+
+(defthm q-xor-no-new-deps
+ (implies (and (not (nth n (ubdd-deps x)))
+ (not (nth n (ubdd-deps y))))
+ (not (nth n (ubdd-deps (q-binary-xor x y)))))
+ :hints (("goal" :induct (2bdd-deps-ind x y n)
+ :in-theory (disable (force))
+ :expand ((q-binary-xor x y)))))
+
+(defthm q-iff-no-new-deps
+ (implies (and (not (nth n (ubdd-deps x)))
+ (not (nth n (ubdd-deps y))))
+ (not (nth n (ubdd-deps (q-binary-iff x y)))))
+ :hints (("goal" :induct (2bdd-deps-ind x y n)
+ :in-theory (disable (force))
+ :expand ((q-binary-iff x y)))))
+
+(defthm ubdd-deps-of-atom
+ (implies (not (consp x))
+ (equal (ubdd-deps x) nil))
+ :hints(("Goal" :in-theory (enable ubdd-deps)))
+ :rule-classes ((:rewrite :backchain-limit-lst 0)))
+
+; Added by Matt K., 9/28/2013, to get around ACL2(hp) error such as:
+; Error: Not owner of hash table #
+; David Rager points out (email, 9/28/2013) that "memoization is known
+; not to be thread-safe"; Jared Davis says this too. (Perhaps this will be
+; addressed in the future.)
+(local (unmemoize 'ubdd-deps))
+
+(defthm q-ite-no-new-deps
+ (implies (and (not (nth n (ubdd-deps x)))
+ (not (nth n (ubdd-deps y)))
+ (not (nth n (ubdd-deps z))))
+ (not (nth n (ubdd-deps (q-ite-fn x y z)))))
+ :hints (("goal" :induct (q-ite-deps-ind x y z n)
+ :in-theory (disable (force))
+ :expand ((q-ite-fn x y z)
+ (:free (a b) (nth n (cons a b)))))))
+
+
diff -Nru acl2-6.2/books/centaur/ubdds/extra-operations.lisp acl2-6.3/books/centaur/ubdds/extra-operations.lisp
--- acl2-6.2/books/centaur/ubdds/extra-operations.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/ubdds/extra-operations.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -1498,6 +1498,8 @@
(local (in-theory (enable ubdd-fix)))
+ (memoize 'ubdd-fix :condition '(consp x))
+
(defthm ubddp-ubdd-fix
(ubddp (ubdd-fix x))
:hints(("Goal" :in-theory (enable ubddp))))
diff -Nru acl2-6.2/books/centaur/ubdds/param.lisp acl2-6.3/books/centaur/ubdds/param.lisp
--- acl2-6.2/books/centaur/ubdds/param.lisp 2013-06-06 17:11:47.000000000 +0000
+++ acl2-6.3/books/centaur/ubdds/param.lisp 2013-09-30 17:53:14.000000000 +0000
@@ -29,14 +29,14 @@
(local (include-book "arithmetic/top" :dir :system))
-(in-theory (disable* default-car default-cdr ;; blp-implies-t
- default-+-2 default-+-1 default-<-2 default-<-1
- (:ruleset canonicalize-to-q-ite)
- equal-by-eval-bdds
- ))
+(local (in-theory (disable* default-car default-cdr ;; blp-implies-t
+ default-+-2 default-+-1 default-<-2 default-<-1
+ (:ruleset canonicalize-to-q-ite)
+ equal-by-eval-bdds
+ )))
-(in-theory (enable eval-bdd eval-bdd-list ubddp ubdd-listp
- q-compose q-compose-list))
+(local (in-theory (enable eval-bdd eval-bdd-list ubddp ubdd-listp
+ q-compose q-compose-list)))
(make-event
@@ -147,8 +147,7 @@
;; more. 2) only holds for variable assignments of length NVARS.
(defn q-param (x nvars)
(cond ((zp (nfix nvars)) nil)
- ((atom x) (if x (qv-list 0 1 nvars)
- (make-list-ac nvars nil nil)))
+ ((atom x) (qv-list 0 1 nvars))
((not (car x))
(cons nil (q-param (cdr x) (1- nvars))))
((not (cdr x))
@@ -709,7 +708,7 @@
(memoize 'from-param-space :condition '(or (consp p) (consp y)))
(defn to-param-space (p y)
- (cond ((atom p) (if p y nil))
+ (cond ((atom p) y)
((atom y) y)
((eq (car p) nil)
(to-param-space (cdr p) (cdr y)))
@@ -734,8 +733,8 @@
(defun param-env (p env)
(declare (xargs :guard t))
- (cond ((atom env) nil)
- ((atom p) env)
+ (cond ((atom p) env)
+ ((atom env) nil)
((eq (car p) nil) (param-env (cdr p) (cdr env)))
((eq (cdr p) nil) (param-env (car p) (cdr env)))
((car env) (cons t (param-env (car p) (cdr env))))
@@ -759,10 +758,35 @@
(cons car (unparam-env (if car (car p) (cdr p))
cdr))))))
+
+(encapsulate
+ nil
+ (local (defun ind (x p env)
+ (if (consp x)
+ (if (consp p)
+ (if (car p)
+ (if (cdr p)
+ (if (car env)
+ (ind (car x) (car p) (cdr env))
+ (ind (cdr x) (cdr p) (cdr env)))
+ (ind x (car p) env))
+ (ind x (cdr p) env))
+ x)
+ env)))
+
+ (defthm eval-param-env-of-unparam-env
+ (equal (eval-bdd x (param-env p (unparam-env p env)))
+ (eval-bdd x env))
+ :hints (("goal" :induct (ind x p env)
+ :in-theory (enable default-car default-cdr))
+ (and stable-under-simplificationp
+ '(:expand ((:free (env) (eval-bdd x env))))))))
+
(defthm eval-with-unparam-env
(implies (and p (ubddp p))
(eval-bdd p (unparam-env p env))))
+
(defun unparam-env-ind (x p env)
(cond ((atom p) (list x env))
((eq (car p) nil) (unparam-env-ind (cdr x) (cdr p) env))
@@ -772,15 +796,20 @@
(cdr env)))))
(defthmd unparam-env-to-param-space
- (implies (and p (ubddp p))
- (equal (eval-bdd (to-param-space p x) env)
- (eval-bdd x (unparam-env p env))))
+ (equal (eval-bdd (to-param-space p x) env)
+ (eval-bdd x (unparam-env p env)))
:hints (("goal" :induct (unparam-env-ind x p env)
:expand ((:free (env) (eval-bdd x env))
(:free (env) (unparam-env p env)))
:in-theory (enable default-car default-cdr))))
-
+(defthm unparam-env-of-param-env
+ (implies (eval-bdd p env)
+ (equal (eval-bdd x (unparam-env p (param-env p env)))
+ (eval-bdd x env)))
+ :hints (("goal" :use ((:instance param-env-to-param-space)
+ (:instance unparam-env-to-param-space
+ (env (param-env p env)))))))
(defn to-param-space-list (p list)
(if (atom list)
@@ -912,6 +941,47 @@
:hints (("goal" :induct (to-param-space p x)
:in-theory (e/d (q-and) (ubddp)))))
+(defthm eval-bdd-of-qcons
+ (equal (eval-bdd (qcons x y) env)
+ (if (car env)
+ (eval-bdd x (cdr env))
+ (eval-bdd y (cdr env)))))
+
+(defun to-from-ind (p x env)
+ (if (consp p)
+ (cond ((eq (car p) nil)
+ (and (not (car env))
+ (to-from-ind (cdr p) (cdr x) (cdr env))))
+ ((eq (cdr p) nil)
+ (and (car env)
+ (to-from-ind (car p) (car x) (cdr env))))
+ (t (list (to-from-ind (car p) (car x) (cdr env))
+ (to-from-ind (cdr p) (cdr x) (cdr env)))))
+ (list p x env)))
+
+
+(defthm from-param-space-of-qcons
+ (implies (and (car p) (cdr p))
+ (equal (from-param-space p (qcons x y))
+ (if (atom (qcons x y))
+ (and x p)
+ (qcons (from-param-space (car p) x)
+ (from-param-space (cdr p) y)))))
+ :otf-flg t)
+
+(defthm consp-qcons
+ (equal (consp (qcons x y))
+ (not (and (booleanp x)
+ (equal x y)))))
+
+(defthm to-from-param-space-eval
+ (equal (eval-bdd (from-param-space p (to-param-space p x)) env)
+ (and (eval-bdd p env)
+ (eval-bdd x env)))
+ :hints (("goal" :induct (to-from-ind p x env)
+ :in-theory (disable qcons))))
+
+
(defthm to-param-space-self
(implies (and (ubddp p) p)
(equal (to-param-space p p) t))
@@ -924,3 +994,23 @@
x))
:hints (("goal" :induct (from-param-space p x)
:in-theory (e/d (q-and) (ubddp)))))
+
+
+
+(defun param-env-ind (x p env)
+ (cond ((atom p) (list x env))
+ ((eq (car p) nil) (param-env-ind x (cdr p) (cdr env)))
+ ((eq (cdr p) nil) (param-env-ind x (car p) (cdr env)))
+ ((car env) (cons t (param-env-ind (car x) (car p) (cdr env))))
+ (t (cons nil (param-env-ind (cdr x) (cdr p) (cdr env))))))
+
+(defthm eval-of-from-param-space
+ (implies (eval-bdd p env)
+ (equal (eval-bdd (from-param-space p x)
+ env)
+ (eval-bdd x (param-env p env))))
+ :hints (("goal" :induct (param-env-ind x p env)
+ :expand ((from-param-space p x)
+ (unparam-env p env)
+ (:free (env) (eval-bdd x env))
+ (eval-bdd p env)))))
diff -Nru acl2-6.2/books/centaur/vcd/esim-snapshot.lisp acl2-6.3/books/centaur/vcd/esim-snapshot.lisp
--- acl2-6.2/books/centaur/vcd/esim-snapshot.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/vcd/esim-snapshot.lisp 2013-09-30 17:53:15.000000000 +0000
@@ -56,7 +56,7 @@
;
; If you want to directly use the resulting alist in a VCD dump, you'll have to
; make sure your values are valid for VCD-DUMP, e.g., they can be concrete
-; FAIGS like *4f*, S-expressions like *4vf*, or results from OT like the
+; FAIGS like (faig-f), S-expressions like *4vf*, or results from OT like the
; symbols T, NIL, X, or U.
;
; However, MOD-VCD-SNAPSHOT doesn't care what values are being used, so for
diff -Nru acl2-6.2/books/centaur/vcd/vcd-impl.lisp acl2-6.3/books/centaur/vcd/vcd-impl.lisp
--- acl2-6.2/books/centaur/vcd/vcd-impl.lisp 2013-06-06 17:11:48.000000000 +0000
+++ acl2-6.3/books/centaur/vcd/vcd-impl.lisp 2013-09-30 17:53:15.000000000 +0000
@@ -22,7 +22,7 @@
(include-book "vcd-stub")
(include-book "oslib/date" :dir :system)
(include-book "centaur/misc/tshell" :dir :system)
-(include-book "centaur/aig/three-four" :dir :system)
+(include-book "centaur/aig/faig-constructors" :dir :system)
(include-book "centaur/misc/hons-extra" :dir :system)
(include-book "centaur/vl/util/print" :dir :system)
(include-book "centaur/vl/toe/toe-emodwire" :dir :system)
@@ -71,7 +71,7 @@
; The VALUE bound to each name may be:
;
; - Concrete FAIGs
-; i.e., *4f*, *4t*, *4x*, or *4z*
+; i.e., (faig-f), (faig-t), (faig-x), or (faig-z)
;
; - Concrete S-Expression Results
; i.e., *4vf*, *4vt*, *4vx*, or *4vz* ('F, 'T, 'X, 'Z)
@@ -147,7 +147,7 @@
(implies (string-listp x)
(iff (first (last x))
(consp x)))
- :hints(("Goal" :in-theory (disable (force)))))
+ :hints(("Goal" :in-theory (e/d (last) ((force))))))
(defthm stringp-of-car-when-string-listp
(implies (string-listp x)
@@ -306,10 +306,10 @@
(defund vcd-value-p (x)
(declare (xargs :guard t))
(if (consp x)
- (or (equal x acl2::*4f*)
- (equal x acl2::*4t*)
- (equal x acl2::*4x*)
- (equal x acl2::*4z*))
+ (or (equal x (acl2::faig-f))
+ (equal x (acl2::faig-t))
+ (equal x (acl2::faig-x))
+ (equal x (acl2::faig-z)))
(or (eq x nil)
(eq x 'acl2::f)
(eq x t)
@@ -323,10 +323,10 @@
(er hard? 'vcd-value->char "Not a vcd-value-p: ~x0." x)
#\x)
((when (consp x))
- (cond ((equal x acl2::*4f*) #\0)
- ((equal x acl2::*4t*) #\1)
- ((equal x acl2::*4z*) #\z)
- (t #\x))))
+ (cond ((equal x (acl2::faig-f)) #\0)
+ ((equal x (acl2::faig-t)) #\1)
+ ((equal x (acl2::faig-z)) #\z)
+ (t #\x))))
(case x
((nil acl2::f) #\0)
((t) #\1)
@@ -341,10 +341,10 @@
(assert! (equal (vcd-value->char 'acl2::x) #\x))
(assert! (equal (vcd-value->char 'acl2::z) #\z))
(assert! (equal (vcd-value->char 'acl2::u) #\z))
- (assert! (equal (vcd-value->char acl2::*4f*) #\0))
- (assert! (equal (vcd-value->char acl2::*4t*) #\1))
- (assert! (equal (vcd-value->char acl2::*4x*) #\x))
- (assert! (equal (vcd-value->char acl2::*4z*) #\z)))))
+ (assert! (equal (vcd-value->char (acl2::faig-f)) #\0))
+ (assert! (equal (vcd-value->char (acl2::faig-t)) #\1))
+ (assert! (equal (vcd-value->char (acl2::faig-x)) #\x))
+ (assert! (equal (vcd-value->char (acl2::faig-z)) #\z)))))
(defsection vcd-valuelist-p
@@ -1826,4 +1826,4 @@
(progn!
(set-raw-mode t)
(defun vcd-dump-fn (filename snapshots viewer emap state)
- (vcd-dump-fn-real filename snapshots viewer emap state)))
\ No newline at end of file
+ (vcd-dump-fn-real filename snapshots viewer emap state)))
diff -Nru acl2-6.2/books/centaur/vl/Makefile acl2-6.3/books/centaur/vl/Makefile
--- acl2-6.2/books/centaur/vl/Makefile 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/Makefile 1970-01-01 00:00:00.000000000 +0000
@@ -1,46 +0,0 @@
-# ACL2 ?= ../../acl2/saved_acl2
-# include ../../acl2/books/Makefile-generic
-#
-# # Dependencies:
-#
-# BOOKS := $(filter-out acl2-customization,$(BOOKS))
-# ACL2_COMPILE_FLG := t :ttags :all :skip-proofs-okp t
-#
-# LISPFILES = $(wildcard *.lisp)
-# LSPFILES = $(wildcard *.lsp)
-# ACL2FILES = $(wildcard *.acl2)
-#
-# TAGS: $(LISPFILES)
-# etags *.lisp
-#
-# -include Makefile-deps
-
-
-.PHONY: all full clean TAGS
-
-all:
- @echo "Use cert.pl to build"
- @echo "Or use 'make full', which runs 'cert.pl -j 8' to build VL."
- @echo ""
-
-allbooks:
- cert.pl -j 8 top.cert lint/lint.cert
-
-full: allbooks
-
-TAGS:
- @echo "Building TAGS"
- etags `find . -name "*.lisp"` `find . -name "*.lsp"` `find . -name "*.acl2"`
-
-CLEANFILES := *.cert *.lx64fsl *.out *.time *~
-
-clean:
- rm -f $(CLEANFILES) TAGS
- cd loader; rm -f $(CLEANFILES)
- cd util; rm -f $(CLEANFILES)
- cd transforms; rm -f $(CLEANFILES)
- cd transforms/occform; rm -f $(CLEANFILES)
- cd checkers; rm -f $(CLEANFILES)
- cd mlib; rm -f $(CLEANFILES)
- cd lint -f $(CLEANFILES)
-
diff -Nru acl2-6.2/books/centaur/vl/README acl2-6.3/books/centaur/vl/README
--- acl2-6.2/books/centaur/vl/README 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/README 2013-09-30 17:53:10.000000000 +0000
@@ -90,13 +90,18 @@
* provides the defmodules command
+vl/kit/ -- VL as a command-line program
+
+ * this is where the "vl" program gets generated from
+
+vl/bin
MISCELLANEOUS STUFF
vl/lint/ -- a basic Verilog linter
-vl/doc/ -- a couple of (old) presentations about VL
+vl/talks/ -- some old talks about VL
-vl/wf-*.lisp -- well-formedness checks
+vl/wf-*.lisp -- well-formedness checks (mostly old)
diff -Nru acl2-6.2/books/centaur/vl/checkers/condcheck.lisp acl2-6.3/books/centaur/vl/checkers/condcheck.lisp
--- acl2-6.2/books/centaur/vl/checkers/condcheck.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/checkers/condcheck.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -320,8 +320,8 @@
(define vl-exprctxalist-condcheck ((x vl-exprctxalist-p))
:returns (warnings vl-warninglist-p)
:parents (condcheck)
- :short "@(call vl-exprctxalist-condcheck) extends @(see
-vl-expr-condcheck-check) across an @(see vl-exprctxalist-p)."
+ :short "@(call vl-exprctxalist-condcheck) extends @(see vl-expr-condcheck)
+across an @(see vl-exprctxalist-p)."
(if (atom x)
nil
diff -Nru acl2-6.2/books/centaur/vl/checkers/dupeinst-check.lisp acl2-6.3/books/centaur/vl/checkers/dupeinst-check.lisp
--- acl2-6.2/books/centaur/vl/checkers/dupeinst-check.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/checkers/dupeinst-check.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -1,5 +1,5 @@
; VL Verilog Toolkit
-; Copyright (C) 2008-2011 Centaur Technology
+; Copyright (C) 2008-2013 Centaur Technology
;
; Contact:
; Centaur Technology Formal Verification Group
@@ -23,6 +23,7 @@
(include-book "duplicate-detect")
(local (include-book "../util/arithmetic"))
+
(defxdoc dupeinst-check
:parents (checkers)
:short "Check for module instances that are driving wires in identical ways."
@@ -46,46 +47,47 @@
want to identify and eliminate. For instance, it's especially useful to
eliminate redundant registers, to improve power usage.
")
+
(defaggregate vl-dupeinst-key
- (modname inputs)
- :tag :vl-dupeinst-key
- :require ((vl-exprlist-p-of-vl-dupeinst-key->inputs
- (vl-exprlist-p inputs))
- (stringp-of-vl-dupeinst-key->modname
- (stringp modname)
- :rule-classes :type-prescription))
:parents (dupeinst-check)
:short "Keys used to determine if module instances have the same inputs."
+ ((modname stringp :rule-classes :type-prescription
+ "Name of the submodule being instantiated. We need to know the
+ name of each instance so that we don't get confused by things
+ like
+
+ @({
+ mymod1 m1 (o1, a, b);
+ mymod2 m2 (o2, a, b);
+ })
+
+ which, despite having the same arguments, are presumably very
+ different things.")
+
+ (inputs vl-exprlist-p
+ "Inputs (not outputs or inouts) to the submodule instance. We
+ expect instances to be argresolved so that these are already in
+ some canonical order. We just keep the expressions because we
+ don't care about port names, directions, etc. We also expect all
+ of these expressions to be fixed so that attributes are
+ ignored."))
+
:long "We generate a key from each modinst. Modinsts with the same keys
are regarded as having the same inputs. That is, the whole point of the
dupeinst check is to find modinsts with the same key.
-The keys we use have to know the modname so we don't get confused by things
-like
-
-@({
- mymod1 m1 (o1, a, b);
- mymod2 m2 (o2, a, b);
-})
-
-Which presumably have the same inputs but are very different things.
-
-They also include the expressions for the inputs. We expect instances to be
-argresolved so that these are already in some canonical order. We just keep
-the expressions because we don't care about port names, directions, etc. We
-also expect all of these expressions to be fixed so that attributes are
-ignored.
-
-Our keys should arguably include the params. But if the inputs are the
-same, then the params should probably be the same or, at any rate, seem
-basically compatible? Well, whatever. It's questionable, but probably doesn't
-matter much at all in practice.
+Our keys should arguably include the parameter arguments. But if the inputs
+are the same, then the parameters should probably be the same or, at any rate,
+seem basically compatible? Well, whatever. It probably doesn't matter much at
+all in practice.
We always hons keys because we're going to use them as fast alist keys.
"
+ :tag :vl-dupeinst-key
:hons t)
+
(defalist vl-dupeinst-alistp (x)
:key (vl-dupeinst-key-p x)
:val (vl-modinstlist-p x)
@@ -97,90 +99,61 @@
@(def vl-dupeinst-alistp)")
-(defsection vl-make-dupeinst-alist
- :parents (dupeinst-check)
- :short "Builds the @(see vl-dupeinst-alistp) for a list of assignments."
-
- (defund vl-make-dupeinst-alist-aux (x alist)
- (declare (xargs :guard (and (vl-modinstlist-p x)
- (vl-dupeinst-alistp alist))))
- (b* (((when (atom x))
- alist)
- (x1 (car x))
- ((vl-modinst x1) x1)
-
- ((when (vl-arguments->namedp x1.portargs))
- ;; Args not resolved, skip it
- (vl-make-dupeinst-alist-aux (cdr x) alist))
-
- ((mv inputs ?outputs inouts unknowns)
- (vl-partition-plainargs (vl-arguments->args x1.portargs) nil nil nil nil))
-
- ((unless (and (atom inouts)
- (atom unknowns)))
- ;; Too hard, skip it
- (vl-make-dupeinst-alist-aux (cdr x) alist))
-
- (ins (vl-plainarglist->exprs inputs))
- ((when (member nil ins))
- ;; Blanks? screw it, skip it.
- (vl-make-dupeinst-alist-aux (cdr x) alist))
- (ins (vl-exprlist-fix ins))
- (key (make-vl-dupeinst-key :modname x1.modname :inputs ins))
- (look (hons-get key alist))
- (alist (hons-acons key (cons x1 (cdr look)) alist)))
- (vl-make-dupeinst-alist-aux (cdr x) alist)))
-
- (local (in-theory (enable vl-make-dupeinst-alist-aux)))
-
- (defthm vl-dupeinst-alistp-of-vl-make-dupeinst-alist-aux
- (implies (and (vl-modinstlist-p x)
- (vl-dupeinst-alistp alist))
- (vl-dupeinst-alistp (vl-make-dupeinst-alist-aux x alist))))
-
- (defund vl-make-dupeinst-alist (x)
- "Returns a slow alist."
- (declare (xargs :guard (vl-modinstlist-p x)))
- (b* ((alist (len x))
- (alist (vl-make-dupeinst-alist-aux x alist))
- (ans (hons-shrink-alist alist nil)))
- (fast-alist-free alist)
- (fast-alist-free ans)
- ans))
-
- (local (in-theory (enable vl-make-dupeinst-alist)))
-
- (defthm vl-dupeinst-alistp-of-vl-make-dupeinst-alist
- (implies (force (vl-modinstlist-p x))
- (vl-dupeinst-alistp (vl-make-dupeinst-alist x)))))
-
-
+(define vl-make-dupeinst-alist-aux
+ ((x vl-modinstlist-p)
+ (alist vl-dupeinst-alistp))
+ :returns (new-alist vl-dupeinst-alistp :hyp :fguard)
+ :parents (vl-make-dupeinst-alist)
+ (b* (((when (atom x))
+ alist)
+ (x1 (car x))
+ ((vl-modinst x1) x1)
+
+ ((when (vl-arguments->namedp x1.portargs))
+ ;; Args not resolved, skip it
+ (vl-make-dupeinst-alist-aux (cdr x) alist))
+
+ ((mv inputs ?outputs inouts unknowns)
+ (vl-partition-plainargs (vl-arguments->args x1.portargs) nil nil nil nil))
+
+ ((unless (and (atom inouts)
+ (atom unknowns)))
+ ;; Too hard, skip it
+ (vl-make-dupeinst-alist-aux (cdr x) alist))
+
+ (ins (vl-plainarglist->exprs inputs))
+ ((when (member nil ins))
+ ;; Blanks? screw it, skip it.
+ (vl-make-dupeinst-alist-aux (cdr x) alist))
+ (ins (vl-exprlist-fix ins))
+ (key (make-vl-dupeinst-key :modname x1.modname :inputs ins))
+ (look (hons-get key alist))
+ (alist (hons-acons key (cons x1 (cdr look)) alist)))
+ (vl-make-dupeinst-alist-aux (cdr x) alist)))
-(defsection vl-maybe-warn-dupeinst
+(define vl-make-dupeinst-alist ((x vl-modinstlist-p))
+ :returns (alist vl-dupeinst-alistp :hyp :fguard)
:parents (dupeinst-check)
- :short "Possibly add warnings about a group of module instances."
- :long "Signature: @(call vl-maybe-warn-dupeinst) returns
-@('warnings'').
-
-
+ :short "Builds a (slow) @(see vl-dupeinst-alistp) for a list of assignments."
-@('key') is the shared @(see vl-dupeinst-key-p) for a group of
-modinsts.
+ (b* ((alist (len x))
+ (alist (vl-make-dupeinst-alist-aux x alist))
+ (ans (hons-shrink-alist alist nil)))
+ (fast-alist-free alist)
+ (fast-alist-free ans)
+ ans))
-@('modinsts') are the modinsts that share this key.
-@('warnings') is the @(see warnings) accumulator to extend.
-
-
+(defsection vl-dupeinst-trivial-p
+ :parents (dupeinst-check)
+ :short "Customizable filter for duplicate module instances."
-Modinsts might not have multiple entries, in which case there is nothing to
-do and we just return @('warnings') unchanged. Otherwise, we issue a warning
-about the modules.
+ :long "By default, all duplicated modules are considered worth warning
+about. But you can configure which modules are considered trivial/okay to
+duplicate by attaching a function to @('vl-dupeinst-trivial-p'). These will be
+filtered out into minor warnings.
-By default, all duplicated modules are considered worth warning about. But
-you can configure which modules are considered trivial/okay to duplicate by
-attaching a function to @('vl-dupeinst-trivial-p'). These will be filtered out
-into minor warnings.
"
+@(def vl-dupeinst-trivial-p)"
(encapsulate
(((vl-dupeinst-trivial-p *) => *
@@ -197,125 +170,107 @@
(ignore modname))
nil)
- (defattach vl-dupeinst-trivial-p vl-dupeinst-trivial-p-default)
+ (defattach vl-dupeinst-trivial-p vl-dupeinst-trivial-p-default))
- (defun vl-modinstlist-fixed-up-outs (x)
- (declare (xargs :guard (vl-modinstlist-p x)))
- (b* (((when (atom x))
- nil)
- ((vl-modinst x1) (car x))
- ((when (vl-arguments->namedp x1.portargs))
- (er hard? 'vl-modinstlist-fixed-up-outs "expected resolved args"))
- ((mv ?inputs outputs ?inouts ?unknowns)
- (vl-partition-plainargs (vl-arguments->args x1.portargs) nil nil nil nil))
- (outexprs (vl-plainarglist->exprs outputs))
- (fixed-outexprs (if (member nil outexprs)
- ;; Can't fix them up because there are blanks. Well, who
- ;; cares. We'll just leave them unfixed.
- outexprs
- (vl-exprlist-fix outexprs))))
- (cons fixed-outexprs
- (vl-modinstlist-fixed-up-outs (cdr x)))))
-
- (defund vl-maybe-warn-dupeinst (key modinsts warnings)
- "Returns WARNINGS'"
- (declare (xargs :guard (and (vl-dupeinst-key-p key)
- (vl-modinstlist-p modinsts)
- (vl-warninglist-p warnings)))
- (ignorable key))
- (b* (((when (or (atom modinsts)
- (atom (cdr modinsts))))
- ;; Nothing to do -- there isn't more than one assignment for this RHS.
- warnings)
-
- ;; BOZO maybe filter some of this stuff?
-
- (fixed-up-outs (vl-modinstlist-fixed-up-outs modinsts))
- (dupes (duplicated-members fixed-up-outs))
-
- (modname (vl-dupeinst-key->modname key))
- (minor-p (vl-dupeinst-trivial-p modname))
-
- (w (make-vl-warning
- :type (if (consp dupes)
- (if minor-p :vl-warn-same-ports-minor :vl-warn-same-ports)
- (if minor-p :vl-warn-same-inputs-minor :vl-warn-same-inputs))
- :msg "Found instances of the same module with ~s0:~%~%~s1"
- :args (list (if (consp dupes)
- "the same arguments"
- "the same inputs (but different outputs)")
- (str::prefix-lines (with-local-ps
- ;; may help avoid unnecessary line wrapping
- (vl-ps-update-autowrap-col 200)
- (vl-pp-modinstlist modinsts nil nil))
- " ")
- ;; These aren't printed, but we include them in the
- ;; warning so our suppression mechanism can be
- ;; applied.
- modinsts)
- :fatalp nil
- :fn 'vl-maybe-warn-dupeinst)))
- (cons w warnings)))
-
- (local (in-theory (enable vl-maybe-warn-dupeinst)))
-
- (defthm vl-warninglist-p-of-vl-maybe-warn-dupeinst
- (implies (force (vl-warninglist-p warnings))
- (vl-warninglist-p (vl-maybe-warn-dupeinst rhs modinsts warnings)))))
-(defsection vl-warnings-for-dupeinst-alist
+(define vl-modinstlist-fixed-up-outs ((x vl-modinstlist-p))
+ :parents (vl-maybe-warn-dupeinst)
+ :short "Extract the @(see vl-expr-fix)ed outputs from each module instance."
+ (b* (((when (atom x))
+ nil)
+ ((vl-modinst x1) (car x))
+ ((when (vl-arguments->namedp x1.portargs))
+ (raise "expected resolved args"))
+ ((mv ?inputs outputs ?inouts ?unknowns)
+ (vl-partition-plainargs (vl-arguments->args x1.portargs) nil nil nil nil))
+ (outexprs (vl-plainarglist->exprs outputs))
+ (fixed-outexprs (if (member nil outexprs)
+ ;; Can't fix them up because there are blanks.
+ ;; Well, who cares. We'll just leave them unfixed.
+ outexprs
+ (vl-exprlist-fix outexprs))))
+ (cons fixed-outexprs
+ (vl-modinstlist-fixed-up-outs (cdr x)))))
+
+(define vl-maybe-warn-dupeinst
+ ((key vl-dupeinst-key-p "The shared key for a group of modinsts.")
+ (modinsts vl-modinstlist-p "The modinsts that share this key.")
+ (warnings vl-warninglist-p "The @(see warnings) accumulator to extend."))
+ :returns (new-warnings vl-warninglist-p
+ :hyp (force (vl-warninglist-p warnings)))
:parents (dupeinst-check)
-
- (defund vl-warnings-for-dupeinst-alist (alist warnings)
- (declare (xargs :guard (and (vl-dupeinst-alistp alist)
- (vl-warninglist-p warnings))))
- (b* (((when (atom alist))
- warnings)
- (rhs (caar alist))
- (assigns (cdar alist))
- (warnings (vl-maybe-warn-dupeinst rhs assigns warnings)))
- (vl-warnings-for-dupeinst-alist (cdr alist) warnings)))
-
- (local (in-theory (enable vl-warnings-for-dupeinst-alist)))
-
- (defthm vl-warninglist-p-of-vl-warnings-for-dupeinst-alist
- (implies (force (vl-warninglist-p warnings))
- (vl-warninglist-p (vl-warnings-for-dupeinst-alist alist warnings)))))
-
-
-(defsection vl-module-dupeinst-check
+ :short "Possibly add warnings about a group of module instances."
+ :long "Modinsts might not have multiple entries, in which case there is
+nothing to do and we just return @('warnings') unchanged. Otherwise, we issue
+a warning about the modules.
"
+
+ (b* (((when (or (atom modinsts)
+ (atom (cdr modinsts))))
+ ;; Nothing to do -- there isn't more than one assignment for this RHS.
+ warnings)
+
+ ;; BOZO maybe filter some of this stuff?
+
+ (fixed-up-outs (vl-modinstlist-fixed-up-outs modinsts))
+ (dupes (duplicated-members fixed-up-outs))
+
+ (modname (vl-dupeinst-key->modname key))
+ (minor-p (vl-dupeinst-trivial-p modname))
+
+ (w (make-vl-warning
+ :type (if (consp dupes)
+ (if minor-p :vl-warn-same-ports-minor :vl-warn-same-ports)
+ (if minor-p :vl-warn-same-inputs-minor :vl-warn-same-inputs))
+ :msg "Found instances of the same module with ~s0:~%~%~s1"
+ :args (list (if (consp dupes)
+ "the same arguments"
+ "the same inputs (but different outputs)")
+ (str::prefix-lines (with-local-ps
+ ;; may help avoid unnecessary line wrapping
+ (vl-ps-update-autowrap-col 200)
+ (vl-pp-modinstlist modinsts nil nil))
+ " ")
+ ;; These aren't printed, but we include them in the
+ ;; warning so our suppression mechanism can be
+ ;; applied.
+ modinsts)
+ :fatalp nil
+ :fn 'vl-maybe-warn-dupeinst)))
+ (cons w warnings)))
+
+
+(define vl-warnings-for-dupeinst-alist ((alist vl-dupeinst-alistp)
+ (warnings vl-warninglist-p))
+ :returns (new-warnings vl-warninglist-p
+ :hyp (force (vl-warninglist-p warnings)))
:parents (dupeinst-check)
+ (b* (((when (atom alist))
+ warnings)
+ (rhs (caar alist))
+ (assigns (cdar alist))
+ (warnings (vl-maybe-warn-dupeinst rhs assigns warnings)))
+ (vl-warnings-for-dupeinst-alist (cdr alist) warnings)))
- (defund vl-module-dupeinst-check (x)
- (declare (xargs :guard (vl-module-p x)))
- (b* (((vl-module x) x)
- (alist (vl-make-dupeinst-alist x.modinsts))
- (warnings (vl-warnings-for-dupeinst-alist alist x.warnings)))
- (change-vl-module x :warnings warnings)))
-
- (local (in-theory (enable vl-module-dupeinst-check)))
-
- (defthm vl-module-p-of-vl-module-dupeinst-check
- (implies (force (vl-module-p x))
- (vl-module-p (vl-module-dupeinst-check x))))
+(define vl-module-dupeinst-check ((x vl-module-p))
+ :parents (dupeinst-check)
+ :returns (new-x vl-module-p :hyp :fguard)
+ (b* (((vl-module x) x)
+ (alist (vl-make-dupeinst-alist x.modinsts))
+ (warnings (vl-warnings-for-dupeinst-alist alist x.warnings)))
+ (change-vl-module x :warnings warnings))
+ ///
(defthm vl-module->name-of-vl-module-dupeinst-check
(equal (vl-module->name (vl-module-dupeinst-check x))
(vl-module->name x))))
-
-(defsection vl-modulelist-dupeinst-check
+(defprojection vl-modulelist-dupeinst-check (x)
+ (vl-module-dupeinst-check x)
+ :guard (vl-modulelist-p x)
+ :result-type vl-modulelist-p
:parents (dupeinst-check)
-
- (defprojection vl-modulelist-dupeinst-check (x)
- (vl-module-dupeinst-check x)
- :guard (vl-modulelist-p x)
- :result-type vl-modulelist-p
- :parents (dupeinst-check))
-
- (defthm vl-modulelist->names-of-vl-modulelist-dupeinst-check
- (equal (vl-modulelist->names (vl-modulelist-dupeinst-check x))
- (vl-modulelist->names x))
- :hints(("Goal" :induct (len x)))))
+ :rest ((defthm vl-modulelist->names-of-vl-modulelist-dupeinst-check
+ (equal (vl-modulelist->names (vl-modulelist-dupeinst-check x))
+ (vl-modulelist->names x)))))
diff -Nru acl2-6.2/books/centaur/vl/checkers/duperhs.lisp acl2-6.3/books/centaur/vl/checkers/duperhs.lisp
--- acl2-6.2/books/centaur/vl/checkers/duperhs.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/checkers/duperhs.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -45,169 +45,149 @@
:valp-of-nil t
:parents (duperhs-check))
+(define vl-make-duperhs-alist-aux ((x vl-assignlist-p)
+ (alist vl-duperhs-alistp))
+ :returns (new-alist vl-duperhs-alistp :hyp :guard)
+ :parents (duperhs-check)
+ (b* (((when (atom x))
+ alist)
+ (x1 (car x))
+ ((vl-assign x1) x1)
+ (rhs1 (hons-copy (vl-expr-fix x1.expr)))
+ (look (hons-get rhs1 alist))
+ ;; It doesn't matter if it exists or not, just add it in.
+ (alist (hons-acons rhs1 (cons x1 (cdr look)) alist)))
+ (vl-make-duperhs-alist-aux (cdr x) alist)))
-(defsection vl-make-duperhs-alist
+(define vl-make-duperhs-alist ((x vl-assignlist-p))
+ :returns (alist "A slow alist."vl-duperhs-alistp :hyp :fguard)
:parents (duperhs-check)
:short "Builds the @(see vl-duperhs-alistp) for a list of assignments."
+ (b* ((alist (len x))
+ (alist (vl-make-duperhs-alist-aux x alist))
+ (ans (hons-shrink-alist alist nil)))
+ (fast-alist-free alist)
+ (fast-alist-free ans)
+ ans))
+
+(define vl-duperhs-too-trivial-p
+ ((rhs vl-expr-p "The rhs shared by some list of assignments."))
+ :returns (trivial-p "Is this too trivial to warn about?"
+ booleanp :rule-classes :type-prescription)
+ :parents (duperhs-check)
+ :short "Heuristic to avoid warning about assigning simple, common right-hand
+sides to multiple wires."
+
+ :long "It seems fine to assign a constant, weirdint, real, or string to
+multiple wires; this is especially frequent for things like 0 and 1, so we
+don't want to warn in these cases.
+
+We'll just suppress warnings for any atoms other than identifiers. This
+will allow us to still flag situations like:
+
+@({
+ assign wire1 = wirefoo;
+ assign wire2 = wirefoo;
+})
+
+I later decided I wanted to extend this, and additionally not cause warnings
+for odd but innocuous things like @('~ 1'b0') and @('{1'b0}').
"
+
+ (b* (((when (vl-fast-atom-p rhs))
+ (not (vl-fast-id-p (vl-atom->guts rhs))))
+ ((vl-nonatom rhs) rhs))
+ (and (or (eq rhs.op :vl-unary-bitnot)
+ (eq rhs.op :vl-concat))
+ (tuplep 1 rhs.args)
+ (vl-fast-atom-p (first rhs.args))
+ (not (vl-fast-id-p (vl-atom->guts (first rhs.args)))))))
+
+(define vl-maybe-warn-duperhs
+ :parents (duperhs-check)
+ :short "Create warnings for assignments that share some RHS."
+ ((rhs vl-expr-p "The shared RHS among all these assignments")
+ (assigns vl-assignlist-p "A list of assignments that share this RHS.")
+ (warnings vl-warninglist-p "A warnings accumulator to extend."))
+ :returns (new-warnings vl-warninglist-p
+ :hyp (force (vl-warninglist-p warnings)))
+ (b* (((when (or (atom assigns)
+ (atom (cdr assigns))))
+ ;; Nothing to do -- there isn't more than one assignment for this RHS.
+ warnings)
+
+ ((when (vl-duperhs-too-trivial-p rhs))
+ warnings)
+
+ (rhs-names (vl-expr-names rhs))
+ (special-names (append (str::collect-strs-with-isubstr "ph1" rhs-names)
+ (str::collect-strs-with-isubstr "reset" rhs-names)
+ (str::collect-strs-with-isubstr "clear" rhs-names)
+ (str::collect-strs-with-isubstr "enable" rhs-names)
+ (str::collect-strs-with-isubstr "clken" rhs-names)
+ (str::collect-strs-with-isubstr "valid" rhs-names)
+ ))
+ ((when (consp special-names))
+ ;; It's common for the same expression to be used multiple times for
+ ;; clock enables and for a clock to go multiple places, so try to
+ ;; filter this out.
+ warnings)
+
+ ;; BOZO maybe filter out other things? (reset, done, clear, stuff like
+ ;; that, by name?)
+ (w (make-vl-warning
+ :type :vl-warn-same-rhs
+ :msg "Found assignments that have exactly the same right-hand ~
+ side, which might indicate a copy/paste error:~%~s0"
+ :args (list (str::prefix-lines (with-local-ps
+ ;; may help avoid unnecessary line wrapping
+ (vl-ps-update-autowrap-col 200)
+ (vl-pp-assignlist assigns))
+ " ")
+ ;; These aren't printed, but we include them in the
+ ;; warning so our warning-suppression mechanism can be
+ ;; applied.
+ assigns)
+ :fatalp nil
+ :fn 'vl-maybe-warn-duperhs)))
+ (cons w warnings)))
- (defund vl-make-duperhs-alist-aux (x alist)
- (declare (xargs :guard (and (vl-assignlist-p x)
- (vl-duperhs-alistp alist))))
- (b* (((when (atom x))
- alist)
- (x1 (car x))
- ((vl-assign x1) x1)
- (rhs1 (hons-copy (vl-expr-fix x1.expr)))
- (look (hons-get rhs1 alist))
- ;; It doesn't matter if it exists or not, just add it in.
- (alist (hons-acons rhs1 (cons x1 (cdr look)) alist)))
- (vl-make-duperhs-alist-aux (cdr x) alist)))
-
- (local (in-theory (enable vl-make-duperhs-alist-aux)))
-
- (defthm vl-duperhs-alistp-of-vl-make-duperhs-alist-aux
- (implies (and (vl-assignlist-p x)
- (vl-duperhs-alistp alist))
- (vl-duperhs-alistp (vl-make-duperhs-alist-aux x alist))))
-
- (defund vl-make-duperhs-alist (x)
- "Returns a slow alist."
- (declare (xargs :guard (vl-assignlist-p x)))
- (b* ((alist (len x))
- (alist (vl-make-duperhs-alist-aux x alist))
- (ans (hons-shrink-alist alist nil)))
- (fast-alist-free alist)
- (fast-alist-free ans)
- ans))
-
- (local (in-theory (enable vl-make-duperhs-alist)))
-
- (defthm vl-duperhs-alistp-of-vl-make-duperhs-alist
- (implies (force (vl-assignlist-p x))
- (vl-duperhs-alistp (vl-make-duperhs-alist x)))))
-
-
-(defsection vl-maybe-warn-duperhs
- :parents (duperhs-check)
-
- (defund vl-maybe-warn-duperhs
- (rhs ;; The shared RHS among all these assignments
- assigns ;; A list of assignments that share this RHS.
- warnings ;; Warnings accumulator to extend
- )
- "Returns WARNINGS'"
- (declare (xargs :guard (and (vl-expr-p rhs)
- (vl-assignlist-p assigns))))
- (b* (((when (or (atom assigns)
- (atom (cdr assigns))))
- ;; Nothing to do -- there isn't more than one assignment for this RHS.
- warnings)
-
- ((when (and (vl-fast-atom-p rhs)
- (not (vl-fast-id-p (vl-atom->guts rhs)))))
- ;; It seems fine to assign a constant, weirdint, real, or string to
- ;; multiple wires; this is especially frequent for things like 0 and
- ;; 1, so don't warn in these cases. However, note that we explicitly
- ;; exclude identifiers here, so if we have a situation like:
- ;; assign wire1 = wirefoo;
- ;; assign wire2 = wirefoo;
- ;; Then we'll still flag it, it might be a copy/paste error.
- warnings)
-
- (rhs-names (vl-expr-names rhs))
- (special-names (append (str::collect-strs-with-isubstr "ph1" rhs-names)
- (str::collect-strs-with-isubstr "reset" rhs-names)
- (str::collect-strs-with-isubstr "clear" rhs-names)
- (str::collect-strs-with-isubstr "enable" rhs-names)
- (str::collect-strs-with-isubstr "clken" rhs-names)
- (str::collect-strs-with-isubstr "valid" rhs-names)
- ))
- ((when (consp special-names))
- ;; It's common for the same expression to be used multiple times for clock
- ;; enables and for a clock to go multiple places, so try to filter this out.
- warnings)
-
- ;; BOZO maybe filter out other things? (reset, done, clear, stuff like
- ;; that, by name?)
- (w (make-vl-warning
- :type :vl-warn-same-rhs
- :msg "Found assignments that have exactly the same right-hand ~
- side, which might indicate a copy/paste error:~%~s0"
- :args (list (str::prefix-lines (with-local-ps
- ;; may help avoid unnecessary line wrapping
- (vl-ps-update-autowrap-col 200)
- (vl-pp-assignlist assigns))
- " ")
- ;; These aren't printed, but we include them in the
- ;; warning so our suppression mechanism can be
- ;; applied.
- assigns)
- :fatalp nil
- :fn 'vl-maybe-warn-duperhs)))
- (cons w warnings)))
-
- (local (in-theory (enable vl-maybe-warn-duperhs)))
-
- (defthm vl-warninglist-p-of-vl-maybe-warn-duperhs
- (implies (force (vl-warninglist-p warnings))
- (vl-warninglist-p (vl-maybe-warn-duperhs rhs assigns warnings)))))
-
-
-(defsection vl-warnings-for-duperhs-alist
- :parents (duperhs-check)
-
- (defund vl-warnings-for-duperhs-alist (alist warnings)
- (declare (xargs :guard (and (vl-duperhs-alistp alist)
- (vl-warninglist-p warnings))))
- (b* (((when (atom alist))
- warnings)
- (rhs (caar alist))
- (assigns (cdar alist))
- (warnings (vl-maybe-warn-duperhs rhs assigns warnings)))
- (vl-warnings-for-duperhs-alist (cdr alist) warnings)))
-
- (local (in-theory (enable vl-warnings-for-duperhs-alist)))
-
- (defthm vl-warninglist-p-of-vl-warnings-for-duperhs-alist
- (implies (force (vl-warninglist-p warnings))
- (vl-warninglist-p (vl-warnings-for-duperhs-alist alist warnings)))))
-
-
-
-(defsection vl-module-duperhs-check
- :parents (duperhs-check)
-
- (defund vl-module-duperhs-check (x)
- (declare (xargs :guard (vl-module-p x)))
- (b* (((vl-module x) x)
- (alist (vl-make-duperhs-alist x.assigns))
-; (- (cw "Alist has ~x0 entries.~%" (len alist)))
- (warnings (vl-warnings-for-duperhs-alist alist x.warnings)))
- (change-vl-module x :warnings warnings)))
-
- (local (in-theory (enable vl-module-duperhs-check)))
-
- (defthm vl-module-p-of-vl-module-duperhs-check
- (implies (force (vl-module-p x))
- (vl-module-p (vl-module-duperhs-check x))))
+(define vl-warnings-for-duperhs-alist
+ :parents (duperhs-check)
+ ((alist vl-duperhs-alistp "The duperhs alist we've built for some module.")
+ (warnings vl-warninglist-p "A warnings accumulator to extend."))
+ :returns (new-warnings vl-warninglist-p
+ :hyp (force (vl-warninglist-p warnings)))
+ (b* (((when (atom alist))
+ warnings)
+ (rhs (caar alist))
+ (assigns (cdar alist))
+ (warnings (vl-maybe-warn-duperhs rhs assigns warnings)))
+ (vl-warnings-for-duperhs-alist (cdr alist) warnings)))
+
+
+(define vl-module-duperhs-check ((x vl-module-p))
+ :parents (duperhs-check)
+ :short "Look for duplicated rhses in a module, and add warnings about them."
+ :returns (new-x "A copy of X, perhaps extended with new warnings."
+ vl-module-p :hyp :fguard)
+ (b* (((vl-module x) x)
+ (alist (vl-make-duperhs-alist x.assigns))
+ (warnings (vl-warnings-for-duperhs-alist alist x.warnings)))
+ (change-vl-module x :warnings warnings))
+ ///
(defthm vl-module->name-of-vl-module-duperhs-check
(equal (vl-module->name (vl-module-duperhs-check x))
(vl-module->name x))))
-(defsection vl-modulelist-duperhs-check
+(defprojection vl-modulelist-duperhs-check (x)
+ (vl-module-duperhs-check x)
+ :guard (vl-modulelist-p x)
+ :result-type vl-modulelist-p
:parents (duperhs-check)
-
- (defprojection vl-modulelist-duperhs-check (x)
- (vl-module-duperhs-check x)
- :guard (vl-modulelist-p x)
- :result-type vl-modulelist-p
- :parents (duperhs-check))
-
- (defthm vl-modulelist->names-of-vl-modulelist-duperhs-check
- (equal (vl-modulelist->names (vl-modulelist-duperhs-check x))
- (vl-modulelist->names x))
- :hints(("Goal" :induct (len x)))))
+ :rest ((defthm vl-modulelist->names-of-vl-modulelist-duperhs-check
+ (equal (vl-modulelist->names (vl-modulelist-duperhs-check x))
+ (vl-modulelist->names x)))))
diff -Nru acl2-6.2/books/centaur/vl/checkers/duplicate-detect.lisp acl2-6.3/books/centaur/vl/checkers/duplicate-detect.lisp
--- acl2-6.2/books/centaur/vl/checkers/duplicate-detect.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/checkers/duplicate-detect.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -25,6 +25,7 @@
(defsection vl-atom-fix
+ :parents (vl-expr-fix)
(local (in-theory (enable vl-atom-p
vl-atom
@@ -53,6 +54,11 @@
(defsection vl-expr-fix
+ :parents (vl-expr-p)
+ :short "Throw away attributes and widths, keeping just the core of an expression."
+ :long "This is often useful when writing heuristic checks where you want
+to look for particular expressions, where attributes and differing sizes are of
+no concern.
"
;; BOZO consider optimizing to avoid reconsing already-fixed expressions
diff -Nru acl2-6.2/books/centaur/vl/checkers/qmarksize-check.lisp acl2-6.3/books/centaur/vl/checkers/qmarksize-check.lisp
--- acl2-6.2/books/centaur/vl/checkers/qmarksize-check.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/checkers/qmarksize-check.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -122,7 +122,27 @@
(test-expr (first args))
(test-size (vl-qmark-test-size test-expr))
- ((unless (equal test-size 1))
+ ((unless (or (equal test-size 1)
+ ;; Historically we didn't have this extra exclusion for
+ ;; nil test sizes. I later discovered that, e.g., due
+ ;; to using arrays or other things that VL doesn't
+ ;; support, we could run into a case like:
+ ;;
+ ;; wire [2:0] foo;
+ ;; wire bar;
+ ;;
+ ;; assign foo = bar ? bad-expression : 3'b0;
+ ;;
+ ;; Here BAR is a perfectly good expression, but due to
+ ;; the bad-expression, our sizing code will fail to
+ ;; assign any size to BAR.
+ ;;
+ ;; In this case, the warning we produced was very
+ ;; confusing because the condition is obviously just a
+ ;; single bit. I think it just doesn't make sense to
+ ;; try to create a warning in this case, so now we will
+ ;; suppress these.
+ (not test-size)))
(cons (make-vl-warning :type :vl-warn-qmark-width
:msg "~a0: ~x1-bit wide \"test\" expression for ?: operator, ~a2."
:args (list ctx test-size test-expr)
diff -Nru acl2-6.2/books/centaur/vl/checkers/typo-detect.lisp acl2-6.3/books/centaur/vl/checkers/typo-detect.lisp
--- acl2-6.2/books/centaur/vl/checkers/typo-detect.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/checkers/typo-detect.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -216,7 +216,7 @@
(defconst *typo-special-substrings-chars*
- (coerce-to-chars-list *typo-special-substrings*))
+ (explode-list *typo-special-substrings*))
(defsection typo-read-special
@@ -496,7 +496,7 @@
(if (atom x)
nil
(cons (cons (car x)
- (typo-partition (coerce (car x) 'list)))
+ (typo-partition (explode (car x))))
(typo-partitioning-alist (cdr x)))))
(local (in-theory (enable typo-partitioning-alist)))
@@ -689,7 +689,7 @@
(if (atom strs)
nil
(let* ((name1 (car strs))
- (partition1 (typo-partition (coerce name1 'list)))
+ (partition1 (typo-partition (explode name1)))
(typos1 (typo-find-plausible-typos1 partition1 alist)))
(if typos1
(cons (cons name1 typos1)
diff -Nru acl2-6.2/books/centaur/vl/checkers/use-set-report.lisp acl2-6.3/books/centaur/vl/checkers/use-set-report.lisp
--- acl2-6.2/books/centaur/vl/checkers/use-set-report.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/checkers/use-set-report.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -98,7 +98,7 @@
(define vl-star-names-of-warning-wires ((x string-listp)
(warning-wires string-listp))
:returns (new-x string-listp :hyp (force (string-listp x)))
- :parents (useset)
+ :parents (use-set)
:short "Change names in @('x') by putting a @('*') in front of any name that
is among the @('warning-wires')."
(cond ((atom x)
diff -Nru acl2-6.2/books/centaur/vl/kit/acl2-customization.lsp acl2-6.3/books/centaur/vl/kit/acl2-customization.lsp
--- acl2-6.2/books/centaur/vl/kit/acl2-customization.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/acl2-customization.lsp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,22 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2011 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(ld "../acl2-customization.lsp")
+(in-package "VL")
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/vl/kit/cert.acl2 acl2-6.3/books/centaur/vl/kit/cert.acl2
--- acl2-6.2/books/centaur/vl/kit/cert.acl2 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/cert.acl2 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,27 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2011 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "ACL2")
+#+gcl (acl2::value :q)
+#+gcl (setq si::*optimize-maximum-pages* nil)
+#+gcl (acl2::lp)
+(include-book "../portcullis")
+; cert-flags: ? t :ttags :all
+
diff -Nru acl2-6.2/books/centaur/vl/kit/json.lisp acl2-6.3/books/centaur/vl/kit/json.lisp
--- acl2-6.2/books/centaur/vl/kit/json.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/json.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,153 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "VL")
+(include-book "../loader/loader")
+(include-book "../mlib/json")
+(include-book "centaur/getopt/top" :dir :system)
+(include-book "std/io/read-file-characters" :dir :system)
+(include-book "progutils")
+(local (include-book "../util/arithmetic"))
+
+(defoptions vl-json-opts
+ :parents (vl-json)
+ :short "Options for running @('vl json')."
+ :tag :vl-json-opts
+
+ ((help booleanp
+ "Show a brief usage message and exit."
+ :rule-classes :type-prescription
+ :alias #\h)
+
+ (readme booleanp
+ "Show a more elaborate README and exit."
+ :rule-classes :type-prescription)
+
+ (outfile (stringp outfile)
+ :argname "FILE"
+ :alias #\o
+ "Write output to FILE. Default: \"foo.v.json\", where
+ \"foo.v\" is the first Verilog file provided."
+ :rule-classes :type-prescription
+ :default "")
+
+ (search-path string-listp
+ :longname "search"
+ :alias #\s
+ :argname "DIR"
+ "Search path for finding modules. You can give this switch
+ multiple times, to set up multiple search paths in priority
+ order."
+ :parser getopt::parse-string
+ :merge acl2::rcons)
+
+ (separate booleanp
+ "Write modules as separate, independent JSON objects instead of
+ as a single, monolithic object."
+ :rule-classes :type-prescription)
+
+ (mem posp
+ :alias #\m
+ :argname "GB"
+ "How much memory to try to use. Default: 4 GB. Raising this
+ may improve performance by avoiding garbage collection. To
+ avoid swapping, keep this below (physical_memory - 2 GB)."
+ :default 4
+ :rule-classes :type-prescription)
+
+ (debug booleanp
+ "Print extra information for debugging."
+ :rule-classes :type-prescription)))
+
+(defconst *vl-json-help* (str::cat "
+vl json: Converts Verilog into JSON, a format that can be easily loaded into
+ scripting languages like Ruby, Perl, etc.
+
+Example: vl json engine.v wrapper.v core.v \\
+ --search ./simlibs \\
+ --search ./baselibs
+
+Usage: vl json [OPTIONS] file.v [file2.v ...]
+
+Options:" *nls* *nls* *vl-json-opts-usage* *nls*))
+
+(defconsts (*vl-json-readme* state)
+ (b* (((mv contents state) (acl2::read-file-characters "json.readme" state))
+ ((when (stringp contents))
+ (raise contents)
+ (mv "" state)))
+ (mv (implode contents) state)))
+
+(define vl-json ((cmdargs string-listp) &optional (state 'state))
+ :parents (kit)
+ :short "The @('vl json') command."
+
+ (b* (((mv errmsg opts start-files)
+ (parse-vl-json-opts cmdargs))
+ ((when errmsg)
+ (die "~@0~%" errmsg)
+ state)
+
+ ((vl-json-opts opts) opts)
+ (- (acl2::set-max-mem ;; newline to appease cert.pl's scanner
+ (* (expt 2 30) opts.mem)))
+
+ ((when opts.help)
+ (vl-cw-ps-seq (vl-print *vl-json-help*))
+ (exit-ok)
+ state)
+
+ ((when opts.readme)
+ (vl-cw-ps-seq (vl-print *vl-json-readme*))
+ (exit-ok)
+ state)
+
+ ((unless (consp start-files))
+ (die "No files to process.")
+ state)
+ (outfile (if (equal opts.outfile "")
+ (cat (car start-files) ".json")
+ opts.outfile))
+
+ (- (or (not opts.debug)
+ (cw "vl json options: ~x0~%" opts)))
+
+ (state (must-be-regular-files! start-files))
+ (state (must-be-directories! opts.search-path))
+
+ (- (cw "Parsing Verilog sources...~%"))
+ ((mv (vl-loadresult res) state)
+ (cwtime (vl-load (make-vl-loadconfig :start-files start-files
+ :search-path opts.search-path
+ :filemapp nil))))
+
+ (- (cw "JSON-Encoding Modules...~%"))
+ (state
+ (cwtime
+ (with-ps-file outfile
+ (vl-ps-update-autowrap-col 120)
+ (vl-ps-update-autowrap-ind 10)
+ (cwtime (if opts.separate
+ (vl-jp-individual-modules res.mods)
+ (vl-jp-modalist (vl-modalist res.mods)))
+ :name vl-json-encode))
+ :name vl-json-export)))
+ (exit-ok)
+ state))
diff -Nru acl2-6.2/books/centaur/vl/kit/json.readme acl2-6.3/books/centaur/vl/kit/json.readme
--- acl2-6.2/books/centaur/vl/kit/json.readme 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/json.readme 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,219 @@
+------------------------------------------------------------------------------
+
+ VL JSON README
+
+------------------------------------------------------------------------------
+
+You can use VL's "json" tool to write programs that process Verilog code
+
+ - in many languages (Ruby, Perl, Python, ...)
+ - without writing a robust Verilog parser yourself
+ - without using some half-assed "grep"-based parser
+ - with a minimum of fuss
+
+The basic flow is (e.g., for Ruby):
+
+ +----------+ (1) +------+ (2) +------------+ (3) +---------+
+ | Verilog | ------> | JSON | --------> | Ruby Data | ------> | Results |
+ | Files | vl2json | File | ruby json | (hashes, | your | |
+ | | | | parser | arrays) | program | |
+ +----------+ +------+ +------------+ +---------+
+
+The remainder of this README has:
+
+ 1. How to run "vl json" to get the JSON file (step 1 above)
+
+ 2. How to load the JSON file into your program (step 2 above)
+ - Example scripts for Ruby, Perl, and Python
+ - Performance comparisons of JSON libraries
+
+ 3. How to write your program (step 3 above)
+ - Documentation for the JSON data format
+
+ 4. Notes
+ - How "vl json" might be adapted to better fit your program
+
+------------------------------------------------------------------------------
+
+ STEP 1. GENERATING THE JSON FILE.
+
+To see the available command-line options, just run:
+
+ vl help json
+
+A typical invocation might look like this:
+
+ time vl json my_mod.v \ <-- starting files to load
+ -s libs/my_lib1 \ <-- search paths for finding
+ -s libs/my_lib2 additional modules
+
+If all goes well, this should load my_mod.v and any supporting libraries, then
+translate them all into a JSON file named, e.g., my_mod.v.json.
+
+Note: the JSON-encoded, parsed Verilog is quite verbose! For instance, a 39 MB
+Verilog test file (plus its libraries, which I didn't try to measure) produced
+a 628 MB output file!
+
+------------------------------------------------------------------------------
+
+ STEP 2. PARSING THE JSON FILE.
+
+JSON libraries are available for almost any popular programming language.
+
+ - Ruby, Perl, and Python are discussed below.
+ - For other languages, see http://www.json.org/ or try googling
+
+RUBY.
+
+ Loading JSON data into Ruby is mostly a matter of installing the right gem.
+ Here are some tips:
+
+ The 'json' gem seems really slow. I also had to add a :max_nesting=>false
+ option to the JSON.parse command, or it would die with an error. It took a
+ little over 4 minutes to load my test file's JSON encoding. Example code:
+
+ require 'json'
+ file = File.open("my_file.v.json")
+ text = file.read
+ file.close
+ parsed = JSON.parse(text, :max_nesting=>false)
+
+ I also tried the 'yajl-ruby' gem, but it also seems slow.
+
+ Fortunately, the 'oj' gem seems much faster! It takes about 50 seconds to
+ load the test file using the following code. Using :symbol_keys seems to
+ make things about 15% faster, but might not be what you want. Example code:
+
+ require 'oj'
+ file = File.open("my_file.v.json")
+ text = file.read
+ file.close
+ design = Oj.load(text, :symbol_keys=>true)
+
+ Note that the above are with Ruby 1.9.3p0, which may be slightly old now.
+ Perhaps newer versions of Ruby are faster?
+
+PERL.
+
+ The plain 'JSON' module seems horribly slow (for my test file, I killed the
+ job after it had run for over 90 minutes without finishing).
+
+ The JSON::XS module is extremely fast! It takes only 30 seconds to run the
+ example script that loads my test file. Example code:
+
+ use JSON::XS;
+
+ sub read_whole_file {
+ my $filename = shift;
+ open (my $fh, "<", $filename) or die("Can't open $filename: $!\n");
+ local $/ = undef;
+ my $ret = <$fh>;
+ close($fh);
+ return $ret;
+ }
+
+ sub read_json_file {
+ my $filename = shift;
+ my $text = read_whole_file($filename);
+ my $json = new JSON::XS;
+ $json->max_depth(20000);
+ my $ret = $json->decode($text);
+ return $ret;
+ }
+
+ my $design = read_json_file('my_file.v.json');
+
+
+PYTHON.
+
+ The built-in JSON importer is not super fast, but can parse my test file in
+ about 2 minutes. I did have to up the recursion limit in python to avoid a
+ stack overflow. Example code:
+
+ import json
+ import sys
+ # Upping the recursion limit seems necessary for reading large designs
+ sys.setrecursionlimit(20000)
+
+ def read_json(filename):
+ with open(filename, 'r') as file:
+ content = file.read()
+ return json.loads(content)
+
+ design = read_json("my_file.v.json")
+
+ There's apparently something called ultrajson for Python that makes JSON
+ loading much faster. I haven't tried it out yet, though.
+
+
+------------------------------------------------------------------------------
+
+ STEP 3. WRITING YOUR PROGRAM.
+
+Once you get the Verilog modules loaded into your program, to do anything with
+them you need to know something about the data format.
+
+The top-level JSON object is just a mapping from
+
+ module name --> module body
+
+Each module body is a JSON structure corresponding to the internal module
+representation used by VL (a Verilog Library for the ACL2 theorem prover). You
+can find lots of documentation about the data format here:
+
+ http://fv.centtech.com/acl2/latest/doc/frames2.html?topic=VL____MODULES
+
+ +------------------------------------------------------------------------+
+ | |
+ | TIP: |
+ | - Click on the yellow + sign next to "VL" on the left frame, then |
+ | - Click on the + sign next to "VL::modules". |
+ | |
+ | Now you have a menu with all the different structures! |
+ | |
+ +------------------------------------------------------------------------+
+
+Most structures are very straightforward. But some others (e.g., expressions
+and statements) are perhaps a bit weird. If you want to deal with these, you
+may want to read the documentation carefully to understand how they work.
+
+
+------------------------------------------------------------------------------
+
+ MISCELLANEOUS NOTES
+
+Today, "vl json" just parses in the Verilog modules and then writes out their
+internal VL representation into JSON. This is straightforward, and may be
+perfectly fine for writing many kinds of programs.
+
+But if you want to write a program that involves some deeper understanding of
+the Verilog, then you may still be facing a lot of work. For instance, suppose
+your program wants to follow wires into submodules. Well, to really do it right,
+you may need to handle both named and position-based argument lists, e.g.,
+
+ my_adder adder1 (.o(o), .a(a), .b(b));
+ my_adder adder2 (o, a, b);
+
+And you might also need to handle port expressions on the submodule side, e.g.,
+
+ module my_adder (o, a({ahigh, alow}), b);
+ input [3:0] ahigh;
+ input [3:0] alow;
+ ...
+ endmodule
+
+And maybe you even need to know the sizes of wires, etc. The point is,
+something that sounds simple can be hard to do in a robust way because of all
+the different forms that Verilog can be written in.
+
+If you want to do something tricky like this, the easiest approach may just be
+to extend "vl json" to simplify the modules before you process them.
+
+VL has a large number of Verilog-to-Verilog transforms that we can run on the
+modules before writing them. These may be able to really reduce the variety of
+structures that your program will need to handle. To get a rough sense of the
+sorts of things VL can do, you might glance through this list of transforms:
+
+ http://fv.centtech.com/acl2/latest/doc/frames2.html?topic=VL____TRANSFORMS
+
+------------------------------------------------------------------------------
diff -Nru acl2-6.2/books/centaur/vl/kit/lint.lisp acl2-6.3/books/centaur/vl/kit/lint.lisp
--- acl2-6.2/books/centaur/vl/kit/lint.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/lint.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,1110 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "VL")
+
+(make-event
+
+; Disabling waterfall parallelism because this book allegedly uses memoization
+; while performing its proofs.
+
+ (if (and (ACL2::hons-enabledp state)
+ (f-get-global 'ACL2::parallel-execution-enabled state))
+ (er-progn (set-waterfall-parallelism nil)
+ (value '(value-triple nil)))
+ (value '(value-triple nil))))
+
+(include-book "../loader/loader")
+
+(include-book "../lint/bit-use-set")
+(include-book "../lint/check-case")
+(include-book "../lint/check-namespace")
+(include-book "../lint/disconnected")
+(include-book "../lint/xf-drop-missing-submodules")
+(include-book "../lint/xf-drop-user-submodules")
+(include-book "../lint/xf-lint-stmt-rewrite")
+(include-book "../lint/xf-remove-toohard")
+(include-book "../lint/xf-undefined-names")
+(include-book "../lint/xf-suppress-warnings")
+
+(include-book "../checkers/condcheck")
+(include-book "../checkers/duplicate-detect")
+(include-book "../checkers/dupeinst-check")
+(include-book "../checkers/duperhs")
+(include-book "../checkers/leftright")
+(include-book "../checkers/multidrive-detect")
+(include-book "../checkers/oddexpr")
+(include-book "../checkers/portcheck")
+(include-book "../checkers/qmarksize-check")
+(include-book "../checkers/selfassigns")
+(include-book "../checkers/skip-detect")
+
+(include-book "../transforms/cn-hooks")
+(include-book "../transforms/xf-argresolve")
+(include-book "../transforms/xf-array-indexing")
+(include-book "../transforms/xf-assign-trunc")
+(include-book "../transforms/xf-blankargs")
+(include-book "../transforms/xf-clean-params")
+(include-book "../transforms/xf-drop-blankports")
+(include-book "../transforms/xf-expr-split")
+(include-book "../transforms/xf-expand-functions")
+(include-book "../transforms/xf-follow-hids")
+(include-book "../transforms/xf-hid-elim")
+(include-book "../transforms/xf-orig")
+(include-book "../transforms/xf-oprewrite")
+(include-book "../transforms/xf-portdecl-sign")
+(include-book "../transforms/xf-resolve-ranges")
+(include-book "../transforms/xf-replicate-insts")
+(include-book "../transforms/xf-sizing")
+(include-book "../transforms/xf-unparameterize")
+(include-book "../transforms/xf-unused-reg")
+
+(include-book "../../misc/sneaky-load")
+
+(include-book "../mlib/json")
+(local (include-book "../mlib/modname-sets"))
+(local (include-book "../util/arithmetic"))
+(local (include-book "../util/osets"))
+
+(include-book "centaur/getopt/top" :dir :system)
+(include-book "std/io/read-file-characters" :dir :system)
+(include-book "progutils")
+
+
+(defsection lint
+ :parents (vl)
+ :short "A linting tool for Verilog."
+
+ :long "A linter is a tool
+that looks for possible bugs in a program. We now implement such a linter for
+Verilog, reusing much of @(see vl).
")
+
+
+(defoptions vl-lintconfig
+ :parents (lint)
+ :short "Command-line options for running @('vl lint')."
+ :tag :vl-lint-opts
+
+ ((start-files string-listp
+ "The list of files to process."
+ :hide t)
+
+ (help booleanp
+ "Show a brief usage message and exit."
+ :rule-classes :type-prescription
+ :alias #\h)
+
+ (readme booleanp
+ "Show a more elaborate README and exit."
+ :rule-classes :type-prescription)
+
+ (search-path string-listp
+ :longname "search"
+ :alias #\s
+ :argname "DIR"
+ "Control the search path for finding modules. You can give
+ this switch multiple times, to set up multiple search paths in
+ priority order."
+ :parser getopt::parse-string
+ :merge acl2::rcons)
+
+ (search-exts string-listp
+ :longname "searchext"
+ :argname "EXT"
+ "Control the search extensions for finding modules. You can
+ give this switch multiple times. By default we just look for
+ files named \"foo.v\" in the --search directories. But if you
+ have Verilog files with different extensions, this won't work,
+ so you can add these extensions here. EXT should not include
+ the period, e.g., use \"--searchext vv\" to consider files
+ like \"foo.vv\", etc."
+ :parser getopt::parse-string
+ :merge acl2::rcons
+ :default '("v"))
+
+ (topmods string-listp
+ :longname "topmod"
+ :argname "MOD"
+ "Limit the scope of the report to MOD. By default we include
+ all warnings for any module we encounter. But if you say
+ \"--topmod foo\", we suppress all warnings for modules that foo
+ does not depend on. You can give this switch multiple times,
+ e.g., \"--topmod foo --topmod bar\" means: only show warnings
+ for foo, bar, and modules that they depend on."
+ :parser getopt::parse-string
+ :merge cons)
+
+ (quiet string-listp
+ :alias #\q
+ :argname "MOD"
+ "Suppress all warnings that about MOD. You can give this switch
+ multiple times, e.g., \"-q foo -q bar\" will hide the warnings
+ about modules foo and bar."
+ :parser getopt::parse-string
+ :merge cons)
+
+ (dropmods string-listp
+ :longname "drop"
+ :alias #\d
+ :argname "MOD"
+ "Delete MOD from the module hierarchy before doing any linting
+ at all. This is a gross (but effective) way to work through
+ any bugs in the linter that are triggered by certain modules.
+ The dropped modules are removed from the module list without
+ destroying modules above them. This may occasionally lead to
+ false warnings about the modules above (e.g., it may think some
+ wires are unused, because the module that uses them has been
+ removed.)"
+ :parser getopt::parse-string
+ :merge cons)
+
+ (ignore string-listp
+ :alias #\i
+ :argname "TYPE"
+ "Ignore warnings of this TYPE. For instance, \"--ignore
+ oddexpr\" will suppress VL_WARN_ODDEXPR warnings. Note that
+ there are much finer-grained ways to suppress warnings; see
+ \"vl lint --readme\" for more information."
+ :parser getopt::parse-string
+ :merge cons)
+
+ (mem posp
+ :alias #\m
+ :argname "GB"
+ "How much memory to try to use. Default: 4 GB. Raising this
+ may improve performance by avoiding garbage collection. To
+ avoid swapping, keep this below (physical_memory - 2 GB)."
+ :default 4
+ :rule-classes :type-prescription)
+
+ (debug booleanp
+ "Print extra information for debugging."
+ :rule-classes :type-prescription)))
+
+(defsection *vl-lint-help*
+ :parents (lint)
+ :short "Usage message for vl lint."
+ :long "@(def *vl-lint-help*)"
+
+ (defconsts *vl-lint-help* (str::cat "
+vl lint: A linting tool for Verilog. Scans your Verilog files for things
+ that look like bugs (size mismatches, unused wires, etc.)
+
+Example: vl lint engine.v wrapper.v core.v \\
+ --search ./simlibs \\
+ --search ./baselibs
+
+Usage: vl lint [OPTIONS] file.v [file2.v ...]
+
+Options:" *nls* *nls* *vl-lintconfig-usage* *nls*)))
+
+
+(define vl-filter-mods-with-good-paramdecls
+ ((x vl-modulelist-p "List of modules to filter.")
+ (good vl-modulelist-p "Accumulator for good modules.")
+ (bad vl-modulelist-p "Accumulator for bad modules."))
+ :returns (mv (good vl-modulelist-p :hyp :fguard)
+ (bad vl-modulelist-p :hyp :fguard))
+ :parents (lint)
+ :short "(unsound transform) Throw away modules with too-complex parameter
+declarations. "
+
+ :long "@(csee unparameterization) requires that the module list is
+complete and that all modules have good parameters. In our ordinary
+translation process (e.g., @(see vl-simplify)), we throw away any modules with
+bad parameters, any then transitively throw away any modules with instances of
+missing modules. But for linting, we'd like to try to carry out
+unparameterization with as little damage as possible.
+
+As a pre-unparameterization step, in this transform we throw away any
+modules with bad parameters and then throw away any instances of missing
+modules. This is obviously unsound, so it should never be used in our ordinary
+translation process.
"
+
+ (cond ((atom x)
+ (mv good bad))
+ ((vl-good-paramdecllist-p (vl-module->paramdecls (car x)))
+ (vl-filter-mods-with-good-paramdecls (cdr x)
+ (cons (car x) good)
+ bad))
+ (t
+ (vl-filter-mods-with-good-paramdecls (cdr x)
+ good
+ (cons (car x) bad)))))
+
+
+(define vl-print-certain-warnings
+ ((mods vl-modulelist-p "Modules to print warnings for.")
+ (show symbol-listp "Types of warnings to show.")
+ (hide symbol-listp "Types of warnings to hide."))
+ :parents (lint)
+ :short "Print warnings of interest to standard output, while hiding other
+warnings."
+
+ :long "You can use this to print just a few warnings you are interested in
+while hiding other warnings you know you are not interested in. If there are
+warnings of other types (that you haven't said to show or hide), they too will
+be hidden but you'll at least get a message saying that they aren't being
+shown.
"
+
+ (b* ((warnings (vl-modulelist-flat-warnings-exec mods nil))
+ (types (mergesort (vl-warninglist->types-exec warnings nil)))
+ (hide (if hide
+ (mergesort hide)
+ types))
+ (show (mergesort show))
+ ;; Misc is all the warning types that we aren't told to show, but aren't
+ ;; told to ignore. We'll print a note that these warnings exist but
+ ;; that we weren't told to show or hide them.
+ (misc (difference types (union show hide)))
+ (warnings (vl-keep-warnings show warnings)))
+ (vl-cw-ps-seq
+ (vl-ps-update-autowrap-col 65)
+ (vl-print-warnings warnings)
+ (vl-println "")
+ (if (not misc)
+ ps
+ (vl-ps-seq
+ (vl-cw "Note: not showing ~&0 warnings.~%" misc)
+ (vl-println ""))))))
+
+
+(defaggregate vl-lintresult
+ :parents (lint)
+ :short "Results from running the linter."
+ :tag :vl-lintresult
+ ((mods vl-modulelist-p
+ "Final, transformed list of modules. Typically this isn't very
+ interesting or relevant to anything.")
+
+ (mods0 vl-modulelist-p
+ "Almost: the initial, pre-transformed modules. The only twist is
+ that we have already removed modules that are unnecessary or
+ that we wanted to drop; see, e.g., the @('topmods') and
+ @('ignore') options of @(see vl-lintconfig-p). This is used for
+ @(see skip-detection), for instance.")
+
+ (mwalist vl-modwarningalist-p
+ "The main result: binds \"original\" (pre-unparameterization)
+ module names to their warnings.")
+
+ (sd-probs sd-problemlist-p
+ "Possible problems noticed by @(see skip-detection). These are
+ in a different format than ordinary @(see warnings), so they
+ aren't included in the @('mwalist').")
+
+ (dalist us-dbalist-p
+ "Use-set database alist, mapping module names to use-set databases.
+ Might actually not be used for anything.")))
+
+
+(define vl-delete-sd-problems-for-modnames-aux
+ ((fal "Fast alist binding names to T or whatever")
+ (x sd-problemlist-p))
+ :returns (new-x sd-problemlist-p :hyp :fguard)
+ (b* (((when (atom x))
+ nil)
+ ((sd-problem x1) (car x))
+ ((vl-context x1.ctx) x1.ctx)
+ ((when (hons-get x1.ctx.mod fal))
+ (vl-delete-sd-problems-for-modnames-aux fal (cdr x))))
+ (cons (car x)
+ (vl-delete-sd-problems-for-modnames-aux fal (cdr x)))))
+
+(define vl-delete-sd-problems-for-modnames ((names string-listp)
+ (probs sd-problemlist-p))
+ :returns (new-x sd-problemlist-p
+ :hyp (force (sd-problemlist-p probs)))
+ (b* ((fal (make-lookup-alist names))
+ (ret (vl-delete-sd-problems-for-modnames-aux fal probs)))
+ (fast-alist-free fal)
+ ret))
+
+
+(local (defthm no-duplicatesp-when-setp
+ (implies (setp x)
+ (no-duplicatesp x))))
+
+(local (defthm VL-MODULELIST-P-OF-APPEND-fast
+ (implies (and (force (vl-modulelist-p x))
+ (force (vl-modulelist-p y)))
+ (vl-modulelist-p (append x y)))))
+
+(local (in-theory (disable
+ NO-DUPLICATESP-EQUAL-WHEN-SAME-LENGTH-MERGESORT
+ SUBSETP-EQUAL-OF-VL-MODINSTLIST->MODNAMESS-WHEN-SUBSETP-EQUAL
+ CDR-OF-VL-MODULELIST-DUPERHS-CHECK
+ CDR-OF-VL-MODULELIST-ORIGEXPRS
+ CDR-OF-VL-MODULELIST-MAKE-ARRAY-INDEXING
+ vl-modulelist-p-of-append
+ NO-DUPLICATESP-EQUAL-OF-APPEND
+ acl2::no-duplicatesp-equal-append-iff
+ mergesort)))
+
+(define run-vl-lint-main ((mods (and (vl-modulelist-p mods)
+ (uniquep (vl-modulelist->names mods))))
+ (config vl-lintconfig-p))
+ :returns (result vl-lintresult-p :hyp :fguard)
+
+ (b* (((vl-lintconfig config) config)
+
+ (mods (vl-modulelist-drop-user-submodules mods config.dropmods))
+
+ ;; You might expect that we'd immediately throw out modules that we
+ ;; don't need for topmods. Historically we did that. But then we found
+ ;; that we'd get a bunch of complaints in other modules about
+ ;; hierarchical identifiers that pointed into the modules we'd just
+ ;; thrown away! So now we deal with this stuff after HID resolution.
+ ;; Except that for skip-detection, we also need to remove them from
+ ;; mods0, so do that now:
+ (mods0 (if (not config.topmods)
+ mods
+ (vl-remove-unnecessary-modules (mergesort config.topmods)
+ (mergesort mods))))
+
+
+ (- (cw "~%vl-lint: initial processing...~%"))
+ (mods (cwtime (vl-modulelist-portcheck mods)))
+ (mods (cwtime (vl-modulelist-check-case mods)))
+ (mods (cwtime (vl-modulelist-duperhs-check mods)))
+ (mods (cwtime (vl-modulelist-duplicate-detect mods)))
+ (mods (cwtime (vl-modulelist-condcheck mods)))
+ (mods (cwtime (vl-modulelist-leftright-check mods)))
+ (mods (cwtime (vl-modulelist-drop-missing-submodules mods)))
+ ;; BOZO reinstate this??
+ ;; (mods (cwtime (vl-modulelist-add-undefined-names mods)))
+ (mods (cwtime (vl-modulelist-portdecl-sign mods)))
+ (mods (cwtime (vl-modulelist-make-array-indexing mods)))
+ (mods (cwtime (vl-modulelist-origexprs mods)))
+ (mods (cwtime (vl-modulelist-check-namespace mods)))
+
+ (- (cw "~%vl-lint: processing arguments, parameters...~%"))
+ (mods (cwtime (vl-modulelist-elim-unused-regs mods)))
+ (mods (cwtime (vl-modulelist-argresolve mods)))
+ (mods (cwtime (vl-modulelist-dupeinst-check mods)))
+
+ ;; BOZO not exactly sure where this should go, maybe this will work.
+ (mods (cwtime (vl-modulelist-expand-functions mods)))
+
+ ;; BOZO we need to do something to throw away instances with unresolved
+ ;; arguments to avoid programming-errors in drop-blankports... and actually
+ ;; we hit errors like that later, too.
+ (mods (cwtime (vl-modulelist-drop-blankports mods)))
+ (mods (cwtime (mp-verror-transform-hook mods)))
+ (mods (cwtime (vl-modulelist-follow-hids mods)))
+ (mods (cwtime (vl-modulelist-clean-params mods)))
+ (mods (cwtime (vl-modulelist-check-good-paramdecls mods)))
+
+ ((mv mods bad)
+ (vl-filter-mods-with-good-paramdecls mods nil nil))
+ (- (or (not bad)
+ (progn$
+ (cw "~%~%Note: deleting ~x0 module~s1 because they include ~
+ unsupported parameter declarations.~%~%~
+ Module~s1 being deleted: ~&2~%~%~
+ Details:~%~%"
+ (len bad)
+ (if (= (len bad) 1) "" "s")
+ (mergesort (vl-modulelist->names bad)))
+ (vl-print-certain-warnings bad
+ (list :vl-bad-paramdecl
+ :vl-bad-paramdecls)
+ nil))))
+ (mods (cwtime (vl-modulelist-drop-missing-submodules mods)))
+ (mods (if (and (uniquep (vl-modulelist->names mods))
+ (vl-modulelist-complete-p mods mods)
+ (vl-good-paramdecllist-list-p-of-vl-modulelist->paramdecls mods))
+ mods
+ (er hard? 'vl-lint
+ "Programming error. Expected modules to be complete ~
+ and to have good parameters, but this is not the case. ~
+ Please tell Jared about this failure.")))
+ ((mv mods failmods) (cwtime (vl-unparameterize mods 30)))
+ (mods (append mods failmods))
+ (- (vl-gc))
+
+ (mods (if (uniquep (vl-modulelist->names mods))
+ mods
+ (progn$
+ (sneaky-save :bad-names mods)
+ (er hard? 'vl-lint
+ "Programming error. Expected modules to have unique ~
+ names after vl-unparameterize, but found duplicate ~
+ modules named ~x0. Please tell Jared."
+ (duplicated-members (vl-modulelist->names mods))))))
+
+
+ (- (cw "~%vl-lint: processing ranges, statements...~%"))
+ (mods (cwtime (vl-modulelist-rangeresolve mods)))
+ (mods (cwtime (vl-modulelist-selresolve mods)))
+ (mods (cwtime (vl-modulelist-check-selfassigns mods)))
+ (mods (cwtime (vl-modulelist-lint-stmt-rewrite mods)))
+ (mods (cwtime (vl-modulelist-stmtrewrite mods 1000)))
+ (mods (cwtime (vl-modulelist-hid-elim mods)))
+
+ (mods (if (uniquep (vl-modulelist->names mods))
+ mods
+ (progn$
+ (sneaky-save :bad-names mods)
+ (er hard? 'vl-lint
+ "Programming error. Expected modules to have unique ~
+ names after vl-modulelist-hid-elim, but found duplicate ~
+ modules named ~x0. Please tell Jared."
+ (duplicated-members (vl-modulelist->names mods))))))
+
+ ;; Now that HIDs are gone, we can throw away any modules we don't care
+ ;; about, if we have been given any topmods.
+ (mods (if (not config.topmods)
+ mods
+ (vl-remove-unnecessary-modules (mergesort config.topmods)
+ (mergesort mods))))
+
+
+ ;; BOZO it seems sort of legitimate to do this before sizing, which
+ ;; might be nice. Of course, a more rigorous use/set analysis will
+ ;; need to be post-sizing.
+ (- (cw "~%vl-lint: finding disconnected wires...~%"))
+ (mods (cwtime (vl-modulelist-remove-toohard mods)))
+ (mods (cwtime (vl-modulelist-find-disconnected mods)))
+
+ (- (cw "~%vl-lint: processing expressions...~%"))
+ (mods (cwtime (vl-modulelist-oddexpr-check mods)))
+ (mods (cwtime (vl-modulelist-oprewrite mods)))
+ (mods (cwtime (vl-modulelist-exprsize mods)))
+ (mods (cwtime (vl-modulelist-qmarksize-check mods)))
+
+ (- (cw "~%vl-lint: finding unused/unset wires...~%"))
+ ;; BOZO this probably doesn't quite work here due to replicate not having been done
+ ((mv mods dalist) (cwtime (us-analyze-mods mods)))
+ (- (vl-gc))
+
+ (- (cw "~%vl-lint: processing assignments...~%"))
+ (mods (cwtime (vl-modulelist-split mods)))
+ (mods (cwtime (vl-modulelist-replicate mods)))
+ (mods (cwtime (vl-modulelist-blankargs mods)))
+ (mods (cwtime (vl-modulelist-trunc mods)))
+
+ (- (cw "~%vl-lint: finding skipped and multiply driven wires...~%"))
+ ;; NOTE: use mods0, not mods, if you ever want this to finish. :)
+ (sd-probs (cwtime (sd-analyze-modulelist mods0)))
+ (mods (cwtime (vl-modulelist-multidrive-detect mods)))
+
+ (- (cw "~%vl-lint: cleaning up...~%"))
+ (mods (cwtime (vl-modulelist-clean-warnings mods)))
+ (mods (cwtime (vl-modulelist-suppress-lint-warnings mods)))
+ (mods (cwtime (vl-modulelist-lint-ignoreall mods config.ignore)))
+ (mods (cwtime (vl-delete-modules config.quiet mods)))
+ (sd-probs (cwtime (vl-delete-sd-problems-for-modnames config.quiet sd-probs)))
+ (mwalist (cwtime (vl-origname-modwarningalist mods))))
+
+ (make-vl-lintresult :mods mods
+ :mods0 mods0
+ :mwalist mwalist
+ :sd-probs sd-probs
+ :dalist dalist)))
+
+
+(define run-vl-lint ((config vl-lintconfig-p) &key (state 'state))
+ :returns (mv (res vl-lintresult-p :hyp :fguard)
+ (state state-p1 :hyp (state-p1 state)))
+ (b* ((- (cw "Starting VL-Lint~%"))
+ ((vl-lintconfig config) config)
+ (- (or (not config.debug)
+ (cw "Lint configuration: ~x0~%" config)))
+
+ (loadconfig (make-vl-loadconfig
+ :start-files config.start-files
+ :search-path config.search-path
+ :search-exts config.search-exts))
+ (- (or (not config.debug)
+ (cw "Load configuration: ~x0~%" loadconfig)))
+
+ (- (cw "~%vl-lint: loading modules...~%"))
+ ((mv loadres state) (cwtime (vl-load loadconfig)))
+
+ (lintres
+ (cwtime (run-vl-lint-main (vl-loadresult->mods loadres)
+ config))))
+ (mv lintres state)))
+
+
+(defund sd-problem-major-p (x)
+ (declare (xargs :guard (sd-problem-p x)))
+ (b* (((sd-problem x) x))
+ (or (>= x.priority 10)
+ (and (>= x.priority 6) (>= x.groupsize 4))
+ (>= (sd-problem-score x) 8))))
+
+(defsection sd-filter-problems
+
+ (defund sd-filter-problems (x major minor)
+ "Returns (MV MAJOR MINOR)"
+ (declare (xargs :guard (sd-problemlist-p x)))
+ (cond ((atom x)
+ (mv major minor))
+ ((sd-problem-major-p (car x))
+ (sd-filter-problems (cdr x) (cons (car x) major) minor))
+ (t
+ (sd-filter-problems (cdr x) major (cons (car x) minor)))))
+
+ (local (in-theory (enable sd-filter-problems)))
+
+ (defthm sd-problemlist-p-of-sd-filter-problems
+ (and (implies (and (sd-problemlist-p x)
+ (sd-problemlist-p major))
+ (sd-problemlist-p (mv-nth 0 (sd-filter-problems x major minor))))
+ (implies (and (sd-problemlist-p x)
+ (sd-problemlist-p minor))
+ (sd-problemlist-p (mv-nth 1 (sd-filter-problems x major minor))))))
+
+ (defthm true-listp-sd-filter-problems
+ (and (implies (true-listp major)
+ (true-listp (mv-nth 0 (sd-filter-problems x major minor))))
+ (implies (true-listp minor)
+ (true-listp (mv-nth 1 (sd-filter-problems x major minor)))))))
+
+
+
+(defthm symbol-listp-of-vl-warninglist->types
+ (implies (force (vl-warninglist-p x))
+ (symbol-listp (vl-warninglist->types x)))
+ :hints(("Goal" :induct (len x))))
+
+
+(define vl-modwarningalist-types ((x vl-modwarningalist-p))
+ (if (atom x)
+ nil
+ (append (vl-warninglist->types (cdar x))
+ (vl-modwarningalist-types (cdr x))))
+ ///
+ (defthm symbol-listp-of-vl-modwarningalist-types
+ (implies (force (vl-modwarningalist-p x))
+ (symbol-listp (vl-modwarningalist-types x)))))
+
+
+(defund vl-keep-from-modwarningalist (types x)
+ ;; Returns a new fast alist.
+ (declare (xargs :guard (and (symbol-listp types)
+ (vl-modwarningalist-p x))))
+ (if (atom x)
+ nil
+ (b* ((name1 (caar x))
+ (warnings1 (cdar x))
+ (keep1 (vl-keep-warnings types warnings1))
+ (rest (vl-keep-from-modwarningalist types (cdr x))))
+ (if keep1
+ (hons-acons name1 keep1 rest)
+ rest))))
+
+(defthm vl-modwarningalist-p-of-vl-keep-from-modwarningalist
+ (implies (and (force (symbol-listp types))
+ (force (vl-modwarningalist-p x)))
+ (vl-modwarningalist-p (vl-keep-from-modwarningalist types x)))
+ :hints(("Goal" :in-theory (enable vl-keep-from-modwarningalist))))
+
+
+(define vl-lint-print-warnings ((filename stringp)
+ (label stringp)
+ (types symbol-listp)
+ (walist vl-modwarningalist-p)
+ &key (ps 'ps))
+ (b* ((walist (vl-keep-from-modwarningalist types walist))
+ (walist (vl-clean-modwarningalist walist))
+ (count (length (append-domains walist)))
+ (- (cond ((int= count 0)
+ (cw "~s0: No ~s1 Warnings.~%" filename label))
+ ((int= count 1)
+ (cw "~s0: One ~s1 Warning.~%" filename label))
+ (t
+ (cw "~s0: ~x1 ~s2 Warnings.~%" filename count label)))))
+ (vl-ps-seq
+ (cond ((int= count 0)
+ (vl-cw "No ~s0 Warnings.~%~%" label))
+ ((int= count 1)
+ (vl-cw "One ~s0 Warning:~%~%" label))
+ (t
+ (vl-cw "~x0 ~s1 Warnings:~%~%" count label)))
+ (vl-print-modwarningalist walist))))
+
+
+(define vl-jp-modwarningalist-aux ((x vl-modwarningalist-p) &key (ps 'ps))
+ (b* (((when (atom x))
+ ps)
+ ((cons modname warnings) (car x)))
+ (vl-ps-seq (vl-indent 1)
+ (jp-str modname)
+ (vl-print ":")
+ (vl-jp-warninglist warnings)
+ (if (atom (cdr x))
+ ps
+ (vl-println ","))
+ (vl-jp-modwarningalist-aux (cdr x)))))
+
+(define vl-jp-modwarningalist ((x vl-modwarningalist-p) &key (ps 'ps))
+ (vl-ps-seq (vl-print "{")
+ (vl-jp-modwarningalist-aux x)
+ (vl-println "}")))
+
+(defconst *use-set-warnings*
+ (list :use-set-fudging
+ :use-set-trainwreck
+ :use-set-future-trainwreck
+ :use-set-warn-1-unset
+ :use-set-warn-1-unset-tricky
+ :use-set-warn-2-unused
+ :use-set-warn-2-unused-tricky
+ :use-set-warn-3-spurious
+ :use-set-warn-3-spurious-tricky
+ :use-set-syntax-error
+ :vl-collect-wires-approx
+ :vl-collect-wires-fail
+ :vl-dropped-always
+ :vl-dropped-assign
+ :vl-dropped-initial
+ :vl-dropped-insts
+ :vl-dropped-modinst
+ :vl-warn-function
+ :vl-warn-taskdecl
+ :vl-unsupported-block))
+
+(defconst *basic-warnings*
+ (list :bad-mp-verror
+ :vl-bad-range
+ :vl-warn-duplicates
+ :vl-bad-instance
+ :vl-unresolved-hid
+ :vl-warn-unused-reg
+ :vl-warn-blank
+ :vl-undefined-names
+ :vl-port-mismatch))
+
+(defconst *trunc-warnings*
+ (list :vl-warn-extension
+ :vl-warn-truncation
+ :vl-warn-integer-size))
+
+(defconst *trunc-minor-warnings*
+ (list :vl-warn-extension-minor
+ :vl-warn-truncation-minor
+ :vl-warn-integer-size-minor
+ :vl-warn-vague-spec))
+
+(defconst *disconnected-warnings*
+ (list :vl-warn-disconnected
+ :vl-warn-disconnected-interesting
+ ;; Caveats that could make the analysis wrong
+ :vl-collect-wires-fail
+ :vl-collect-wires-approx
+ :vl-dropped-always
+ :vl-dropped-assign
+ :vl-dropped-initial
+ :vl-dropped-insts
+ :vl-dropped-modinst
+ :vl-warn-function
+ :vl-warn-taskdecl
+ :vl-unsupported-block))
+
+(defconst *smell-warnings*
+ (list :vl-warn-qmark-width
+ :vl-warn-qmark-const
+ :vl-warn-leftright
+ :vl-warn-selfassign
+ :vl-warn-instances-same
+ :vl-warn-case-sensitive-names
+ :vl-warn-same-rhs))
+
+(defconst *smell-minor-warnings*
+ (list :vl-warn-partselect-same
+ :vl-warn-instances-same-minor))
+
+(defconst *multidrive-warnings*
+ (list :vl-warn-multidrive))
+
+(defconst *multidrive-minor-warnings*
+ (list :vl-warn-multidrive-minor))
+
+(defconst *fussy-size-warnings*
+ (list :vl-fussy-size-warning-1
+ :vl-fussy-size-warning-2
+ :vl-fussy-size-warning-3
+ :vl-fussy-size-warning-1-const-toobig
+ :vl-fussy-size-warning-2-const-toobig
+ :vl-fussy-size-warning-3-const-toobig
+ :vl-fussy-size-warning-1-complex
+ :vl-fussy-size-warning-2-complex
+ :vl-fussy-size-warning-3-complex
+ ))
+
+(defconst *same-ports-warnings*
+ (list :vl-warn-same-ports
+ :vl-warn-same-inputs))
+
+(defconst *same-ports-minor-warnings*
+ (list :vl-warn-same-ports-minor
+ :vl-warn-same-inputs-minor))
+
+(defconst *fussy-size-minor-warnings*
+ (list :vl-fussy-size-warning-1-minor
+ :vl-fussy-size-warning-2-minor
+ :vl-fussy-size-warning-3-minor))
+
+
+
+
+(defconst *warnings-covered*
+
+ ;; Warnings that are covered by our regular reports. Other warnings besides
+ ;; these will get put into vl-other.txt
+
+ (append *use-set-warnings*
+ *basic-warnings*
+ *trunc-warnings*
+ *trunc-minor-warnings*
+ *disconnected-warnings*
+ *smell-warnings*
+ *smell-minor-warnings*
+ *multidrive-warnings*
+ *multidrive-minor-warnings*
+ *fussy-size-warnings*
+ *fussy-size-minor-warnings*
+ *same-ports-warnings*
+ *same-ports-minor-warnings*
+ ))
+
+(defconst *warnings-ignored*
+
+ ;; Warnings that aren't covered but which we don't want to put into vl-other.txt
+ ;; anyway.
+
+ (list
+ :vl-warn-taskdecl
+ :vl-warn-function
+
+ ))
+
+(local (in-theory (disable sets::in sets::in-tail
+ sets::difference sets::mergesort)))
+
+(defun vl-lint-report (lintresult state)
+ (declare (xargs :guard (vl-lintresult-p lintresult)
+ :stobjs state))
+
+ (b* (((vl-lintresult lintresult) lintresult)
+ (walist lintresult.mwalist)
+ (sd-probs lintresult.sd-probs)
+
+ ((mv major minor)
+ (cwtime (sd-filter-problems sd-probs nil nil)))
+ (major (reverse major))
+ (minor (reverse minor))
+
+ (- (cw "~%vl-lint: saving results...~%~%"))
+
+ (othertypes (difference (mergesort (vl-modwarningalist-types walist))
+ (mergesort (append *warnings-covered*
+ *warnings-ignored*))))
+
+ (state
+ (with-ps-file
+ "vl-basic.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-basic.txt" "Basic" *basic-warnings* walist)))
+
+ (state
+ (with-ps-file
+ "vl-trunc.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-print "
+NOTE: see the bottom of this file for an explanation of what these warnings
+mean and how to avoid them.
+
+")
+
+ (vl-lint-print-warnings "vl-trunc.txt" "Truncation/Extension" *trunc-warnings* walist)
+
+ (vl-print "
+
+UNDERSTANDING THESE WARNINGS.
+
+1. VL-WARN-TRUNCATION warnings are issued when the left-hand side of an
+assignment statement is not as wide as the right-hand side.
+
+False positives here can typically be suppressed by using part-selects to make
+the intended truncations explicit. For instance:
+
+ wire [47:0] foo ;
+ wire [63:0] bar ;
+
+ assign foo = bar ; // implicit truncation, causes warning
+ assign foo = bar[47:0] ; // explicit truncation, no warning
+
+ assign foo = condition ? bar : 0 ; // implicit truncation, causes warning
+ assign foo = condition ? bar[47:0] : 0; // explicit truncation, no warning
+
+
+2. VL-WARN-EXTENSION warnings are the opposite: they are issued when the
+left-hand side is wider than the right-hand side would have been on its own.
+
+False-positives can again typically be suppressed by explicitly concatenting in
+zeroes, or by using part-selects to cut the left-hand side to the right size.
+For instance:
+
+ wire [47:0] foo ;
+ wire [63:0] bar ;
+
+ assign bar = foo ; // implicit extension, causes warning
+ assign bar = { 16'b0, foo } ; // explicit extension, no warning
+ assign bar[47:0] = foo; // no extension, no warning
+
+
+Note that we consider certain truncation and extension warnings to be \"minor\"
+and do not report them here. Such warnings are unlikely to be a problem, but
+you can see \"vl-trunc-minor.txt\" to review them.")))
+
+ (state
+ (with-ps-file
+ "vl-fussy.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-fussy.txt" "Fussy Size Warnings" *fussy-size-warnings* walist)))
+
+ (state
+ (with-ps-file
+ "vl-fussy-minor.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-fussy-minor.txt" "Minor Fussy Size Warnings" *fussy-size-minor-warnings* walist)))
+
+ (state
+ (with-ps-file
+ "vl-disconnected.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-disconnected.txt" "Disconnected Wire" *disconnected-warnings* walist)))
+
+ (state
+ (with-ps-file
+ "vl-multi.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-multi.txt" "Multidrive" *multidrive-warnings* walist)))
+
+ (state
+ (if (not major)
+ (progn$
+ (cw "; No Skip-Detect Warnings.~%")
+ state)
+ (progn$
+ (cw "vl-skipdet.txt: ~x0 Skip-Detect Warnings.~%" (len major))
+ (with-ps-file "vl-skipdet.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-cw "Skip-Detect Warnings.~%~%")
+ (sd-pp-problemlist-long major)))))
+
+ (state
+ (with-ps-file
+ "vl-trunc-minor.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-print "
+NOTE: see the bottom of this file for an explanation of what these warnings
+mean and how to avoid them.
+
+")
+ (vl-lint-print-warnings "vl-trunc-minor.txt" "Minor Truncation/Extension" *trunc-minor-warnings* walist)
+ (vl-print "
+
+UNDERSTANDING THESE WARNINGS.
+
+1. VL-WARN-TRUNCATION-32 warnings are generated for any assignments that are
+being truncated and whose right-hand sides are 32-bits wide. This is a minor
+warning because it typically arises from assignments where plain integers are
+involved, e.g., if foo and bar are 10 bits wide, then a truncation-32 warning
+will be generated for:
+
+ assign foo = bar ^ 5;
+
+This is because \"5\" has an implementation-dependent width (of at least 32
+bits), and in VL-Lint we treat it as being 32-bits wide. So, the above
+describes a 32-bit XOR that is then truncated down to 10 bits. Fixing these
+warnings is usually easy: just explicitly specify the sizes of the numbers
+involved, e.g., a \"corrected\" version might be:
+
+ assign foo = bar ^ 10'd 5;
+
+This is generally a good idea since it avoids any implementation-dependent
+sizing (which can occasionally affect the results of expressions).
+
+
+2. VL-WARN-EXTENSION-MINOR warnings are generated for any assignments where
+the width of the left-hand side is used to size the expression, and where the
+right-hand side involves only addition operations. For instance, given:
+
+ wire [9:0] foo;
+ wire [9:0] bar;
+ wire [9:0] sum;
+ wire carry;
+
+Then an assignment like this:
+
+ assign { carry, sum } = foo + bar;
+
+would result in a minor extension warning. These warnings are typically quite
+minor since you frequently want to get the carry out of a sum. But you could
+suppress them by writing something like this:
+
+ Variant 1: assign {carry, sum} = {1'b0,foo} + bar;
+ Variant 2: assign {carry, sum} = foo + bar + 11'b0;
+
+or similar, to make explicit on the right-hand side that you want an 11-bit
+wide addition instead of a 10-bit wide addition.")))
+
+ (state
+ (with-ps-file
+ "vl-multi-minor.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-multi-minor.txt" "Minor Multidrive" *multidrive-minor-warnings* walist)))
+
+ (state
+ (if (not minor)
+ (prog2$
+ (cw "; No Minor Skip-Detect Warnings.~%")
+ state)
+ (prog2$
+ (cw "vl-skipdet-minor.txt: ~x0 Minor Skip-Detect Warnings.~%" (len minor))
+ (with-ps-file "vl-skipdet-minor.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-cw "Minor Skip-Detect Warnings.~%~%")
+ (sd-pp-problemlist-long minor)))))
+
+
+ (state
+ (with-ps-file
+ "vl-use-set.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-use-set.txt"
+ "Unused/Unset Wire Warnings"
+ *use-set-warnings*
+ walist)))
+
+
+ (state
+ (with-ps-file
+ "vl-smells.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-smells.txt" "Code-Smell Warnings" *smell-warnings* walist)))
+
+ (state
+ (with-ps-file
+ "vl-smells-minor.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-smells-minor.txt" "Minor Code-Smell Warnings" *smell-minor-warnings* walist)))
+
+
+ (state
+ (with-ps-file "vl-same-ports.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-same-ports.txt"
+ "Same-ports Warnings"
+ *same-ports-warnings*
+ walist)))
+ (state
+ (with-ps-file "vl-same-ports-minor.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-same-ports-minor.txt"
+ "Minor same-ports Warnings"
+ *same-ports-minor-warnings*
+ walist)))
+
+ (state
+ (with-ps-file
+ "vl-other.txt"
+ (vl-ps-update-autowrap-col 68)
+ (vl-lint-print-warnings "vl-other.txt" "Other/Unclassified" othertypes walist)))
+
+ (- (cw "~%"))
+
+ (state
+ (cwtime
+ (with-ps-file "vl-warnings.json"
+ (vl-print "{\"warnings\":")
+ (vl-jp-modwarningalist walist)
+ (vl-println "}"))
+ :name write-warnings-json)))
+
+ state))
+
+
+(defconsts (*vl-lint-readme* state)
+ (b* (((mv contents state) (acl2::read-file-characters "lint.readme" state))
+ ((when (stringp contents))
+ (raise contents)
+ (mv "" state)))
+ (mv (implode contents) state)))
+
+(define vl-lint ((args string-listp) &key (state 'state))
+ :parents (kit lint)
+ :short "The @('vl lint') command."
+
+ (b* (((mv errmsg config start-files)
+ (parse-vl-lintconfig args))
+ ((when errmsg)
+ (die "~@0~%" errmsg)
+ state)
+ (config
+ (change-vl-lintconfig config
+ :start-files start-files))
+ ((vl-lintconfig config) config)
+
+ (- (acl2::set-max-mem ;; newline to appease cert.pl
+ (* (expt 2 30) config.mem)))
+
+ ((when config.help)
+ (vl-cw-ps-seq (vl-print *vl-lint-help*))
+ (exit-ok)
+ state)
+
+ ((when config.readme)
+ (vl-cw-ps-seq (vl-print *vl-lint-readme*))
+ (exit-ok)
+ state)
+
+ (- (or (not config.debug)
+ (vl-cw-ps-seq
+ (vl-cw "Raw args: ~x0~%" args)
+ (vl-cw "Start-files: ~x0~%" start-files))))
+
+ ((unless (consp config.start-files))
+ (die "No files to process.")
+ state)
+
+ (state (must-be-regular-files! config.start-files))
+ (state (must-be-directories! config.search-path))
+
+ ((mv result state)
+ (cwtime (run-vl-lint config)
+ :name vl-lint))
+ (state
+ (cwtime (vl-lint-report result state))))
+ (exit-ok)
+ state))
+
+
+#||
+
+(vl-lint (list "
+
+||#
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/vl/kit/lint.readme acl2-6.3/books/centaur/vl/kit/lint.readme
--- acl2-6.2/books/centaur/vl/kit/lint.readme 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/lint.readme 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,85 @@
+------------------------------------------------------------------------------
+
+ VL LINT README
+
+------------------------------------------------------------------------------
+
+You can use VL's "lint" tool to identify potential problems in Verilog code.
+
+It can warn you about things like:
+
+ - Duplicate module elements
+ - Wires driven by multiple sources
+ - Implicit truncations and extensions in assignments
+ - Unused and unset parts of wires
+ - Possible problems with operator precedence
+ - Strange statements that sometimes indicate copy/paste errors
+ - Potentially skipped wires in expressions like:
+ assign bar = (foo0 & foo1 & foo2 & foo4 & foo5)
+ ^^ where is foo3?
+
+
+------------------------------------------------------------------------------
+
+ Running the Linter
+
+To see the available command-line options, just run
+
+ vl help lint
+
+A typical invocation might look like this:
+
+ vl lint my_mod1.v my_mod2.v \ <-- starting files to load
+ -s libs/my_lib1 \ <-- search paths for finding
+ -s libs/my_lib2 additional modules
+
+The linter will print some progress messages, then writes several text files
+containing its report. (It generally produces too much output, so to try to
+filter this out and let you focus on the most likely errors, we split the
+output into several files).
+
+Here is a summary:
+
+Generic warnings: (probably the most interesting)
+ vl-basic.txt - basic warnings
+
+Multiply driven wires: (sometimes interesting)
+ vl-multi.txt - more likely to be problems
+ vl-multi-minor.txt - unlikely to be problems
+
+Truncation/Extension warnings: (sometimes interesting)
+ vl-trunc.txt - more likely to be problems
+ vl-trunc-minor.txt - unlikely to be problems
+
+Fussy size warnings: (sometimes interesting)
+ vl-fussy.txt - like truncation warnings on stroids
+ vl-fussy-minor.txt - unlikely to be problems
+
+Unconnected wires: (useful when cleaning up)
+ vl-disconnected.txt - wires that aren't connected at all
+ vl-use-set.txt - wires that seem to be undriven/unused (sometimes wrong)
+
+Skip detection: (only occasionally useful)
+ vl-skipdet.txt - high-scoring expressions, more likely to be problems
+ vl-skipdet-minor.txt - low-scoring expressions, unlikely to be problems
+
+
+------------------------------------------------------------------------------
+
+ Suppressing False Positives
+
+You can tell the linter to ignore certain things by adding comments to your
+Verilog source files. For instance:
+
+ //@VL LINT_IGNORE_TRUNCATION // to suppress the truncation warning
+ assign foo[3:0] = bar[5:0];
+
+ //@VL LINT_IGNORE // to suppress all warnings
+ assign foo[3:0] = bar[5:0];
+
+This feature is probably fancier than anyone needs. There are also some
+command-line options to suppress all warnings for particular modules, or all
+warnings of particular types, etc. See "vl help lint" for details.
+
+
+------------------------------------------------------------------------------
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/vl/kit/model.lisp acl2-6.3/books/centaur/vl/kit/model.lisp
--- acl2-6.2/books/centaur/vl/kit/model.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/model.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,270 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "VL")
+(include-book "../top")
+(include-book "centaur/getopt/top" :dir :system)
+(include-book "std/io/read-file-characters" :dir :system)
+(include-book "progutils")
+(include-book "oslib/catpath" :dir :system)
+(local (include-book "../util/arithmetic"))
+(local (include-book "../util/osets"))
+
+
+; I don't think we care about emaps anymore. It looks like they still may be
+; supported in the VCD dumping code, but I'm pretty sure we don't actually use
+; them. So, I'm not going to build them in here.
+
+(defoptions vl-model-opts
+ :parents (vl-model)
+ :short "Options for running @('vl model')."
+ :tag :vl-model-opts
+
+ ((help booleanp
+ :alias #\h
+ "Show a brief usage message and exit."
+ :rule-classes :type-prescription)
+
+ (readme booleanp
+ "Show a more elaborate README and exit."
+ :rule-classes :type-prescription)
+
+ (outdir stringp
+ :argname "DIR"
+ "Default is \".\". Controls where the translation files should
+ be written."
+ :default "."
+ :rule-classes :type-prescription)
+
+ (model-file stringp
+ :argname "NAME"
+ :default "model.sao"
+ "Default is \"model.sao\". Contains the main vl-translation-p
+ object with E modules as well as copious other information
+ about from the translation. See the readme for details. To
+ avoid writing this file, you can use the empty string, i.e.,
+ --model-file ''."
+ :rule-classes :type-prescription)
+
+ (esims-file stringp
+ :argname "NAME"
+ :default "esims.sao"
+ "Default is \"esims.sao\". Contains just the E modules, and is
+ typically much smaller than model.sao. To avoid writing this
+ file, you can use the empty string, i.e., --esims-file ''."
+ :rule-classes :type-prescription)
+
+ (start-files string-listp
+ "The list of files to parse. (Not options; this is the rest of
+ the command line, hence :hide t)"
+ :hide t)
+
+ (search-path string-listp
+ :longname "search"
+ :alias #\s
+ :argname "DIR"
+ "Control the search path for finding modules. You can give
+ this switch multiple times, to set up multiple search paths in
+ priority order."
+ :parser getopt::parse-string
+ :merge acl2::rcons)
+
+ (search-exts string-listp
+ :longname "searchext"
+ :argname "EXT"
+ "Control the search extensions for finding modules. You can
+ give this switch multiple times. By default we just look for
+ files named \"foo.v\" in the --search directories. But if you
+ have Verilog files with different extensions, this won't work,
+ so you can add these extensions here. EXT should not include
+ the period, e.g., use \"--searchext vv\" to consider files
+ like \"foo.vv\", etc."
+ :parser getopt::parse-string
+ :merge acl2::rcons
+ :default '("v"))
+
+ (overrides string-listp
+ :longname "override"
+ :argname "DIR"
+ "(Advanced) Set up VL override directories. You can give this
+ switch multiple times. By default there are no override
+ directories. See the VL documentation on overrides (under
+ loader) for more information."
+ :parser getopt::parse-string
+ :merge acl2::rcons)
+
+ (defines string-listp
+ :longname "define"
+ :alias #\D
+ :argname "VAR"
+ "Set up definitions to use before parsing begins. Equivalent
+ to putting `define VAR 1 at the top of your Verilog file.
+ You can give this option multiple times."
+ :parser getopt::parse-string
+ :merge acl2::cons)
+
+ (unroll-limit natp
+ :longname "unroll"
+ :argname "LIMIT"
+ "Set the maximum number of times to unroll loops to LIMIT.
+ Default: 100."
+ :default 100)
+
+ (dropmods string-listp
+ :longname "drop"
+ :argname "MOD"
+ "Delete MOD from the module hierarchy before doing any simplification.
+ This is a gross (but effective) way to work through any bugs in
+ VL that cause hard errors and are triggered by certain modules.
+ We will fail to model anything that depends on the dropped
+ modules."
+ :parser getopt::parse-string
+ :merge cons)
+
+ (mem posp
+ :alias #\m
+ :argname "GB"
+ "How much memory to try to use. Default: 4 GB. Raising this
+ may improve performance by avoiding garbage collection. To
+ avoid swapping, keep this below (physical_memory - 2 GB)."
+ :default 4
+ :rule-classes :type-prescription)
+ ))
+
+
+(defconst *vl-model-help* (str::cat "
+vl model: Make an ACL2 model of a Verilog design.
+
+Example: vl model engine.v wrapper.v core.v \\
+ --search ./simlibs \\
+ --search ./baselibs
+
+Usage: vl model [OPTIONS] file.v [file2.v ...]
+
+Options:" *nls* *nls* *vl-model-opts-usage* *nls*))
+
+
+(define vl-model-main ((opts vl-model-opts-p)
+ &key (state 'state))
+
+ (b* (((vl-model-opts opts) opts)
+
+ (want-translation-p (not (equal opts.model-file "")))
+
+ (loadconfig (make-vl-loadconfig
+ :override-dirs opts.overrides
+ :start-files opts.start-files
+ :search-path opts.search-path
+ :search-exts opts.search-exts
+ :defines (vl-make-initial-defines opts.defines)
+ :filemapp want-translation-p))
+
+ (simpconfig (make-vl-simpconfig
+ :problem-mods opts.dropmods
+ :unroll-limit opts.unroll-limit
+ :compress-p want-translation-p))
+
+ ((mv translation state)
+ (defmodules-fn loadconfig simpconfig))
+
+ (state
+ (if (equal opts.model-file "")
+ state
+ (serialize-write (oslib::catpath opts.outdir opts.model-file)
+ translation
+ :verbosep t)))
+
+ (state
+ (if (equal opts.esims-file "")
+ state
+ (serialize-write (oslib::catpath opts.outdir opts.esims-file)
+ (vl-modulelist->esims (vl-translation->mods translation))
+ :verbosep t))))
+ state))
+
+(defconsts (*vl-model-readme* state)
+ (b* (((mv contents state) (acl2::read-file-characters "model.readme" state))
+ ((when (stringp contents))
+ (raise contents)
+ (mv "" state)))
+ (mv (implode contents) state)))
+
+
+(define vl-model ((argv string-listp) &key (state 'state))
+ :parents (kit lint)
+ :short "The @('vl model') command."
+ (b* (((mv errmsg opts start-files)
+ (parse-vl-model-opts argv))
+ ((when errmsg)
+ (die "~@0~%" errmsg)
+ state)
+ (opts (change-vl-model-opts opts
+ :start-files start-files))
+ ((vl-model-opts opts) opts)
+
+ ((when opts.help)
+ (vl-cw-ps-seq (vl-print *vl-model-help*))
+ (exit-ok)
+ state)
+
+ ((when opts.readme)
+ (vl-cw-ps-seq (vl-print *vl-model-readme*))
+ (exit-ok)
+ state)
+
+ ((unless (consp opts.start-files))
+ (die "No files to process.")
+ state)
+
+ (- (cw "Building ACL2 model for:~%"))
+
+ (- (cw " - start files: ~x0~%" opts.start-files))
+ (state (must-be-regular-files! opts.start-files))
+
+ (- (cw " - search path: ~x0~%" opts.search-path))
+ (state (must-be-directories! opts.search-path))
+
+ (- (and opts.overrides
+ (cw " - overrides: ~x0~%" opts.overrides)))
+ (state (must-be-directories! opts.overrides))
+
+ (- (and opts.defines (cw "; defines: ~x0~%" opts.defines)))
+
+ (- (cw "Writing output to ~x0:~%" opts.outdir))
+ (state (must-be-directories! (list opts.outdir)))
+
+ ((when (and (equal opts.model-file "")
+ (equal opts.esims-file "")))
+ (die "No model file or esims file, so nothing to do?")
+ state)
+
+ (- (or (equal opts.model-file "")
+ (cw " - model file: ~x0" opts.model-file)))
+
+ (- (or (equal opts.esims-file "")
+ (cw " - esims file: ~x0" opts.esims-file)))
+
+ (- (cw "Soft heap size ceiling: ~x0 GB~%" opts.mem))
+ (- (acl2::set-max-mem ;; newline to appease cert.pl's scanner
+ (* (expt 2 30) opts.mem)))
+
+ (state (vl-model-main opts)))
+ (exit-ok)
+ state))
diff -Nru acl2-6.2/books/centaur/vl/kit/model.readme acl2-6.3/books/centaur/vl/kit/model.readme
--- acl2-6.2/books/centaur/vl/kit/model.readme 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/model.readme 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,77 @@
+------------------------------------------------------------------------------
+
+ VL MODEL README
+
+------------------------------------------------------------------------------
+
+You can use VL's "model" tool to translate Verilog designs into formal models
+that can be analyzed by the ACL2 theorem prover.
+
+
+ PREREQUISITES
+
+ To get any use out of this, you would typically need to know how to use ACL2.
+ For basic information about the theorem prover, see its homepage:
+
+ http://www.cs.utexas.edu/users/moore/acl2/
+
+ VL itself is an ACL2 library for processing Verilog files. It is distributed
+ as part of the ACL2 Community Books project, see the centaur/vl directory:
+
+ http://acl2-books.googlecode.com/
+
+ VL has considerable documentation. The documentation corresponding to the
+ latest ACL2 release is found at:
+
+ http://fv.centtech.com/acl2/latest/doc/frames2.html?topic=ACL2____VL
+
+ More bleeding-edge documentation can be generated from the sources (which you
+ can get from the acl2-books project, above).
+
+ After getting a copy of VL and glancing through its documentation, you should
+ probably complete the small Centaur Hardware Verification Tutorial. The
+ starting point is:
+
+ acl2-books/centaur/tutorial/intro.lisp
+
+
+ THE VL MODEL TOOL
+
+ The "vl model" command is really nothing more than a command-line interface
+ to the DEFMODULES command. It lets you parse Verilog files and translate
+ them into E modules directly, without, for instance, having to load the VL
+ books into ACL2 (which can take as long as a minute).
+
+ "vl model" can convert Verilog designs into two .sao files.
+
+ (The extension .sao stands for "Serialized ACL2 Object." These files can
+ be quickly read into ACL2 using serialize-read. For more information,
+ see:
+ http://fv.centtech.com/acl2/latest/doc/frames2.html?topic=ACL2____SERIALIZE)
+
+
+ model.sao -- This is just the serialized VL-TRANSLATION-P object produced
+ by DEFMODULES. It contains a lot of information, including
+ for instance
+
+ - the original source code that was read in,
+ - the original, parsed versions of your Verilog modules,
+ - the final, "fully simplified" versions of your modules,
+ - the corresponding E modules for successful modules,
+ - warnings that were encountered,
+ - etc., etc.
+
+ All of this stuff tends to make model.sao rather large, but
+ can be very useful for exploring a translation. (We use it
+ as the basis for a web-based Verilog browsing tool.)
+
+
+
+ esims.sao -- This is a much smaller file that includes only the final
+ E modules for successfully translated modules.
+
+ Since this is much smaller than model.sao, it can be loaded
+ more quickly. We usually use this file as the basis for our
+ ACL2 proofs.
+
+------------------------------------------------------------------------------
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/vl/kit/progutils.lisp acl2-6.3/books/centaur/vl/kit/progutils.lisp
--- acl2-6.2/books/centaur/vl/kit/progutils.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/progutils.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,97 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "VL")
+(include-book "oslib/file-types" :dir :system)
+(include-book "../util/defs")
+(local (include-book "../util/arithmetic"))
+(local (include-book "../util/osets"))
+
+(in-theory (disable (:executable-counterpart acl2::good-bye-fn)))
+
+(define exit-ok ()
+ (exit 0))
+
+(define exit-fail ()
+ (exit 1))
+
+(in-theory (disable (:executable-counterpart exit-ok)
+ (:executable-counterpart exit-fail)))
+
+(defmacro die (&rest args)
+ `(progn$ (cw . ,args)
+ (exit-fail)))
+
+
+(define must-be-regular-files! ((files string-listp) &key (state 'state))
+ :returns (state state-p1 :hyp (force (state-p1 state)))
+ (b* ((files (mergesort files))
+ ((mv err missing-files state) (oslib::missing-paths files))
+ ((when err)
+ (die "Error checking existence of ~&0:~%~@1~%" files err)
+ state)
+ (missing-files (mergesort missing-files))
+ ((when missing-files)
+ (die "File~s0 not found: ~&1~%"
+ (if (vl-plural-p missing-files) "s" "")
+ missing-files)
+ state)
+ ((mv err regular-files state) (oslib::regular-files files))
+ ((when err)
+ (die "Error checking file types of ~&0:~%~@1~%" files err)
+ state)
+ (irregular-files (difference files (mergesort regular-files)))
+ ((when irregular-files)
+ (die "File~s0 not regular: ~&1~%"
+ (if (vl-plural-p irregular-files) "s are" " is")
+ irregular-files)
+ state))
+ state))
+
+
+(define must-be-directories! ((dirs string-listp) &key (state 'state))
+ :returns (state state-p1 :hyp (force (state-p1 state)))
+ (b* ((dirs (mergesort dirs))
+ ((mv err missing-dirs state) (oslib::missing-paths dirs))
+ ((when err)
+ (die "Error checking existence of ~&0:~%~@1~%" dirs err)
+ state)
+ (missing-dirs (mergesort missing-dirs))
+ ((when missing-dirs)
+ (die "~s0 not found: ~&1~%"
+ (if (vl-plural-p missing-dirs) "Directories" "Directory")
+ missing-dirs)
+ state)
+ ((mv err regular-dirs state) (oslib::directories dirs))
+ ((when err)
+ (die "Error checking file types of ~&0:~%~@1~%" dirs err)
+ state)
+ (irregular-dirs (difference dirs (mergesort regular-dirs)))
+ ((when irregular-dirs)
+ (die "~s0: ~&1~%"
+ (if (vl-plural-p irregular-dirs)
+ "Paths are not directories"
+ "Path is not a directory")
+ irregular-dirs)
+ state))
+ state))
+
+
+
diff -Nru acl2-6.2/books/centaur/vl/kit/save.lsp acl2-6.3/books/centaur/vl/kit/save.lsp
--- acl2-6.2/books/centaur/vl/kit/save.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/save.lsp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,38 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "ACL2")
+(ld "cert.acl2")
+(in-package "VL")
+(include-book "top")
+(set-deferred-ttag-notes t state)
+(set-gag-mode :goals)
+
+:q
+
+;; Set up our program to not print a bunch of ACL2 banners.
+(setq *print-startup-banner* nil)
+
+;; Set up our program NOT try to read the any customization files.
+(defun initial-customization-filename () :none)
+
+(save-exec "../bin/vl" "VL Verilog Toolkit"
+ :inert-args ""
+ :return-from-lp '(vl::vl-main))
diff -Nru acl2-6.2/books/centaur/vl/kit/shell-raw.lsp acl2-6.3/books/centaur/vl/kit/shell-raw.lsp
--- acl2-6.2/books/centaur/vl/kit/shell-raw.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/shell-raw.lsp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,54 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "ACL2")
+
+(defun vl::vl-shell-fn (argv state)
+ (declare (ignore argv))
+ (format t "VL Verilog Toolkit
+Copyright (C) 2008-2013 Centaur Technology
+
+ This program is free software; you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation; either version 2 of the License, or (at your option) any later
+ version. This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ more details. You should have received a copy of the GNU General Public
+ License along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ USA.
+
+,-------------------------,
+| VL Interactive Shell | This is an interactive ACL2 shell with VL pre-
+| (for experts) | loaded. To learn about ACL2 (and hence how to
+| | use this shell) see the ACL2 homepage:
+| Type :quit to quit | http://www.cs.utexas.edu/users/moore/acl2
+`-------------------------'
+
+")
+
+ (f-put-global 'ld-verbose nil state)
+ ;; well, this doesn't seem to actually work and get us into an interactive
+ ;; LP shell. But at least we get into a raw-lisp shell, which is probably
+ ;; fine for now.
+ (lp)
+ state)
+
diff -Nru acl2-6.2/books/centaur/vl/kit/shell.lisp acl2-6.3/books/centaur/vl/kit/shell.lisp
--- acl2-6.2/books/centaur/vl/kit/shell.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/shell.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,49 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "VL")
+(include-book "progutils")
+(include-book "tools/include-raw" :dir :system)
+(include-book "cutil/define" :dir :system)
+; (depends-on "shell-raw.lsp")
+
+(defconst *vl-shell-help* "
+vl shell: Starts an interactive VL command loop (for experts).
+
+Usage: vl shell (there are no options)
+
+VL is built atop the ACL2 theorem prover. The VL shell gives you access to the
+ACL2 command loop, with all of the VL functions already built in.
+
+This is mainly useful for VL developers who want to debug problems or explore
+adding new functionality.
+
+")
+
+(define vl-shell ((argv string-listp) &key (state 'state))
+ :returns state
+ :ignore-ok t
+ (progn$ (die "Raw lisp definition not installed?")
+ state))
+
+
+(defttag :vl-shell)
+(acl2::include-raw "shell-raw.lsp")
+
diff -Nru acl2-6.2/books/centaur/vl/kit/top.lisp acl2-6.3/books/centaur/vl/kit/top.lisp
--- acl2-6.2/books/centaur/vl/kit/top.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/kit/top.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,204 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "VL")
+(include-book "json")
+(include-book "lint")
+(include-book "model")
+(include-book "shell")
+(include-book "oslib/argv" :dir :system)
+(include-book "centaur/misc/intern-debugging" :dir :system)
+(include-book "centaur/misc/memory-mgmt" :dir :system)
+(local (include-book "../util/arithmetic"))
+(local (include-book "../util/osets"))
+
+(defconst *vl-generic-help*
+ "VL Verilog Toolkit
+Copyright (C) 2008-2013 Centaur Technology
+
+Usage: vl [arguments]
+
+Commands:
+
+ help Print this message, or get help on a particular VL command
+ json Convert Verilog designs into JSON files (for easy parsing)
+ lint Find potential bugs in a Verilog design
+ model Translate Verilog designs for the ACL2 theorem prover
+ shell Interactive VL shell (for experts)
+
+Use 'vl help ' for help on a specific command.
+")
+
+(make-event
+ `(defsection kit
+ :parents (vl)
+ :short "A command-line program for using VL in basic ways."
+
+ :long ,(cat "@(see VL) is mainly an ACL2 library, and a lot of its
+functionality and features are available only from within ACL2. However, to
+make VL more widely approachable, we have bundled up certain pieces of it into
+a command line program, which we call the Kit.
+
+The kit is ordinarily built by running @('make vl') in the @('acl2/books')
+directory. The source files are found in @('acl2/books/centaur/vl/kit') but
+the resulting executable is put into @('acl2/books/centaur/vl/bin') and is
+simply named @('vl').
+
+This @('vl') program is really just a wrapper for several sub-commands:
+
+@({" *vl-generic-help* " })")))
+
+
+(defsection vl-toolkit-help-message
+ :parents (vl-help)
+ :short "Look up the help message for a VL kit program."
+ :long "This is attachable so advanced users can add additional
+commands.
+
+@(def *vl-help-messages*)
+@(def vl-toolkit-help-message)"
+
+ (defconst *vl-help-messages*
+ (list (cons "help" *vl-generic-help*)
+ (cons "json" *vl-json-help*)
+ (cons "lint" *vl-lint-help*)
+ (cons "model" *vl-model-help*)
+ (cons "shell" *vl-shell-help*)))
+
+ (encapsulate
+ (((vl-toolkit-help-message *) => *
+ :formals (command)
+ :guard (stringp command)))
+ (local (defun vl-toolkit-help-message (command)
+ (declare (ignore command))
+ nil))
+ (defthm vl-toolkit-help-message-constraint
+ (or (not (vl-toolkit-help-message command))
+ (stringp (vl-toolkit-help-message command)))
+ :rule-classes :type-prescription)))
+
+
+(define vl-toolkit-help-message-default ((command stringp))
+ :parents (vl-toolkit-help-message)
+ :returns (help (or (not help)
+ (stringp help))
+ :rule-classes :type-prescription)
+ (cdr (assoc-equal command *vl-help-messages*))
+ ///
+ (defattach vl-toolkit-help-message vl-toolkit-help-message-default))
+
+
+(define vl-help ((args string-listp) &key (state 'state))
+ :parents (kit)
+ :short "The @('vl help') command."
+
+ (b* (((unless (or (atom args)
+ (atom (cdr args))))
+ (die "Usage: vl help ~%")
+ state)
+ (command (if (atom args)
+ "help"
+ (car args)))
+ (help (vl-toolkit-help-message command))
+ ((unless help)
+ (die "Unknown command ~s0." command)
+ state))
+ (vl-cw-ps-seq (vl-print help))
+ state))
+
+
+(defsection vl-toolkit-other-command
+ :parents (kit)
+ :short "Handler for additional vl toolkit commands."
+
+ :long "By default this just dies with an error message that says the
+command is unknown. But it is attachable, so advanced users can extend the
+toolkit with their own commands.
+
+@(def vl-toolkit-other-command)"
+
+ (encapsulate
+ (((vl-toolkit-other-command * * state) => state
+ :formals (command args state)
+ :guard (and (stringp command)
+ (string-listp args)
+ (state-p1 state))))
+ (local (defun vl-toolkit-other-command (command args state)
+ (declare (ignore command args)
+ (xargs :stobjs state))
+ state))))
+
+
+(define vl-toolkit-other-command-default ((command stringp)
+ (args string-listp)
+ state)
+ :parents (vl-toolkit-other-command)
+ :ignore-ok t
+ (progn$
+ (die "Unknown command ~s0.~%" command)
+ state)
+ ///
+ (defattach vl-toolkit-other-command vl-toolkit-other-command-default))
+
+
+(define vl-main (&key (state 'state))
+ :parents (kit)
+ :short "The top-level @('vl') meta-command."
+
+ (b* (((mv argv state) (oslib::argv))
+
+ ((unless (consp argv))
+ (b* ((state (vl-help '("help"))))
+ (exit-fail)
+ state))
+
+ ((cons cmd args) argv)
+
+ ((when (or (equal cmd "help")
+ (equal cmd "-h")
+ (equal cmd "--help")))
+ (b* ((state (vl-help args)))
+ (exit-ok)
+ state))
+
+ ((when (equal cmd "json"))
+ (b* ((state (vl-json args)))
+ (exit-ok)
+ state))
+
+ ((when (equal cmd "lint"))
+ (b* ((state (vl-lint args)))
+ (exit-ok)
+ state))
+
+ ((when (equal cmd "model"))
+ (b* ((state (vl-model args)))
+ (exit-ok)
+ state))
+
+ ((when (equal cmd "shell"))
+ (b* ((state (vl-shell args)))
+ ;; Do NOT exit here. If you do, commands like :q quit entirely
+ ;; instead of dropping you into raw Lisp.
+ state))
+ )
+
+ (vl-toolkit-other-command cmd args state)))
+
diff -Nru acl2-6.2/books/centaur/vl/lint/bit-use-set.lisp acl2-6.3/books/centaur/vl/lint/bit-use-set.lisp
--- acl2-6.2/books/centaur/vl/lint/bit-use-set.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/lint/bit-use-set.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -269,8 +269,8 @@
:vl-inout))
:hints(("Goal"
:in-theory (e/d (vl-direction-p)
- (vl-direction-p-of-vl-portdecl->dir))
- :use ((:instance vl-direction-p-of-vl-portdecl->dir)))))
+ (return-type-of-vl-portdecl->dir))
+ :use ((:instance return-type-of-vl-portdecl->dir)))))
;; (defthm vl-compounstmt->ctrl-when-timingstmt
;; ;; BOZO move to stmt tools
@@ -2705,7 +2705,7 @@
(cons (make-vl-warning
:type :use-set-fudging
:msg "~a0: No wires for this net?"
- :args (list x)
+ :args (list (car x))
:fatalp nil
:fn 'vl-netdecllist-wires)
warnings)))
diff -Nru acl2-6.2/books/centaur/vl/lint/lint.acl2 acl2-6.3/books/centaur/vl/lint/lint.acl2
--- acl2-6.2/books/centaur/vl/lint/lint.acl2 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/lint/lint.acl2 1970-01-01 00:00:00.000000000 +0000
@@ -1,7 +0,0 @@
-(in-package "ACL2")
-#+gcl (acl2::value :q)
-#+gcl (setq si::*optimize-maximum-pages* nil)
-#+gcl (acl2::lp)
-(include-book "../portcullis")
-; cert-flags: ? t :ttags :all
-(certify-book "lint" ? t :ttags :all)
diff -Nru acl2-6.2/books/centaur/vl/lint/lint.lisp acl2-6.3/books/centaur/vl/lint/lint.lisp
--- acl2-6.2/books/centaur/vl/lint/lint.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/lint/lint.lisp 1970-01-01 00:00:00.000000000 +0000
@@ -1,912 +0,0 @@
-; VL Verilog Toolkit
-; Copyright (C) 2008-2013 Centaur Technology
-;
-; Contact:
-; Centaur Technology Formal Verification Group
-; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
-; http://www.centtech.com/
-;
-; This program is free software; you can redistribute it and/or modify it under
-; the terms of the GNU General Public License as published by the Free Software
-; Foundation; either version 2 of the License, or (at your option) any later
-; version. This program is distributed in the hope that it will be useful but
-; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
-; more details. You should have received a copy of the GNU General Public
-; License along with this program; if not, write to the Free Software
-; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
-;
-; Original author: Jared Davis
-
-(in-package "VL")
-
-(include-book "bit-use-set")
-(include-book "check-case")
-(include-book "check-namespace")
-(include-book "disconnected")
-(include-book "xf-drop-missing-submodules")
-(include-book "xf-drop-user-submodules")
-(include-book "xf-lint-stmt-rewrite")
-(include-book "xf-remove-toohard")
-(include-book "xf-undefined-names")
-(include-book "xf-suppress-warnings")
-
-(include-book "../checkers/condcheck")
-(include-book "../checkers/duplicate-detect")
-(include-book "../checkers/dupeinst-check")
-(include-book "../checkers/duperhs")
-(include-book "../checkers/leftright")
-(include-book "../checkers/multidrive-detect")
-(include-book "../checkers/oddexpr")
-(include-book "../checkers/portcheck")
-(include-book "../checkers/qmarksize-check")
-(include-book "../checkers/selfassigns")
-(include-book "../checkers/skip-detect")
-
-(include-book "../loader/loader")
-(include-book "../transforms/cn-hooks")
-(include-book "../transforms/xf-argresolve")
-(include-book "../transforms/xf-array-indexing")
-(include-book "../transforms/xf-assign-trunc")
-(include-book "../transforms/xf-blankargs")
-(include-book "../transforms/xf-clean-params")
-(include-book "../transforms/xf-drop-blankports")
-(include-book "../transforms/xf-expr-split")
-(include-book "../transforms/xf-expand-functions")
-(include-book "../transforms/xf-follow-hids")
-(include-book "../transforms/xf-hid-elim")
-(include-book "../transforms/xf-orig")
-(include-book "../transforms/xf-oprewrite")
-(include-book "../transforms/xf-portdecl-sign")
-(include-book "../transforms/xf-resolve-ranges")
-(include-book "../transforms/xf-replicate-insts")
-(include-book "../transforms/xf-sizing")
-(include-book "../transforms/xf-unparameterize")
-(include-book "../transforms/xf-unused-reg")
-
-(include-book "../../misc/sneaky-load")
-
-(local (include-book "../mlib/modname-sets"))
-(local (include-book "../util/arithmetic"))
-(local (include-book "../util/osets"))
-
-(make-event
-
-; Disabling waterfall parallelism because this book allegedly uses memoization
-; while performing its proofs.
-
- (if (and (ACL2::hons-enabledp state)
- (f-get-global 'ACL2::parallel-execution-enabled state))
- (er-progn (set-waterfall-parallelism nil)
- (value '(value-triple nil)))
- (value '(value-triple nil))))
-
-
-(defsection lint
- :parents (vl)
- :short "A linting tool for Verilog."
- :long "A linter is a tool
-that looks for possible bugs in a program. We now implement such a linter for
-Verilog, reusing much of @(see vl).
")
-
-
-(define vl-filter-mods-with-good-paramdecls
- ((x vl-modulelist-p "List of modules to filter.")
- (good vl-modulelist-p "Accumulator for good modules.")
- (bad vl-modulelist-p "Accumulator for bad modules."))
- :returns (mv (good vl-modulelist-p :hyp :fguard)
- (bad vl-modulelist-p :hyp :fguard))
- :parents (lint)
- :short "(unsound transform) Throw away modules with too-complex parameter
-declarations. "
-
- :long "@(csee unparameterization) requires that the module list is
-complete and that all modules have good parameters. In our ordinary
-translation process (e.g., @(see vl-simplify)), we throw away any modules with
-bad parameters, any then transitively throw away any modules with instances of
-missing modules. But for linting, we'd like to try to carry out
-unparameterization with as little damage as possible.
-
-As a pre-unparameterization step, in this transform we throw away any
-modules with bad parameters and then throw away any instances of missing
-modules. This is obviously unsound, so it should never be used in our ordinary
-translation process.
"
-
- (cond ((atom x)
- (mv good bad))
- ((vl-good-paramdecllist-p (vl-module->paramdecls (car x)))
- (vl-filter-mods-with-good-paramdecls (cdr x)
- (cons (car x) good)
- bad))
- (t
- (vl-filter-mods-with-good-paramdecls (cdr x)
- good
- (cons (car x) bad)))))
-
-
-(define vl-print-certain-warnings
- ((mods vl-modulelist-p "Modules to print warnings for.")
- (show symbol-listp "Types of warnings to show.")
- (hide symbol-listp "Types of warnings to hide."))
- :parents (lint)
- :short "Print warnings of interest to standard output, while hiding other
-warnings."
-
- :long "You can use this to print just a few warnings you are interested in
-while hiding other warnings you know you are not interested in. If there are
-warnings of other types (that you haven't said to show or hide), they too will
-be hidden but you'll at least get a message saying that they aren't being
-shown.
"
-
- (b* ((warnings (vl-modulelist-flat-warnings-exec mods nil))
- (types (mergesort (vl-warninglist->types-exec warnings nil)))
- (hide (if hide
- (mergesort hide)
- types))
- (show (mergesort show))
- ;; Misc is all the warning types that we aren't told to show, but aren't
- ;; told to ignore. We'll print a note that these warnings exist but
- ;; that we weren't told to show or hide them.
- (misc (difference types (union show hide)))
- (warnings (vl-keep-warnings show warnings)))
- (vl-cw-ps-seq
- (vl-ps-update-autowrap-col 65)
- (vl-print-warnings warnings)
- (vl-println "")
- (if (not misc)
- ps
- (vl-ps-seq
- (vl-cw "Note: not showing ~&0 warnings.~%" misc)
- (vl-println ""))))))
-
-
-(defaggregate vl-lintconfig
- :parents (lint)
- :short "Options for running the linter."
- :tag :vl-lintconfig
- ((loadconfig vl-loadconfig-p
- "Configuration for @(see vl-load); says what files to load, what
- search paths to use, etc.")
-
- (topmods string-listp
- "This is a way to filter the report to exclude modules you do
- not care about. If @('nil'), no filtering is done and we
- include warnings for every module. Otherwise, we throw out any
- modules that aren't necessary for some module in
- @('topmods').")
-
- (dropmods string-listp
- "This is a way to explicitly drop modules that are problematic
- for whatever reason. The dropped modules are removed from the
- module list without destroying modules above them. This is
- obviously unsound, but can be useful.")
-
- (ignore string-listp
- ;; BOZO xdoc for how this stuff works
- "Ignore warnings of certain types, e.g., if this list includes
- the string \"oddexpr\" then we will suppress warnings such as
- @(':VL-WARN-ODDEXPR). See @('xf-suppress-warnings.lisp') for
- details.")))
-
-(defaggregate vl-lintresult
- :parents (lint)
- :short "Results from running the linter."
- :tag :vl-lintresult
- ((mods vl-modulelist-p
- "Final, transformed list of modules. Typically this isn't very
- interesting or relevant to anything.")
-
- (mods0 vl-modulelist-p
- "Almost: the initial, pre-transformed modules. The only twist is
- that we have already removed modules that are unnecessary or
- that we wanted to drop; see, e.g., the @('topmods') and
- @('ignore') options of @(see vl-lintconfig-p). This is used for
- @(see skip-detection), for instance.")
-
- (mwalist vl-modwarningalist-p
- "The main result: binds \"original\" (pre-unparameterization)
- module names to their warnings.")
-
- (sd-probs sd-problemlist-p
- "Possible problems noticed by @(see skip-detection). These are
- in a different format than ordinary @(see warnings), so they
- aren't included in the @('mwalist').")
-
- (dalist us-dbalist-p
- "Use-set database alist, mapping module names to use-set databases.
- Might actually not be used for anything.")))
-
-(define run-vl-lint-main ((mods (and (vl-modulelist-p mods)
- (uniquep (vl-modulelist->names mods))))
- (config vl-lintconfig-p))
- :returns (result vl-lintresult-p :hyp :fguard)
-
- (b* (((vl-lintconfig config) config)
-
- (mods (vl-modulelist-drop-user-submodules mods config.dropmods))
-
- ;; You might expect that we'd immediately throw out modules that we
- ;; don't need for topmods. Historically we did that. But then we found
- ;; that we'd get a bunch of complaints in other modules about
- ;; hierarchical identifiers that pointed into the modules we'd just
- ;; thrown away! So now we deal with this stuff after HID resolution.
- ;; Except that for skip-detection, we also need to remove them from
- ;; mods0, so do that now:
- (mods0 (if (not config.topmods)
- mods
- (vl-remove-unnecessary-modules (mergesort config.topmods)
- (mergesort mods))))
-
-
- (- (cw "~%vl-lint: initial processing...~%"))
- (mods (cwtime (vl-modulelist-portcheck mods)))
- (mods (cwtime (vl-modulelist-check-case mods)))
- (mods (cwtime (vl-modulelist-duperhs-check mods)))
- (mods (cwtime (vl-modulelist-duplicate-detect mods)))
- (mods (cwtime (vl-modulelist-condcheck mods)))
- (mods (cwtime (vl-modulelist-leftright-check mods)))
- (mods (cwtime (vl-modulelist-drop-missing-submodules mods)))
- ;; BOZO reinstate this??
- ;; (mods (cwtime (vl-modulelist-add-undefined-names mods)))
- (mods (cwtime (vl-modulelist-portdecl-sign mods)))
- (mods (cwtime (vl-modulelist-make-array-indexing mods)))
- (mods (cwtime (vl-modulelist-origexprs mods)))
- (mods (cwtime (vl-modulelist-check-namespace mods)))
-
- (- (cw "~%vl-lint: processing arguments, parameters...~%"))
- (mods (cwtime (vl-modulelist-elim-unused-regs mods)))
- (mods (cwtime (vl-modulelist-argresolve mods)))
- (mods (cwtime (vl-modulelist-dupeinst-check mods)))
-
- ;; BOZO not exactly sure where this should go, maybe this will work.
- (mods (cwtime (vl-modulelist-expand-functions mods)))
-
- ;; BOZO we need to do something to throw away instances with unresolved
- ;; arguments to avoid programming-errors in drop-blankports... and actually
- ;; we hit errors like that later, too.
- (mods (cwtime (vl-modulelist-drop-blankports mods)))
- (mods (cwtime (mp-verror-transform-hook mods)))
- (mods (cwtime (vl-modulelist-follow-hids mods)))
- (mods (cwtime (vl-modulelist-clean-params mods)))
- (mods (cwtime (vl-modulelist-check-good-paramdecls mods)))
-
- ((mv mods bad)
- (vl-filter-mods-with-good-paramdecls mods nil nil))
- (- (or (not bad)
- (progn$
- (cw "~%~%Note: deleting ~x0 module~s1 because they include ~
- unsupported parameter declarations.~%~%~
- Module~s1 being deleted: ~&2~%~%~
- Details:~%~%"
- (len bad)
- (if (= (len bad) 1) "" "s")
- (mergesort (vl-modulelist->names bad)))
- (vl-print-certain-warnings bad
- (list :vl-bad-paramdecl
- :vl-bad-paramdecls)
- nil))))
- (mods (cwtime (vl-modulelist-drop-missing-submodules mods)))
- (mods (if (and (uniquep (vl-modulelist->names mods))
- (vl-modulelist-complete-p mods mods)
- (vl-good-paramdecllist-list-p-of-vl-modulelist->paramdecls mods))
- mods
- (er hard? 'vl-lint
- "Programming error. Expected modules to be complete ~
- and to have good parameters, but this is not the case. ~
- Please tell Jared about this failure.")))
- ((mv mods failmods) (cwtime (vl-unparameterize mods 30)))
- (mods (append mods failmods))
- (- (vl-gc))
-
- (mods (if (uniquep (vl-modulelist->names mods))
- mods
- (progn$
- (sneaky-save :bad-names mods)
- (er hard? 'vl-lint
- "Programming error. Expected modules to have unique ~
- names after vl-unparameterize, but found duplicate ~
- modules named ~x0. Please tell Jared."
- (duplicated-members (vl-modulelist->names mods))))))
-
-
- (- (cw "~%vl-lint: processing ranges, statements...~%"))
- (mods (cwtime (vl-modulelist-rangeresolve mods)))
- (mods (cwtime (vl-modulelist-selresolve mods)))
- (mods (cwtime (vl-modulelist-check-selfassigns mods)))
- (mods (cwtime (vl-modulelist-lint-stmt-rewrite mods)))
- (mods (cwtime (vl-modulelist-stmtrewrite mods 1000)))
- (mods (cwtime (vl-modulelist-hid-elim mods)))
-
- (mods (if (uniquep (vl-modulelist->names mods))
- mods
- (progn$
- (sneaky-save :bad-names mods)
- (er hard? 'vl-lint
- "Programming error. Expected modules to have unique ~
- names after vl-modulelist-hid-elim, but found duplicate ~
- modules named ~x0. Please tell Jared."
- (duplicated-members (vl-modulelist->names mods))))))
-
- ;; Now that HIDs are gone, we can throw away any modules we don't care
- ;; about, if we have been given any topmods.
- (mods (if (not config.topmods)
- mods
- (vl-remove-unnecessary-modules (mergesort config.topmods)
- (mergesort mods))))
-
-
- ;; BOZO it seems sort of legitimate to do this before sizing, which
- ;; might be nice. Of course, a more rigorous use/set analysis will
- ;; need to be post-sizing.
- (- (cw "~%vl-lint: finding disconnected wires...~%"))
- (mods (cwtime (vl-modulelist-remove-toohard mods)))
- (mods (cwtime (vl-modulelist-find-disconnected mods)))
-
- (- (cw "~%vl-lint: processing expressions...~%"))
- (mods (cwtime (vl-modulelist-oddexpr-check mods)))
- (mods (cwtime (vl-modulelist-oprewrite mods)))
- (mods (cwtime (vl-modulelist-exprsize mods)))
- (mods (cwtime (vl-modulelist-qmarksize-check mods)))
-
- (- (cw "~%vl-lint: finding unused/unset wires...~%"))
- ;; BOZO this probably doesn't quite work here due to replicate not having been done
- ((mv mods dalist) (cwtime (us-analyze-mods mods)))
- (- (vl-gc))
-
- (- (cw "~%vl-lint: processing assignments...~%"))
- (mods (cwtime (vl-modulelist-split mods)))
- (mods (cwtime (vl-modulelist-replicate mods)))
- (mods (cwtime (vl-modulelist-blankargs mods)))
- (mods (cwtime (vl-modulelist-trunc mods)))
-
- (- (cw "~%vl-lint: finding skipped and multiply driven wires...~%"))
- ;; NOTE: use mods0, not mods, if you ever want this to finish. :)
- (sd-probs (cwtime (sd-analyze-modulelist mods0)))
- (mods (cwtime (vl-modulelist-multidrive-detect mods)))
-
- (- (cw "~%vl-lint: cleaning up...~%"))
- (mods (cwtime (vl-modulelist-clean-warnings mods)))
- (mods (cwtime (vl-modulelist-suppress-lint-warnings mods)))
- (mods (cwtime (vl-modulelist-lint-ignoreall mods config.ignore)))
- (mwalist (cwtime (vl-origname-modwarningalist mods))))
-
- (make-vl-lintresult :mods mods
- :mods0 mods0
- :mwalist mwalist
- :sd-probs sd-probs
- :dalist dalist)))
-
-
-(define run-vl-lint
- (&key (start-files string-listp)
- (search-path string-listp)
- (search-exts string-listp)
- (topmods string-listp)
- (dropmods string-listp)
- (ignore string-listp)
- (state 'state))
- :returns (mv (res vl-lintresult-p :hyp :fguard)
- (state state-p1 :hyp (state-p1 state)))
- (b* ((- (cw "Starting VL-Lint~%"))
- (loadconfig (make-vl-loadconfig
- :start-files start-files
- :search-path search-path
- :search-exts search-exts))
- (lintconfig (make-vl-lintconfig
- :loadconfig loadconfig
- :topmods topmods
- :dropmods dropmods
- :ignore ignore))
- (- (cw "~%vl-lint: loading modules...~%"))
- ((mv loadres state) (cwtime (vl-load loadconfig)))
-
- (lintres
- (cwtime (run-vl-lint-main (vl-loadresult->mods loadres)
- lintconfig))))
- (mv lintres state)))
-
-
-(defund sd-problem-major-p (x)
- (declare (xargs :guard (sd-problem-p x)))
- (b* (((sd-problem x) x))
- (or (>= x.priority 10)
- (and (>= x.priority 6) (>= x.groupsize 4))
- (>= (sd-problem-score x) 8))))
-
-(defsection sd-filter-problems
-
- (defund sd-filter-problems (x major minor)
- "Returns (MV MAJOR MINOR)"
- (declare (xargs :guard (sd-problemlist-p x)))
- (cond ((atom x)
- (mv major minor))
- ((sd-problem-major-p (car x))
- (sd-filter-problems (cdr x) (cons (car x) major) minor))
- (t
- (sd-filter-problems (cdr x) major (cons (car x) minor)))))
-
- (local (in-theory (enable sd-filter-problems)))
-
- (defthm sd-problemlist-p-of-sd-filter-problems
- (and (implies (and (sd-problemlist-p x)
- (sd-problemlist-p major))
- (sd-problemlist-p (mv-nth 0 (sd-filter-problems x major minor))))
- (implies (and (sd-problemlist-p x)
- (sd-problemlist-p minor))
- (sd-problemlist-p (mv-nth 1 (sd-filter-problems x major minor)))))))
-
-
-
-
-
-
-(defund vl-modwarningalist-types (x)
- (declare (xargs :guard (vl-modwarningalist-p x)))
- (if (atom x)
- nil
- (append (vl-warninglist->types (cdar x))
- (vl-modwarningalist-types (cdr x)))))
-
-
-(defund vl-keep-from-modwarningalist (types x)
- ;; Returns a new fast alist.
- (declare (xargs :guard (and (symbol-listp types)
- (vl-modwarningalist-p x))))
- (if (atom x)
- nil
- (b* ((name1 (caar x))
- (warnings1 (cdar x))
- (keep1 (vl-keep-warnings types warnings1))
- (rest (vl-keep-from-modwarningalist types (cdr x))))
- (if keep1
- (hons-acons name1 keep1 rest)
- rest))))
-
-(defthm vl-modwarningalist-p-of-vl-keep-from-modwarningalist
- (implies (and (force (symbol-listp types))
- (force (vl-modwarningalist-p x)))
- (vl-modwarningalist-p (vl-keep-from-modwarningalist types x)))
- :hints(("Goal" :in-theory (enable vl-keep-from-modwarningalist))))
-
-
-(define vl-lint-print-warnings ((filename stringp)
- (label stringp)
- (types symbol-listp)
- (walist vl-modwarningalist-p)
- &key (ps 'ps))
- (b* ((walist (vl-keep-from-modwarningalist types walist))
- (walist (vl-clean-modwarningalist walist))
- (count (length (append-domains walist)))
- (- (cond ((int= count 0)
- (cw "~s0: No ~s1 Warnings.~%" filename label))
- ((int= count 1)
- (cw "~s0: One ~s1 Warning.~%" filename label))
- (t
- (cw "~s0: ~x1 ~s2 Warnings.~%" filename count label)))))
- (vl-ps-seq
- (cond ((int= count 0)
- (vl-cw "No ~s0 Warnings.~%~%" label))
- ((int= count 1)
- (vl-cw "One ~s0 Warning:~%~%" label))
- (t
- (vl-cw "~x0 ~s1 Warnings:~%~%" count label)))
- (vl-print-modwarningalist walist))))
-
-
-
-(defconst *use-set-warnings*
- (list :use-set-fudging
- :use-set-trainwreck
- :use-set-future-trainwreck
- :use-set-warn-1-unset
- :use-set-warn-1-unset-tricky
- :use-set-warn-2-unused
- :use-set-warn-2-unused-tricky
- :use-set-warn-3-spurious
- :use-set-warn-3-spurious-tricky
- :use-set-syntax-error
- :vl-collect-wires-approx
- :vl-collect-wires-fail
- :vl-dropped-always
- :vl-dropped-assign
- :vl-dropped-initial
- :vl-dropped-insts
- :vl-dropped-modinst
- :vl-warn-function
- :vl-warn-taskdecl
- :vl-unsupported-block))
-
-(defconst *basic-warnings*
- (list :bad-mp-verror
- :vl-bad-range
- :vl-warn-duplicates
- :vl-bad-instance
- :vl-unresolved-hid
- :vl-warn-unused-reg
- :vl-warn-blank
- :vl-undefined-names
- :vl-port-mismatch))
-
-(defconst *trunc-warnings*
- (list :vl-warn-extension
- :vl-warn-truncation
- :vl-warn-integer-size))
-
-(defconst *trunc-minor-warnings*
- (list :vl-warn-extension-minor
- :vl-warn-truncation-minor
- :vl-warn-integer-size-minor
- :vl-warn-vague-spec))
-
-(defconst *disconnected-warnings*
- (list :vl-warn-disconnected
- :vl-warn-disconnected-interesting
- ;; Caveats that could make the analysis wrong
- :vl-collect-wires-fail
- :vl-collect-wires-approx
- :vl-dropped-always
- :vl-dropped-assign
- :vl-dropped-initial
- :vl-dropped-insts
- :vl-dropped-modinst
- :vl-warn-function
- :vl-warn-taskdecl
- :vl-unsupported-block))
-
-(defconst *smell-warnings*
- (list :vl-warn-qmark-width
- :vl-warn-qmark-const
- :vl-warn-leftright
- :vl-warn-selfassign
- :vl-warn-instances-same
- :vl-warn-case-sensitive-names
- :vl-warn-same-rhs))
-
-(defconst *smell-minor-warnings*
- (list :vl-warn-partselect-same
- :vl-warn-instances-same-minor))
-
-(defconst *multidrive-warnings*
- (list :vl-warn-multidrive))
-
-(defconst *multidrive-minor-warnings*
- (list :vl-warn-multidrive-minor))
-
-(defconst *fussy-size-warnings*
- (list :vl-fussy-size-warning-1
- :vl-fussy-size-warning-2
- :vl-fussy-size-warning-3
- :vl-fussy-size-warning-1-const-toobig
- :vl-fussy-size-warning-2-const-toobig
- :vl-fussy-size-warning-3-const-toobig
- :vl-fussy-size-warning-1-complex
- :vl-fussy-size-warning-2-complex
- :vl-fussy-size-warning-3-complex
- ))
-
-(defconst *same-ports-warnings*
- (list :vl-warn-same-ports
- :vl-warn-same-inputs))
-
-(defconst *same-ports-minor-warnings*
- (list :vl-warn-same-ports-minor
- :vl-warn-same-inputs-minor))
-
-(defconst *fussy-size-minor-warnings*
- (list :vl-fussy-size-warning-1-minor
- :vl-fussy-size-warning-2-minor
- :vl-fussy-size-warning-3-minor))
-
-
-
-
-(defconst *warnings-covered*
-
- ;; Warnings that are covered by our regular reports. Other warnings besides
- ;; these will get put into vl-other.txt
-
- (append *use-set-warnings*
- *basic-warnings*
- *trunc-warnings*
- *trunc-minor-warnings*
- *disconnected-warnings*
- *smell-warnings*
- *smell-minor-warnings*
- *multidrive-warnings*
- *multidrive-minor-warnings*
- *fussy-size-warnings*
- *fussy-size-minor-warnings*
- *same-ports-warnings*
- *same-ports-minor-warnings*
- ))
-
-(defconst *warnings-ignored*
-
- ;; Warnings that aren't covered but which we don't want to put into vl-other.txt
- ;; anyway.
-
- (list
- :vl-warn-taskdecl
- :vl-warn-function
-
- ))
-
-(defun vl-lint-report (lintresult state)
- (declare (xargs :guard (vl-lintresult-p lintresult)
- :mode :program
- :stobjs state))
-
- (b* (((vl-lintresult lintresult) lintresult)
- (walist lintresult.mwalist)
- (sd-probs lintresult.sd-probs)
-
- ((mv major minor)
- (cwtime (sd-filter-problems sd-probs nil nil)))
- (major (reverse major))
- (minor (reverse minor))
-
- (- (cw "~%vl-lint: saving results...~%~%"))
-
- (othertypes (difference (mergesort (vl-modwarningalist-types walist))
- (mergesort (append *warnings-covered*
- *warnings-ignored*))))
-
- (state
- (with-ps-file
- "vl-basic.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-basic.txt" "Basic" *basic-warnings* walist)))
-
- (state
- (with-ps-file
- "vl-trunc.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-print "
-NOTE: see the bottom of this file for an explanation of what these warnings
-mean and how to avoid them.
-
-")
-
- (vl-lint-print-warnings "vl-trunc.txt" "Truncation/Extension" *trunc-warnings* walist)
-
- (vl-print "
-
-UNDERSTANDING THESE WARNINGS.
-
-1. VL-WARN-TRUNCATION warnings are issued when the left-hand side of an
-assignment statement is not as wide as the right-hand side.
-
-False positives here can typically be suppressed by using part-selects to make
-the intended truncations explicit. For instance:
-
- wire [47:0] foo ;
- wire [63:0] bar ;
-
- assign foo = bar ; // implicit truncation, causes warning
- assign foo = bar[47:0] ; // explicit truncation, no warning
-
- assign foo = condition ? bar : 0 ; // implicit truncation, causes warning
- assign foo = condition ? bar[47:0] : 0; // explicit truncation, no warning
-
-
-2. VL-WARN-EXTENSION warnings are the opposite: they are issued when the
-left-hand side is wider than the right-hand side would have been on its own.
-
-False-positives can again typically be suppressed by explicitly concatenting in
-zeroes, or by using part-selects to cut the left-hand side to the right size.
-For instance:
-
- wire [47:0] foo ;
- wire [63:0] bar ;
-
- assign bar = foo ; // implicit extension, causes warning
- assign bar = { 16'b0, foo } ; // explicit extension, no warning
- assign bar[47:0] = foo; // no extension, no warning
-
-
-Note that we consider certain truncation and extension warnings to be \"minor\"
-and do not report them here. Such warnings are unlikely to be a problem, but
-you can see \"vl-trunc-minor.txt\" to review them.")))
-
- (state
- (with-ps-file
- "vl-fussy.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-fussy.txt" "Fussy Size Warnings" *fussy-size-warnings* walist)))
-
- (state
- (with-ps-file
- "vl-fussy-minor.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-fussy-minor.txt" "Minor Fussy Size Warnings" *fussy-size-minor-warnings* walist)))
-
- (state
- (with-ps-file
- "vl-disconnected.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-disconnected.txt" "Disconnected Wire" *disconnected-warnings* walist)))
-
- (state
- (with-ps-file
- "vl-multi.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-multi.txt" "Multidrive" *multidrive-warnings* walist)))
-
- (state
- (if (not major)
- (progn$
- (cw "; No Skip-Detect Warnings.~%")
- state)
- (progn$
- (cw "vl-skipdet.txt: ~x0 Skip-Detect Warnings.~%" (len major))
- (with-ps-file "vl-skipdet.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-cw "Skip-Detect Warnings.~%~%")
- (sd-pp-problemlist-long major)))))
-
- (state
- (with-ps-file
- "vl-trunc-minor.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-print "
-NOTE: see the bottom of this file for an explanation of what these warnings
-mean and how to avoid them.
-
-")
- (vl-lint-print-warnings "vl-trunc-minor.txt" "Minor Truncation/Extension" *trunc-minor-warnings* walist)
- (vl-print "
-
-UNDERSTANDING THESE WARNINGS.
-
-1. VL-WARN-TRUNCATION-32 warnings are generated for any assignments that are
-being truncated and whose right-hand sides are 32-bits wide. This is a minor
-warning because it typically arises from assignments where plain integers are
-involved, e.g., if foo and bar are 10 bits wide, then a truncation-32 warning
-will be generated for:
-
- assign foo = bar ^ 5;
-
-This is because \"5\" has an implementation-dependent width (of at least 32
-bits), and in VL-Lint we treat it as being 32-bits wide. So, the above
-describes a 32-bit XOR that is then truncated down to 10 bits. Fixing these
-warnings is usually easy: just explicitly specify the sizes of the numbers
-involved, e.g., a \"corrected\" version might be:
-
- assign foo = bar ^ 10'd 5;
-
-This is generally a good idea since it avoids any implementation-dependent
-sizing (which can occasionally affect the results of expressions).
-
-
-2. VL-WARN-EXTENSION-MINOR warnings are generated for any assignments where
-the width of the left-hand side is used to size the expression, and where the
-right-hand side involves only addition operations. For instance, given:
-
- wire [9:0] foo;
- wire [9:0] bar;
- wire [9:0] sum;
- wire carry;
-
-Then an assignment like this:
-
- assign { carry, sum } = foo + bar;
-
-would result in a minor extension warning. These warnings are typically quite
-minor since you frequently want to get the carry out of a sum. But you could
-suppress them by writing something like this:
-
- Variant 1: assign {carry, sum} = {1'b0,foo} + bar;
- Variant 2: assign {carry, sum} = foo + bar + 11'b0;
-
-or similar, to make explicit on the right-hand side that you want an 11-bit
-wide addition instead of a 10-bit wide addition.")))
-
- (state
- (with-ps-file
- "vl-multi-minor.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-multi-minor.txt" "Minor Multidrive" *multidrive-minor-warnings* walist)))
-
- (state
- (if (not minor)
- (prog2$
- (cw "; No Minor Skip-Detect Warnings.~%")
- state)
- (prog2$
- (cw "vl-skipdet-minor.txt: ~x0 Minor Skip-Detect Warnings.~%" (len minor))
- (with-ps-file "vl-skipdet-minor.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-cw "Minor Skip-Detect Warnings.~%~%")
- (sd-pp-problemlist-long minor)))))
-
-
- (state
- (with-ps-file
- "vl-use-set.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-use-set.txt"
- "Unused/Unset Wire Warnings"
- *use-set-warnings*
- walist)))
-
-
- (state
- (with-ps-file
- "vl-smells.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-smells.txt" "Code-Smell Warnings" *smell-warnings* walist)))
-
- (state
- (with-ps-file
- "vl-smells-minor.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-smells-minor.txt" "Minor Code-Smell Warnings" *smell-minor-warnings* walist)))
-
-
- (state
- (with-ps-file "vl-same-ports.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-same-ports.txt"
- "Same-ports Warnings"
- *same-ports-warnings*
- walist)))
- (state
- (with-ps-file "vl-same-ports-minor.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-same-ports-minor.txt"
- "Minor same-ports Warnings"
- *same-ports-minor-warnings*
- walist)))
-
- (state
- (with-ps-file
- "vl-other.txt"
- (vl-ps-update-autowrap-col 68)
- (vl-lint-print-warnings "vl-other.txt" "Other/Unclassified" othertypes walist)))
-
- (- (cw "~%")))
-
- state))
-
-
-(encapsulate
- ()
- (defttag vl-lint)
- (remove-untouchable acl2::writes-okp nil))
-
-(defun vl-lint-report-wrapper (result state)
- (declare (xargs :mode :program :stobjs state))
- (vl-lint-report result state))
-
-(defmacro vl-lint (&key start-files
- search-path
- (search-exts ''("v"))
- topmods
- dropmods
- ignore
- ;; gross yucky thing; acl2-suppress defaults to all
- ;; ACL2 output, but for debugging use :acl2-suppress
- ;; nil to be able to see what is wrong.
- (acl2-suppress ':all))
- `(with-output
- :off ,(or acl2-suppress 'proof-tree)
- (make-event
- (b* ((- (acl2::set-max-mem (* 12 (expt 2 30))))
- (- (acl2::hons-resize :str-ht 1000000))
- ((mv & & state)
- ;; For some reason we have to assign to this here, inside the
- ;; make-event code, rather than ahead of time.
- (assign acl2::writes-okp t))
- ((mv result state)
- (cwtime (run-vl-lint :start-files ,start-files
- :search-path ,search-path
- :search-exts ,search-exts
- :topmods ,topmods
- :dropmods ,dropmods
- :ignore ,ignore)
- :name vl-lint))
- (state
- (cwtime (vl-lint-report-wrapper result state))))
- (value `(defconst *lint-result* ',result))))))
-
diff -Nru acl2-6.2/books/centaur/vl/lint/use-set-ignore.lisp acl2-6.3/books/centaur/vl/lint/use-set-ignore.lisp
--- acl2-6.2/books/centaur/vl/lint/use-set-ignore.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/lint/use-set-ignore.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -147,7 +147,7 @@
(defsection vl-warninglist-change-types
:parents (warnings)
:short "@(call vl-warninglist-change-types) changes the @('type') of every
-warning in @(see x) to @('new-type')."
+warning in the list @('x') to @('new-type')."
(defund vl-warninglist-change-types (new-type x)
(declare (xargs :guard (and (symbolp new-type)
diff -Nru acl2-6.2/books/centaur/vl/lint/xf-remove-toohard.lisp acl2-6.3/books/centaur/vl/lint/xf-remove-toohard.lisp
--- acl2-6.2/books/centaur/vl/lint/xf-remove-toohard.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/lint/xf-remove-toohard.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -23,19 +23,20 @@
(include-book "../mlib/allexprs")
(local (include-book "../util/arithmetic"))
+(defsection remove-toohard
+ :parents (lint)
+ :short "(Unsound transform). Remove from each module any assignments,
+instances, or inital/always blocks that have any \"toohard\" expressions in
+them, such as unresolved hierarchical identifiers, strings, function calls,
+system functions, and similar."
+
+ :long "This is obviously unsound and should never be used in the ordinary
+transformation process. We use it in our @(see lint)ing tool to prepare
+modules for sizing for the linter.
")
-; VL-Lint Only.
-;
-; (VL-MODULELIST-REMOVE-TOOHARD X) removes from each module any assignments,
-; instances, or inital/always blocks that have any "toohard" expressions in
-; them, such as unresolved hierarchical identifiers, strings, function calls,
-; system functions, and similar.
-;
-; This is obviously unsound and should never be used in the ordinary
-; transformation process. We use it to prepare modules for sizing.
-
-(defsection vl-expr-toohard-subexpr
-
+(defsection vl-atom-toohard
+ :parents (remove-toohard)
+
(defund vl-atom-toohard (x)
;; Returns NIL if the atom is okay, or X otherwise.
(declare (xargs :guard (vl-atom-p x)))
@@ -53,7 +54,10 @@
(if (vl-atom-toohard x)
t
nil)))
- :hints(("Goal" :in-theory (enable vl-atom-toohard))))
+ :hints(("Goal" :in-theory (enable vl-atom-toohard)))))
+
+(defsection vl-expr-toohard-subexpr
+ :parents (remove-toohard)
(defconst *not-toohard-ops*
(list :VL-UNARY-PLUS :VL-UNARY-MINUS :VL-UNARY-LOGNOT
@@ -142,6 +146,7 @@
(defsection vl-assignlist-remove-toohard
+ :parents (remove-toohard)
(defund vl-assignlist-remove-toohard (x warnings)
"Returns (MV WARNINGS X-PRIME)"
@@ -180,6 +185,7 @@
(defsection vl-modinstlist-remove-toohard
+ :parents (remove-toohard)
(defund vl-modinstlist-remove-toohard (x warnings)
"Returns (MV WARNINGS X-PRIME)"
@@ -218,6 +224,7 @@
(defsection vl-gateinstlist-remove-toohard
+ :parents (remove-toohard)
(defund vl-gateinstlist-remove-toohard (x warnings)
"Returns (MV WARNINGS X-PRIME)"
@@ -256,6 +263,7 @@
(defsection vl-initiallist-remove-toohard
+ :parents (remove-toohard)
(defund vl-initiallist-remove-toohard (x warnings)
"Returns (MV WARNINGS X-PRIME)"
@@ -294,6 +302,7 @@
(defsection vl-alwayslist-remove-toohard
+ :parents (remove-toohard)
(defund vl-alwayslist-remove-toohard (x warnings)
"Returns (MV WARNINGS X-PRIME)"
@@ -332,6 +341,7 @@
(defsection vl-module-remove-toohard
+ :parents (remove-toohard)
(defund vl-module-remove-toohard (x)
"Returns X-PRIME"
@@ -362,18 +372,14 @@
(vl-module->name x))))
-(defsection vl-modulelist-remove-toohard
-
- (defprojection vl-modulelist-remove-toohard (x)
- (vl-module-remove-toohard x)
- :guard (vl-modulelist-p x)
- :result-type vl-modulelist-p)
-
- (local (in-theory (enable vl-modulelist-remove-toohard)))
-
- (defthm vl-modulelist->names-of-vl-modulelist-remove-toohard
- (equal (vl-modulelist->names (vl-modulelist-remove-toohard x))
- (vl-modulelist->names x))))
+(defprojection vl-modulelist-remove-toohard (x)
+ (vl-module-remove-toohard x)
+ :guard (vl-modulelist-p x)
+ :result-type vl-modulelist-p
+ :parents (remove-toohard)
+ :rest ((defthm vl-modulelist->names-of-vl-modulelist-remove-toohard
+ (equal (vl-modulelist->names (vl-modulelist-remove-toohard x))
+ (vl-modulelist->names x)))))
#||
diff -Nru acl2-6.2/books/centaur/vl/lint/xf-suppress-warnings.lisp acl2-6.3/books/centaur/vl/lint/xf-suppress-warnings.lisp
--- acl2-6.2/books/centaur/vl/lint/xf-suppress-warnings.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/lint/xf-suppress-warnings.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -22,30 +22,37 @@
(include-book "../parsetree")
(local (include-book "../util/arithmetic"))
-; VL Warning Suppression
-;
-; This is quick and dirty, but probably is actually a pretty effective and
-; reasonable way to deal with suppressing unwanted warnings from VL-Lint.
-;
-; The basic idea is to stick attributes such as (* LINT_IGNORE *) into the
-; source code, which with our comment syntax can be done using the form //@VL
-; LINT_IGNORE, or similar. We then look for these attributes to decide whether
-; to suppress a warning.
-;
-; For convenience we treat LINT_IGNORE directives in a case-insensitive way and
-; treat _ interchangeably with -. This is useful because the Verilog user has
-; to use _ since these are attribute names and hence must be valid identifiers.
-;
-; We let the user write things like LINT_IGNORE_VL_WARN_ODDEXPR, or, more
-; conveniently, LINT_IGNORE_ODDEXPR, by just "mashing" the tail of what they
-; write by throwing away any leading VL_ or VL_WARN_ part. By convention a
-; plain LINT_IGNORE with no further information means just ignore all warnings.
+(defsection lint-warning-suppression
+ :parents (lint warnings)
+ :short "An attribute- mechanism for suppressing particular @(see warnings)
+when using @(see lint)."
+
+ :long "This is quick and dirty, but probably is actually a pretty
+effective and reasonable way to deal with suppressing unwanted warnings from
+VL-Lint.
+
+The basic idea is to stick attributes such as @('(* LINT_IGNORE *)') into
+the source code, which with our comment syntax can be done using the form
+@('//@VL LINT_IGNORE'), or similar. We then look for these attributes to
+decide whether to suppress a warning.
+
+For convenience we treat @('LINT_IGNORE') directives in a case-insensitive
+way and treat _ interchangeably with -. This is useful because the Verilog
+user typically has to use _ since these are attribute names and hence must be
+valid identifiers.
+
+We let the user write things like @('LINT_IGNORE_VL_WARN_ODDEXPR'), or, more
+conveniently, @('LINT_IGNORE_ODDEXPR'), by just \"mashing\" the tail of what
+they write by throwing away any leading @('VL_') or @('VL_WARN_') part. By
+convention a plain @('LINT_IGNORE') with no further information means just
+ignore all warnings.
")
-(defsection vl-mash-warning-string
-; do basic string mashing to allow the user to refer to warnings in either
-; upper or lower case, treating - and _ as equivalent, and with or without
-; vl_warn_ prefixes.
+(defsection vl-mash-warning-string
+ :parents (lint-warning-suppression)
+ :short "Do basic string mashing to allow the user to refer to warnings in
+either upper or lower case, treating - and _ as equivalent, and with or without
+@('vl_warn_') prefixes."
(defund vl-mash-warning-string (x)
(declare (xargs :guard (stringp x)))
@@ -69,15 +76,13 @@
:rule-classes :type-prescription))
-(defsection vl-mash-warning-strings
-
- (defprojection vl-mash-warning-strings (x)
- (vl-mash-warning-string x)
- :guard (string-listp x))
-
- (defthm string-listp-of-vl-mash-warning-strings
- (string-listp (vl-mash-warning-strings x))
- :hints(("Goal" :induct (len x)))))
+(defprojection vl-mash-warning-strings (x)
+ (vl-mash-warning-string x)
+ :guard (string-listp x)
+ :parents (lint-warning-suppression)
+ :rest ((defthm string-listp-of-vl-mash-warning-strings
+ (string-listp (vl-mash-warning-strings x))
+ :hints(("Goal" :induct (len x))))))
@@ -89,6 +94,7 @@
(defsection vl-lint-ignore-att-mash
+ :parents (lint-warning-suppression)
(defund vl-lint-ignore-att-mash (x)
(declare (xargs :guard (and (stringp x)
@@ -103,6 +109,7 @@
(defsection vl-warning-type-mash
+ :parents (lint-warning-suppression)
(defund vl-warning-type-mash (x)
(declare (xargs :guard (symbolp x)))
@@ -207,6 +214,7 @@
(defsection vl-lint-suppress-warnings
+ :parents (lint-warning-suppression)
(defund vl-lint-suppress-warnings (x)
(declare (xargs :guard (vl-warninglist-p x)))
@@ -226,6 +234,7 @@
(defsection vl-module-suppress-lint-warnings
+ :parents (lint-warning-suppression)
(defund vl-module-suppress-lint-warnings (x)
(declare (xargs :guard (vl-module-p x)))
@@ -244,6 +253,7 @@
(defsection vl-modulelist-suppress-lint-warnings
+ :parents (lint-warning-suppression)
(defprojection vl-modulelist-suppress-lint-warnings (x)
(vl-module-suppress-lint-warnings x)
@@ -260,6 +270,7 @@
; We'll also allow you to globally suppress warnings.
(defsection vl-warninglist-lint-ignoreall
+ :parents (lint-warning-suppression)
(defund vl-warninglist-lint-ignoreall (x mashed-ignore-list)
(declare (xargs :guard (and (vl-warninglist-p x)
@@ -281,6 +292,7 @@
(defsection vl-module-lint-ignoreall
+ :parents (lint-warning-suppression)
(defund vl-module-lint-ignoreall (x mashed-ignore-list)
(declare (xargs :guard (and (vl-module-p x)
@@ -301,6 +313,7 @@
(defsection vl-modulelist-lint-ignoreall-aux
+ :parents (lint-warning-suppression)
(defprojection vl-modulelist-lint-ignoreall-aux (x mashed-ignore-list)
(vl-module-lint-ignoreall x mashed-ignore-list)
@@ -315,6 +328,7 @@
(defsection vl-modulelist-lint-ignoreall
+ :parents (lint-warning-suppression)
; The user-ignore-list here is just a list of user-level ignore strings. That
; is, we'll mash them all first. The user can say all kinds of things, like
diff -Nru acl2-6.2/books/centaur/vl/loader/filemap.lisp acl2-6.3/books/centaur/vl/loader/filemap.lisp
--- acl2-6.2/books/centaur/vl/loader/filemap.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/filemap.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -198,7 +198,7 @@
(defthm bounds-of-vl-string-findloc
(implies (stringp x)
(and (<= 0 (vl-string-findloc x loc))
- (<= (vl-string-findloc x loc) (len (coerce x 'list)))))
+ (<= (vl-string-findloc x loc) (len (explode x)))))
:rule-classes :linear))
diff -Nru acl2-6.2/books/centaur/vl/loader/find-file.lisp acl2-6.3/books/centaur/vl/loader/find-file.lisp
--- acl2-6.2/books/centaur/vl/loader/find-file.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/find-file.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -42,7 +42,7 @@
(cat dir
(if (vl-ends-with-directory-separatorp dir)
""
- (coerce (list ACL2::*directory-separator*) 'string))
+ (implode (list ACL2::*directory-separator*)))
filename))
(defthm stringp-of-vl-extend-pathname
diff -Nru acl2-6.2/books/centaur/vl/loader/inject-comments.lisp acl2-6.3/books/centaur/vl/loader/inject-comments.lisp
--- acl2-6.2/books/centaur/vl/loader/inject-comments.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/inject-comments.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -327,7 +327,7 @@
(vl-gather-comments-fal-aux minl maxl (- n 1) min max fal acc))))
(verify-guards vl-gather-comments-fal-aux
- :hints(("goal" :use ((:instance posp-of-vl-location->line
+ :hints(("goal" :use ((:instance return-type-of-vl-location->line
(x min))))))
(defthm vl-commentmap-p-of-vl-gather-comments-fal-aux
diff -Nru acl2-6.2/books/centaur/vl/loader/lexer-tests.lisp acl2-6.3/books/centaur/vl/loader/lexer-tests.lisp
--- acl2-6.2/books/centaur/vl/loader/lexer-tests.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/lexer-tests.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -194,14 +194,14 @@
(vl-lex-string-testcase :input "\"crazy \\7\""
:successp t
:expansion (cat "crazy "
- (coerce (list (code-char 7)) 'string)))
+ (implode (list (code-char 7)))))
(vl-lex-string-testcase :input "\"\\\\ another \\n basic \\t escape \\\" test\""
:successp t
:expansion (cat "\\ another "
- (coerce (list #\Newline) 'string)
+ (implode (list #\Newline))
" basic "
- (coerce (list #\Tab) 'string)
+ (implode (list #\Tab))
" escape \" test"))
;; Should fail string tests
@@ -436,7 +436,7 @@
:signedp nil
:value nil
:wasunsized t
- :bits (coerce (repeat #\X 32) 'string)
+ :bits (implode (repeat #\X 32))
:nwarnings 1)
(vl-lex-integer-testcase :input "'hxxx"
@@ -446,7 +446,7 @@
:signedp nil
:value nil
:wasunsized t
- :bits (coerce (repeat #\X 32) 'string)
+ :bits (implode (repeat #\X 32))
:nwarnings 1)
(vl-lex-integer-testcase :input "'bz"
@@ -456,7 +456,7 @@
:signedp nil
:value nil
:wasunsized t
- :bits (coerce (repeat #\Z 32) 'string)
+ :bits (implode (repeat #\Z 32))
:nwarnings 1)
(vl-lex-integer-testcase :input "'o zzz"
@@ -466,7 +466,7 @@
:signedp nil
:value nil
:wasunsized t
- :bits (coerce (repeat #\Z 32) 'string)
+ :bits (implode (repeat #\Z 32))
:nwarnings 1)
(vl-lex-integer-testcase :input "'bx1"
@@ -476,7 +476,7 @@
:signedp nil
:value nil
:wasunsized t
- :bits (coerce (append (repeat #\X 31) (list #\1)) 'string)
+ :bits (implode (append (repeat #\X 31) (list #\1)))
:nwarnings 1)
diff -Nru acl2-6.2/books/centaur/vl/loader/lexer-utils.lisp acl2-6.3/books/centaur/vl/loader/lexer-utils.lisp
--- acl2-6.2/books/centaur/vl/loader/lexer-utils.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/lexer-utils.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -119,7 +119,7 @@
@('echars'). More exactly, it computes:
@({
- (prefixp (coerce string 'list)
+ (prefixp (explode string)
(vl-echarlist->chars echars))
})
@@ -150,7 +150,7 @@
(xargs :guard (and (not (equal string ""))
(vl-echarlist-p echars))
:verify-guards nil))
- (mbe :logic (prefixp (coerce (string-fix string) 'list) (vl-echarlist->chars echars))
+ (mbe :logic (prefixp (explode (string-fix string)) (vl-echarlist->chars echars))
:exec (vl-matches-string-p-impl string 0 (length string) echars)))
(local (defthm lemma
@@ -160,7 +160,8 @@
(equal len (length string))
(vl-echarlist-p echars))
(equal (vl-matches-string-p-impl string i len echars)
- (prefixp (nthcdr i (coerce string 'list)) (vl-echarlist->chars echars))))
+ (prefixp (nthcdr i (explode string))
+ (vl-echarlist->chars echars))))
:hints(("Goal" :in-theory (enable vl-matches-string-p-impl)))))
(verify-guards vl-matches-string-p$inline)
@@ -169,7 +170,7 @@
(defthm len-when-vl-matches-string-p-fc
(implies (vl-matches-string-p string echars)
- (<= (len (coerce string 'list))
+ (<= (len (explode string))
(len echars)))
:rule-classes ((:forward-chaining)
(:linear)))
@@ -223,7 +224,7 @@
(implies (and (mv-nth 0 (vl-read-literal string echars))
(force (vl-echarlist-p echars)))
(equal (vl-echarlist->chars (mv-nth 0 (vl-read-literal string echars)))
- (coerce (string-fix string) 'list)))
+ (explode (string-fix string))))
:hints(("Goal" :in-theory (enable vl-matches-string-p))))
(defthm vl-echarlist->string-of-prefix-of-vl-read-literal
@@ -338,7 +339,7 @@
(defthm len-of-vl-read-until-literal
(implies (mv-nth 0 (vl-read-until-literal string echars))
- (<= (len (coerce string 'list))
+ (<= (len (explode string))
(len (mv-nth 2 (vl-read-until-literal string echars)))))
:rule-classes ((:rewrite) (:linear)))
diff -Nru acl2-6.2/books/centaur/vl/loader/lexer.lisp acl2-6.3/books/centaur/vl/loader/lexer.lisp
--- acl2-6.2/books/centaur/vl/loader/lexer.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/lexer.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -773,7 +773,7 @@
(vl-location-string (vl-echar->loc (car echars)))
err)
nil echars)
- (mv (reverse (coerce vacc 'string))
+ (mv (str::rchars-to-string vacc)
(cons (car echars) (reverse eacc))
remainder))))
@@ -1386,7 +1386,7 @@
;; Basic extension test with a fixed width
(assert! (b* (((mv warn bits)
(vl-correct-bitlist *vl-fakeloc*
- (vl-binary-digits-to-bitlist (coerce "0111" 'list))
+ (vl-binary-digits-to-bitlist (explode "0111"))
8
nil)))
(and (not warn)
@@ -1394,7 +1394,7 @@
(assert! (b* (((mv warn bits)
(vl-correct-bitlist *vl-fakeloc*
- (vl-binary-digits-to-bitlist (coerce "1111" 'list))
+ (vl-binary-digits-to-bitlist (explode "1111"))
8
nil)))
(and (not warn)
@@ -1402,7 +1402,7 @@
(assert! (b* (((mv warn bits)
(vl-correct-bitlist *vl-fakeloc*
- (vl-binary-digits-to-bitlist (coerce "x111" 'list))
+ (vl-binary-digits-to-bitlist (explode "x111"))
8
nil)))
(and (not warn)
@@ -1410,7 +1410,7 @@
(assert! (b* (((mv warn bits)
(vl-correct-bitlist *vl-fakeloc*
- (vl-binary-digits-to-bitlist (coerce "z111" 'list))
+ (vl-binary-digits-to-bitlist (explode "z111"))
8
nil)))
(and (not warn)
@@ -1419,7 +1419,7 @@
(assert! (b* (((mv warn bits)
(vl-correct-bitlist *vl-fakeloc*
- (vl-binary-digits-to-bitlist (coerce "110111" 'list))
+ (vl-binary-digits-to-bitlist (explode "110111"))
4
nil)))
(and (consp warn)
@@ -1427,25 +1427,23 @@
(assert! (b* (((mv warn ?bits)
(vl-correct-bitlist *vl-fakeloc*
- (vl-binary-digits-to-bitlist (coerce "0111" 'list))
+ (vl-binary-digits-to-bitlist (explode "0111"))
nil
nil)))
(and (not warn)
(equal (vl-bitlist->string bits)
- (coerce (append (repeat #\0 29)
- (repeat #\1 3))
- 'string)))))
+ (implode (append (repeat #\0 29)
+ (repeat #\1 3)))))))
(assert! (b* (((mv warn ?bits)
(vl-correct-bitlist *vl-fakeloc*
- (vl-binary-digits-to-bitlist (coerce "Z111" 'list))
+ (vl-binary-digits-to-bitlist (explode "Z111"))
nil
nil)))
(and (consp warn)
(equal (vl-bitlist->string bits)
- (coerce (append (repeat #\Z 29)
- (repeat #\1 3))
- 'string))))))))
+ (implode (append (repeat #\Z 29)
+ (repeat #\1 3))))))))))
diff -Nru acl2-6.2/books/centaur/vl/loader/loader.lisp acl2-6.3/books/centaur/vl/loader/loader.lisp
--- acl2-6.2/books/centaur/vl/loader/loader.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/loader.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -56,8 +56,8 @@
-Our top-level function for loading Verilog files, @(see vl-load), implements
-such a scheme. It has various options that allow you to specify the search paths and
extensions to use when looking for files, etc. It also features an @(see
overrides) mechanism that can be used to \"safely\" use alternate definitions
@@ -295,7 +295,7 @@
:returns (mv (merged (vl-modulelist-p merged) :hyp :fguard)
(modalist (equal modalist (vl-modalist merged)) :hyp :fguard)
(walist vl-modwarningalist-p :hyp :fguard))
- :parents (vl-load)
+ :parents (loader)
:short "Merge newly found Verilog modules with previously loaded modules,
warning about multiply defined modules."
@@ -342,7 +342,7 @@
state)
:returns (mv (st vl-loadstate-p :hyp :fguard)
(state state-p1 :hyp (force (state-p1 state))))
- :parents (vl-load)
+ :parents (loader)
:short "Main function for loading a single Verilog file."
:long "
Even loading a single file is a multi-step process:
@@ -504,7 +504,7 @@
state)
:returns (mv (st vl-loadstate-p :hyp :fguard)
(state state-p1 :hyp (force (state-p1 state))))
- :parents (vl-load)
+ :parents (loader)
:short "Load a list of files."
(b* (((when (atom filenames))
(mv st state))
@@ -518,7 +518,7 @@
state)
:returns (mv (st vl-loadstate-p :hyp :fguard)
(state state-p1 :hyp (force (state-p1 state))))
- :parents (vl-load)
+ :parents (loader)
:short "Try to load a module from the search path."
(b* (((vl-loadstate st) st)
@@ -545,7 +545,7 @@
state)
:returns (mv (st vl-loadstate-p :hyp :fguard)
(state state-p1 :hyp (force (state-p1 state))))
- :parents (vl-load)
+ :parents (loader)
:short "Extend @(see vl-load-module) to try to load a list of modules."
(b* (((when (atom modnames))
@@ -557,7 +557,7 @@
(define vl-modules-left-to-load ((st vl-loadstate-p))
:returns (names string-listp :hyp :fguard)
- :parents (vl-load)
+ :parents (loader)
:short "Determine which modules we still need to load."
:long "For loading to be completely done, we want to have:
@@ -598,7 +598,7 @@
:returns (mv (st vl-loadstate-p :hyp :fguard)
(state state-p1 :hyp (force (state-p1 state))
:hints(("Goal" :in-theory (disable (force))))))
- :parents (vl-load)
+ :parents (loader)
:short "Attempt to find and load any missing modules."
:long "After some initial files have been loaded, it is generally
@@ -705,7 +705,7 @@
state)
:returns (mv (result vl-loadresult-p :hyp :fguard)
(state state-p1 :hyp (force (state-p1 state))))
- :parents (vl-load)
+ :parents (loader)
:short "Top level interface for loading Verilog sources."
(b* ((config
@@ -775,7 +775,8 @@
(result (make-vl-loadresult :mods mods
:filemap st.filemap
- :warnings st.warnings)))
+ :warnings st.warnings
+ :defines st.defines)))
(fast-alist-free overrides)
(fast-alist-free (vl-loadstate->modalist st))
@@ -784,7 +785,7 @@
(defsection vl-load-summary
- :parents (vl-load)
+ :parents (loader)
:short "Print summary information (e.g., warnings, numbers of modules loaded,
etc.) after modules have been loaded."
@@ -846,6 +847,13 @@
(define vl-load ((config vl-loadconfig-p)
&key
(state 'state))
+ :parents (loader)
+ :short "Wrapper for @(see vl-load-main) that also reports errors or (with
+some configuration) can print other information."
+
+ :long "
This is very similar to @(see vl-load-main), but calls @(see
+vl-load-summary) afterwards.
"
+
:returns (mv (result vl-loadresult-p :hyp :fguard)
(state state-p1 :hyp (force (state-p1 state))))
(b* (((vl-loadconfig config) config)
diff -Nru acl2-6.2/books/centaur/vl/loader/overrides.lisp acl2-6.3/books/centaur/vl/loader/overrides.lisp
--- acl2-6.2/books/centaur/vl/loader/overrides.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/overrides.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -565,10 +565,10 @@
(defsection vl-read-override-file
:parents (overrides)
- :short "Load an override file into a @(see vl-override-alistp)."
+ :short "Load an override file into a @(see vl-overridelist-p)."
:long "Signature: @(call vl-read-override-file) returns @('(mv successp
-override-alist filemap defines' comment-map' walist' state)').
"
+overridelist filemap defines' comment-map' walist' state)')."
(defund vl-read-override-file (path modname defines comment-map walist filemapp state)
"Returns (MV SUCCESSP OVERRIDE-LIST FILEMAP DEFINES' COMMENT-MAP' WALIST' STATE)"
diff -Nru acl2-6.2/books/centaur/vl/loader/parse-nets.lisp acl2-6.3/books/centaur/vl/loader/parse-nets.lisp
--- acl2-6.2/books/centaur/vl/loader/parse-nets.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/parse-nets.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -27,6 +27,7 @@
;; BOZO some of these are expensive; consider backchain limits.
(local (in-theory (disable acl2::consp-under-iff-when-true-listp
+ consp-when-member-equal-of-cons-listp
member-equal-when-member-equal-of-cdr-under-iff
default-car
default-cdr)))
diff -Nru acl2-6.2/books/centaur/vl/loader/parse-statements-def.lisp acl2-6.3/books/centaur/vl/loader/parse-statements-def.lisp
--- acl2-6.2/books/centaur/vl/loader/parse-statements-def.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/parse-statements-def.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -526,7 +526,7 @@
(:= (vl-match-token :vl-colon))
(id := (vl-match-token :vl-idtoken))
(items :w= (vl-parse-0+-block-item-declarations)))
- (stmts := (vl-parse-statements-until-end))
+ (stmts := (vl-parse-statements-until-join))
(:= (vl-match-token :vl-kwd-join))
(return (make-vl-blockstmt :sequentialp nil
:name (and id (vl-idtoken->name id))
@@ -686,6 +686,17 @@
(ret := (vl-parse-statement-aux atts))
(return ret)))
+ (defparser vl-parse-statements-until-join (tokens warnings)
+ (declare (xargs :measure (two-nats-measure (acl2-count tokens) 3)))
+ ;; Returns a list of vl-stmt-p's.
+ ;; Tries to read until the keyword "join"
+ (seqw tokens warnings
+ (when (vl-is-token? :vl-kwd-join)
+ (return nil))
+ (first :s= (vl-parse-statement))
+ (rest := (vl-parse-statements-until-join))
+ (return (cons first rest))))
+
(defparser vl-parse-statements-until-end (tokens warnings)
(declare (xargs :measure (two-nats-measure (acl2-count tokens) 3)))
;; Returns a list of vl-stmt-p's.
diff -Nru acl2-6.2/books/centaur/vl/loader/parse-statements-error.lisp acl2-6.3/books/centaur/vl/loader/parse-statements-error.lisp
--- acl2-6.2/books/centaur/vl/loader/parse-statements-error.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/parse-statements-error.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -82,6 +82,7 @@
,(vl-val-when-error-claim vl-parse-statement-fn)
,(vl-val-when-error-claim vl-parse-statement-or-null-fn)
,(vl-val-when-error-claim vl-parse-statements-until-end-fn)
+ ,(vl-val-when-error-claim vl-parse-statements-until-join-fn)
:hints(("Goal" :induct (vl-flag-parse-statement flag atts tokens warnings))
'(:do-not '(simplify))
(flag::expand-calls-computed-hint
diff -Nru acl2-6.2/books/centaur/vl/loader/parse-statements-progress.lisp acl2-6.3/books/centaur/vl/loader/parse-statements-progress.lisp
--- acl2-6.2/books/centaur/vl/loader/parse-statements-progress.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/parse-statements-progress.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -79,6 +79,7 @@
:extra-args (atts))
,(vl-progress-claim vl-parse-statement-fn)
,(vl-progress-claim vl-parse-statement-or-null-fn)
+
(vl-parse-statements-until-end-fn
(and (<= (acl2-count (mv-nth 2 (vl-parse-statements-until-end-fn tokens warnings)))
(acl2-count tokens))
@@ -88,6 +89,17 @@
(< (acl2-count (mv-nth 2 (vl-parse-statements-until-end-fn tokens warnings)))
(acl2-count tokens))))
:rule-classes ((:rewrite) (:linear)))
+
+ (vl-parse-statements-until-join-fn
+ (and (<= (acl2-count (mv-nth 2 (vl-parse-statements-until-join-fn tokens warnings)))
+ (acl2-count tokens))
+ (implies (and (not (mv-nth 0 (vl-parse-statements-until-join-fn
+ tokens warnings)))
+ (mv-nth 1 (vl-parse-statements-until-join-fn tokens warnings)))
+ (< (acl2-count (mv-nth 2 (vl-parse-statements-until-join-fn tokens warnings)))
+ (acl2-count tokens))))
+ :rule-classes ((:rewrite) (:linear)))
+
:hints(("Goal" :induct (vl-flag-parse-statement flag atts tokens warnings))
'(:do-not '(simplify))
(flag::expand-calls-computed-hint
diff -Nru acl2-6.2/books/centaur/vl/loader/parse-statements-result.lisp acl2-6.3/books/centaur/vl/loader/parse-statements-result.lisp
--- acl2-6.2/books/centaur/vl/loader/parse-statements-result.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/parse-statements-result.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -125,6 +125,9 @@
,(vl-stmt-claim vl-parse-statements-until-end-fn
(vl-stmtlist-p val)
:true-listp t)
+ ,(vl-stmt-claim vl-parse-statements-until-join-fn
+ (vl-stmtlist-p val)
+ :true-listp t)
:hints(("Goal" :induct (vl-flag-parse-statement flag atts tokens warnings))
(and acl2::stable-under-simplificationp
(flag::expand-calls-computed-hint
diff -Nru acl2-6.2/books/centaur/vl/loader/parse-statements-tokenlist.lisp acl2-6.3/books/centaur/vl/loader/parse-statements-tokenlist.lisp
--- acl2-6.2/books/centaur/vl/loader/parse-statements-tokenlist.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/parse-statements-tokenlist.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -85,6 +85,7 @@
,(vl-tokenlist-claim vl-parse-statement-fn)
,(vl-tokenlist-claim vl-parse-statement-or-null-fn)
,(vl-tokenlist-claim vl-parse-statements-until-end-fn)
+ ,(vl-tokenlist-claim vl-parse-statements-until-join-fn)
:hints(("Goal" :induct (vl-flag-parse-statement flag atts tokens warnings))
(and acl2::stable-under-simplificationp
(flag::expand-calls-computed-hint
diff -Nru acl2-6.2/books/centaur/vl/loader/parse-statements-warninglist.lisp acl2-6.3/books/centaur/vl/loader/parse-statements-warninglist.lisp
--- acl2-6.2/books/centaur/vl/loader/parse-statements-warninglist.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/loader/parse-statements-warninglist.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -47,6 +47,7 @@
,(vl-warninglist-claim vl-parse-statement-fn)
,(vl-warninglist-claim vl-parse-statement-or-null-fn)
,(vl-warninglist-claim vl-parse-statements-until-end-fn)
+ ,(vl-warninglist-claim vl-parse-statements-until-join-fn)
:hints(("Goal" :induct (vl-flag-parse-statement flag atts tokens warnings))
(and acl2::stable-under-simplificationp
(flag::expand-calls-computed-hint
diff -Nru acl2-6.2/books/centaur/vl/mlib/comment-writer.lisp acl2-6.3/books/centaur/vl/mlib/comment-writer.lisp
--- acl2-6.2/books/centaur/vl/mlib/comment-writer.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/mlib/comment-writer.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -129,6 +129,20 @@
(vl-vardecllist-ppmap (cdr x)
(acons (vl-vardecl->loc (car x)) str alist)))))
+(define vl-eventdecllist-ppmap ((x vl-eventdecllist-p)
+ (alist vl-commentmap-p)
+ &key (ps 'ps))
+ :returns (mv (alist vl-commentmap-p
+ :hyp (and (force (vl-eventdecllist-p x))
+ (force (vl-commentmap-p alist))))
+ (ps))
+ (if (atom x)
+ (mv alist ps)
+ (mv-let (str ps)
+ (with-semilocal-ps (vl-pp-eventdecl (car x)))
+ (vl-eventdecllist-ppmap (cdr x)
+ (acons (vl-eventdecl->loc (car x)) str alist)))))
+
(define vl-modinstlist-ppmap ((x vl-modinstlist-p)
(mods vl-modulelist-p)
(modalist (equal modalist (vl-modalist mods)))
@@ -327,6 +341,7 @@
((mv imap ps) (vl-portdecllist-ppmap x.portdecls imap))
((mv imap ps) (vl-regdecllist-ppmap x.regdecls imap))
((mv imap ps) (vl-vardecllist-ppmap x.vardecls imap))
+ ((mv imap ps) (vl-eventdecllist-ppmap x.eventdecls imap))
((mv imap ps) (vl-netdecllist-ppmap x.netdecls imap))
((mv imap ps) (vl-fundecllist-ppmap x.fundecls imap))
((mv imap ps) (vl-taskdecllist-ppmap x.taskdecls imap))
@@ -387,11 +402,6 @@
(vl-print " (")
(vl-pp-portlist x.ports)
(vl-println ");")
-
- (if (not x.eventdecls)
- ps
- (vl-println "// BOZO implement eventdecl printing"))
-
(vl-pp-encoded-commentmap guts)
(vl-ps-span "vl_key" (vl-println "endmodule"))
(vl-println "")
diff -Nru acl2-6.2/books/centaur/vl/mlib/ctxexprs.lisp acl2-6.3/books/centaur/vl/mlib/ctxexprs.lisp
--- acl2-6.2/books/centaur/vl/mlib/ctxexprs.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/mlib/ctxexprs.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -106,6 +106,7 @@
(type-thm (mksym 'vl-exprctxalist-p-of- collect))
(true-thm (mksym 'true-listp-of- collect)))
`(defsection ,collect
+ :parents (ctxexprs)
(defund ,collect (mod x)
(declare (xargs :guard (and (stringp mod)
@@ -136,6 +137,7 @@
(,collect-elem mod x)
:guard (and (stringp mod)
(,list-type-p x))
+ :parents (ctxexprs)
:rest
((defthm ,type-thm
(implies (and (force (stringp mod))
@@ -173,6 +175,7 @@
(def-vl-ctxexprs-list :element vl-initial :list vl-initiallist)
(defsection vl-module-ctxexprs
+ :parents (ctxexprs)
(defund vl-module-ctxexprs (x)
(declare (xargs :guard (vl-module-p x)))
diff -Nru acl2-6.2/books/centaur/vl/mlib/expr-slice.lisp acl2-6.3/books/centaur/vl/mlib/expr-slice.lisp
--- acl2-6.2/books/centaur/vl/mlib/expr-slice.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/mlib/expr-slice.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -835,6 +835,7 @@
(repeat (vl-expr->finalwidth a) n))
:hints(("Goal" :in-theory (enable repeat)))))
+ (local (in-theory (disable car-of-vl-exprlist->finalwidths)))
(local (defthm vl-expr->finalwidth-of-first
(equal (vl-expr->finalwidth (first x))
(first (vl-exprlist->finalwidths x)))))
@@ -855,12 +856,12 @@
(equal (vl-exprlist->finalwidths (mv-nth 2 ret))
(repeat 1 (vl-atom->finalwidth x))))))
-
(local (defthm vl-exprlist->finaltypes-of-repeat
(equal (vl-exprlist->finaltypes (repeat a n))
(repeat (vl-expr->finaltype a) n))
:hints(("Goal" :in-theory (enable repeat)))))
+ (local (in-theory (disable car-of-vl-exprlist->finaltypes)))
(local (defthm vl-expr->finaltype-of-first
(equal (vl-expr->finaltype (first x))
(first (vl-exprlist->finaltypes x)))))
diff -Nru acl2-6.2/books/centaur/vl/mlib/hid-tools.lisp acl2-6.3/books/centaur/vl/mlib/hid-tools.lisp
--- acl2-6.2/books/centaur/vl/mlib/hid-tools.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/mlib/hid-tools.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -568,7 +568,7 @@
;; natural number.
(cat (vl-hidpiece->name (vl-atom->guts (first args)))
"["
- (coerce (explode-atom (vl-resolved->val (second args)) 10) 'string)
+ (implode (explode-atom (vl-resolved->val (second args)) 10))
"]"
(vl-flatten-hidexpr (third args))))
diff -Nru acl2-6.2/books/centaur/vl/mlib/hierarchy.lisp acl2-6.3/books/centaur/vl/mlib/hierarchy.lisp
--- acl2-6.2/books/centaur/vl/mlib/hierarchy.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/mlib/hierarchy.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -583,7 +583,7 @@
@(thm correctness-of-vl-depalist)
This alist is useful in dependency computations such as @(see
-vl-dependent-module). It satisfies @(see alistp), @(see vl-depalist-p), and
+vl-dependent-modules). It satisfies @(see alistp), @(see vl-depalist-p), and
@(see vl-set-values-p).
"
(defund vl-depalist (x)
@@ -1600,7 +1600,7 @@
(defsection vl-maximal-deporder
:parents (vl-deporder)
:short "@(call vl-maximal-deporder) returns the maximum level for any module
-in @('names'), according to the @(see vl-deporder-alist)."
+in @('names'), according to a @(see vl-deporder-alistp)."
(defund vl-maximal-deporder (names alist)
(declare (xargs :guard (and (true-listp names)
@@ -1626,7 +1626,7 @@
(defsection vl-deporder-pass
:parents (vl-deporder)
- :short "@(call vl-deporder-pass) extends a partial @(see vl-deporder-alist)
+ :short "@(call vl-deporder-pass) extends a partial @(see vl-deporder-alistp)
with entries for the modules whose level is now apparent."
:long "@('mods') are a list of modules, @('alist') is a partial
diff -Nru acl2-6.2/books/centaur/vl/mlib/json.lisp acl2-6.3/books/centaur/vl/mlib/json.lisp
--- acl2-6.2/books/centaur/vl/mlib/json.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/mlib/json.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -0,0 +1,983 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2013 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "VL")
+(include-book "fmt")
+(include-book "find-module")
+(include-book "centaur/bridge/to-json" :dir :system)
+(local (include-book "../util/arithmetic"))
+
+
+(defsection json-printing
+ :parents (printer)
+ :short "Routines for encoding various ACL2 structures into JSON format."
+
+ :long "This is a collection of printing routines for translating ACL2
+structures into JSON format. These routines are mainly meant to make it easy
+to convert @(see vl) @(see modules) into nice JSON data, but are somewhat
+flexible and may be useful for other applications.
")
+
+
+(defsection json-encoders
+ :parents (json-printing)
+ :short "A table of JSON encoders to use for for different kinds of data."
+ :long "A JSON encoder is a function of the following signature:
+
+@({ encode-foo : foo * ps --> ps })
+
+Where @('foo') is expected to be an object of some type @('foop'), and
+@('ps') is the @(see vl) @(see printer) state stobj, @(see ps). Each such
+routine is responsible for printing a JSON encoding of its @('foop') argument.
+Each such function may assume that @(see ps) is set to text mode.
+
+The encoder table is a simple association of @('foop') to @('encode-foo')
+functions. We can use it to automatically generate encoders for, e.g., @(see
+defaggregate) structures.
"
+
+ (table vl-json)
+ (table vl-json 'encoders
+ ;; Alist binding each recognizer foop to its JSON encoder, vl-jp-foo
+ )
+
+ (defun get-json-encoders (world)
+ "Look up the current alist of json encoders."
+ (declare (xargs :mode :program))
+ (cdr (assoc 'encoders (table-alist 'vl-json world))))
+
+ (defmacro add-json-encoder (foop encoder-fn)
+ (declare (xargs :guard (and (symbolp foop)
+ (symbolp encoder-fn))))
+ `(table vl-json 'encoders
+ (cons (cons ',foop ',encoder-fn)
+ (get-json-encoders world))))
+
+ (defun get-json-encoder (foop world)
+ (declare (xargs :mode :program))
+ (let ((entry (assoc foop (get-json-encoders world))))
+ (if entry
+ (cdr entry)
+ (er hard? 'get-json-encoder
+ "No json encoder defined for ~x0.~%" foop)))))
+
+
+#||
+(get-json-encoders (w state))
+(add-json-encoder barp vl-enc-bar)
+(get-json-encoders (w state))
+(get-json-encoder 'barp (w state)) ;; vl-enc-bar
+(get-json-encoder 'foop (w state)) ;; fail, no encoder defined
+||#
+
+
+(define jp-bool ((x booleanp) &key (ps 'ps))
+ :parents (json-encoders)
+ :short "Encode a @(see booleanp) into JSON as @('true') or @('false')."
+ (if x
+ (vl-print-str "true")
+ (vl-print-str "false")))
+
+(add-json-encoder booleanp jp-bool)
+
+
+
+(define jp-col-after-printing-string-aux
+ ((col natp "Current column we're at.")
+ (x stringp "String we're about to print, not yet reversed.")
+ (n natp "Current position in X.")
+ (xl natp "Pre-computed length of X."))
+ :returns (new-col natp :rule-classes :type-prescription)
+ :parents (jp-str)
+ :short "Fast way to figure out the new column after printing a JSON string
+with proper encoding."
+ :guard (and (<= n xl)
+ (= xl (length x)))
+ :measure (nfix (- (nfix xl) (nfix n)))
+ (declare (type (integer 0 *) col n xl)
+ (type string x))
+ (b* (((when (mbe :logic (zp (- (nfix xl) (nfix n)))
+ :exec (= n xl)))
+ (lnfix col))
+ ((the (unsigned-byte 8) code) (char-code (char x n)))
+ ((when (or (<= code 31)
+ (>= code 127)))
+ ;; This is a "json weird char." Our encoder will turn it into
+ ;; \uXXXX. The length of \uXXXX is 6.
+ (jp-col-after-printing-string-aux (+ 6 col) x (+ 1 (lnfix n)) xl)))
+ ;; Else there is only one character.
+ (jp-col-after-printing-string-aux (+ 1 col) x (+ 1 (lnfix n)) xl)))
+
+(define jp-str ((x :type string) &key (ps 'ps))
+ :parents (json-encoders)
+ :short "Print the JSON encoding of a string, handling all escaping correctly
+and including the surrounding quotes."
+ :long "We go to some effort to make this fast.
"
+ (b* ((rchars (vl-ps->rchars))
+ (col (vl-ps->col))
+ (xl (length x))
+ (rchars (cons #\" (bridge::json-encode-str-aux x 0 xl (cons #\" rchars))))
+ (col (+ 2 (jp-col-after-printing-string-aux col x 0 xl))))
+ (vl-ps-seq
+ (vl-ps-update-rchars rchars)
+ (vl-ps-update-col col)))
+ :prepwork
+ ((local (defthm l0
+ (implies (and (vl-printedlist-p acc)
+ (character-listp x))
+ (vl-printedlist-p (bridge::json-encode-chars x acc)))
+ :hints(("Goal"
+ :in-theory (enable bridge::json-encode-chars
+ bridge::json-encode-char
+ bridge::json-encode-weird-char)))))))
+
+(add-json-encoder stringp jp-str)
+
+(define jp-maybe-string ((x vl-maybe-string-p) &key (ps 'ps))
+ :parents (json-encoders)
+ (if x
+ (jp-str x)
+ (vl-print "null")))
+
+(add-json-encoder vl-maybe-string-p jp-maybe-string)
+
+
+
+(define jp-bignat ((x natp) &key (ps 'ps))
+ :parents (json-encoders)
+ :short "Encode a potentially large natural number as a JSON string."
+ (vl-print-str (str::natstr x)))
+
+(define jp-nat ((x natp) &key (ps 'ps))
+ :parents (json-encoders)
+ :short "Encode a probably small natural number as a JSON number."
+ :long "We require that the integer is at most 2^31, which we think is the
+minimum reasonable size for a JSON implementation to support.
"
+ (b* (((unless (<= x (expt 2 31)))
+ (raise "Scarily trying to JSON-encode large natural: ~x0." x)
+ ps))
+ (vl-print-nat x)))
+
+(define jp-maybe-nat ((x vl-maybe-natp) &key (ps 'ps))
+ :parents (json-encoders)
+ (if x
+ (jp-nat x)
+ (vl-print-str "null")))
+
+(add-json-encoder natp jp-nat)
+(add-json-encoder posp jp-nat)
+(add-json-encoder vl-maybe-natp jp-maybe-nat)
+(add-json-encoder vl-maybe-posp jp-maybe-nat)
+
+
+
+(define jp-sym-main ((x symbolp) &key (ps 'ps))
+ :parents (json-encoders)
+ :short "Encode a simple symbol as a JSON string, including the surrounding
+quotes."
+
+ :long "We assume that @('x') has a simple enough name to print without any
+encoding. This is generally true for keyword constants used as tags and in
+basic enumerations like @(see vl-exprtype-p). We print only the symbol name,
+in lower-case.
"
+
+ (vl-ps-seq (vl-print "\"")
+ (vl-print-str (str::downcase-string (symbol-name x)))
+ (vl-print "\"")))
+
+(defsection jp-sym
+ :parents (json-encoders)
+ :short "Optimized version of @(see jp-sym-main)."
+ :long "This is a simple macro that is meant to be the same as @(see
+jp-sym-main). The only difference is that if we are given a literal symbol,
+e.g., @(':foo'), we can do the string manipulation at compile time.
"
+
+ (defmacro jp-sym (x &key (ps 'ps))
+ (if (or (keywordp x)
+ (booleanp x)
+ (and (quotep x)
+ (symbolp (acl2::unquote x))))
+ ;; Yes, want to optimize.
+ (let* ((guts (if (quotep x) (acl2::unquote x) x))
+ (ans (str::cat "\""
+ (str::downcase-string (symbol-name guts))
+ "\"")))
+ `(vl-print-str ,ans :ps ,ps))
+ `(jp-sym-main ,x :ps ,ps))))
+
+#||
+(top-level (vl-cw-ps-seq (jp-sym :foo))) ;; "foo"
+(top-level (vl-cw-ps-seq (jp-sym t))) ;; "t"
+(top-level (vl-cw-ps-seq (jp-sym nil))) ;; "nil"
+(top-level (vl-cw-ps-seq (jp-sym 'bar))) ;; "bar"
+(top-level (let ((x 'baz))
+ (vl-cw-ps-seq (jp-sym x)))) ;; "baz"
+||#
+
+
+
+(defsection jp-object
+ :parents (json-encoders)
+ :short "Utility for printing JSON objects , which in some other
+languages might be called alists, dictionaries, hashes, records, etc."
+ :long "Syntax Example:
+
+@({
+ (jp-object :tag (vl-print \"loc\")
+ :file (vl-print x.filename)
+ :line (vl-print x.line)
+ :col (vl-print x.col))
+ --->
+ { \"tag\": \"loc\", \"file\": ... }
+})
+
+The arguments to @('jp-object') should be an alternating list of literal
+keywords, which (for better performance) we assume are so simple they do not
+need to be encoded, and printing expressions which should handle any necessary
+encoding.
"
+
+ :autodoc nil
+
+ (defun jp-object-aux (forms)
+ (declare (xargs :guard t))
+ (b* (((when (atom forms))
+ nil)
+ ((unless (keywordp (car forms)))
+ (er hard? 'jp-object "Expected alternating keywords and values."))
+ ((unless (consp (cdr forms)))
+ (er hard? 'jp-object "No argument found after ~x0." (car forms)))
+ ;; Suppose the keyword is :foo.
+ ;; We create the string: "foo":
+ ;; We can create this at macroexpansion time.
+ (name1 (str::downcase-string (symbol-name (car forms))))
+ (name1-colon (str::cat "\"" name1 "\": ")))
+ (list* `(vl-print-str ,name1-colon)
+ (second forms)
+ (if (atom (cddr forms))
+ nil
+ (cons `(vl-println? ", ")
+ (jp-object-aux (cddr forms)))))))
+
+ (defmacro jp-object (&rest forms)
+ `(vl-ps-seq (vl-print "{")
+ ,@(jp-object-aux forms)
+ (vl-println? "}"))))
+
+
+
+; Fancy automatic json encoding of cutil structures
+
+(program)
+
+(define make-json-encoder-alist
+ (efields ;; A proper cutil::formallist-p for this structure's fields
+ omit ;; A list of any fields to omit from the encoded output
+ overrides ;; An alist of (fieldname . encoder-to-use-instead-of-default)
+ world ;; For looking up default encoders
+ )
+ ;; Returns an alist of the form (fieldname . encoder-to-use)
+ (b* (((when (atom efields))
+ nil)
+ ((cutil::formal e1) (car efields))
+ (- (cw "Determining encoder for ~x0... " e1.name))
+
+ ;; Are we supposed to omit it?
+ ((when (member e1.name omit))
+ (cw "omitting it.~%")
+ (make-json-encoder-alist (cdr efields) omit overrides world))
+
+ ;; Are we supposed to override it?
+ (look (assoc e1.name overrides))
+ ((when look)
+ (cw "overriding with ~x0.~%" (cdr look))
+ (cons (cons e1.name (cdr look))
+ (make-json-encoder-alist (cdr efields) omit overrides world)))
+
+ ((unless (and (tuplep 2 e1.guard)
+ (equal (second e1.guard) e1.name)))
+ (raise "Guard ~x0 too complex.~%" e1.guard))
+
+ (predicate (first e1.guard))
+ (encoder (get-json-encoder predicate world)))
+ (cw "defaulting to ~x0~%" encoder)
+ (cons (cons e1.name encoder)
+ (make-json-encoder-alist (cdr efields) omit overrides world))))
+
+(define encoder-alist-main-actions
+ (basename ;; base name for aggregate, e.g., 'vl-location
+ alist ;; alist of fields->encoder to use
+ newlines ;; NIL means don't auto-newline between elements; any number means
+ ;; newline and indent to that many places between lines
+ )
+ (b* (((when (atom alist))
+ nil)
+ ((cons fieldname encoder) (car alist))
+ (foo->bar (cutil::da-accessor-name basename fieldname))
+ ;; Suppose the fieldname is foo. We create the string ["foo":]. We can
+ ;; create this at macroexpansion time.
+ (name1 (str::downcase-string (symbol-name fieldname)))
+ (name1-colon (str::cat "\"" name1 "\": ")))
+ (list* `(vl-print-str ,name1-colon)
+ `(,encoder (,foo->bar x))
+ (if (atom (cdr alist))
+ nil
+ (cons (if newlines
+ `(vl-ps-seq (vl-println ", ")
+ (vl-indent ,newlines))
+ `(vl-println? ", "))
+ (encoder-alist-main-actions basename (cdr alist) newlines))))))
+
+(define def-vl-jp-aggregate-fn (type omit overrides long newlines world)
+ (b* ((mksym-package-symbol 'vl::foo)
+ (elem-print (mksym 'vl-jp- type))
+ (elem (mksym 'vl- type))
+ (elem-p (mksym 'vl- type '-p))
+ (elem-p-str (symbol-name elem-p))
+
+ ((cutil::agginfo agg) (cutil::get-aggregate elem world))
+ ((unless (cutil::formallist-p agg.efields))
+ (raise "Expected :efields for ~x0 to be a valid formallist, found ~x1."
+ elem agg.efields))
+ (enc-alist (make-json-encoder-alist agg.efields omit overrides world))
+ ((unless (consp enc-alist))
+ (raise "Expected at least one field to encode."))
+ (main (encoder-alist-main-actions elem enc-alist newlines)))
+
+ `(define ,elem-print ((x ,elem-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :short ,(cat "Print the JSON encoding of a @(see " elem-p-str
+ ") to @(see ps).")
+ :long ,long
+ (vl-ps-seq
+ (vl-print "{\"tag\": ")
+ (jp-sym ,agg.tag)
+ ,(if newlines
+ `(vl-ps-seq (vl-println ", ")
+ (vl-indent ,newlines))
+ `(vl-print ", "))
+ ,@main
+ (vl-println? "}"))
+ ///
+ (add-json-encoder ,elem-p ,elem-print))))
+
+#|
+(def-vl-jp-aggregate-fn
+ 'location
+ '(col)
+ '((filename . blah))
+ "long"
+ (w state))
+|#
+
+(defmacro def-vl-jp-aggregate (type &key omit override newlines
+ (long '""))
+ (declare (xargs :guard (vl-maybe-natp newlines)))
+ `(make-event
+ (let ((form (def-vl-jp-aggregate-fn ',type ',omit ',override ',long ',newlines
+ (w state))))
+ (value form))))
+
+(logic)
+
+
+(defmacro def-vl-jp-list (type &key newlines)
+ (declare (xargs :guard (vl-maybe-natp newlines)))
+ (b* ((mksym-package-symbol 'vl::foo)
+ (list-p (mksym 'vl- type 'list-p))
+ (elem-print (mksym 'vl-jp- type))
+ (list-print-aux (mksym 'vl-jp- type 'list-aux))
+ (list-print (mksym 'vl-jp- type 'list))
+ (list-p-str (symbol-name list-p)))
+ `(encapsulate ()
+ (define ,list-print-aux ((x ,list-p) &key (ps 'ps))
+ :parents (,list-print)
+ :short ,(cat "Prints out the elements of a @(see " list-p-str
+ ") without the enclosing brackets.")
+ (if (atom x)
+ ps
+ (vl-ps-seq (,elem-print (car x))
+ (if (atom (cdr x))
+ ps
+ ,(if newlines
+ `(vl-ps-seq (vl-println ",")
+ (vl-indent ,newlines))
+ `(vl-println? ", ")))
+ (,list-print-aux (cdr x)))))
+ (define ,list-print ((x ,list-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :short ,(cat "Prints out the elements of a @(see " list-p-str
+ ") with the enclosing brackets.")
+ (vl-ps-seq (vl-print "[")
+ (,list-print-aux x)
+ (vl-println? "]")))
+ (add-json-encoder ,list-p ,list-print))))
+
+
+
+;; Real Verilog JSON Encoding
+
+(define vl-jp-exprtype ((x vl-exprtype-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-cstrength ((x vl-cstrength-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-dstrength ((x vl-dstrength-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-direction ((x vl-direction-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-gatetype ((x vl-gatetype-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-evatomtype ((x vl-evatomtype-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-assign-type ((x vl-assign-type-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-deassign-type ((x vl-deassign-type-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-casetype ((x vl-casetype-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-netdecltype ((x vl-netdecltype-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-taskporttype ((x vl-taskporttype-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-vardecltype ((x vl-vardecltype-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-paramdecltype ((x vl-paramdecltype-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(define vl-jp-compoundstmttype ((x vl-compoundstmttype-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (jp-sym x))
+
+(add-json-encoder vl-exprtype-p vl-jp-exprtype)
+(add-json-encoder vl-cstrength-p vl-jp-cstrength)
+(add-json-encoder vl-dstrength-p vl-jp-dstrength)
+(add-json-encoder vl-direction-p vl-jp-direction)
+(add-json-encoder vl-gatetype-p vl-jp-gatetype)
+(add-json-encoder vl-evatomtype-p vl-jp-evatomtype)
+(add-json-encoder vl-assign-type-p vl-jp-assign-type)
+(add-json-encoder vl-deassign-type-p vl-jp-deassign-type)
+(add-json-encoder vl-casetype-p vl-jp-casetype)
+(add-json-encoder vl-netdecltype-p vl-jp-netdecltype)
+(add-json-encoder vl-taskporttype-p vl-jp-taskporttype)
+(add-json-encoder vl-vardecltype-p vl-jp-vardecltype)
+(add-json-encoder vl-paramdecltype-p vl-jp-paramdecltype)
+(add-json-encoder vl-compoundstmttype-p vl-jp-compoundstmttype)
+
+
+(define vl-jp-maybe-exprtype ((x vl-maybe-exprtype-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (if x
+ (vl-jp-exprtype x)
+ (vl-print "null")))
+
+(define vl-jp-maybe-cstrength ((x vl-maybe-cstrength-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (if x
+ (vl-jp-cstrength x)
+ (vl-print "null")))
+
+(define vl-jp-maybe-direction ((x vl-maybe-direction-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :inline t
+ (if x
+ (vl-jp-direction x)
+ (vl-print "null")))
+
+(add-json-encoder vl-maybe-exprtype-p vl-jp-maybe-exprtype)
+(add-json-encoder vl-maybe-cstrength-p vl-jp-maybe-cstrength)
+(add-json-encoder vl-maybe-direction-p vl-jp-maybe-direction)
+
+(def-vl-jp-aggregate location)
+
+#||
+(top-level
+ (vl-cw-ps-seq (vl-jp-location *vl-fakeloc*)))
+||#
+
+
+
+(def-vl-jp-aggregate constint
+ :override ((value . jp-bignat))
+ :long "Note that we always encode the value as a string. This is
+because it is quite common for Verilog constants to run into the hundreds
+of bits, but the JSON standard doesn't really ever say how big of numbers
+must be supported and JSON implementations often use machine integers
+which could not hold such large values.
")
+
+(define jp-bitlist ((x vl-bitlist-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :short "Encode a @(see vl-bitlist-p) as a JSON string."
+ (jp-str (vl-bitlist->string x)))
+
+(add-json-encoder vl-bitlist-p jp-bitlist)
+
+(def-vl-jp-aggregate weirdint)
+(def-vl-jp-aggregate string)
+(def-vl-jp-aggregate real)
+(def-vl-jp-aggregate id)
+(def-vl-jp-aggregate hidpiece)
+(def-vl-jp-aggregate sysfunname)
+(def-vl-jp-aggregate funname)
+
+(define vl-jp-atomguts ((x vl-atomguts-p) &key (ps 'ps))
+ :parents (vl-jp-expr vl-atomguts-p)
+ :guard-hints (("Goal" :in-theory (enable vl-atomguts-p)))
+ (case (tag x)
+ (:vl-id (vl-jp-id x))
+ (:vl-constint (vl-jp-constint x))
+ (:vl-weirdint (vl-jp-weirdint x))
+ (:vl-string (vl-jp-string x))
+ (:vl-real (vl-jp-real x))
+ (:vl-hidpiece (vl-jp-hidpiece x))
+ (:vl-funname (vl-jp-funname x))
+ (otherwise (vl-jp-sysfunname x))))
+
+(add-json-encoder vl-atomguts-p vl-jp-atomguts)
+
+(def-vl-jp-aggregate atom)
+
+(defsection vl-jp-expr
+ :parents (json-encoders)
+
+ (defmacro vl-jp-expr (x &key (ps 'ps))
+ `(vl-jp-expr-fn ,x ,ps))
+
+ (defmacro vl-jp-atts (x &key (ps 'ps))
+ `(vl-jp-atts-fn ,x ,ps))
+
+ (defmacro vl-jp-atts-aux (x &key (ps 'ps))
+ `(vl-jp-atts-aux-fn ,x ,ps))
+
+ (defmacro vl-jp-exprlist (x &key (ps 'ps))
+ `(vl-jp-exprlist-fn ,x ,ps))
+
+ (defmacro vl-jp-exprlist-aux (x &key (ps 'ps))
+ `(vl-jp-exprlist-aux-fn ,x ,ps))
+
+ (mutual-recursion
+ (defund vl-jp-expr-fn (x ps)
+ (declare (xargs :guard (vl-expr-p x)
+ :stobjs ps
+ :measure (two-nats-measure (acl2-count x) 2)))
+ (b* (((when (vl-fast-atom-p x))
+ (vl-jp-atom x))
+ ((vl-nonatom x) x))
+ (jp-object :tag (jp-sym :vl-nonatom)
+ :atts (vl-jp-atts x.atts)
+ :args (vl-jp-exprlist x.args)
+ :finalwidth (jp-maybe-nat x.finalwidth)
+ :finaltype (vl-jp-maybe-exprtype x.finaltype))))
+
+ (defund vl-jp-atts-fn (x ps)
+ ;; Atts are a string->maybe-expr alist, so turn them into a JSON object
+ ;; binding keys to values...
+ (declare (xargs :guard (vl-atts-p x)
+ :stobjs ps
+ :measure (two-nats-measure (acl2-count x) 1)))
+ (vl-ps-seq (vl-print "{")
+ (vl-jp-atts-aux x)
+ (vl-println? "}")))
+
+ (defund vl-jp-atts-aux-fn (x ps)
+ (declare (xargs :guard (vl-atts-p x)
+ :stobjs ps
+ :measure (two-nats-measure (acl2-count x) 0)))
+ (b* (((when (atom x))
+ ps)
+ ((cons name1 val1) (car x)))
+ (vl-ps-seq (jp-str name1)
+ (vl-print ": ")
+ (if val1
+ (vl-jp-expr val1)
+ (vl-print "null"))
+ (if (atom (cdr x))
+ ps
+ (vl-println? ", "))
+ (vl-jp-atts-aux (cdr x)))))
+
+ (defund vl-jp-exprlist-fn (x ps)
+ ;; Print the expressions as a JSON array with brackets.
+ (declare (xargs :guard (vl-exprlist-p x)
+ :stobjs ps
+ :measure (two-nats-measure (acl2-count x) 1)))
+ (vl-ps-seq (vl-print "[")
+ (vl-jp-exprlist-aux x)
+ (vl-println? "]")))
+
+ (defund vl-jp-exprlist-aux-fn (x ps)
+ (declare (xargs :guard (vl-exprlist-p x)
+ :stobjs ps
+ :measure (two-nats-measure (acl2-count x) 0)))
+ (b* (((when (atom x))
+ ps))
+ (vl-ps-seq (vl-jp-expr (car x))
+ (if (atom (cdr x))
+ ps
+ (vl-println? ", "))
+ (vl-jp-exprlist-aux (cdr x)))))))
+
+(define vl-jp-maybe-expr ((x vl-maybe-expr-p) &key (ps 'ps))
+ (if x
+ (vl-jp-expr x)
+ (vl-print "null")))
+
+(add-json-encoder vl-expr-p vl-jp-expr)
+(add-json-encoder vl-exprlist-p vl-jp-exprlist)
+(add-json-encoder vl-atts-p vl-jp-atts)
+(add-json-encoder vl-maybe-expr-p vl-jp-maybe-expr)
+
+(def-vl-jp-aggregate range)
+(def-vl-jp-list range)
+
+(define vl-jp-maybe-range ((x vl-maybe-range-p) &key (ps 'ps))
+ (if x
+ (vl-jp-range x)
+ (vl-print "null")))
+
+(add-json-encoder vl-maybe-range-p vl-jp-maybe-range)
+
+(def-vl-jp-aggregate port)
+(def-vl-jp-list port :newlines 4)
+
+
+(def-vl-jp-aggregate gatedelay)
+
+(define vl-jp-maybe-gatedelay ((x vl-maybe-gatedelay-p) &key (ps 'ps))
+ :parents (json-encoders vl-maybe-gatedelay-p)
+ (if x
+ (vl-jp-gatedelay x)
+ (vl-print "null")))
+
+(add-json-encoder vl-maybe-gatedelay-p vl-jp-maybe-gatedelay)
+
+(def-vl-jp-aggregate netdecl)
+(def-vl-jp-list netdecl :newlines 4)
+
+(def-vl-jp-aggregate regdecl)
+(def-vl-jp-list regdecl :newlines 4)
+
+(def-vl-jp-aggregate plainarg)
+(def-vl-jp-list plainarg :newlines 4)
+
+(def-vl-jp-aggregate namedarg)
+(def-vl-jp-list namedarg :newlines 4)
+
+(def-vl-jp-aggregate vardecl)
+(def-vl-jp-list vardecl :newlines 4)
+
+(def-vl-jp-aggregate eventdecl)
+(def-vl-jp-list eventdecl :newlines 4)
+
+(def-vl-jp-aggregate paramdecl)
+(def-vl-jp-list paramdecl :newlines 4)
+
+(define vl-jp-blockitem ((x vl-blockitem-p) &key (ps 'ps))
+ :guard-hints (("Goal" :in-theory (enable vl-blockitem-p)))
+ (mbe :logic
+ (cond ((vl-regdecl-p x) (vl-jp-regdecl x))
+ ((vl-vardecl-p x) (vl-jp-vardecl x))
+ ((vl-eventdecl-p x) (vl-jp-eventdecl x))
+ (t (vl-jp-paramdecl x)))
+ :exec
+ (case (tag x)
+ (:vl-regdecl (vl-jp-regdecl x))
+ (:vl-vardecl (vl-jp-vardecl x))
+ (:vl-eventdecl (vl-jp-eventdecl x))
+ (otherwise (vl-jp-paramdecl x)))))
+
+(add-json-encoder vl-blockitem-p vl-jp-blockitem)
+(def-vl-jp-list blockitem)
+
+(define vl-jp-arguments ((x vl-arguments-p) &key (ps 'ps))
+ :parents (json-encoders vl-arguments-p)
+ (b* (((vl-arguments x) x))
+ (jp-object :tag (jp-sym :vl-arguments)
+ :namedp (jp-bool x.namedp)
+ :args (if x.namedp
+ (vl-jp-namedarglist x.args)
+ (vl-jp-plainarglist x.args)))))
+
+(add-json-encoder vl-arguments-p vl-jp-arguments)
+
+(def-vl-jp-aggregate gatestrength)
+
+(define vl-jp-maybe-gatestrength ((x vl-maybe-gatestrength-p) &key (ps 'ps))
+ (if x
+ (vl-jp-gatestrength x)
+ (vl-print "null")))
+
+(add-json-encoder vl-maybe-gatestrength-p vl-jp-maybe-gatestrength)
+
+(def-vl-jp-aggregate modinst)
+(def-vl-jp-list modinst)
+
+(def-vl-jp-aggregate gateinst)
+(def-vl-jp-list gateinst)
+
+(def-vl-jp-aggregate delaycontrol)
+(def-vl-jp-aggregate evatom)
+(def-vl-jp-list evatom)
+
+(def-vl-jp-aggregate eventcontrol)
+(def-vl-jp-aggregate repeateventcontrol)
+
+
+(define vl-jp-delayoreventcontrol ((x vl-delayoreventcontrol-p) &key (ps 'ps))
+ :guard-hints (("Goal" :in-theory (enable vl-delayoreventcontrol-p)))
+ (cond ((vl-delaycontrol-p x) (vl-jp-delaycontrol x))
+ ((vl-eventcontrol-p x) (vl-jp-eventcontrol x))
+ (t (vl-jp-repeateventcontrol x))))
+
+(add-json-encoder vl-delayoreventcontrol-p vl-jp-delayoreventcontrol)
+
+(define vl-jp-maybe-delayoreventcontrol ((x vl-maybe-delayoreventcontrol-p)
+ &key (ps 'ps))
+ (if x
+ (vl-jp-delayoreventcontrol x)
+ (vl-print "null")))
+
+(add-json-encoder vl-maybe-delayoreventcontrol-p vl-jp-maybe-delayoreventcontrol)
+
+(def-vl-jp-aggregate assignstmt)
+(def-vl-jp-aggregate nullstmt)
+(def-vl-jp-aggregate enablestmt)
+(def-vl-jp-aggregate deassignstmt)
+(def-vl-jp-aggregate disablestmt)
+(def-vl-jp-aggregate eventtriggerstmt)
+
+(define vl-jp-atomicstmt ((x vl-atomicstmt-p) &key (ps 'ps))
+ :guard-hints (("Goal" :in-theory (enable vl-atomicstmt-p)))
+ (mbe :logic
+ (cond ((vl-nullstmt-p x) (vl-jp-nullstmt x))
+ ((vl-assignstmt-p x) (vl-jp-assignstmt x))
+ ((vl-deassignstmt-p x) (vl-jp-deassignstmt x))
+ ((vl-enablestmt-p x) (vl-jp-enablestmt x))
+ ((vl-disablestmt-p x) (vl-jp-disablestmt x))
+ (t (vl-jp-eventtriggerstmt x)))
+ :exec
+ (case (tag x)
+ (:vl-nullstmt (vl-jp-nullstmt x))
+ (:vl-assignstmt (vl-jp-assignstmt x))
+ (:vl-deassignstmt (vl-jp-deassignstmt x))
+ (:vl-enablestmt (vl-jp-enablestmt x))
+ (:vl-disablestmt (vl-jp-disablestmt x))
+ (otherwise (vl-jp-eventtriggerstmt x)))))
+
+
+(defmacro vl-jp-stmt (x)
+ `(vl-jp-stmt-fn ,x ps))
+
+(defmacro vl-jp-stmtlist (x)
+ `(vl-jp-stmtlist-fn ,x ps))
+
+(defmacro vl-jp-stmtlist-aux (x)
+ `(vl-jp-stmtlist-aux-fn ,x ps))
+
+(mutual-recursion
+
+ (defund vl-jp-stmt-fn (x ps)
+ (declare (xargs :guard (vl-stmt-p x)
+ :stobjs ps
+ :measure (two-nats-measure (acl2-count x) 2)))
+ (b* (((when (vl-fast-atomicstmt-p x))
+ (vl-jp-atomicstmt x))
+ ((vl-compoundstmt x) x))
+ (jp-object :tag (jp-sym :vl-compoundstmt)
+ :type (vl-jp-compoundstmttype x.type)
+ :exprs (vl-jp-exprlist x.exprs)
+ :stmts (vl-jp-stmtlist x.stmts)
+ :name (jp-maybe-string x.name)
+ :decls (vl-jp-blockitemlist x.decls)
+ :ctrl (vl-jp-maybe-delayoreventcontrol x.ctrl)
+ :sequentialp (jp-bool x.sequentialp)
+ :casetype (vl-jp-casetype x.casetype)
+ :atts (vl-jp-atts x.atts))))
+
+ (defund vl-jp-stmtlist-fn (x ps)
+ ;; Print the stmtessions as a JSON array with brackets.
+ (declare (xargs :guard (vl-stmtlist-p x)
+ :stobjs ps
+ :measure (two-nats-measure (acl2-count x) 1)))
+ (vl-ps-seq (vl-print "[")
+ (vl-jp-stmtlist-aux x)
+ (vl-println? "]")))
+
+ (defund vl-jp-stmtlist-aux-fn (x ps)
+ (declare (xargs :guard (vl-stmtlist-p x)
+ :stobjs ps
+ :measure (two-nats-measure (acl2-count x) 0)))
+ (b* (((when (atom x))
+ ps))
+ (vl-ps-seq (vl-jp-stmt (car x))
+ (if (atom (cdr x))
+ ps
+ (vl-println? ", "))
+ (vl-jp-stmtlist-aux (cdr x))))))
+
+(add-json-encoder vl-stmt-p vl-jp-stmt)
+(add-json-encoder vl-stmtlist-p vl-jp-stmtlist)
+
+
+(def-vl-jp-aggregate always)
+(def-vl-jp-list always :newlines 4)
+
+(def-vl-jp-aggregate initial)
+(def-vl-jp-list initial :newlines 4)
+
+(def-vl-jp-aggregate taskport)
+(def-vl-jp-list taskport :newlines 4)
+
+(def-vl-jp-aggregate fundecl)
+(def-vl-jp-list fundecl :newlines 4)
+
+(def-vl-jp-aggregate taskdecl)
+(def-vl-jp-list taskdecl :newlines 4)
+
+(def-vl-jp-aggregate portdecl)
+(def-vl-jp-list portdecl :newlines 4)
+
+(def-vl-jp-aggregate assign)
+(def-vl-jp-list assign :newlines 4)
+
+
+
+
+(define vl-jp-warning ((x vl-warning-p) &key (ps 'ps))
+ :parents (json-encoders)
+ :short "Special, custom JSON encoder for warnings."
+
+ :long "We probably don't want to use the ordinary aggregate-encoding stuff
+to print @(see vl-warning-p) objects, since the types in the @(':args') field
+are dynamic and, besides, who wants to reimplement @(see vl-cw) in other
+languages. Instead, it's probably more convenient to just go ahead and convert
+the warning into a printed message here. We'll include both HTML and plain
+TEXT versions of the message.
"
+
+ (b* (((vl-warning x) x)
+ (text (with-local-ps (vl-cw-obj x.msg x.args)))
+ (html (with-local-ps (vl-ps-update-htmlp t)
+ (vl-cw-obj x.msg x.args))))
+ (jp-object :tag (vl-print "\"warning\"")
+ :fatalp (jp-bool x.fatalp)
+ :type (jp-str (symbol-name x.type))
+ :fn (jp-str (symbol-name x.fn))
+ :text (jp-str text)
+ :html (jp-str html))))
+
+(add-json-encoder vl-warning-p jp-warning)
+
+(def-vl-jp-list warning :newlines 4)
+
+
+
+
+(define vl-jp-commentmap-aux ((x vl-commentmap-p) &key (ps 'ps))
+ (b* (((when (atom x))
+ ps))
+ (vl-ps-seq (vl-print "{\"loc\": ")
+ (vl-jp-location (caar x))
+ (vl-println? ", \"comment\": ")
+ (jp-str (cdar x))
+ (vl-print "}")
+ (if (atom (cdr x))
+ ps
+ (vl-println? ", "))
+ (vl-jp-commentmap-aux (cdr x)))))
+
+(define vl-jp-commentmap ((x vl-commentmap-p) &key (ps 'ps))
+ (vl-ps-seq (vl-print "[")
+ (vl-jp-commentmap-aux x)
+ (vl-println? "]")))
+
+(add-json-encoder vl-commentmap-p vl-jp-commentmap)
+
+(def-vl-jp-aggregate module
+ :omit (params esim)
+ :newlines 2)
+
+(def-vl-jp-list module
+ :newlines 1)
+
+(define vl-jp-modalist-aux ((x vl-modalist-p) &key (ps 'ps))
+ (b* (((when (atom x))
+ ps))
+ (vl-ps-seq (jp-str (caar x))
+ (vl-print ": ")
+ (vl-jp-module (cdar x))
+ (if (atom (cdr x))
+ ps
+ (vl-println ", "))
+ (vl-jp-modalist-aux (cdr x)))))
+
+(define vl-jp-modalist ((x vl-modalist-p) &key (ps 'ps))
+ (vl-ps-seq (vl-print "{")
+ (vl-jp-modalist-aux x)
+ (vl-println "}")))
+
+
+(define vl-jp-individual-modules ((x vl-modulelist-p) &key (ps 'ps))
+ ;; This doesn't print a single valid JSON object. Instead, it prints a whole
+ ;; list of JSON objects separated by newlines.
+ (if (atom x)
+ ps
+ (vl-ps-seq (vl-jp-module (car x))
+ (vl-print "
+
+")
+ (vl-jp-individual-modules (cdr x)))))
diff -Nru acl2-6.2/books/centaur/vl/mlib/writer.lisp acl2-6.3/books/centaur/vl/mlib/writer.lisp
--- acl2-6.2/books/centaur/vl/mlib/writer.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/mlib/writer.lisp 2013-09-30 17:53:06.000000000 +0000
@@ -84,19 +84,19 @@
((when (zp len))
(raise "Empty identifier")
"")
+ ;; BOZO it'd be really good to avoid this coerce
+ (chars (explode x))
((when (and (vl-simple-id-head-p (char x 0))
(vl-simple-id-tail-string-p x 1 len)
- (not (member #\$ (coerce x 'list)))))
+ (not (member #\$ chars))))
;; A simple identifier, nothing to add.
(string-fix x))
;; Escaped identifier. This isn't efficient but this should be pretty
;; unusual.
- (chars (coerce x 'list))
((when (member #\Space chars))
(raise "Identifier name has spaces? ~x0" x)
""))
- (coerce (cons #\\ (append chars (list #\Space)))
- 'string)))
+ (implode (cons #\\ (append chars (list #\Space))))))
(define vl-print-modname ((x stringp) &key (ps 'ps))
:parents (verilog-printing)
@@ -1086,6 +1086,72 @@
(vl-ps-seq (vl-pp-vardecl (car x))
(vl-pp-vardecllist (cdr x)))))
+(define vl-pp-eventdecl ((x vl-eventdecl-p) &key (ps 'ps))
+ (b* (((vl-eventdecl x) x))
+ (vl-ps-seq
+ (if x.atts (vl-pp-atts x.atts) ps)
+ (vl-ps-span "vl_key" (vl-print " event "))
+ (vl-print-wirename x.name)
+ (if x.arrdims
+ (vl-pp-rangelist x.arrdims)
+ ps)
+ (vl-println " ;"))))
+
+(define vl-pp-eventdecllist ((x vl-eventdecllist-p) &key (ps 'ps))
+ (if (atom x)
+ ps
+ (vl-ps-seq (vl-pp-eventdecl (car x))
+ (vl-pp-eventdecllist (cdr x)))))
+
+(define vl-pp-paramdecl ((x vl-paramdecl-p) &key (ps 'ps))
+ (b* (((vl-paramdecl x) x))
+ (vl-ps-seq (vl-print " ")
+ (if x.atts
+ (vl-ps-seq (vl-pp-atts x.atts)
+ (vl-print " "))
+ ps)
+ (vl-ps-span "vl_key"
+ (if x.localp
+ (vl-print "localparam ")
+ (vl-print "parameter "))
+ (case x.type
+ (:vl-signed (vl-print "signed "))
+ (:vl-integer (vl-print "integer "))
+ (:vl-real (vl-print "real "))
+ (:vl-time (vl-print "time "))
+ (:vl-realtime (vl-print "realtime "))
+ (otherwise ps)))
+ (if x.range
+ (vl-ps-seq (vl-pp-range x.range)
+ (vl-print " "))
+ ps)
+ (vl-print-wirename x.name)
+ (vl-print " = ")
+ (vl-pp-expr x.expr)
+ (vl-println ";"))))
+
+(define vl-pp-paramdecllist ((x vl-paramdecllist-p) &key (ps 'ps))
+ (if (atom x)
+ ps
+ (vl-ps-seq (vl-pp-paramdecl (car x))
+ (vl-pp-paramdecllist (cdr x)))))
+
+(define vl-pp-blockitem ((x vl-blockitem-p) &key (ps 'ps))
+ (case (tag x)
+ (:vl-regdecl (vl-pp-regdecl x))
+ (:vl-vardecl (vl-pp-vardecl x))
+ (:vl-eventdecl (vl-pp-eventdecl x))
+ (:vl-paramdecl (vl-pp-paramdecl x))
+ (otherwise (progn$ (impossible) ps))))
+
+(define vl-pp-blockitemlist ((x vl-blockitemlist-p) &key (ps 'ps))
+ (if (atom x)
+ ps
+ (vl-ps-seq (vl-pp-blockitem (car x))
+ (vl-pp-blockitemlist (cdr x)))))
+
+
+
(define vl-pp-gatedelay ((x vl-gatedelay-p) &key (ps 'ps))
(b* (((vl-gatedelay x) x))
(cond
@@ -1099,8 +1165,16 @@
(vl-ps-span "vl_int"
(vl-print-nat (vl-constint->value (vl-atom->guts x.rise))))))
+ ((and (hide (equal x.rise x.fall))
+ (hide (equal x.fall x.high)))
+ ;; Print #(a,a,a) just as #(a)
+ (vl-ps-seq
+ (vl-print "#(")
+ (vl-pp-expr x.rise)
+ (vl-print ")")))
+
(x.high
- ;; All three specified
+ ;; All three specified, and not equal...
(vl-ps-seq (vl-print "#(")
(vl-pp-expr x.rise)
(vl-println? ", ")
@@ -1535,7 +1609,7 @@
(:vl-bufif0 "bufif0")
(:vl-bufif1 "bufif1")
(:vl-notif0 "notif0")
- (:vl-notif1 "notif")
+ (:vl-notif1 "notif1")
(:vl-nmos "nmos")
(:vl-pmos "pmos")
(:vl-rnmos "rnmos")
@@ -1697,6 +1771,13 @@
(ps (vl-ps-update-autowrap-ind _pp_stmt_autowrap_ind_)))
ps))
+(define vl-pp-blockitemlist-indented ((x vl-blockitemlist-p) &key (ps 'ps))
+ (if (atom x)
+ ps
+ (vl-ps-seq
+ (vl-pp-stmt-indented (vl-pp-blockitem (car x)))
+ (vl-pp-blockitemlist-indented (cdr x)))))
+
(define vl-pp-assignstmt ((x vl-assignstmt-p) &key (ps 'ps))
(b* (((vl-assignstmt x) x))
(vl-ps-seq (vl-pp-stmt-autoindent)
@@ -1739,18 +1820,54 @@
ps)
(vl-println " ;"))))
+(define vl-pp-disablestmt ((x vl-disablestmt-p) &key (ps 'ps))
+ (b* (((vl-disablestmt x) x))
+ (vl-ps-seq (vl-pp-stmt-autoindent)
+ (if x.atts (vl-pp-atts x.atts) ps)
+ (vl-ps-span "vl_key"
+ (vl-print "disable "))
+ (vl-pp-expr x.id)
+ (vl-println " ;"))))
+
+(define vl-pp-deassignstmt ((x vl-deassignstmt-p) &key (ps 'ps))
+ (b* (((vl-deassignstmt x) x))
+ (vl-ps-seq (vl-pp-stmt-autoindent)
+ (if x.atts (vl-pp-atts x.atts) ps)
+ (vl-ps-span "vl_key"
+ (case x.type
+ (:vl-deassign (vl-print "deassign "))
+ (:vl-release (vl-print "release "))
+ (otherwise (progn$ (impossible) ps))))
+ (vl-pp-expr x.lvalue)
+ (vl-println " ;"))))
+
+(define vl-pp-eventtriggerstmt ((x vl-eventtriggerstmt-p) &key (ps 'ps))
+ (b* (((vl-eventtriggerstmt x) x))
+ (vl-ps-seq (vl-pp-stmt-autoindent)
+ (if x.atts (vl-pp-atts x.atts) ps)
+ (vl-print "-> ")
+ (vl-pp-expr x.id)
+ (vl-println " ;"))))
+
(define vl-pp-atomicstmt ((x vl-atomicstmt-p) &key (ps 'ps))
- (cond ((vl-fast-nullstmt-p x)
- (vl-pp-nullstmt x))
- ((vl-fast-assignstmt-p x)
- (vl-pp-assignstmt x))
- ((vl-fast-enablestmt-p x)
- (vl-pp-enablestmt x))
- (t
- (vl-ps-seq
- (vl-print "// OOPS, IMPLEMENT ")
- (vl-println (symbol-name (tag x)))
- ps))))
+ :guard-hints(("Goal" :in-theory (enable vl-atomicstmt-p)))
+ (mbe :logic
+ (cond ((vl-nullstmt-p x) (vl-pp-nullstmt x))
+ ((vl-assignstmt-p x) (vl-pp-assignstmt x))
+ ((vl-deassignstmt-p x) (vl-pp-deassignstmt x))
+ ((vl-enablestmt-p x) (vl-pp-enablestmt x))
+ ((vl-disablestmt-p x) (vl-pp-disablestmt x))
+ ((vl-eventtriggerstmt-p x) (vl-pp-eventtriggerstmt x))
+ (t
+ (progn$ (impossible) ps)))
+ :exec
+ (case (tag x)
+ (:vl-nullstmt (vl-pp-nullstmt x))
+ (:vl-assignstmt (vl-pp-assignstmt x))
+ (:vl-deassignstmt (vl-pp-deassignstmt x))
+ (:vl-enablestmt (vl-pp-enablestmt x))
+ (:vl-disablestmt (vl-pp-disablestmt x))
+ (otherwise (vl-pp-eventtriggerstmt x)))))
(define vl-casetype-string ((x vl-casetype-p))
:returns (str stringp :rule-classes :type-prescription)
@@ -1813,17 +1930,16 @@
(vl-ps-span "vl_key"
(vl-print (if x.sequentialp "begin " "fork ")))
(if (not x.name)
- ps
+ (vl-println "")
(vl-ps-seq
(vl-print " : ")
(vl-ps-span "vl_id"
(vl-print-str (vl-maybe-escape-identifier x.name)))
(if (not x.decls)
- ps
- (vl-ps-span
- "vl_cmt"
- (vl-print "// BOZO implement vl-pp-stmt for block with decls")))))
- (vl-println "")
+ (vl-println "")
+ (vl-ps-seq
+ (vl-println "")
+ (vl-pp-blockitemlist-indented x.decls)))))
(vl-pp-stmt-indented (vl-pp-stmtlist x.stmts))
(vl-pp-stmt-autoindent)
(vl-ps-span "vl_key" (vl-print-str (if x.sequentialp "end" "join")))
@@ -1869,13 +1985,74 @@
(vl-ps-span "vl_key" (vl-print "endcase"))
(vl-println ""))))
- (otherwise
- ;; :vl-forstmt :vl-foreverstmt
- ;; :vl-waitstmt :vl-repeatstmt :vl-whilestmt
- (vl-ps-span "vl_cmt"
- (vl-pp-stmt-autoindent)
- (vl-print "// BOZO implement vl-pp-stmt for ")
- (vl-println (symbol-name type)))))))))
+ ((:vl-foreverstmt)
+ (b* (((vl-foreverstmt x) x))
+ (vl-ps-seq (vl-pp-stmt-autoindent)
+ (if atts (vl-pp-atts atts) ps)
+ (vl-ps-span "vl_key" (vl-println "forever"))
+ (vl-pp-stmt-indented (vl-pp-stmt x.body))
+ ;; no ending semicolon, the body prints one
+ )))
+
+ ((:vl-repeatstmt)
+ (b* (((vl-repeatstmt x) x))
+ (vl-ps-seq (vl-pp-stmt-autoindent)
+ (if atts (vl-pp-atts atts) ps)
+ (vl-ps-span "vl_key" (vl-print "repeat"))
+ (vl-print " (")
+ (vl-pp-expr x.condition)
+ (vl-println ")")
+ (vl-pp-stmt-indented (vl-pp-stmt x.body))
+ ;; no ending semicolon, the body prints one
+ )))
+
+ ((:vl-waitstmt)
+ (b* (((vl-waitstmt x) x))
+ (vl-ps-seq (vl-pp-stmt-autoindent)
+ (if atts (vl-pp-atts atts) ps)
+ (vl-ps-span "vl_key" (vl-print "wait"))
+ (vl-print " (")
+ (vl-pp-expr x.condition)
+ (vl-println ")")
+ (vl-pp-stmt-indented (vl-pp-stmt x.body))
+ ;; no ending semicolon, the body prints one
+ )))
+
+ ((:vl-whilestmt)
+ (b* (((vl-whilestmt x) x))
+ (vl-ps-seq (vl-pp-stmt-autoindent)
+ (if atts (vl-pp-atts atts) ps)
+ (vl-ps-span "vl_key" (vl-print "while"))
+ (vl-print " (")
+ (vl-pp-expr x.condition)
+ (vl-println ")")
+ (vl-pp-stmt-indented (vl-pp-stmt x.body))
+ ;; no ending semicolon, the body prints one
+ )))
+
+ ((:vl-forstmt)
+ (b* (((vl-forstmt x) x))
+ (vl-ps-seq (vl-pp-stmt-autoindent)
+ (if atts (vl-pp-atts atts) ps)
+ (vl-ps-span "vl_key" (vl-print "for "))
+ (vl-print "(")
+ (vl-pp-expr x.initlhs)
+ (vl-print " = ")
+ (vl-pp-expr x.initrhs)
+ (vl-print "; ")
+ (vl-pp-expr x.test)
+ (vl-print "; ")
+ (vl-pp-expr x.nextlhs)
+ (vl-print " = ")
+ (vl-pp-expr x.nextrhs)
+ (vl-println ")")
+ (vl-pp-stmt-indented (vl-pp-stmt x.body))
+ ;; no ending semicolon, the body prints one
+ )))
+
+ (otherwise (progn$
+ (impossible)
+ ps)))))))
(defund vl-pp-stmtlist-fn (x ps)
(declare (xargs :guard (vl-stmtlist-p x)
@@ -1913,7 +2090,10 @@
(vl-pp-stmtlist-fn . list)
(vl-pp-cases-fn . case)))
-(verify-guards vl-pp-stmt-fn)
+(verify-guards vl-pp-stmt-fn
+ :hints(("Goal"
+ :in-theory (disable double-containment
+ member-equal-when-member-equal-of-cdr-under-iff))))
(define vl-pp-always ((x vl-always-p) &key (ps 'ps))
(b* (((vl-always x) x))
@@ -1944,52 +2124,6 @@
(vl-println "")
(vl-pp-initiallist (cdr x)))))
-(define vl-pp-paramdecl ((x vl-paramdecl-p) &key (ps 'ps))
- (b* (((vl-paramdecl x) x))
- (vl-ps-seq (vl-print " ")
- (if x.atts
- (vl-ps-seq (vl-pp-atts x.atts)
- (vl-print " "))
- ps)
- (vl-ps-span "vl_key"
- (if x.localp
- (vl-print "localparam ")
- (vl-print "parameter "))
- (case x.type
- (:vl-signed (vl-print "signed "))
- (:vl-integer (vl-print "integer "))
- (:vl-real (vl-print "real "))
- (:vl-time (vl-print "time "))
- (:vl-realtime (vl-print "realtime "))
- (otherwise ps)))
- (if x.range
- (vl-ps-seq (vl-pp-range x.range)
- (vl-print " "))
- ps)
- (vl-print-wirename x.name)
- (vl-print " = ")
- (vl-pp-expr x.expr)
- (vl-println ";"))))
-
-(define vl-pp-paramdecllist ((x vl-paramdecllist-p) &key (ps 'ps))
- (if (atom x)
- ps
- (vl-ps-seq (vl-pp-paramdecl (car x))
- (vl-pp-paramdecllist (cdr x)))))
-
-(define vl-pp-blockitem ((x vl-blockitem-p) &key (ps 'ps))
- (case (tag x)
- (:vl-regdecl (vl-pp-regdecl x))
- (:vl-vardecl (vl-pp-vardecl x))
- (:vl-eventdecl (vl-println "// BOZO implement eventdecl printing"))
- (:vl-paramdecl (vl-pp-paramdecl x))
- (otherwise (progn$ (impossible) ps))))
-
-(define vl-pp-blockitemlist ((x vl-blockitemlist-p) &key (ps 'ps))
- (if (atom x)
- ps
- (vl-ps-seq (vl-pp-blockitem (car x))
- (vl-pp-blockitemlist (cdr x)))))
(define vl-taskporttype-string ((x vl-taskporttype-p))
:returns (str stringp :rule-classes :type-prescription)
@@ -2134,9 +2268,7 @@
(vl-pp-regdecllist x.regdecls)
(vl-pp-netdecllist x.netdecls)
(vl-pp-vardecllist x.vardecls)
- (if (not x.eventdecls)
- ps
- (vl-println "// BOZO implement eventdecl printing"))
+ (vl-pp-eventdecllist x.eventdecls)
(vl-pp-fundecllist x.fundecls) ;; put them here, so they can refer to declared wires
(vl-pp-taskdecllist x.taskdecls)
(vl-pp-assignlist x.assigns)
diff -Nru acl2-6.2/books/centaur/vl/onehot.lisp acl2-6.3/books/centaur/vl/onehot.lisp
--- acl2-6.2/books/centaur/vl/onehot.lisp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/onehot.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -208,7 +208,7 @@
(submodules (append sub-A sub-B))
;; module VL_N_BIT_ONEHOT (out, in);
- (name (hons-copy (cat "VL_" (coerce (explode-atom n 10) 'string) "_BIT_ONEHOT")))
+ (name (hons-copy (cat "VL_" (natstr n) "_BIT_ONEHOT")))
((mv out-expr out-port out-portdecl out-netdecl) (vl-occform-mkport "out" :vl-output 1))
((mv in-expr in-port in-portdecl in-netdecl) (vl-occform-mkport "in" :vl-input n))
diff -Nru acl2-6.2/books/centaur/vl/other-packages.lsp acl2-6.3/books/centaur/vl/other-packages.lsp
--- acl2-6.2/books/centaur/vl/other-packages.lsp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/other-packages.lsp 2013-09-30 17:53:10.000000000 +0000
@@ -27,3 +27,4 @@
(ld "str/package.lsp" :dir :system)
(ld "xdoc/package.lsp" :dir :system)
(ld "cowles/packages.lsp" :dir :system)
+(ld "centaur/getopt/package.lsp" :dir :system)
\ No newline at end of file
diff -Nru acl2-6.2/books/centaur/vl/package.lsp acl2-6.3/books/centaur/vl/package.lsp
--- acl2-6.2/books/centaur/vl/package.lsp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/package.lsp 2013-09-30 17:53:10.000000000 +0000
@@ -20,13 +20,11 @@
(in-package "ACL2")
-;; Must be included here for sets:: functions
-(ld "finite-set-theory/osets/sets.defpkg" :dir :system)
-
-;; Must be included here for cutil:: functions
-(ld "cutil/package.lsp" :dir :system)
-
-(ld "oslib/package.lsp" :dir :system)
+(include-book "std/osets/portcullis" :dir :system)
+(include-book "cutil/portcullis" :dir :system)
+(include-book "oslib/portcullis" :dir :system)
+(include-book "centaur/bridge/portcullis" :dir :system)
+(include-book "centaur/getopt/portcullis" :dir :system)
(defmacro multi-union-eq (x y &rest rst)
(xxxjoin 'union-eq (list* x y rst)))
@@ -36,6 +34,7 @@
;; Things to add:
(multi-union-eq
cutil::*cutil-exports*
+ getopt::*getopt-exports*
sets::*sets-exports*
acl2::*acl2-exports*
acl2::*common-lisp-symbols-from-main-lisp-package*
@@ -171,17 +170,21 @@
str::cat
str::natstr
-
+ str::implode
+ str::explode
;; To make VL::VL show up as just VL in the ACL2 package, e.g., to
;; make the XDOC index prettier.
vl
-
+ hardware-verification
+ esim
;; acl2-customization file stuff
why
with-redef
+
+
))
;; Things to remove:
diff -Nru acl2-6.2/books/centaur/vl/parsetree.lisp acl2-6.3/books/centaur/vl/parsetree.lisp
--- acl2-6.2/books/centaur/vl/parsetree.lisp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/parsetree.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -281,9 +281,8 @@
:parents (vl-expr-p)
:short "Recognizer for an @(see vl-exprtype-p) or @('nil')."
- :long "As with @(see vl-maybe-exprwidth-p), we use this for the @('sign')
-fields in our expressions, which allows us to represent expressions whose signs
-have not yet been computed.
"
+ :long "We use this for the @('sign') fields in our expressions. It allows
+us to represent expressions whose signs have not yet been computed.
"
(or (not x)
(vl-exprtype-p x))
@@ -307,53 +306,60 @@
(defaggregate vl-constint
- (origwidth origtype value wasunsized)
+ :parents (vl-expr-p)
+ :short "Representation for constant integer literals with no X or Z bits."
:tag :vl-constint
:hons t
:legiblep nil
+
+ ((value natp
+ :rule-classes :type-prescription
+ "The most important part of a constant integer. Even
+ immediately upon parsing the value has already been determined
+ and is available to you as an ordinary natural number.")
+
+ (origwidth posp
+ :rule-classes :type-prescription
+ "Subtle; generally should not be used ; see below.")
+
+ (origtype vl-exprtype-p
+ :rule-classes
+ ((:rewrite)
+ (:type-prescription
+ :corollary
+ (implies (force (vl-constint-p x))
+ (and (symbolp (vl-constint->origtype x))
+ (not (equal (vl-constint->origtype x) nil))
+ (not (equal (vl-constint->origtype x) t))))))
+ "Subtle; generally should not be used ; see below.")
+
+ (wasunsized booleanp
+ :rule-classes :type-prescription
+ "Set to @('t') by the parser for unsized constants like @('5')
+ and @(''b0101'), but not for sized ones like @('4'b0101')."))
+
:require
- ((posp-of-vl-constint->origwidth
- (posp origwidth)
- :rule-classes :type-prescription)
- (vl-exprtype-p-of-vl-constint->origtype
- (vl-exprtype-p origtype)
- :rule-classes ((:rewrite)
- (:type-prescription
- :corollary (implies (force (vl-constint-p x))
- (and (symbolp (vl-constint->origtype x))
- (not (equal (vl-constint->origtype x) nil))
- (not (equal (vl-constint->origtype x) t)))))))
- (natp-of-vl-constint->value
- (natp value)
- :rule-classes :type-prescription)
- (upper-bound-of-vl-constint->value
+ ((upper-bound-of-vl-constint->value
(< value (expt '2 origwidth))
- :rule-classes ((:rewrite) (:linear)))
- (booleanp-of-vl-constint->wasunsized
- (booleanp wasunsized)
- :rule-classes :type-prescription))
- :parents (vl-expr-p)
- :short "Representation for constant integer literals with no X or Z bits."
+ :rule-classes ((:rewrite) (:linear))))
:long "Constant integers are produced from source code constructs like
@('5'), @('4'b0010'), and @('3'h0').
-The most important part of a constant integer is its @('value'), which even
-immediately upon parsing has already been determined and is available to you as
-an ordinary natural number. Note that the value of a constant integer is never
-negative. In Verilog there are no negative literals; instead, an expression
-like @('-5') is basically parsed the same as @('-(5)'), so the negative sign is
-not part of the literal. See Section 3.5.1 of the spec.
-
-The @('origwidth') and @('origtype') fields are subtle and should generally
-not be used unless you think you know what you are doing. These fields
-indicate the original width and signedness of the literal as specified
-in the source code, e.g., if the source code contains @('8'sd 65'), then the
-origwidth will be 8 and the origtype will be @(':vl-signed.') These fields are
-subtle because expression sizing will generally alter the widths and types of
-subexpressions, so these may not represent the final widths and types used in
-expressions. Instead, the preferred way to determine a constint's final width
-and sign is to inspect the @('vl-atom-p') that contains it.
+Note that the value of a constant integer is never negative. In Verilog
+there are no negative literals; instead, an expression like @('-5') is
+basically parsed the same as @('-(5)'), so the negative sign is not part of the
+literal. See Section 3.5.1 of the spec.
+
+The @('origwidth') and @('origtype') fields are subtle. They indicate the
+original width and signedness of the literal as specified in the source
+code, e.g., if the source code contains @('8'sd 65'), then the origwidth will
+be 8 and the origtype will be @(':vl-signed.') These fields are subtle because
+@(see expression-sizing) generally alters the widths and types of
+subexpressions, so these may not represent the final widths and types of these
+constants in the context of the larger expression. Instead, the preferred way
+to determine a constint's final width and sign is to inspect the @('vl-atom-p')
+that contains it.
We insist that @('0 <= value <= 2^origwidth') for every constant integer.
If our @(see lexer) encounters something ill-formed like @('3'b 1111'), it
@@ -368,135 +374,133 @@
conveniently makes the width of a constant integer just a positive number. On
the other hand, some expressions may produce different results on 32-bit
versus, say, 64-bit implementations. Because of this, we added the
-@('wasunsized') attribute so that we might later statically check for
-problematic uses of unsized constants. This attribute will be set for unsized
-constants like @('5') and @(''b0101'), but not for sized constants like
-@('4'b0101').
+@('wasunsized') field so that we might later statically check for problematic
+uses of unsized constants.
All constints are automatically created with @(see hons). This is probably
pretty trivial, but it seems nice. For instance, the constant integers from
0-32 are probably used thousands of times throughout a design for bit-selects
and wire ranges, so sharing their memory may be useful.
")
+
(defaggregate vl-weirdint
- (origwidth origtype bits wasunsized)
+ :parents (vl-expr-p)
+ :short "Representation for constant integer literals with X or Z bits."
:tag :vl-weirdint
:hons t
:legiblep nil
+
+ ((bits vl-bitlist-p
+ "An MSB-first list of the four-valued Verilog bits making up
+ this constant's value; see @(see vl-bit-p).")
+
+ (origwidth posp
+ :rule-classes :type-prescription
+ "Subtle; generally should not be used ; see below.")
+
+ (origtype vl-exprtype-p
+ :rule-classes
+ ((:rewrite)
+ (:type-prescription
+ :corollary
+ (implies (force (vl-weirdint-p x))
+ (and (symbolp (vl-weirdint->origtype x))
+ (not (equal (vl-weirdint->origtype x) nil))
+ (not (equal (vl-weirdint->origtype x) t))))))
+ "Subtle; generally should not be used ; see below.")
+
+ (wasunsized booleanp
+ :rule-classes :type-prescription
+ "Did this constant have an explicit size?"))
+
:require
- ((posp-of-vl-weirdint->origwidth
- (posp origwidth)
- :rule-classes :type-prescription)
- (vl-exprtype-p-of-vl-weirdint->origtype
- (vl-exprtype-p origtype)
- :rule-classes ((:rewrite)
- (:type-prescription
- :corollary (implies (force (vl-weirdint-p x))
- (and (symbolp (vl-weirdint->origtype x))
- (not (equal (vl-weirdint->origtype x) nil))
- (not (equal (vl-weirdint->origtype x) t)))))))
- (vl-bitlist-p-of-vl-weirdint->bits
- (vl-bitlist-p bits))
- (len-of-vl-weirdint->bits
+ ((len-of-vl-weirdint->bits
(equal (len bits) origwidth)
:rule-classes ((:rewrite)
(:type-prescription
:corollary (implies (force (vl-weirdint-p x))
(consp (vl-weirdint->bits x)))))))
- :parents (vl-expr-p)
- :short "Representation for constant integer literals with X or Z bits."
:long "Weird integers are produced by source code constructs like
@('1'bz'), @('3'b0X1'), and so on.
The @('origwidth'), @('origtype'), and @('wasunsized') fields are analogous
-to those from @(see vl-constint-p); see the discussion there for details.
-
-Unlike a constint, a weirdint does not have a @('value') but instead has a
-list of @('bits'), stored in MSB-first order as a @(see vl-bitlist-p) of the
-appropriate width.
+to those from @(see vl-constint-p); see the discussion there for details. But
+unlike a constint, a weirdint does not have a natural-number @('value').
+Instead it has a list of four-valued @('bits') that may include X and Z
+values.
Like constinsts, all weirdints are automatically constructed with @(see
hons). This may not be worthwhile since there are probably usually not too
many weirdints, but by the same reasoning it shouldn't be too harmful.
")
-
(defaggregate vl-string
- (value)
- :tag :vl-string
- :legiblep nil
- :require ((stringp-of-vl-string->value
- (stringp value)
- :rule-classes :type-prescription))
:parents (vl-expr-p)
:short "Representation for string literals."
+ :tag :vl-string
+ :legiblep nil
- :long "The @('value') of a string literal is an ordinary ACL2 string,
-where special sequences like @('\\n') and @('\\t') have been replaced with
-actual newline and tab characters, etc.
")
-
+ ((value stringp
+ :rule-classes :type-prescription
+ "An ordinary ACL2 string where, e.g., special sequences like @('\\n')
+ and @('\\t') have been resolved into real newline and tab
+ characters, etc.")))
(defaggregate vl-real
- (value)
- :tag :vl-real
- :legiblep nil
- :require ((stringp-of-vl-real->value
- (stringp value)
- :rule-classes :type-prescription))
:parents (vl-expr-p)
:short "Representation of real (floating point) literals."
+ :tag :vl-real
+ :legiblep nil
- :long "We currently provide virtually no support for working with real
-numbers. The @('value') field simply stores the actual characters found in the
-source code, i.e., it might be a string such as @('\"3.41e+12\"'). Do not rely
-on this representation; we will almost certainly want to change it as soon as
-we want to do anything with real numbers.
")
-
+ ((value stringp
+ :rule-classes :type-prescription
+ "The actual characters found in the source code, i.e., it might be
+ a string such as @('\"3.41e+12\"')."))
+
+ :long "We have almost no support for working with real numbers. You
+should probably not rely on our current representation, since q we will almost
+certainly want to change it as soon as we want to do anything with real
+numbers.
")
(defaggregate vl-id
- (name)
+ :parents (vl-expr-p)
+ :short "Representation for simple identifiers."
:tag :vl-id
:hons t
:legiblep nil
- :require ((stringp-of-vl-id->name
- (stringp name)
- :rule-classes :type-prescription))
- :parents (vl-expr-p)
- :short "Representation for simple identifiers."
+
+ ((name stringp
+ :rule-classes :type-prescription
+ "This identifier's name. Our structure only requires that this is an
+ ACL2 string; in practice the name can include any character
+ besides whitespace and should be non-empty. Note that for escaped
+ identifiers like @('\\foo '), the @('\\') and trailing space are not
+ included in the name; see @(see vl-read-escaped-identifier)."))
:long "@('vl-id-p') objects are used to represent identifiers used in
-expressions, which might be the names of wires, ports, parameters, registers,
-and so on. The @('name') of the identifier is a string, which should generally
-correspond to one of these items.
+expressions which might be the names of wires, ports, parameters, registers,
+and so on.
A wonderful feature of our representation @('vl-id-p') atoms are guaranteed
to not be part of any hierarchical identifier, nor are they the names of
functions or system functions. See the discussion in @(see vl-hidpiece-p) for
more information.
-Note that names created at parse time may include any character
-except for whitespace, and will not be empty. One might eventually add these
-restrictions to vl-id tokens, and in other places such as port names, but we
-have not done so since this is all relatively obscure.
-
Like @(see vl-constint-p)s, we automatically create these structures with
@(see hons). This seems quite nice, since the same names may be used many
times throughout all the expressions in a design.
")
-
(defaggregate vl-hidpiece
- (name)
- :tag :vl-hidpiece
- :legiblep nil
- :require ((stringp-of-vl-hidpiece->name
- (stringp name)
- :rule-classes :type-prescription))
:parents (vl-expr-p)
:short "Represents one piece of a hierarchical identifier."
+ :tag :vl-hidpiece
+ :legiblep nil
+
+ ((name stringp :rule-classes :type-prescription))
:long "We represent hierarchical identifiers like
@('top.processor[2].reset') as non-atomic expressions. To represent this
@@ -511,8 +515,8 @@
hierarchical identifier, and @(':vl-hid-arraydot') is used when instance arrays
are accessed.
-To add slightly more precision, our representation is really more like
-the following:
+To add slightly more precision, our representation is really more like the
+following:
@({
(:vl-hid-dot (hidpiece \"top\")
@@ -531,38 +535,30 @@
identifier.")
-
(defaggregate vl-sysfunname
- (name)
- :tag :vl-sysfunname
- :legiblep nil
- :require ((stringp-of-vl-sysfunname->name
- (stringp name)
- :rule-classes :type-prescription))
:parents (vl-expr-p)
:short "Represents a system function name."
+ :tag :vl-sysfunname
+ :legiblep nil
+
+ ((name stringp :rule-classes :type-prescription))
:long "We use a custom representation for the names of system functions,
so that we do not confuse them with ordinary @(see vl-id-p) objects.
")
-
(defaggregate vl-funname
- (name)
- :tag :vl-funname
- :legiblep nil
- :require ((stringp-of-vl-funname->name
- (stringp name)
- :rule-classes :type-prescription))
:parents (vl-expr-p)
:short "Represents a (non-system) function name."
+ :tag :vl-funname
+ :legiblep nil
+
+ ((name stringp :rule-classes :type-prescription))
:long "We use a custom representation for the names of functions, so that
we do not confuse them with ordinary @(see vl-id-p) objects.
")
-
-
(define vl-atomguts-p (x)
:parents (vl-expr-p)
:short "The main contents of a @(see vl-atom-p)."
@@ -570,6 +566,8 @@
:long "The guts of an atom are its main contents. See @(see vl-expr-p)
for a discussion of the valid types.
"
+ ;; BOZO some kind of defsum macro could eliminate a lot of this boilerplate
+
(mbe :logic (or (vl-constint-p x)
(vl-weirdint-p x)
(vl-string-p x)
@@ -747,25 +745,25 @@
(defaggregate vl-atom
- (guts finalwidth finaltype)
- :tag :vl-atom
- :legiblep nil
- :require
- ((vl-atomguts-p-of-vl-atom->guts
- (vl-atomguts-p guts))
- (vl-maybe-natp-of-vl-atom->finalwidth
- (vl-maybe-natp finalwidth)
- :rule-classes :type-prescription)
- (vl-maybe-exprtype-p-of-vl-atom->finaltype
- (vl-maybe-exprtype-p finaltype)
- :rule-classes ((:rewrite)
- (:type-prescription
- :corollary (implies (force (vl-atom-p x))
- (and (symbolp (vl-atom->finaltype x))
- (not (equal (vl-atom->finaltype x) t))))))))
:parents (vl-expr-p)
:short "Representation of atomic expressions."
- :long "See the discussion in @(see vl-expr-p).
")
+ :long "See the discussion in @(see vl-expr-p).
"
+ :tag :vl-atom
+ :legiblep nil
+
+ ((guts vl-atomguts-p)
+
+ (finalwidth vl-maybe-natp
+ :rule-classes :type-prescription)
+
+ (finaltype vl-maybe-exprtype-p
+ :rule-classes
+ ((:rewrite)
+ (:type-prescription
+ :corollary
+ (implies (force (vl-atom-p x))
+ (and (symbolp (vl-atom->finaltype x))
+ (not (equal (vl-atom->finaltype x) t)))))))))
(deflist vl-atomlist-p (x)
(vl-atom-p x)
@@ -775,36 +773,41 @@
(defaggregate vl-nonatom
- (op atts args finalwidth finaltype)
- :tag :vl-nonatom
- :legiblep nil
- :require
- ((vl-op-p-of-vl-nonatom->op
- (vl-op-p op)
- :rule-classes ((:rewrite)
- (:type-prescription
- ;; I previously forced this, but it got irritating because it
- ;; kept screwing up termination proofs. Consider case-split?
- :corollary (implies (vl-nonatom-p x)
- (and (symbolp (vl-nonatom->op x))
- (not (equal (vl-nonatom->op x) t))
- (not (equal (vl-nonatom->op x) nil)))))))
- (vl-maybe-natp-of-vl-nonatom->finalwidth
- (vl-maybe-natp finalwidth)
- :rule-classes :type-prescription)
- (vl-maybe-exprtype-p-of-vl-nonatom->finaltype
- (vl-maybe-exprtype-p finaltype)
- :rule-classes ((:rewrite)
- (:type-prescription
- ;; I previously forced this, but maybe that's a bad idea for
- ;; the same reasons as vl-op-p-of-vl-nonatom->op?
- :corollary (implies (vl-nonatom-p x)
- (and (symbolp (vl-nonatom->finaltype x))
- (not (equal (vl-nonatom->finaltype x) t))))))))
:parents (vl-expr-p)
:short "Structural validity of non-atomic expressions."
:long "This is only a simple structural check, and does not imply
@('vl-expr-p'). See @(see vl-expr-p) for details.
"
+ :tag :vl-nonatom
+ :legiblep nil
+
+ ((op vl-op-p
+ :rule-classes
+ ((:rewrite)
+ (:type-prescription
+ :corollary
+ ;; I previously forced the hyp, but it got irritating because it
+ ;; kept screwing up termination proofs. Consider case-split?
+ (implies (vl-nonatom-p x)
+ (and (symbolp (vl-nonatom->op x))
+ (not (equal (vl-nonatom->op x) t))
+ (not (equal (vl-nonatom->op x) nil)))))))
+
+ (atts "No requirements (yet) due to mutual recursion.")
+ (args "No requirements (yet) due to mutual recursion.")
+
+ (finalwidth vl-maybe-natp
+ :rule-classes :type-prescription)
+
+ (finaltype vl-maybe-exprtype-p
+ :rule-classes
+ ((:rewrite)
+ (:type-prescription
+ :corollary
+ ;; I previously forced this, but maybe that's a bad idea for
+ ;; the same reasons as vl-op-p-of-vl-nonatom->op?
+ (implies (vl-nonatom-p x)
+ (and (symbolp (vl-nonatom->finaltype x))
+ (not (equal (vl-nonatom->finaltype x) t))))))))
:rest
((defthm acl2-count-of-vl-nonatom->args
@@ -835,7 +838,6 @@
-
(defsection vl-expr-p
:parents (modules)
:short "Representation of Verilog expressions."
@@ -882,7 +884,7 @@
-@('finalwidth'), which is a @(see vl-maybe-natp-p), and
+@('finalwidth'), which is a @(see vl-maybe-natp), and
@('finaltype'), which is a @(see vl-maybe-exprtype-p).
@@ -1032,7 +1034,7 @@
:parents (vl-expr-p)
:short "Get the @('finalwidth') from an expression."
:long "See @(see vl-expr-p) for a discussion of widths. The result is a
-@(see vl-maybe-exprwidth-p).
"
+@(see vl-maybe-natp)."
(if (eq (tag x) :vl-atom)
(vl-atom->finalwidth x)
(vl-nonatom->finalwidth x))
@@ -1128,7 +1130,7 @@
version\" of the expression before simplification has taken place.
@('VL_ZERO_EXTENSION') is added when we create certain zero-extension
-expressions, mainly to pad operands during @(see ctxsize).
+expressions, mainly to pad operands during @(see expression-sizing).
Net Declarations
@@ -1139,7 +1141,7 @@
@('VL_PORT_IMPLICIT'), with no value, is given to wires that are declared
to be ports (i.e., @('input a;')) but which are not also declared to be
-wires (i.e., @('wire a;')) by @(see make-port-wires)
+wires (i.e., @('wire a;')) by @(see make-implicit-wires)
@('VL_UNUSED') and @('VL_MAYBE_UNUSED') may be added by @(see use-set) when
a wire appears to be unused.
@@ -1453,14 +1455,14 @@
(defaggregate vl-range
- (msb lsb)
- :tag :vl-range
- :legiblep nil
- :require ((vl-expr-p-of-vl-range->msb (vl-expr-p msb))
- (vl-expr-p-of-vl-range->lsb (vl-expr-p lsb)))
:parents (modules)
:short "Representation of ranges on wire declarations, instance array
declarations, and so forth."
+ :tag :vl-range
+ :legiblep nil
+
+ ((msb vl-expr-p)
+ (lsb vl-expr-p))
:long "Ranges are discussed in Section 7.1.5.
@@ -1522,33 +1524,35 @@
:parents (modules))
-
(defaggregate vl-port
- (name expr loc)
- :tag :vl-port
- :require ((vl-maybe-string-p-of-vl-port->name
- (vl-maybe-string-p name)
- :rule-classes
- ((:type-prescription)
- (:rewrite :corollary
- ;; BOZO horrible gross stupid hack because type rule isn't forcing
- (implies (force (vl-port-p x))
- (equal (stringp (vl-port->name x))
- (if (vl-port->name x)
- t
- nil))))))
- (vl-maybe-expr-p-of-vl-port->expr
- (vl-maybe-expr-p expr))
- (vl-location-p-of-vl-port->loc
- (vl-location-p loc)))
- :legiblep nil
:parents (modules)
:short "Representation of a single Verilog port."
+ :tag :vl-port
+ :legiblep nil
+
+ ((name vl-maybe-string-p
+ :rule-classes
+ ((:type-prescription)
+ (:rewrite :corollary
+ ;; BOZO horrible gross stupid hack because type rule isn't forcing
+ (implies (force (vl-port-p x))
+ (equal (stringp (vl-port->name x))
+ (if (vl-port->name x)
+ t
+ nil)))))
+ "The \"externally visible\" name of this port, for use in named module
+ instances. Usually it is best to avoid this; see below.")
+
+ (expr vl-maybe-expr-p
+ "How the port is wired internally within the module. Most of the time,
+ this is a simple identifier expression that is just @('name'). But
+ it can also be more complex; see below.")
- :long "Introduction to Ports
+ (loc vl-location-p
+ "Where this port came from in the Verilog source code."))
-Ports are described in Section 12.3 of the standard. In simple cases, a
-module's ports look like this:
+ :long "Ports are described in Section 12.3 of the standard. In simple
+cases, a module's ports look like this:
@({
module mod(a,b,c) ; <-- ports are a, b, and c
@@ -1580,33 +1584,20 @@
endmodule
})
-
-Representation of Ports
-
-The @('name') of every port is a @(see vl-maybe-string-p). We think of this
-name as the \"externally visible\" name of the port.
-
-The @('expr') of every port is a @(see vl-maybe-expr-p) that determines how
-the port is wired internally within the module.
-
-The @('loc') for each port is a @(see vl-location-p) that says where the
-port came from in the Verilog source code.
-
-For instance, in the \"complex\" example above, the names of the ports would
-be represented, respectively, as: @('\"a\"'), @('\"b\"'), @('nil') (i.e., this
-port has no externally visible name), and @('\"d\"'). Meanwhile, the first two
-ports are internally wired to @('a') and @('w'), respectively, while the third
-and fourth ports collectively specify the bits of @('c').
-
+In this example, the @('name')s of these ports would be, respectively:
+@('\"a\"'), @('\"b\"'), @('nil') (because this port has no externally visible
+name), and @('\"d\"'). Meanwhile, the first two ports are internally wired to
+@('a') and @('w'), respectively, while the third and fourth ports collectively
+specify the bits of @('c').
Using Ports
It is generally best to avoid using port names except perhaps for
things like error messages. Why? As shown above, some ports might not have
names, and even when a port does have a name, it does not necessarily
-correspond to any wires in the module. Since these cases are exotic, code
+correspond to any wires in the module. But these cases are exotic, so code
based on port names is likely to work for simple test cases and then fail later
-when more complex examples are encountered.
+when more complex examples are encountered!
Usually you should not need to deal with port names. The @(see argresolve)
transform converts module instances that use named arguments into their plain
@@ -1632,8 +1623,8 @@
implement a comprehensive approach to detecting and dealing with backflow.
The width of a port can be determined after expression sizing has been
-performed by examining the width of the port expression. See @(see selfsize)
-and @(see ctxsize) for details.
")
+performed by examining the width of the port expression. See @(see
+expression-sizing) for details.")
(deflist vl-portlist-p (x)
(vl-port-p x)
@@ -1701,28 +1692,47 @@
(defaggregate vl-portdecl
- (name dir signedp range loc atts)
- :tag :vl-portdecl
- :legiblep nil
- :require ((stringp-of-vl-portdecl->name
- (stringp name)
- :rule-classes :type-prescription)
- (vl-direction-p-of-vl-portdecl->dir
- (vl-direction-p dir))
- (booleanp-of-vl-portdecl->signedp
- (booleanp signedp)
- :rule-classes :type-prescription)
- (vl-maybe-range-p-of-vl-portdecl->range
- (vl-maybe-range-p range))
- (vl-location-p-vl-portdecl->loc
- (vl-location-p loc))
- (vl-atts-p-of-vl-portdecl->atts
- (vl-atts-p atts)))
:parents (modules)
:short "Representation of Verilog port declarations."
+ :tag :vl-portdecl
+ :legiblep nil
- :long "Port declarations ascribe certain properties (direction,
-signedness, size, and so on) to the ports of a module. Here is an example:
+ ((name stringp
+ :rule-classes :type-prescription
+ "An ordinary string that should agree with some identifier used in
+ the \"internal\" wiring expressions from some port(s) in the
+ module.")
+
+ (dir vl-direction-p
+ "Says whether this port is an input, output, or bidirectional
+ (inout) port.")
+
+ (signedp booleanp
+ :rule-classes :type-prescription
+ "Whether the @('signed') keyword was present in the declaration;
+ but warning : per page 175, port declarations and net/reg
+ declarations must be checked against one another: if either
+ declaration includes the @('signed') keyword, then both are to be
+ considered signed. The @(see loader) DOES NOT do this
+ cross-referencing automatically; instead the @(see portdecl-sign)
+ transformation needs to be run.")
+
+ (range vl-maybe-range-p
+ "Indicates whether the input is a vector and, if so, how large the
+ input is. Per page 174, if there is also a net declaration, then
+ the range must agree. This is checked in @(see
+ vl-overlap-compatible-p) as part of our notion of @(see
+ reasonable) modules.")
+
+ (atts vl-atts-p
+ "Any attributes associated with this declaration.")
+
+ (loc vl-location-p
+ "Where the port was declared in the source code."))
+
+ :long "Port declarations, described in Section 12.3.3 of the
+specification, ascribe certain properties (direction, signedness, size, and so
+on) to the ports of a module. Here is an example:
@({
module m(a, b) ;
@@ -1736,35 +1746,6 @@
separate @('vl-portdecl-p') objects for each port. Because of this, every
@('vl-portdecl-p') has only a single name.
-Port declarations are described in Section 12.3.3 of the specification.
-
-The @('name') of the port is an ordinary string, which should agree with the
-name of some port in the module. (BOZO Is that the external or internal
-name? Oh my God...)
-
-The @('direction') of the port is a @(see vl-direction-p) that says whether
-this port is an input, output, or bidirectional port.
-
-The @('signedp') flag indicates whether the @('signed') keyword was present
-in the declaration.
-
-Warning : Note that per page 175, port declarations and net/reg
-declarations must be checked against one another: if either declaration
-includes the @('signed') keyword, then both are to be considered signed. The
-parser DOES NOT do this cross-referencing automatically; instead the @(see
-portdecl-sign) transformation needs to be run.
-
-The @('range') indicates how whether the input is a vector and, if so, how
-large the input is. Per page 174, if there is also a net declaration then the
-range must agree. This is checked in @(see vl-overlap-compatible-p) as part of
-our notion of @(see reasonable) modules.
-
-The @('loc') is a @(see vl-location-p) that describes where the port was
-declared in the source code.
-
-The @('atts') are any attribute (see @(see vl-atts-p)) associated with this
-declaration.
-
A Note about Port Types
If you look at the grammar for port declarations, you will see that you
@@ -1790,20 +1771,25 @@
(defaggregate vl-gatedelay
- (rise fall high)
- :tag :vl-gatedelay
- :legiblep nil
- :require ((vl-expr-p-of-vl-gatedelay->rise (vl-expr-p rise))
- (vl-expr-p-of-vl-gatedelay->fall (vl-expr-p fall))
- (vl-maybe-expr-p-of-vl-gatedelay->high (vl-maybe-expr-p high)))
:parents (modules)
:short "Representation of delay expressions."
+ :tag :vl-gatedelay
+ :legiblep nil
+
+ ((rise vl-expr-p
+ "Rising delay.")
+
+ (fall vl-expr-p
+ "Falling delay.")
+
+ (high vl-maybe-expr-p
+ "High-impedence delay or charge decay time." ))
:long "
WARNING . We have not paid much attention to delays, and our
transformations probably do not handle them properly.
-Delays are mainly discussed in 7.14 and 5.3, with some other
-discussion in 6.13 and the earlier parts of Section 7. In short:
+Delays are mainly discussed in 7.14 and 5.3, with some other discussion in
+6.13 and the earlier parts of Section 7. In short:
A \"delay expression\" can be an arbitrary expression. Of particular note,
@@ -1866,17 +1852,14 @@
(defaggregate vl-gatestrength
- (zero one)
- :tag :vl-gatestrength
:parents (modules)
- :legiblep nil
- :require ((vl-dstrength-p-of-vl-gatestrength->zero
- (vl-dstrength-p zero))
- (vl-dstrength-p-of-vl-gatestrength->one
- (vl-dstrength-p one)))
-
:short "Representation of strengths for a assignment statements, gate
instances, and module instances."
+ :tag :vl-gatestrength
+ :legiblep nil
+
+ ((zero vl-dstrength-p "Drive strength toward logical zero.")
+ (one vl-dstrength-p "Drive strength toward logical one."))
:long "WARNING . We have not paid much attention to strengths, and
our transformations probably do not handle them properly.
@@ -1957,23 +1940,19 @@
(defaggregate vl-assign
- (lvalue expr strength delay loc atts)
- :tag :vl-assign
- :legiblep nil
- :require ((vl-expr-p-of-vl-assign->lvalue
- (vl-expr-p lvalue))
- (vl-expr-p-of-vl-assign->expr
- (vl-expr-p expr))
- (vl-maybe-gatedelay-p-of-vl-assign->delay
- (vl-maybe-gatedelay-p delay))
- (vl-maybe-gatestrength-p-of-vl-assign->strength
- (vl-maybe-gatestrength-p strength))
- (vl-location-p-of-vl-assign->loc
- (vl-location-p loc))
- (vl-atts-p-of-vl-assign->atts
- (vl-atts-p atts)))
:parents (modules)
:short "Representation of a continuous assignment statement."
+ :tag :vl-assign
+ :legiblep nil
+
+ ((lvalue vl-expr-p "The location being assigned to.")
+ (expr vl-expr-p "The right-hand side.")
+ (strength vl-maybe-gatestrength-p)
+ (delay vl-maybe-gatedelay-p)
+ (atts vl-atts-p
+ "Any attributes associated with this assignment.")
+ (loc vl-location-p
+ "Where the assignment was found in the source code."))
:long "In the Verilog sources, continuous assignment statements can take
two forms, as illustrated below.
@@ -2067,16 +2046,7 @@
Warning: Although the parser is careful to handle the strength
correctly, we are generally uninterested in strengths and our transforms may not
-properly preserve them.
-
-Loc, Atts
-
-The @('loc') is the location of this continuous assignment in the source
-code, and is useful for producing error messages; see @(see vl-location-p).
-
-The @('atts') are any Verilog-2005 style attributes associated with this
-assignment; see @(see vl-atts-p). We mostly ignore attributes, but we may
-sometimes add them as annotations.
")
+properly preserve them.")
(deflist vl-assignlist-p (x)
(vl-assign-p x)
@@ -2146,37 +2116,48 @@
(defaggregate vl-netdecl
- (name type range arrdims atts vectoredp scalaredp signedp delay cstrength loc)
- :tag :vl-netdecl
- :legiblep nil
- :require ((stringp-of-vl-netdecl->name
- (stringp name)
- :rule-classes :type-prescription)
- (vl-netdecltype-p-of-vl-netdecl->type
- (vl-netdecltype-p type))
- (vl-maybe-range-p-of-vl-netdecl->range
- (vl-maybe-range-p range))
- (vl-rangelist-p-of-vl-netdecl->arrdims
- (vl-rangelist-p arrdims))
- (vl-atts-p-of-vl-netdecl->atts
- (vl-atts-p atts))
- (booleanp-of-vl-netdecl->vectoredp
- (booleanp vectoredp)
- :rule-classes :type-prescription)
- (booleanp-of-vl-netdecl->scalaredp
- (booleanp scalaredp)
- :rule-classes :type-prescription)
- (booleanp-of-vl-netdecl->signedp
- (booleanp signedp)
- :rule-classes :type-prescription)
- (vl-maybe-gatedelay-p-of-vl-netdecl->delay
- (vl-maybe-gatedelay-p delay))
- (vl-maybe-cstrength-p-of-vl-netdecl->cstrength
- (vl-maybe-cstrength-p cstrength))
- (vl-location-p-of-vl-netdecl->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of net (wire) declarations."
+ :tag :vl-netdecl
+ :legiblep nil
+ ((name stringp
+ :rule-classes :type-prescription
+ "Name of the wire being declared.")
+
+ (type vl-netdecltype-p
+ "Wire type, e.g., @('wire'), @('supply1'), etc.")
+
+ (range vl-maybe-range-p
+ "A single, optional range that preceeds the wire name; this
+ ordinarily governs the \"size\" of a wire.")
+
+ (arrdims vl-rangelist-p
+ "Used for arrays like memories; see below.")
+
+ (vectoredp booleanp
+ :rule-classes :type-prescription
+ "True if the @('vectored') keyword was explicitly provided.")
+
+ (scalaredp booleanp
+ :rule-classes :type-prescription
+ "True if the @('scalared') keyword was explicitly provided.")
+
+ (signedp booleanp
+ :rule-classes :type-prescription
+ "Indicates whether the @('signed') keyword was supplied on this
+ declaration. But warning : per page 175, port
+ declarations and net/reg declarations must be checked against
+ one another: if either declaration includes the @('signed')
+ keyword, then both are to be considered signed. The parser
+ DOES NOT do this cross-referencing automatically; instead the
+ @(see portdecl-sign) transformation needs to be run.")
+
+ (delay vl-maybe-gatedelay-p)
+ (cstrength vl-maybe-cstrength-p)
+ (atts vl-atts-p
+ "Any attributes associated with this declaration.")
+ (loc vl-location-p
+ "Where the declaration was found in the source code."))
:long "Net declarations introduce new wires with certain properties (type,
signedness, size, and so on). Here are some examples of basic net
@@ -2214,24 +2195,19 @@
and truly only represents a declaration.
-Basic Fields
-
-The @('name'), @('type'), @('atts'), and @('loc') fields should be
-self-explanatory after reading the descriptions of @(see vl-netdecltype-p),
-@(see vl-atts-p), and @(see vl-location-p).
+Arrays
-
-Arrays and Vectors
-
-The @('range') and @('arrdims') fields deal with vectors and arrays. In
-particular, @('range') is a single, optional range that preceeds the wire name.
-For instance, the range of @('w') is @('[4:0]') in the following
-declaration:
+The @('arrdims') fields is for arrays. Normally, you do not encounter
+these. For instance, a wide wire declaration like this is not an
+array:
@({
wire [4:0] w;
})
+Instead, the @('[4:0]') part here is the @('range') of the wire and its
+@('arrdims') are just @('nil').
+
In contrast, the @('arrdims') are a list of ranges, also optional, which
follow the wire name. For instance, the arrdims of @('v') below is a singleton
list with the range @('[4:0]').
@@ -2252,7 +2228,7 @@
wire [4:0] a [10:0];
})
-declares @('a') to be an 11-element array of five bit wires. The @('range')
+
declares @('a') to be an 11-element array of five-bit wires. The @('range')
for @('a') is @('[4:0]'), and the arrdims are a list with one entry, namely the
range @('[10:0]').
@@ -2262,23 +2238,18 @@
Vectorness and Signedness
-The @('signedp') flag indicates whether the @('signed') keyword was supplied
-on this declaration. Warning : Note that per page 175, port declarations
-and net/reg declarations must be checked against one another: if either
-declaration includes the @('signed') keyword, then both are to be considered
-signed. The parser DOES NOT do this cross-referencing automatically; instead
-the @(see portdecl-sign) transformation needs to be run.
-
-The @('vectoredp') and @('scalaredp') fields are booleans, which are set to
-@('t') when, respectively, the Verilog keywords @('vectored') and @('scalared')
-are provided. In other words, these fields might both be @('nil'). I do not
-know what these keywords are supposed to mean; the Verilog specification says
-almost nothing about it, and does not even say what the default is. According
-to some random guy on the internet, it's supposed to be a syntax error to try
-to bit- or part-select from a vectored net. Maybe I can find a more definitive
-explanation somewhere. Hey, in 6.1.3 there are some differences mentioned
-w.r.t. how delays go to scalared and vectored nets. 4.3.2 has a little bit
-more.
+These are only set to @('t') when the keywords @('vectored') or
+@('scalared') are explicitly provided; i.e., they may both be @('nil').
+
+I do not know what these keywords are supposed to mean; the Verilog
+specification says almost nothing about it, and does not even say what the
+default is.
+
+According to some random guy on the internet, it's supposed to be a syntax
+error to try to bit- or part-select from a vectored net. Maybe I can find a
+more definitive explanation somewhere. Hey, in 6.1.3 there are some
+differences mentioned w.r.t. how delays go to scalared and vectored nets.
+4.3.2 has a little bit more.
Delay
@@ -2329,27 +2300,36 @@
(defaggregate vl-plainarg
- (expr atts portname dir)
- :tag :vl-plainarg
- :legiblep nil
- :require
- ((vl-maybe-expr-p-of-vl-plainarg->expr
- (vl-maybe-expr-p expr))
- (vl-atts-p-of-vl-plainarg->atts
- (vl-atts-p atts))
- (vl-maybe-string-p-of-vl-plainarg->portname
- (vl-maybe-string-p portname)
- :rule-classes ((:type-prescription)
- (:rewrite
- :corollary (implies (force (vl-plainarg-p x))
- (equal (stringp (vl-plainarg->portname x))
- (if (vl-plainarg->portname x)
- t
- nil))))))
- (vl-maybe-direction-p-of-vl-plainarg->dir
- (vl-maybe-direction-p dir)))
:parents (modules vl-arguments-p)
:short "Representation of a single argument in a plain argument list."
+ :tag :vl-plainarg
+ :legiblep nil
+
+ ((expr vl-maybe-expr-p
+ "Expression being connected to the port. In programming languages
+ parlance, this is the actual . Note that this may be
+ @('nil') because Verilog allows expressions to be \"blank\", in
+ which case they represent an unconnected wire.")
+
+ (portname vl-maybe-string-p
+ :rule-classes
+ ((:type-prescription)
+ (:rewrite
+ :corollary (implies (force (vl-plainarg-p x))
+ (equal (stringp (vl-plainarg->portname x))
+ (if (vl-plainarg->portname x)
+ t
+ nil)))))
+ "Not part of the Verilog syntax. This may indicate the
+ name of the port (i.e., the formal ) that this expression
+ is connected to; see below.")
+
+ (dir vl-maybe-direction-p
+ "Not part of the Verilog syntax. This may indicate the
+ direction of this port; see below.")
+
+ (atts vl-atts-p
+ "Any attributes associated with this argument."))
:long "There are two kinds of argument lists for module instantiations,
which we call plain and named arguments.
@@ -2362,35 +2342,24 @@
A @('vl-plainarg-p') represents a single argument in a plain argument
list.
-The @('expr') is the expression being connected to this port; in programming
-languages parlance, the @('expr') is an actual . Note that @('expr') is
-only a @(see vl-maybe-expr-p), and may be @('nil'). This is because Verilog
-allows expressions to be \"blank\", in which case they represent an unconnected
-wire. This seems to be used only very rarely, but is supported.
-
-The @('atts') are any attributes (see @(see vl-atts-p)) associated with this
-argument.
-
-The @('dir') is an @(see vl-maybe-direction-p) object. This is not
-part of the Verilog syntax, but may sometimes be added by the @(see argresolve)
-transformation to indicate whether this port for this argument is an input,
-output, or inout for the module or gate being instantiated.
-
-Note that after @(see argresolve), all well-formed gate instances will have
-their direction information computed. You may rely upon the @('dir') field for
-gate instances.
-
-However, for module instances the direction of a port may not be apparent;
-see @(see vl-port-direction) for details. So even after @(see argresolve) some
-arguments to module instances may not have a @('dir') annotation, and so the
-@('dir') field should generally not be relied upon for module instances.
-
-The @('portname') is also not part of the Verilog syntax, but may sometimes
-be added by the @(see argresolve) transformation as a convenience for error
-message generation. This field should never be used for anything that
-is semantically important. Note that no argument to a gate instance will ever
-have a portname. Also note that since not every @(see vl-port-p) has a name,
-some arguments to module instances may also not be given portnames.
")
+The @('dir') is initially @('nil') but may get filled in by the @(see
+argresolve) transformation to indicate whether this port for this argument is
+an input, output, or inout for the module or gate being instantiated. After
+@(see argresolve), all well-formed gate instances will have their
+direction information computed and so you may rely upon the @('dir') field for
+gate instances. HOWEVER , for module instances the direction of a
+port may not be apparent; see @(see vl-port-direction) for details. So even
+after @(see argresolve) some arguments to module instances may not have a
+@('dir') annotation, and you should generally not rely on the @('dir') field
+for module instances.
+
+The @('portname') is similar. The @(see argresolve) transformation may
+sometimes be able to fill in the name of the port, but this is meant only as a
+convenience for error message generation. This field should never be
+used for anything that is semantically important. No argument to a gate
+instance will ever have a portname. Also, since not every @(see vl-port-p) has
+a name, some arguments to module instances may also not be given
+portnames.
")
(deflist vl-plainarglist-p (x)
(vl-plainarg-p x)
@@ -2429,34 +2398,26 @@
(defaggregate vl-namedarg
- (name expr atts)
- :tag :vl-namedarg
- :legiblep nil
- :require ((stringp-of-vl-namedarg->name
- (stringp name)
- :rule-classes :type-prescription)
- (vl-maybe-expr-p-of-vl-namedarg->expr
- (vl-maybe-expr-p expr))
- (vl-atts-p-of-vl-namedarg->atts
- (vl-atts-p atts)))
:parents (modules)
:short "Representation of a single argument in a named argument list."
+ :tag :vl-namedarg
+ :legiblep nil
- :long "See @(see vl-plainarg-p) for a general discussion of arguments.
-Each @('vl-namedarg-p') represents a single argument in a named argument list.
-Its fields include:
-
-
-
-@('name'), a string, e.g., @('foo') in @('.foo(3)'),
-
-@('expr'), a @(see vl-maybe-expr-p) which is the actual for this port, and
-may be @('nil') for blank ports as described in @(see vl-plainarg-p), and
+ ((name stringp
+ :rule-classes :type-prescription
+ "Name of the port being connected to, e.g., @('foo') in
+ @('.foo(3)')")
+
+ (expr vl-maybe-expr-p
+ "The actual being connected to this port; may be
+ @('nil') for blank ports.")
-@('atts'), any attributes (see @(see vl-atts-p)) associated with this
-argument.
+ (atts vl-atts-p
+ "Any attributes associated with this argument."))
-
+ :long "See @(see vl-plainarg-p) for a general discussion of arguments.
+Each @('vl-namedarg-p') represents a single argument in a named argument
+list.
Unlike plain arguments, our named arguments do not have a direction field.
Our basic transformation strategy is to quickly eliminate named arguments and
@@ -2594,38 +2555,54 @@
(defaggregate vl-modinst
- (instname modname range paramargs portargs str delay atts loc)
- :tag :vl-modinst
- :legiblep nil
- :require ((vl-maybe-string-p-of-vl-modinst->instname
- (vl-maybe-string-p instname)
- :rule-classes ((:type-prescription)
- (:rewrite :corollary
- (implies (force (vl-modinst-p x))
- (equal (stringp (vl-modinst->instname x))
- (if (vl-modinst->instname x)
- t
- nil))))))
- (stringp-of-vl-modinst->modname
- (stringp modname)
- :rule-classes :type-prescription)
- (vl-maybe-range-p-of-vl-modinst->range
- (vl-maybe-range-p range))
- (vl-arguments-p-of-vl-modinst->paramargs
- (vl-arguments-p paramargs))
- (vl-arguments-p-of-vl-modinst->portargs
- (vl-arguments-p portargs))
- (vl-maybe-gatestrength-p-of-vl-modinst->str
- (vl-maybe-gatestrength-p str))
- (vl-maybe-gatedelay-p-of-vl-modinst->delay
- (vl-maybe-gatedelay-p delay))
- (vl-atts-p-of-vl-modinst->atts
- (vl-atts-p atts))
- (vl-location-p-of-vl-modinst->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of a single module (or user-defined primitive)
instance."
+ :tag :vl-modinst
+ :legiblep nil
+
+ ((instname vl-maybe-string-p
+ :rule-classes
+ ((:type-prescription)
+ (:rewrite :corollary
+ (implies (force (vl-modinst-p x))
+ (equal (stringp (vl-modinst->instname x))
+ (if (vl-modinst->instname x)
+ t
+ nil)))))
+ "Either the name of this instance or @('nil') if the instance has
+ no name. See also the @(see addinstnames) transform.")
+
+ (modname stringp
+ :rule-classes :type-prescription
+ "Name of the module or user-defined primitive that is being
+ instantiated.")
+
+ (range vl-maybe-range-p
+ "When present, indicates that this is an array of instances,
+ instead of a single instance.")
+
+ (paramargs vl-arguments-p
+ "Values to use for module parameters, e.g., this might specify
+ the width to use for an adder module, etc.")
+
+ (portargs vl-arguments-p
+ "Connections to use for the submodule's input, output, and inout
+ ports.")
+
+ (str vl-maybe-gatestrength-p
+ "Strength for user-defined primitive instances. Does not make
+ sense for module instances. VL mostly ignores this.")
+
+ (delay vl-maybe-gatedelay-p
+ "Delay for user-defined primitive instances. Does not make sense
+ for module instances. VL mostly ignores this.")
+
+ (atts vl-atts-p
+ "Any attributes associated with this instance.")
+
+ (loc vl-location-p
+ "Where the instance was found in the source code."))
:long "
We represent module and user-defined primitive instances in a
uniform manner with @('vl-modinst-p') structures. Because of this, certain
@@ -2638,33 +2615,7 @@
As with variables, nets, etc., we split up combined instantiations such as
@('modname inst1 (...), inst2 (...)') into separate, individual structures, one
for @('inst1'), and one for @('inst2'), so that each @('vl-modinst-p')
-represents exactly one instance (or instance array).
-
-The @('modname') is the name of the module or user-defined primitive that is
-being instantiated, and @('instname') is either the name of this instance or
-@('nil') if the instance has no name.
-
-If present, the @('range') indicates that this is an array of instances,
-instead of a single instance.
-
-The @('paramargs') field is a @(see vl-arguments-p) that gives the values
-for the module parameters. (E.g., in an instance of a parameterized adder
-module, this list might include the @('width') of the adder being
-instantiated.)
-
-The @('portargs') field is a @(see vl-arguments-p) that gives the values for
-the module's ports. (E.g., in an instance of an adder module, this list would
-contain the expressions for the inputs and outputs.)
-
-The @('gatestrength') and @('gatedelay') should only be used for
-user-defined primitives. Warning: we have generally ignored these
-fields and our transforms may not handle them correctly.
-
-The @('atts') are any attributes (see @(see vl-atts-p)) associated with this
-module instance.
-
-The @('loc') is a @(see vl-location-p) that says where in the source code
-this module instance was introduced, and is useful for error messages.
")
+represents exactly one instance (or instance array).")
(deflist vl-modinstlist-p (x)
(vl-modinst-p x)
@@ -2705,34 +2656,68 @@
recognized by @(call vl-gatetype-p).")
(defaggregate vl-gateinst
- (type name range strength delay args atts loc)
- :tag :vl-gateinst
- :legiblep nil
- :require ((vl-gatetype-p-of-vl-gateinst->type
- (vl-gatetype-p type))
- (vl-maybe-string-p-of-vl-gateinst->name
- (vl-maybe-string-p name)
- :rule-classes ((:type-prescription)
- (:rewrite :corollary
- (implies (force (vl-gateinst-p x))
- (equal (stringp (vl-gateinst->name x))
- (if (vl-gateinst->name x)
- t
- nil))))))
- (vl-maybe-range-p-of-vl-gateinst->range
- (vl-maybe-range-p range))
- (vl-maybe-gatestrength-p-of-vl-gateinst->strength
- (vl-maybe-gatestrength-p strength))
- (vl-maybe-gatedelay-p-of-vl-gateinst->delay
- (vl-maybe-gatedelay-p delay))
- (vl-plainarglist-p-of-vl-gateinst->args
- (vl-plainarglist-p args))
- (vl-atts-p-of-vl-gateinst->atts
- (vl-atts-p atts))
- (vl-location-p-of-vl-gateinst->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of a single gate instantiation."
+ :tag :vl-gateinst
+ :legiblep nil
+ ((type vl-gatetype-p
+ "What kind of gate this is, e.g., @('and'), @('xor'), @('rnmos'),
+ etc."
+ :rule-classes
+ ((:rewrite)
+ (:type-prescription
+ :corollary
+ ;; BOZO may not want to force this
+ (implies (force (vl-gateinst-p x))
+ (and (symbolp (vl-gateinst->type x))
+ (not (equal (vl-gateinst->type x) t))
+ (not (equal (vl-gateinst->type x) nil)))))))
+
+ (name vl-maybe-string-p
+ :rule-classes
+ ((:type-prescription)
+ (:rewrite :corollary
+ (implies (force (vl-gateinst-p x))
+ (equal (stringp (vl-gateinst->name x))
+ (if (vl-gateinst->name x)
+ t
+ nil)))))
+ "The name of this gate instance, or @('nil') if it has no name;
+ see also the @(see addinstnames) transform.")
+
+ (range vl-maybe-range-p
+ "When present, indicates that this is an array of instances
+ instead of a single instance.")
+
+ (strength vl-maybe-gatestrength-p
+ "The parser leaves this as @('nil') unless it is explicitly provided.
+ Note from Section 7.8 that pullup and pulldown gates are special
+ in that the strength0 from a pullup source and the strength1 on a
+ pulldown source are supposed to be ignored. Warning: in
+ general we have not paid much attention to strengths, so we may
+ not handle them correctly in our various transforms.")
+
+ (delay vl-maybe-gatedelay-p
+ "The parser leaves this as @('nil') unless it is explicitly provided.
+ Certain gates (tran, rtran, pullup, and pulldown) never have
+ delays according to the Verilog grammar, but this is only
+ enforced by the parser, and is not part of our @('vl-gateinst-p')
+ definition. Warning: as with strengths, we have not paid
+ much attention to delays, and our transforms may not handle them
+ correctly.")
+
+ (args vl-plainarglist-p
+ "Arguments to the gate instance. Note that this differs from
+ module instances where @(see vl-arguments-p) structures are used,
+ because gate arguments are never named. The grammar restricts
+ how many arguments certain gates can have, but we do not enforce
+ these restrictions in the definition of @('vl-gateinst-p').")
+
+ (atts vl-atts-p
+ "Any attributes associated with this gate instance.")
+
+ (loc vl-location-p
+ "Where the gate instance was found in the source code."))
:long "@('vl-gateinst-p') is our representation for any single gate
instance (or instance array).
@@ -2742,53 +2727,7 @@
Verilog grammar restricts the list of expressions in certain cases, e.g., for
an @('and') gate, the first expression must be an lvalue. Although our parser
enforces these restrictions, we do not encode them into the definition of
-@('vl-gateinst-p').
-
-The @('type') of the gate is an @(see vl-gatetype-p) and says what kind of
-gate this is, (e.g., rmos, nand, xor, ...).
-
-The @('name') may be a string that names this instance, or may be @('nil')
-when the instance has no name.
-
-If provided, the @('range') indicates that this is an array of instances
-instead of a single instance.
-
-The @('strength') is represented by a @(see vl-maybe-gatestrength-p). The
-parser leaves this as @('nil') unless it is explicitly provided. Note from
-Section 7.8 that pullup and pulldown gates are special in that the strength0
-from a pullup source and the strength1 on a pulldown source are supposed to be
-ignored. Warning: in general we have not paid much attention to
-strengths, so we may not handle them correctly in our various transforms.
-
-The @('delay') is represented by a @(see vl-maybe-gatedelay-p), and is also
-left as @('nil') unless it is explicitly provided. Note that certain
-gates (tran, rtran, pullup, and pulldown) never have delays according to the
-Verilog grammar, but this is not enforced in our @('vl-gateinst-p') definition,
-only by the parser. Warning: as with strengths, we have not paid much
-attention to delays, and our transforms may not handle them correctly.
-
-The @('args') are a list of @(see vl-plainarg-p) structures. Note that this
-differs from module instances where @(see vl-arguments-p) structures are used,
-because gate arguments are never named. The grammar restricts how many
-arguments certain gates can have, but we do not enforce these restrictions in
-the definition of @('vl-gateinst-p').
-
-The @('atts') are any attributes (see @(see vl-atts-p)) associated with this
-module instance.
-
-The @('loc') is a @(see vl-location-p) that says where in the source code
-this module instance was introduced, and is useful for error messages.
"
-
- :rest
- ((defthm symbolp-of-vl-gateinst->type
- (implies (force (vl-gateinst-p x))
- (and (symbolp (vl-gateinst->type x))
- (not (equal (vl-gateinst->type x) t))
- (not (equal (vl-gateinst->type x) nil))))
- :hints(("Goal"
- :use ((:instance vl-gatetype-p-of-vl-gateinst->type))
- :in-theory (e/d (vl-gatetype-p)
- (vl-gatetype-p-of-vl-gateinst->type)))))))
+@('vl-gateinst-p').")
(deflist vl-gateinstlist-p (x)
(vl-gateinst-p x)
@@ -2810,117 +2749,104 @@
BOZO consider consolidating variable and register declarations into a
single parse tree element by adding an extra reg type to vl-vardecl-p.
")
+
(defaggregate vl-vardecl
- (name type arrdims initval atts loc)
- :tag :vl-vardecl
- :legiblep nil
- :require ((stringp-of-vl-vardecl->name
- (stringp name)
- :rule-classes :type-prescription)
- (vl-vardecltype-p-of-vl-vardecl->type
- (vl-vardecltype-p type))
- (vl-rangelist-p-of-vl-vardecl->arrdims
- (vl-rangelist-p arrdims))
- (vl-maybe-expr-p-of-vl-vardecl->initval
- (vl-maybe-expr-p initval))
- (vl-atts-p-of-vl-vardecl->atts
- (vl-atts-p atts))
- (vl-location-p-vl-vardecl->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of a single variable declaration."
- :long "@('vl-vardecl-p') is our representation for a single variable
-declaration, and is used for @('integer'), @('real'), @('time'), and
-@('realtime') variable declarations. As with nets and ports, our parser splits
-up combined declarations such as \"integer a, b\" into multiple, individual
-declarations, so each @('vl-vardecl-p') represents only one declaration.
-
-The @('name') is an ordinary ACL2 string which contains the name of this
-variable.
-
-The @('type') is a @(see vl-vardecltype-p) that says whether this is an
-integer, real, time, or realtime variable.
-
-The @('arrdims') are a list of @(see vl-range-p) objects that give the
-dimensions for arrays of variables.
-
-The @('initval') is used when the declaration inclues an initial value for
-the variable, e.g., if one writes @('integer i = 3;'), then the @('initval')
-will be a @(see vl-expr-p) that represents @('3').
-
-The @('atts') are any attributes (see @(see vl-atts-p)) associated with this
-declaration.
-
-The @('loc') is a @(see vl-location-p) that identifies where this
-declaration comes from in the source code.
")
+ :tag :vl-vardecl
+ :legiblep nil
+ ((name stringp
+ :rule-classes :type-prescription
+ "Name of the variable being declared.")
+
+ (type vl-vardecltype-p
+ "Kind of variable, e.g., integer, real, etc.")
+
+ (arrdims vl-rangelist-p
+ "A list of array dimensions; empty unless this is an array or
+ multi-dimensional array of variables.")
+
+ (initval vl-maybe-expr-p
+ ;; BOZO eliminate initval and replace with an initial statement.
+ ;; Update the docs for vl-initial-p and also below when this is
+ ;; done.
+ "When present, indicates the initial value for the variable, e.g.,
+ if one writes @('integer i = 3;'), then the @('initval') will be
+ the @(see vl-expr-p) for @('3').")
+
+ (atts vl-atts-p
+ "Any attributes associated with this declaration.")
+
+ (loc vl-location-p
+ "Where the declaration was found in the source code."))
+
+ :long "We use @('vl-vardecl-p')s to represent @('integer'), @('real'),
+@('time'), and @('realtime') variable declarations. As with nets and ports,
+our parser splits up combined declarations such as \"integer a, b\" into
+multiple, individual declarations, so each @('vl-vardecl-p') represents only
+one declaration.
")
(defaggregate vl-regdecl
- (name signedp range arrdims initval atts loc)
- :tag :vl-regdecl
- :legiblep nil
- :require ((stringp-of-vl-regdecl->name
- (stringp name)
- :rule-classes :type-prescription)
- (booleanp-of-vl-regdecl->signedp
- (booleanp signedp)
- :rule-classes :type-prescription)
- (vl-maybe-range-p-of-vl-regdecl->range
- (vl-maybe-range-p range))
- (vl-rangelist-p-of-vl-regdecl->arrdims
- (vl-rangelist-p arrdims))
-
-; BOZO eliminate initval and replace with an initial statement. Update the
-; docs for vl-initial-p and also below when this is done.
-
- (vl-maybe-expr-p-of-vl-regdecl->initval
- (vl-maybe-expr-p initval))
- (vl-atts-p-of-vl-regdecl->atts
- (vl-atts-p atts))
- (vl-location-p-vl-regdecl->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of a single @('reg') declaration."
- :long "@('vl-regdecl-p') is our representation for a single
-@('reg') declaration. Our parser splits up combined declarations such as
-\"reg a, b\" into multiple, individual declarations, so each
-@('vl-regdecl-p') represents only one declaration.
-
-The @('name') is the name of this register as an ordinary ACL2 string.
-
-The @('signedp') flag indicates whether they keyword @('signed') was used in
-the declaration of the register. (By default, registers are unsigned.)
-
-The @('range') and @('arrdims') are used for multi-bit regs and arrays of
-regs. More discussion is available in @(see vl-netdecl-p).
-
-The @('initval') is an expression that provides an initial value to this
-register, if one was provided.
-
-The @('atts') are any attributes (see @(see vl-atts-p)) associated with this
-declaration.
-
-The @('loc') is a @(see vl-location-p) that identifies where this
-declaration comes from in the source code.
")
+ :tag :vl-regdecl
+ :legiblep nil
+ ((name stringp
+ :rule-classes :type-prescription
+ "Name of the register being declared.")
+
+ (signedp booleanp
+ :rule-classes :type-prescription
+ "Indicates whether they keyword @('signed') was used in the
+ declaration of the register. By default, registers are
+ unsigned.")
+
+ (range vl-maybe-range-p
+ "Size for wide registers; see also @(see vl-netdecl-p) for
+ more discussion of @('range') versus @('arrdims').")
+
+ (arrdims vl-rangelist-p
+ "Array dimensions for arrays of registers; see @(see
+ vl-netdecl-p) for more discussion.")
+
+ (initval vl-maybe-expr-p
+ ;; BOZO eliminate initval and replace with an initial statement.
+ ;; Update the docs for vl-initial-p and also below when this is
+ ;; done.
+ "When present, indicates the initial value for this register.")
+
+ (atts vl-atts-p
+ "Any attributes associated with this declaration.")
+
+ (loc vl-location-p
+ "Where the declaration was found in the source code."))
+
+ :long "@('vl-regdecl-p') is our representation for a single @('reg')
+declaration. Our parser splits up combined declarations such as \"reg a, b\"
+into multiple, individual declarations, so each @('vl-regdecl-p') represents
+only one declaration.
")
(defaggregate vl-eventdecl
- (name arrdims atts loc)
- :tag :vl-eventdecl
- :legiblep nil
- :require ((stringp-of-vl-eventdecl->name
- (stringp name)
- :rule-classes :type-prescription)
- (vl-rangelist-p-of-vl-eventdecl->arrdims
- (vl-rangelist-p arrdims))
- (vl-atts-p-of-vl-eventdecl->atts
- (vl-atts-p atts))
- (vl-location-p-vl-eventdecl->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of a single event declaration."
- :long "BOZO document this
")
+ :tag :vl-eventdecl
+ :legiblep nil
+
+ ((name stringp
+ :rule-classes :type-prescription
+ "Name of the event being declared.")
+ (arrdims vl-rangelist-p
+ "Indicates that this is an array of events? Because that makes
+ sense?")
+ (atts vl-atts-p
+ "Any attributes associated with this declaration.")
+ (loc vl-location-p
+ "Where the declaration was found in the source code."))
+
+ :long "BOZO document event declarations.
")
(defenum vl-paramdecltype-p
@@ -2966,28 +2892,43 @@
")
(defaggregate vl-paramdecl
- (name expr type localp range atts loc)
- :tag :vl-paramdecl
- :legiblep nil
- :require ((stringp-of-vl-paramdecl->name
- (stringp name)
- :rule-classes :type-prescription)
- (vl-expr-p-of-vl-paramdecl->expr
- (vl-expr-p expr))
- (vl-paramdecltype-p-of-vl-paramdecl->type
- (vl-paramdecltype-p type))
- (booleanp-of-vl-paramdecl->localp
- (booleanp localp)
- :rule-classes :type-prescription)
- (vl-maybe-range-p-of-vl-paramdecl->range
- (vl-maybe-range-p range))
- (vl-atts-p-of-vl-paramdecl->atts
- (vl-atts-p atts))
- (vl-location-p-of-vl-paramdecl->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of a single @('parameter') or @('localparam')
declaration."
+ :tag :vl-paramdecl
+ :legiblep nil
+
+ ((name stringp
+ :rule-classes :type-prescription
+ "Name of the parameter being declared.")
+
+ (expr vl-expr-p
+ "Default value for this parameter.")
+
+ (type vl-paramdecltype-p
+ "Indicates the type of the parameter, e.g., @('signed'), @('integer'),
+ @('realtime'), etc.")
+
+ (localp booleanp
+ :rule-classes :type-prescription
+ "True for @('localparam') declarations, @('nil') for @('parameter')
+ declarations. The difference is apparently that @('localparam')s
+ such as @('TWICE_WIDTH') below cannot be overridden from outside
+ the module, except insofar as that they depend upon non-local
+ parameters. (These @('localparam') declarations are a way to
+ introduce named constants without polluting the @('`define')
+ namespace.)")
+
+ (range vl-maybe-range-p
+ "Some ridiculous thing allowed by the grammar and who knows what it
+ means. Some description of it in 12.2.")
+
+ (atts vl-atts-p
+ "Any attributes associated with this declaration.")
+
+ (loc vl-location-p
+ "Where the declaration was found in the source code."))
+
:long "Parameters are discussed in 12.2. Some examples of parameter
declarations include:
@@ -2997,29 +2938,7 @@
localparam TWICE_WIDTH = 2 * WIDTH;
...
endmodule
-})
-
-The @('name') of the parameter is an ordinary ACL2 @('stringp'), e.g.,
-@('WIDTH') or @('TWICE_WIDTH') in the examples above.
-
-The @('expr') is the default value for this expression.
-
-The @('type') is a @(see vl-paramdecltype-p) that might indicate the
-parameter is a signed or has a particular type (e.g., integer, realtime).
-
-The @('localp') flag is @('t') if this delaration was made with
-@('localparam'), or @('nil') if the declaration was made with @('parameter').
-The difference is apparently that @('localparam')s such as @('TWICE_WIDTH')
-cannot be overridden from outside the module, except insofar as that they
-depend upon other, non-local parameters. Apparently the use of @('localparam')
-may be useful for introducing named constants without polluting the
-@('`define') namespace.
-
-The @('range') is some ridiculous thing allowed by the grammar and who knows
-what it means. Some description of it in 12.2.
-
-The @('atts') and @('loc') should be obvious; see @(see vl-atts-p) and @(see
-vl-location-p).
")
+})")
(deflist vl-vardecllist-p (x)
(vl-vardecl-p x)
@@ -3154,25 +3073,23 @@
atoms like @('a') and @('b') in @('always @@(a or b)').")
(defaggregate vl-evatom
- (type expr)
- :tag :vl-evatom
- :legiblep nil
- :require ((vl-evatomtype-p-of-vl-evatom->type
- (vl-evatomtype-p type))
- (vl-expr-p-of-vl-evatom->expr
- (vl-expr-p expr)))
:parents (modules)
:short "A single item in an event control list."
+ :tag :vl-evatom
+ :legiblep nil
+
+ ((type vl-evatomtype-p
+ "Kind of atom, e.g., posedge, negedge, or plain.")
+
+ (expr vl-expr-p
+ "Associated expression, e.g., @('foo') for @('posedge foo')."))
+
:long "Event expressions and controls are described in Section 9.7.
We represent the expressions for an event control (see @(see
vl-eventcontrol-p)) as a list of @('vl-evatom-p') structures. Each individual
evatom is either a plain Verilog expression, or is @('posedge') or @('negedge')
-applied to a Verilog expression.
-
-The @('type') is the type of edge; see @(see vl-evatomtype-p).
-
-The @('expr') is the associated expression.
")
+applied to a Verilog expression.")
(deflist vl-evatomlist-p (x)
(vl-evatom-p x)
@@ -3182,73 +3099,66 @@
(defaggregate vl-eventcontrol
- (starp atoms)
- :tag :vl-eventcontrol
- :legiblep nil
- :require ((booleanp-of-vl-eventcontrol->star
- (booleanp starp)
- :rule-classes :type-prescription)
- (vl-evatomlist-p-of-vl-eventcontrol->atoms
- (vl-evatomlist-p atoms)))
:parents (modules)
:short "Representation of an event controller like @('@@(posedge clk)') or
@('@@(a or b)')."
+ :tag :vl-eventcontrol
+ :legiblep nil
- :long "Event controls are described in Section 9.7. We represent each
-event controller as a @('vl-eventcontrol-p') aggregates.
-
-If the @('starp') flag is @('T'), then this event control represents
-@('@@(*)').
+ ((starp booleanp
+ :rule-classes :type-prescription
+ "True to represent @('@(*)'), or @('nil') for any other kind of
+ event controller.")
+
+ (atoms vl-evatomlist-p
+ "A list of @(see vl-evatom-p)s that describe the various
+ events. Verilog allows two kinds of syntax for these lists, e.g.,
+ one can write @('@(a or b)') or @('@(a, b)'). The meaning is
+ identical in either case, so we just use a list of atoms."))
-Otherwise, @('atoms') contains a list of @(see vl-evatom-p) structures that
-describe the various events. Verilog allows two kinds of syntax for these
-lists, e.g., one can write @('@@(a or b)') or @('@@(a, b)'). The meaning is
-identical in either case, so we just use a list of atoms.
")
+ :long "Event controls are described in Section 9.7. We represent each
+event controller as a @('vl-eventcontrol-p') aggregates.
")
(defaggregate vl-delaycontrol
- (value)
- :tag :vl-delaycontrol
- :legiblep nil
- :require ((vl-expr-p-of-vl-delaycontrol->value
- (vl-expr-p value)))
:parents (modules)
:short "Representation of a delay controller like @('#6')."
+ :tag :vl-delaycontrol
+ :legiblep nil
+ ((value vl-expr-p "The expression that governs the delay amount."))
+
:long "Delay controls are described in Section 9.7. An example is
@({
#10 foo = 1; <-- The #10 is a delay control
-})
-
-The @('expr') is an expression that represents the delay.
")
+})")
(defaggregate vl-repeateventcontrol
- (expr ctrl)
- :tag :vl-repeat-eventcontrol
- :legiblep nil
- :require ((vl-expr-p-of-vl-repeateventcontrol->expr
- (vl-expr-p expr))
- (vl-eventcontrol-p-of-vl-repeateventcontrol->ctrl
- (vl-eventcontrol-p ctrl)))
:parents (modules)
:short "Representation of @('repeat') constructs in intra-assignment delays."
+ :tag :vl-repeat-eventcontrol
+ :legiblep nil
+ ((expr vl-expr-p
+ "The number of times to repeat the control, e.g., @('3') in the below
+ example.")
+
+ (ctrl vl-eventcontrol-p
+ "Says which event to wait for, e.g., @('@(posedge clk)') in the below
+ example."))
+
:long "See Section 9.7.7. These are used to represent special
intra-assignment delays, where the assignment should not occur until some
number of occurrences of an event. For instance:
@({
- a = repeat(3) @@(posedge clk) b;
+ a = repeat(3) @(posedge clk) <-- repeat expr ctrl
+ b; <-- statement to repeat
})
-The @('expr') indicates how many times to repeat, e.g., @('3') in the above
-example. The @('ctrl') is an @(see vl-eventcontrol-p) that says which event is
-being waited for.
-
BOZO Consider consolidating all of these different kinds of
controls into a single, unified representation. E.g., you could at
least extend eventcontrol with a maybe-expr that is its count, and get
rid of repeateventcontrol.
")
-
(define vl-delayoreventcontrol-p (x)
:parents (modules)
:short "BOZO document this."
@@ -3331,23 +3241,41 @@
respectivley.")
(defaggregate vl-assignstmt
- (type lvalue expr ctrl atts loc)
- :tag :vl-assignstmt
- :legiblep nil
- :require ((vl-assign-type-p-of-vl-assignstmt->type
- (vl-assign-type-p type))
- (vl-expr-p-of-vl-assignstmt->lvalue
- (vl-expr-p lvalue))
- (vl-expr-p-of-vl-assignstmt->expr
- (vl-expr-p expr))
- (vl-maybe-delayoreventcontrol-p-of-vl-assignstmt->ctrl
- (vl-maybe-delayoreventcontrol-p ctrl))
- (vl-atts-p-of-vl-assignstmt->atts
- (vl-atts-p atts))
- (vl-location-p-of-vl-assignstmt->loc
- (vl-location-p loc)))
:parents (vl-stmt-p)
:short "Representation of an assignment statement."
+ :tag :vl-assignstmt
+ :legiblep nil
+
+ ((type vl-assign-type-p
+ "Kind of assignment statement, e.g., blocking, nonblocking, etc.")
+
+ (lvalue vl-expr-p
+ "Location being assigned to. Note that the specification places
+ various restrictions on lvalues, e.g., for a procedural assignment
+ the lvalue may contain only plain variables, and bit-selects,
+ part-selects, memory words, and nested concatenations of these
+ things. We do not enforce these restrictions in
+ @('vl-assignstmt-p'), but only require that the lvalue is an
+ expression.")
+
+ (expr vl-expr-p
+ "The right-hand side expression that should be assigned to the
+ lvalue.")
+
+ (ctrl vl-maybe-delayoreventcontrol-p
+ "Control that affects when the assignment is done, if any. These
+ controls can be a delay like @('#(6)') or an event control like
+ @('@@(posedge clk)'). The rules for this are covered in Section
+ 9.2 and appear to perhaps be different depending upon the type of
+ assignment. Further coverage seems to be available in Section
+ 9.7.7.")
+
+ (atts vl-atts-p
+ "Any attributes associated with this statement.")
+
+ (loc vl-location-p
+ "Where the statement was found in the source code."))
+
:long "Assignment statements are covered in Section 9.2. There are two
major types of assignment statements.
@@ -3380,34 +3308,7 @@
})
We represent all of these kinds of assignment statements uniformly as
-@('vl-assignstmt-p') objects.
-
-The @('type') of the object is a @(see vl-assign-type-p) that says what kind
-of assignment this is.
-
-The @('lvalue') is the location being assigned to. Note that the
-specification places various restrictions on lvalues, e.g., for a procedural
-assignment the lvalue may contain only plain variables, and bit-selects,
-part-selects, memory words, and nested concatenations of these things. These
-restrictions are not enforced by @('vl-assignstmt-p'), where we only require
-that the lvalue is an expression.
-
-The @('expr') is the right-hand side expression that is being assigned to
-this lvalue.
-
-All forms of assignment may have a @('ctrl') associated with them. This
-control may be a delay control such as @('#(6)') an event control like
-@('@@(posedge clk)'), which can affect when the assignment is done. The rules
-for this are covered in Section 9.2 and appear to perhaps be different
-depending upon the type of assignment. Further coverage seems to be available
-in Section 9.7.7.
-
-The @('atts') are any attributes (see @(see vl-atts-p)) associated with the
-assignment.
-
-The @('loc') is a @(see vl-location-p) describing the origin of this
-assignment in the original Verilog sources.
")
-
+@('vl-assignstmt-p') objects.")
(defenum vl-deassign-type-p
(:vl-deassign :vl-release)
@@ -3415,64 +3316,50 @@
:short "Type of an deassignment statement.")
(defaggregate vl-deassignstmt
- (type lvalue atts)
- :tag :vl-deassignstmt
- :legiblep nil
- :require ((vl-deassign-type-p-of-vl-deassignstmt->type
- (vl-deassign-type-p type))
- (vl-expr-p-of-vl-deassignstmt->lvalue
- (vl-expr-p lvalue))
- (vl-atts-p-of-vl-deassignstmt->atts
- (vl-atts-p atts)))
:parents (vl-stmt-p)
:short "Representation of a deassign or release statement."
+ :tag :vl-deassignstmt
+ :legiblep nil
+ ((type vl-deassign-type-p)
+ (lvalue vl-expr-p)
+ (atts vl-atts-p "Any attributes associated with this statement."))
:long "Deassign and release statements are described in Section 9.3.1 and
9.3.2.
")
(defaggregate vl-enablestmt
- (id args atts)
- :tag :vl-enablestmt
- :legiblep nil
- :require ((vl-expr-p-of-vl-enablestmt->id
- (vl-expr-p id))
- (vl-exprlist-p-of-vl-enablestmt->args
- (vl-exprlist-p args))
- (vl-atts-p-of-vl-enablestmt->atts
- (vl-atts-p atts)))
:parents (vl-stmt-p)
:short "Representation of an enable statement."
-
+ :tag :vl-enablestmt
+ :legiblep nil
+ ((id vl-expr-p)
+ (args vl-exprlist-p)
+ (atts vl-atts-p "Any attributes associated with this statement."))
:long "Enable statements have an identifier (which should be either a
hierarchial identifier or a system identifier), which we represent as an
expression. They also have a list of arguments, which are expressions.
")
(defaggregate vl-disablestmt
- (id atts)
- :tag :vl-disablestmt
- :legiblep nil
- :require ((vl-expr-p-of-vl-disablestmt->id
- (vl-expr-p id))
- (vl-atts-p-of-vl-disablestmt->atts
- (vl-atts-p atts)))
:parents (vl-stmt-p)
:short "Representation of a disable statement."
-
+ :tag :vl-disablestmt
+ :legiblep nil
+ ((id vl-expr-p)
+ (atts vl-atts-p "Any attributes associated with this statement."))
:long "Disable statements are simpler and just have a hierarchial
identifier. Apparently there are no disable statements for system
identifiers.
")
-
-
(defaggregate vl-eventtriggerstmt
- (id atts)
- :tag :vl-eventtriggerstmt
- :legiblep nil
- :require ((vl-expr-p-of-vl-eventtriggerstmt->id
- (vl-expr-p id))
- (vl-atts-p-of-vl-eventtriggerstmt->atts
- (vl-atts-p atts)))
:parents (vl-stmt-p)
:short "Representation of an event trigger."
+ :tag :vl-eventtriggerstmt
+ :legiblep nil
+ ((id vl-expr-p
+ "Typically a name like @('foo') and @('bar'), but may instead be a
+ hierarchical identifier.")
+ (atts vl-atts-p
+ "Any attributes associated with this statement."))
+
:long "Event trigger statements are used to explicitly trigger named
events. They are discussed in Section 9.7.3 and looks like this:
@@ -3481,32 +3368,20 @@
-> bar[1][2][3]; // I think?
})
-The @('id') for an event trigger are the names such as @('foo') and @('bar')
-above, and may be a hierarchical identifier. We represent the @('id') as an
-expression.
-
-The @('atts') are any attributes (see @(see vl-atts-p)) associated with the
-statement.
-
BOZO are we handling the syntax correctly? What about the
expressions that can follow the trigger? Maybe they just become part of the
@('id')?
")
-
(defaggregate vl-nullstmt
- (atts)
- :tag :vl-nullstmt
- :legiblep nil
- :require ((vl-atts-p-of-vl-nullstmt->atts
- (vl-atts-p atts)))
:parents (vl-stmt-p)
:short "Representation of an empty statement."
-
+ :tag :vl-nullstmt
+ :legiblep nil
+ ((atts vl-atts-p "Any attributes associated with this statement."))
:long "We allow explicit null statements. This allows us to canonicalize
@('if') expressions so that any missing branches are turned into null
statements.
")
-
(define vl-atomicstmt-p (x)
:parents (vl-stmt-p)
:short "Representation of an atomic statement."
@@ -3740,46 +3615,73 @@
(defaggregate vl-compoundstmt
- (type exprs stmts name decls ctrl sequentialp casetype atts)
+ :parents (vl-stmt-p)
+ :short "Representation of a compound statement."
:tag :vl-compoundstmt
:legiblep nil
- :require ((vl-compoundstmttype-p-of-vl-compoundstmt->type
- (vl-compoundstmttype-p type))
- (vl-exprlist-p-of-vl-compoundstmt->exprs
- (vl-exprlist-p exprs))
- ;; no requirements on stmts due to mutual recursion
- (vl-maybe-string-p-of-vl-compoundstmt->name
- (vl-maybe-string-p name)
- :rule-classes ((:type-prescription)
- (:rewrite :corollary
- (implies (force (vl-compoundstmt-p x))
- (equal (stringp (vl-compoundstmt->name x))
- (if (vl-compoundstmt->name x)
- t
- nil))))))
- (vl-blockitemlist-p-of-vl-compoundstmt->decls
- (vl-blockitemlist-p decls))
- (vl-maybe-delayoreventcontrol-p-of-vl-compoundstmt->ctrl
- (vl-maybe-delayoreventcontrol-p ctrl)
- :rule-classes ((:rewrite)
- (:rewrite
- :corollary
- (implies (force (vl-compoundstmt-p x))
- (iff (vl-delayoreventcontrol-p (vl-compoundstmt->ctrl x))
- (vl-compoundstmt->ctrl x))))))
- (booleanp-of-vl-compoundstmt->sequentialp
- (booleanp sequentialp)
- :rule-classes :type-prescription)
- (vl-casetype-p-of-vl-compoundstmt->casetype
- (vl-casetype-p casetype))
- (vl-atts-p-of-vl-compoundstmt->atts
- (vl-atts-p atts))
- (vl-compoundstmt-basic-checksp-of-vl-compoundstmt
- (vl-compoundstmt-basic-checksp type exprs stmts name decls
- ctrl sequentialp casetype)))
- :parents (vl-stmt-p)
+ ((type vl-compoundstmttype-p
+ "Keyword symbol that says what kind of statement this is,
+ e.g., an @('if') statement, @('while') loop, etc.")
+
+ (exprs vl-exprlist-p
+ "A list of expressions associated with the statement. Some
+ statements (e.g., @('begin ... end') blocks) have no
+ expressions, but other statements, such as @('if'),
+ @('while'), and @('case') statements, may have one or many.")
+
+ (stmts "Any sub-statements that are associated with the statement.
+ Every kind of compound statement may have sub-statements,
+ since otherwise it would be an atomic statement. Note that
+ there is no restriction on @('stmts') in
+ @('vl-compoundstmt-p') itself due to mutual recursion; see
+ @(see vl-stmt-p).")
+
+ (name vl-maybe-string-p
+ :rule-classes
+ ((:type-prescription)
+ (:rewrite :corollary
+ (implies (force (vl-compoundstmt-p x))
+ (equal (stringp (vl-compoundstmt->name x))
+ (if (vl-compoundstmt->name x)
+ t
+ nil)))))
+ "Only valid on block statements (i.e., @('begin ... end') and
+ @('fork ... join') statements). If present, it is a string
+ that names this block.")
+
+ (decls vl-blockitemlist-p
+ "Only valid on block statements. Contains any declarations for
+ the block; see @(see vl-blockitem-p).")
+
+ (ctrl vl-maybe-delayoreventcontrol-p
+ :rule-classes
+ ((:rewrite)
+ (:rewrite
+ :corollary
+ (implies (force (vl-compoundstmt-p x))
+ (iff (vl-delayoreventcontrol-p (vl-compoundstmt->ctrl x))
+ (vl-compoundstmt->ctrl x)))))
+ "Only valid on procedural timing control statements like
+ @('@(posedge clk) substmt') or @('#6 substmt'). If present,
+ describes what to wait for, e.g., this is the @('@(posedge
+ clk)') or @('#6') part.")
+
+ (sequentialp booleanp
+ :rule-classes :type-prescription
+ "Only valid on block statements. This is @('t') for a
+ @('begin/end') block, or @('nil') if this is a @('fork/join')
+ block.")
+
+ (casetype vl-casetype-p
+ "Only valid on case statements. Indicates whether this is a
+ @('case'), @('casex'), or @('casez') statement.")
- :short "Representation of a compound statement."
+ (atts vl-atts-p
+ "Any attributes associated with this statement."))
+ :require
+ ((vl-compoundstmt-basic-checksp-of-vl-compoundstmt
+ (vl-compoundstmt-basic-checksp type exprs stmts name decls
+ ctrl sequentialp casetype)))
:long "Introduction
@@ -3801,45 +3703,6 @@
together is that we can recur over statements while largely ignoring their
actual types, etc., making the mutually recursive scheme much simpler.
-Field Descriptions
-
-The @('type') is keyword symbol that says what kind of statement this is,
-e.g., an @('if') or @('casez') statement. The @('type') must be one of the
-types recognized by @(see vl-compoundstmttype-p).
-
-The @('exprs') are a list of expressions associated with the statement.
-Some statements (e.g., @('begin ... end') blocks) have no expressions, but
-other statements, such as @('if'), @('while'), and @('case') statements, may
-have one or many.
-
-The @('stmts') are any sub-statements that are associated with the
-statement. Every kind of compound statement may have sub-statements, since
-otherwise it would be an atomic statement.
-
-The @('name') is only valid on block statements (i.e., @('begin ... end')
-and @('fork ... join') statements). If present, it is a string that names this
-block.
-
-The @('decls') are only valid on block statements, and includes any
-declarations for the block; see @(see vl-blockitem-p).
-
-The @('sequentialp') flag is only valid on block statements, and is @('t')
-if this is a @('begin/end') block, or @('nil') if this is a @('fork/join')
-block.
-
-The @('casetype') is only valid on case statements, and indicates whether
-this is a @('case'), @('casex'), or @('casez') statement; see @(see
-vl-casetype-p).
-
-The @('ctrl') is only valid on procedural timing control statements such as
-@('@@(posedge clk) substmt') or @('#6 substmt'). If present, it should be
-either a @(see vl-eventcontrol-p) that describes what event to wait for, e.g.,
-\"@('posedge clk')\", or a @(see vl-delaycontrol-p) that says how long to
-delay, e.g., \"@('#6')\".
-
-The @('atts') are any attributes
-associated with the statement.
-
Basic Well-Formedness Checks
A \"problem\" with using a combined representation is that, for instance, an
@@ -3915,9 +3778,9 @@
(vl-stmtlist-p (cdr x)))
t)))
- ;; I'm not exactly sure what to put here, and what to put in mu-stmt-tools.
- ;; I'm going to try to keep most stuff in mu-stmt-tools, and just leave a
- ;; few basics here.
+ ;; I'm not exactly sure what to put here, and what to put in mlib/stmt-tools.
+ ;; I'm going to try to keep most stuff in stmt-tools, and just leave a few
+ ;; basics here.
(FLAG::make-flag vl-flag-stmt-p
vl-stmt-p
@@ -4041,7 +3904,6 @@
(mbe :logic (vl-enablestmt-p x)
:exec (eq (tag x) :vl-enablestmt)))
-
(define vl-atomicstmt->atts ((x vl-atomicstmt-p))
:returns (atts vl-atts-p :hyp :fguard)
:parents (vl-atomicstmt-p vl-stmt->atts)
@@ -4079,17 +3941,19 @@
; attributes.
(defaggregate vl-initial
- (stmt atts loc)
- :tag :vl-initial
- :legiblep nil
- :require ((vl-stmt-p-of-vl-initial->stmt
- (vl-stmt-p stmt))
- (vl-atts-p-of-vl-initial->atts
- (vl-atts-p atts))
- (vl-location-p-of-vl-initial->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of an initial statement."
+ :tag :vl-initial
+ :legiblep nil
+
+ ((stmt vl-stmt-p
+ "Represents the actual statement, e.g., @('r = 0') below.")
+
+ (atts vl-atts-p
+ "Any attributes associated with this @('initial') block.")
+
+ (loc vl-location-p
+ "Where the initial block was found in the source code."))
:long "
Initial statements in Verilog are used to set up initial values for
simulation. For instance,
@@ -4101,51 +3965,27 @@
endmodule
})
-
-
-The @('stmt') is a @(see vl-stmt-p) that represents the actual statement,
-e.g., @('r = 0') above. Such a statement is frequently a sequential block
-statement (i.e., @('begin ... end')), but as shown above it can be
-anything.
-
-The @('atts') are any attribute (see @(see vl-atts-p)) associated with this
-initial statement.
-
-The @('loc') is a @(see vl-location-p) that describes where this initial
-statement was read from in the source code.
-
-
-
BOZO Our plan is to eventually generate @('initial') statements from
register and variable declarations with initial values, i.e., @('reg r =
-0;').
"
-
- :rest
- (
- ;; (defthm acl2-count-of-vl-initial->stmt
- ;; (and (<= (acl2-count (vl-initial->stmt x))
- ;; (acl2-count x))
- ;; (implies (consp x)
- ;; (< (acl2-count (vl-initial->stmt x))
- ;; (acl2-count x))))
- ;; :hints(("Goal" :in-theory (enable vl-initial->stmt)))
- ;; :rule-classes ((:rewrite) (:linear)))
- ))
-
+0;').")
(defaggregate vl-always
- (stmt atts loc)
- :tag :vl-always
- :legiblep nil
- :require ((vl-stmt-p-of-vl-always->stmt
- (vl-stmt-p stmt))
- (vl-atts-p-of-vl-always->atts
- (vl-atts-p atts))
- (vl-location-p-of-vl-always->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of an always statement."
+ :tag :vl-always
+ :legiblep nil
+
+ ((stmt vl-stmt-p
+ "The actual statement, e.g., @('@(posedge clk) myreg <= in')
+ below. The statement does not have to include a timing control like
+ @('@(posedge clk)') or @('@(a or b or c)'), but often does.")
+
+ (atts vl-atts-p
+ "Any attributes associated with this @('always') block.")
+
+ (loc vl-location-p
+ "Where the always block was found in the source code."))
:long "Always statements in Verilog are often used to model latches and
flops, and to set up other simulation events. A simple example would be:
@@ -4154,34 +3994,7 @@
module mymod (a, b, ...) ;
always @@(posedge clk) myreg <= in;
endmodule
-})
-
-
-
-The @('stmt') is a @(see vl-stmt-p) that represents the actual statement,
-e.g., @('@@(posedge clk) myreg <= in') above. Such a statement need not have a
-timing control such as @('@@(posedge clk)') or @('@@(a or b or c)'), but often
-does.
-
-The @('atts') are any attribute (see @(see vl-atts-p)) associated with this
-always statement.
-
-The @('loc') is a @(see vl-location-p) that describes where this always
-statement was read from in the source code.
-
- "
-
- :rest
- (
- ;; (defthm acl2-count-of-vl-always->stmt
- ;; (and (<= (acl2-count (vl-always->stmt x))
- ;; (acl2-count x))
- ;; (implies (consp x)
- ;; (< (acl2-count (vl-always->stmt x))
- ;; (acl2-count x))))
- ;; :hints(("Goal" :in-theory (enable vl-always->stmt)))
- ;; :rule-classes ((:rewrite) (:linear))))
- ))
+})")
(deflist vl-initiallist-p (x)
(vl-initial-p x)
@@ -4235,26 +4048,51 @@
Likewise, the inputs to Verilog functions use these same kinds of
types.
")
-
(defaggregate vl-taskport
- (name dir type range atts loc)
- :tag :vl-taskport
- :legiblep nil
- :require ((stringp-of-vl-taskport->name
- (stringp name)
- :rule-classes :type-prescription)
- (vl-direction-p-of-vl-taskport->dir
- (vl-direction-p dir))
- (vl-taskporttype-p-of-vl-taskport->type
- (vl-taskporttype-p type))
- (vl-maybe-range-p-of-vl-taskport->range
- (vl-maybe-range-p range))
- (vl-atts-p-of-vl-taskport->atts
- (vl-atts-p atts))
- (vl-location-p-of-vl-taskport->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of a task port or a function input."
+ :tag :vl-taskport
+ :legiblep nil
+
+ ((name stringp
+ :rule-classes :type-prescription
+ "The name of this task port.")
+
+ (dir vl-direction-p
+ :rule-classes
+ ((:rewrite)
+ (:type-prescription
+ :corollary
+ (implies (force (vl-taskport-p x))
+ (and (symbolp (vl-taskport->dir x))
+ (not (equal (vl-taskport->dir x) t))
+ (not (equal (vl-taskport->dir x) nil))))))
+ "Says whether this is an input, output, or inout port. Note that
+ tasks can have all three kinds of ports, but functions only have
+ inputs.")
+
+ (type vl-taskporttype-p
+ :rule-classes
+ ((:rewrite)
+ (:type-prescription
+ :corollary
+ (implies (force (vl-taskport-p x))
+ (and (symbolp (vl-taskport->type x))
+ (not (equal (vl-taskport->type x) t))
+ (not (equal (vl-taskport->type x) nil))))))
+ "Says what kind of port this is, i.e., @('integer'), @('real'),
+ etc.")
+
+ (range vl-maybe-range-p
+ "The size of this input. A range only makes sense when the type is
+ @(':vl-unsigned') or @(':vl-signed'). It should be @('nil') when
+ other types are used.")
+
+ (atts vl-atts-p
+ "Any attributes associated with this input.")
+
+ (loc vl-location-p
+ "Where this input was found in the source code."))
:long "Verilog tasks have ports that are similar to the ports of a module.
We represent these ports with their own @('vl-taskport-p') structures, rather
@@ -4263,43 +4101,7 @@
While Verilog functions don't have @('output') or @('inout') ports, they do
have input ports that are very similar to task ports. So, we reuse
-@('vl-taskport-p') structures for function inputs.
-
-The @('name') is just a string that is the name of this port.
-
-The @('dir') is a @(see vl-direction-p) that says whether this port is an
-input, output, or inout port. Note that tasks can have all three kinds of
-ports, but functions only have inputs.
-
-The @('type') is a @(see vl-taskporttype-p) that gives the type for this
-input.
-
-The @('range') is a @(see vl-maybe-range-p) that gives the size of this
-input. This only makes sense when the type is @(':vl-unsigned') or
-@(':vl-signed'), and is @('nil') when other types are used.
-
-The @('atts') are any attributes (see @(see vl-atts-p)) associated with this
-input. Syntactically, the attributes come before the @('input') keyword.
-
-The @('loc') is the @(see vl-location-p) where the @('name') of the function
-was found in the source code. We use this location, instead of the location of
-the input keyword, because a list of inputs can be declared using the same
-input keyword.
"
-
- :rest
- ((defthm type-of-vl-taskport->dir
- (implies (force (vl-taskport-p x))
- (and (symbolp (vl-taskport->dir x))
- (not (equal (vl-taskport->dir x) t))
- (not (equal (vl-taskport->dir x) nil))))
- :rule-classes :type-prescription)
-
- (defthm type-of-vl-taskport->type
- (implies (force (vl-taskport-p x))
- (and (symbolp (vl-taskport->type x))
- (not (equal (vl-taskport->type x) t))
- (not (equal (vl-taskport->type x) nil))))
- :rule-classes :type-prescription)))
+@('vl-taskport-p') structures for function inputs.")
(deflist vl-taskportlist-p (x)
(vl-taskport-p x)
@@ -4315,31 +4117,64 @@
(defaggregate vl-fundecl
- (name automaticp rtype rrange inputs decls body atts loc)
- :tag :vl-fundecl
- :legiblep nil
- :require ((stringp-of-vl-fundecl->name
- (stringp name)
- :rule-classes :type-prescription)
- (booleanp-of-vl-fundecl->automaticp
- (booleanp automaticp)
- :rule-classes :type-prescription)
- (vl-taskporttype-p-of-vl-fundecl->rtype
- (vl-taskporttype-p rtype))
- (vl-maybe-range-p-of-vl-fundecl->rrange
- (vl-maybe-range-p rrange))
- (vl-taskportlist-p-of-vl-fundecl->inputs
- (vl-taskportlist-p inputs))
- (vl-blockitemlist-p-of-vl-fundecl->decls
- (vl-blockitemlist-p decls))
- (vl-stmt-p-of-vl-fundecl->body
- (vl-stmt-p body))
- (vl-atts-p-of-vl-fundecl->atts
- (vl-atts-p atts))
- (vl-location-p-of-vl-fundecl->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of a single Verilog function."
+ :tag :vl-fundecl
+ :legiblep nil
+
+ ((name stringp
+ :rule-classes :type-prescription
+ "Name of this function, e.g., @('lower_bits') below.")
+
+ (automaticp booleanp
+ :rule-classes :type-prescription
+ "Says whether the @('automatic') keyword was provided. This
+ keyword indicates that the function should be reentrant and
+ have its local parameters dynamically allocated for each
+ function call, with various consequences.")
+
+ (rtype vl-taskporttype-p
+ "Return type of the function, e.g., a function might return an
+ ordinary unsigned or signed result of some width, or might
+ return a @('real') value, etc. For instance, the return type
+ of @('lower_bits') below is @(':vl-unsigned').")
+
+ (rrange vl-maybe-range-p
+ "Range for the function's return value. This only makes sense
+ when the @('rtype') is @(':vl-unsigned') or @(':vl-signed').
+ For instance, the return range of @('lower_bits') below is
+ @('[7:0]').")
+
+ (inputs vl-taskportlist-p
+ "The arguments to the function, e.g., @('input [7:0] a') below.
+ Functions must have at least one input. We check this in our
+ parser, but we don't syntactically enforce this requirement in
+ the @('vl-fundecl-p') structure. Furthermore, functions may
+ only have inputs (i.e., they can't have outputs or inouts), but
+ our @(see vl-taskport-p) structures have a direction. This
+ direction should always be @(':vl-input') for a function's
+ input; we again check this in our parser, but not in the
+ @('vl-fundecl-p') structure itself.")
+
+ (decls vl-blockitemlist-p
+ "Any local variable declarations for the function, e.g., the
+ declarations of @('lowest_pair') and @('next_lowest_pair')
+ below. We represent the declarations as an ordinary @(see
+ vl-blockitemlist-p), and it appears that it may even contain
+ event declarations, parameter declarations, etc., which seems
+ pretty absurd.")
+
+ (body vl-stmt-p
+ "The body of the function. We represent this as an ordinary statement,
+ but it must follow certain rules as outlined in 10.4.4, e.g.,
+ it cannot have any time controls, cannot enable tasks, cannot
+ have non-blocking assignments, etc.")
+
+ (atts vl-atts-p
+ "Any attributes associated with this function declaration.")
+
+ (loc vl-location-p
+ "Where this declaration was found in the source code."))
:long "Functions are described in Section 10.4 of the standard. An
example of a function is:
@@ -4358,72 +4193,7 @@
})
Note that functions don't have any inout or output ports. Instead, you
-assign to a function's name to indicate its return value.
-
-Representation of Functions
-
-The @('name') is a string that names the function, e.g.,
-@('\"lower_bits\"').
-
-The @('automaticp') flag says whether the @('automatic') keyword was
-provided. This keyword indicates that the function should be reentrant and
-have its local parameters dynamically allocated for each function call, with
-various consequences.
-
-The @('rtype') is a @(see vl-taskporttype-p) that describes the return type
-of the function, e.g., a function might return an ordinary unsigned or signed
-result of some width, or might return a @('real') value, etc. For instance,
-the return type of @('lower_bits') is @(':vl-unsigned').
-
-The @('rrange') is a @(see vl-maybe-range-p) that describes the width of the
-function's result. This only makes sense when the @('rtype') is
-@(':vl-unsigned') or @(':vl-signed'). For instance, the return range of
-@('lower_bits') is @('[7:0]').
-
-The @('inputs') are the arguments to the function, e.g., @('input [7:0] a')
-above. We represent these inputs as an @(see vl-taskportlist-p). There are a
-couple of things to note here:
-
-
-
-Functions must have at least one input. We check this in our parser, but
-we don't syntactically enforce this requirement in the @('vl-fundecl-p')
-structure.
-
-Functions only have inputs (i.e., they don't have outputs or inouts), but
-our @(see vl-taskport-p) structures have a direction. This direction should
-always be @(':vl-input') for a function's input. We again check this in our
-parser, but not in the @('vl-fundecl-p') structure itself.
-
-
-
-The @('decls') are the local variable declarations for the function, e.g.,
-the declarations of @('lowest_pair') and @('next_lowest_pair') above. We
-represent the declarations as an ordinary @(see vl-blockitemlist-p), and it
-appears that it may even contain event declarations, parameter declarations,
-etc., which seems pretty absurd.
-
-The @('body') is a @(see vl-stmt-p) that gives the body of the function. We
-represent this as an ordinary statement, but it must follow certain rules as
-outlined in 10.4.4, e.g., it cannot have any time controls, cannot enable
-tasks, cannot have non-blocking assignments, etc.
-
-The @('atts') are any attributes (see @(see vl-atts-p)) associated with this
-function. The attributes come before the @('function') keyword.
-
-The @('loc') is the @(see vl-location-p) where the @('function') keyword was
-found in the source code.
"
-
- ;; :rest
- ;; ((defthm acl2-count-of-vl-fundecl->body
- ;; (and (<= (acl2-count (vl-fundecl->body x))
- ;; (acl2-count x))
- ;; (implies (consp x)
- ;; (< (acl2-count (vl-fundecl->body x))
- ;; (acl2-count x))))
- ;; :hints(("Goal" :in-theory (enable vl-fundecl->body)))
- ;; :rule-classes ((:rewrite) (:linear)))))
- )
+assign to a function's name to indicate its return value.")
(deflist vl-fundecllist-p (x)
(vl-fundecl-p x)
@@ -4439,27 +4209,41 @@
(defaggregate vl-taskdecl
- (name automaticp ports decls body atts loc)
- :tag :vl-taskdecl
- :legiblep nil
- :require ((stringp-of-vl-taskdecl->name
- (stringp name)
- :rule-classes :type-prescription)
- (booleanp-of-vl-taskdecl->automaticp
- (booleanp automaticp)
- :rule-classes :type-prescription)
- (vl-taskportlist-p-of-vl-taskdecl->ports
- (vl-taskportlist-p ports))
- (vl-blockitemlist-p-of-vl-taskdecl->decls
- (vl-blockitemlist-p decls))
- (vl-stmt-p-of-vl-taskdecl->body
- (vl-stmt-p body))
- (vl-atts-p-of-vl-taskdecl->atts
- (vl-atts-p atts))
- (vl-location-p-of-vl-taskdecl->loc
- (vl-location-p loc)))
:parents (modules)
:short "Representation of a single Verilog task."
+ :tag :vl-taskdecl
+ :legiblep nil
+
+ ((name stringp
+ :rule-classes :type-prescription
+ "The name of this task.")
+
+ (automaticp booleanp
+ :rule-classes :type-prescription
+ "Says whether the @('automatic') keyword was provided. This
+ keyword indicates that each invocation of the task has its own
+ copy of its variables. For instance, the task below had
+ probably better be automatic if it there are going to be
+ concurrent instances of it running, since otherwise @('temp')
+ could be corrupted by the other task.")
+
+ (ports vl-taskportlist-p
+ "The input, output, and inout ports for the task.")
+
+ (decls vl-blockitemlist-p
+ "Any local declarations for the task, e.g., for the task below,
+ the declaration of @('temp') would be found here.")
+
+ (body vl-stmt-p
+ "The statement that gives the actions for this task, i.e., the
+ entire @('begin/end') statement in the below task.")
+
+ (atts vl-atts-p
+ "Any attributes associated with this task declaration.")
+
+ (loc vl-location-p
+ "Where this task was found in the source code."))
+
:long "Tasks are described in Section 10.2 of the standard. An example
of a task is:
@@ -4483,33 +4267,7 @@
Tasks are somewhat like functions ,
but they can have fewer restrictions, e.g., they can have multiple outputs, can
-include delays, etc.
-
-Representation of Tasks
-
-The @('name') is a string that names the function, e.g.,
-@('\"dostuff\"').
-
-The @('automaticp') flag says whether the @('automatic') keyword was
-provided. This keyword indicates that each invocation of the task has its own
-copy of its variables. For instance, the task above had probably better be
-automatic if it there are going to be concurrent instances of it running, or
-else @('temp') could be corrupted by the other task.
-
-The @('ports') of the task are a @(see vl-taskportlist-p) that says what the
-inputs, outputs, and inouts of the task are.
-
-The @('decls') are a @(see vl-blockitemlist-p) with the local declarations
-for the task, e.g., the declaration of @('temp') would be found here.
-
-The @('body') is a @(see vl-stmt-p) that gives the body of the function. We
-represent this as an ordinary statement.
-
-The @('atts') are any attributes (see @(see vl-atts-p)) associated with this
-task. The attributes come before the @('task') keyword.
-
-The @('loc') is the @(see vl-location-p) where the @('task') keyword was
-found in the source code.
")
+include delays, etc.")
(deflist vl-taskdecllist-p (x)
(vl-taskdecl-p x)
@@ -4525,178 +4283,111 @@
(defaggregate vl-module
- (name
- params
- ports
- portdecls
- assigns
- netdecls
- vardecls
- regdecls
- eventdecls
- paramdecls
- fundecls
- taskdecls
- modinsts
- gateinsts
- alwayses
- initials
- atts
- minloc
- maxloc
- origname
- warnings
- comments
- esim
- )
- :tag :vl-module
- :legiblep nil
- :require
- ((stringp-of-vl-module->name
- (stringp name)
- :rule-classes :type-prescription)
-
- ;; BOZO add params?
- (vl-portlist-p-of-vl-module->ports (vl-portlist-p ports))
- (vl-portdecllist-p-of-vl-module->portdecls (vl-portdecllist-p portdecls))
- (vl-assignlist-p-of-vl-module->assigns (vl-assignlist-p assigns))
- (vl-netdecllist-p-of-vl-module->netdecls (vl-netdecllist-p netdecls))
- (vl-vardecllist-p-of-vl-module->vardecls (vl-vardecllist-p vardecls))
- (vl-regdecllist-p-of-vl-module->regdecls (vl-regdecllist-p regdecls))
- (vl-eventdecllist-p-of-vl-module->eventdecls (vl-eventdecllist-p eventdecls))
- (vl-paramdecllist-p-of-vl-module->paramdecls (vl-paramdecllist-p paramdecls))
- (vl-fundecllist-p-of-vl-module->fundecls (vl-fundecllist-p fundecls))
- (vl-taskdecllist-p-of-vl-module->taskdecls (vl-taskdecllist-p taskdecls))
- (vl-modinstlist-p-of-vl-module->modinsts (vl-modinstlist-p modinsts))
- (vl-gateinstlist-p-of-vl-module->gateinsts (vl-gateinstlist-p gateinsts))
- (vl-alwayslist-p-of-vl-module->alwayses (vl-alwayslist-p alwayses))
- (vl-initiallist-p-of-vl-module->initials (vl-initiallist-p initials))
- (vl-atts-p-of-vl-module->atts (vl-atts-p atts))
- (vl-location-p-of-vl-module->minloc (vl-location-p minloc))
- (vl-location-p-of-vl-module->maxloc (vl-location-p maxloc))
-
- (stringp-of-vl-module->origname
- (stringp origname)
- :rule-classes :type-prescription)
-
- (vl-warninglist-p-of-vl-module->warnings (vl-warninglist-p warnings))
- (vl-commentmap-p-of-vl-module->comments (vl-commentmap-p comments))
- )
:parents (modules)
:short "Representation of a single module."
+ :tag :vl-module
+ :legiblep nil
- :long "This is our representation for a single module. There are
-many fields.
-
-Semantically Meaningful Fields
-
-The @('name') is the name of this module as a string. The name is used to
-instantiate this module, so generally we require that modules in our list have
-unique names. A module's name is initially set when it is parsed, but is not
-guaranteed to remain fixed throughout simplification. In particular, it is
-currently changed during @(see unparameterization), e.g., a module named
-@('adder') may be renamed to @('adder$size=12'). We may also wish to change
-module names it in other, future transformations.
-
-Ports and Parameters
-
-The @('ports') are a list of @(see vl-port-p) objects that describe the
-module's ports, i.e., @('a'), @('b'), and @('c') in @('module
-mod(a,b,c);').
-
-The @('portdecls') are a list of @(see vl-portdecl-p) objects that describe
-the input, output, and inout declarations for this module, e.g., @('input [3:0]
-a;').
-
-The @('paramdecls') are a list of @(see vl-paramdecl-p) objects that
-describe all of the parameter declarations for this module, e.g., @('parameter
-width = 1;').
-
-
-Other Declarations
-
-The @('netdecls') are a list of @(see vl-netdecl-p) objects that describe
-all of the wire declarations such as @('wire [3:0] w;') and @('tri v;'). Note
-that registers and variables (integer, real, ...) are kept separately.
-
-The @('regdecls') are a list of @(see vl-regdecl-p) objects that describe
-all register declarations like @('reg [3:0] r;').
-
-The @('vardecls') are a list of @(see vl-vardecl-p) objects that describe
-all variable declarations like @('integer i;') and @('real foo;').
-
-The @('eventdecls') are a list of @(see vl-eventdecl-p) objects that
-describe any events for the module.
-
-The @('fundecls') are a list of @(see vl-fundecl-p) objects that describe
-any functions for the module.
-
-
-
-Assignments and Instances
-
-The @('assigns') are a list of @(see vl-assign-p) objects that describe the
-continuous assignments in this module, e.g., @('assign lhs = rhs;').
-
-The @('modinsts') are a list of @(see vl-modinst-p) objects that describe
-all submodule (or user-defined primitive) instances in this module, e.g.,
-@('adder my_adder1 (...);').
-
-The @('gateinsts') are a list of @(see vl-gateinst-p) objects that describe
-any primitive gate instances in this module, e.g., @('and (o, a, b);').
-
-
-Statements
-
-The @('alwayses') are a list of @(see vl-always-p) objects that describe any
-@('always') statements found in the module.
-
-The @('initials') are a list of @(see vl-initial-p) objects that describe
-any @('initial') statements found in the module.
-
-
-Miscellaneous
-
-The @('params') are any @('defparam') statements found in the module. BOZO
-eventually provide better support for this and document the structure of these
-defparams.
-
-The @('warnings') for a module is an @(see warnings) accumulator that stores
-any problems we have with this module. Warnings are semantically meaningful
-only in that any fatal warning indicates the module is invalid and
-should not be discarded. The list of warnings may be extended by any
-transformation or well-formedness check.
-
-
-Semantically Irrelevant Fields
-
-The @('origname') of a module is its original name in the source code (a
-string). It is set at parse-time, and is expected to remain fixed throughout
-all simplifications. That is, while a module named @('adder') might be renamed
-to @('adder$size=12') during unparameterization, its origname will always be
-@('adder'). The @('origname') is only intended to be used for display purposes
-such as hyperlinking.
-
-The @('minloc') and @('maxloc') fields are @(see vl-location-p) objects that
-describe the locations of the @('module') and @('endmodule') keywords that we
-encountered when parsing this module. These fields remain fixed throughout the
-simplification process, and are mainly useful for displaying the module.
-
-The @('atts') are a @(see vl-atts-p) object for any @('(* ... *)')-style
-attributes associated with this module. This list is initially set at parse
-time, and may be consulted or extended by transformations.
-
-The @('comments') field is a @(see vl-commentmap-p) that maps locations to
-source-code comments that occurred in this module. We expect that comments are
-never consulted for any semantic content, and this field is mainly intended for
-displaying the transformed module with comments preserved.
-
-
-Fields for E Translation
-
-The @('esim') field is a temporary/historic artifact used in the translation
-to @(see esim). This is in flux so I'm not going to document it right
-now.
")
+ ((name stringp
+ :rule-classes :type-prescription
+ "The name of this module as a string. The name is used to
+ instantiate this module, so generally we require that modules
+ in our list have unique names. A module's name is initially
+ set when it is parsed, but it may not remain fixed throughout
+ simplification. For instance, during @(see unparameterization)
+ a module named @('adder') might become @('adder$size=12').")
+
+ (params "Any @('defparam') statements for this module. BOZO these are
+ bad form anyway, but eventually we should provide better
+ support for them and proper structures.")
+
+ (ports vl-portlist-p
+ "The module's ports list, i.e., @('a'), @('b'), and @('c') in
+ @('module mod(a,b,c);').")
+
+ (portdecls vl-portdecllist-p
+ "The input, output, and inout declarations for this module,
+ e.g., @('input [3:0] a;').")
+
+ (netdecls vl-netdecllist-p
+ "Wire declarations like @('wire [3:0] w;') and @('tri v;').
+ Does not include registers and variables (integer, real,
+ ...).")
+
+ (vardecls vl-vardecllist-p
+ "Variable declarations like @('integer i;') and @('real
+ foo;').")
+
+ (regdecls vl-regdecllist-p
+ "Register declarations like @('reg [3:0] r;').")
+
+ (eventdecls vl-eventdecllist-p
+ "Event declarations like @('event foo ...')")
+
+ (paramdecls vl-paramdecllist-p
+ "The parameter declarations for this module, e.g., @('parameter
+ width = 1;').")
+
+ (fundecls vl-fundecllist-p
+ "Function declarations like @('function f ...').")
+
+ (taskdecls vl-taskdecllist-p
+ "Task declarations, e.g., @('task foo ...').")
+
+ (assigns vl-assignlist-p
+ "Top-level continuous assignments like @('assign lhs = rhs;').")
+
+ (modinsts vl-modinstlist-p
+ "Instances of modules and user-defined primitives, e.g.,
+ @('adder my_adder1 (...);').")
+
+ (gateinsts vl-gateinstlist-p
+ "Instances of primitive gates, e.g., @('and (o, a, b);').")
+
+ (alwayses vl-alwayslist-p
+ "Always blocks like @('always @(posedge clk) ...').")
+
+ (initials vl-initiallist-p
+ "Initial blocks like @('initial begin ...').")
+
+ (atts vl-atts-p
+ "Any attributes associated with this top-level module.")
+
+ (minloc vl-location-p
+ "Where we found the @('module') keyword for this module, i.e.,
+ the start of this module's source code.")
+
+ (maxloc vl-location-p
+ "Where we found the @('endmodule') keyword for this module, i.e.,
+ the end of this module's source code.")
+
+ (origname stringp
+ :rule-classes :type-prescription
+ "Original name of the module from parse time. Unlike the
+ module's @('name'), this is meant to remain fixed throughout
+ all simplifications. That is, while a module named @('adder')
+ might be renamed to @('adder$size=12') during @(see
+ unparameterization), its origname will always be @('adder').
+ The @('origname') is only intended to be used for display
+ purposes such as hyperlinking.")
+
+ (warnings vl-warninglist-p
+ "A @(see warnings) accumulator that stores any problems we have
+ with this module. Warnings are semantically meaningful only in
+ that any fatal warning indicates the module is invalid
+ and should not be discarded. The list of warnings may be
+ extended by any transformation or well-formedness check.")
+
+ (comments vl-commentmap-p
+ "A map from locations to source-code comments that occurred in
+ this module. We expect that comments are never consulted for
+ any semantic meaning. This field is mainly intended for
+ displaying the transformed module with comments preserved,
+ e.g., see @(see vl-ppc-module).")
+
+ (esim "This is meant to be @('nil') until @(see esim) conversion, at
+ which point it becomes the E module corresponding to this
+ VL module.")))
(deflist vl-modulelist-p (x)
(vl-module-p x)
@@ -4704,7 +4395,7 @@
:parents (modules))
(defthm vl-module-identity
- ;; This is occaisonally useful when we want to prove that some optimized
+ ;; This is occasionally useful when we want to prove that some optimized
;; version of a transform, that doesn't re-cons the module, is equivalent to
;; the naive version that does.
(implies (vl-module-p x)
@@ -4716,8 +4407,9 @@
:in-theory (union-theories
(union-theories (current-theory :here)
'(vl-module-p vl-module))
- (b* ((fields (cutil::get-aggregate-fields 'vl-module world)))
- (cutil::da-accessor-names 'vl-module fields))))))
+ (b* (((cutil::agginfo agg)
+ (cutil::get-aggregate 'vl-module world)))
+ (cutil::da-accessor-names 'vl-module agg.fields))))))
(define vl-module->hands-offp ((x vl-module-p))
:inline t
diff -Nru acl2-6.2/books/centaur/vl/portcullis.acl2 acl2-6.3/books/centaur/vl/portcullis.acl2
--- acl2-6.2/books/centaur/vl/portcullis.acl2 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/portcullis.acl2 2013-09-30 17:53:10.000000000 +0000
@@ -20,6 +20,11 @@
(in-package "ACL2")
(ld "package.lsp")
-(ld "other-packages.lsp")
+(ld "data-structures/define-u-package.lsp" :dir :system)
+(ld "tools/flag-package.lsp" :dir :system)
+(ld "cowles/packages.lsp" :dir :system)
+(include-book "str/portcullis" :dir :system)
+(include-book "xdoc/portcullis" :dir :system)
+(include-book "centaur/getopt/portcullis" :dir :system)
; cert-flags: ? t :ttags :all
-(certify-book "portcullis" ? t :ttags :all)
+
diff -Nru acl2-6.2/books/centaur/vl/portcullis.lisp acl2-6.3/books/centaur/vl/portcullis.lisp
--- acl2-6.2/books/centaur/vl/portcullis.lisp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/portcullis.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -26,7 +26,6 @@
(include-book "tools/safe-case" :dir :system)
(include-book "xdoc/top" :dir :system)
-(include-book "clause-processors/autohide" :dir :system)
(include-book "tools/rulesets" :dir :system)
(defmacro VL::case (&rest args)
diff -Nru acl2-6.2/books/centaur/vl/primitives.lisp acl2-6.3/books/centaur/vl/primitives.lisp
--- acl2-6.2/books/centaur/vl/primitives.lisp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/primitives.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -362,8 +362,8 @@
endmodule
})
-VL takes this as a primitive. It is used by our @(see assigndelays)
-transform to separate delays from assignment statements.
+VL takes this as a primitive. It is used by our @(see delayredux) transform
+to separate delays from assignment statements.
The corresponding @(see esim) primitive is @(see acl2::*esim-del*), but note
that esim really has no notion of delays and this ends up being equivalent to
@@ -766,9 +766,9 @@
1 z | z z z | x
})
-
The corresponding @(see esim) primitive is @(see *esim-tri*), which drives
-its output to @('(tristate sel a)'); see @(see 4v-tristate). This matches the
-Verilog truth table exactly.
")
+The corresponding @(see esim) primitive is @(see acl2::*esim-tri*), which
+drives its output to @('(tristate sel a)'); see @(see acl2::4v-tristate). This
+matches the Verilog truth table exactly.
")
(defconsts *vl-1-bit-zmux*
(b* ((name "VL_1_BIT_ZMUX")
@@ -1102,4 +1102,4 @@
(vl-pps-module *vl-1-bit-resolve-wire*)
(vl-pps-module *vl-1-bit-resolve-wor*)
-||#
\ No newline at end of file
+||#
diff -Nru acl2-6.2/books/centaur/vl/simpconfig.lisp acl2-6.3/books/centaur/vl/simpconfig.lisp
--- acl2-6.2/books/centaur/vl/simpconfig.lisp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/simpconfig.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -26,7 +26,11 @@
:short "Options for how to simplify Verilog modules."
:tag :vl-simpconfig
- ((problem-mods string-listp
+ ((compress-p booleanp
+ "Hons the modules at various points. This takes some time,
+ but can produce smaller translation files.")
+
+ (problem-mods string-listp
"Names of modules that should thrown out, perhaps because they
cause some kind of problems."
:default nil)
diff -Nru acl2-6.2/books/centaur/vl/toe/toe-add-res-modules.lisp acl2-6.3/books/centaur/vl/toe/toe-add-res-modules.lisp
--- acl2-6.2/books/centaur/vl/toe/toe-add-res-modules.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/toe/toe-add-res-modules.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -260,11 +260,12 @@
(defsection vl-make-res-sexpr
:parents (vl-make-res-occs)
- :short "Generate a @(see 4v-res) expression to resolve a list of emodwires."
+ :short "Generate a @(see acl2::4v-res) expression to resolve a list of
+emodwires."
:long "@(call vl-make-res-sexpr) generates a 4v-sexpr that joins together all of its arguments with @(url
-4v-res) operations.
+acl2::4v-sexprs)'>4v-sexpr that joins together all of its arguments with
+@(see acl2::4v-res) operations.
Note that the RES operation is commutative and associative, so any nest of
RES operations is equivalent. So, we just resolve the arguments in a
diff -Nru acl2-6.2/books/centaur/vl/toe/toe-emodwire.lisp acl2-6.3/books/centaur/vl/toe/toe-emodwire.lisp
--- acl2-6.2/books/centaur/vl/toe/toe-emodwire.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/toe/toe-emodwire.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -64,17 +64,16 @@
on the expression-slicing code.
")
-#!ACL2
(local (defthm equal-of-string-and-nil-string
(implies (force (stringp str))
(equal (equal str "NIL")
- (equal (coerce str 'list)
+ (equal (explode str)
'(#\N #\I #\L))))
:hints(("Goal"
- :in-theory (disable equal-of-coerce-lists)
- :use ((:instance equal-of-coerce-lists
- (x str)
- (y "NIL")))))))
+ :in-theory (disable str::equal-of-explodes)
+ :use ((:instance str::equal-of-explodes
+ (acl2::x str)
+ (acl2::y "NIL")))))))
#!ACL2
(local (defthm intern-in-package-of-symbol-not-nil
@@ -94,9 +93,9 @@
(member-equal a (make-character-list chars)))
:hints(("Goal" :in-theory (enable make-character-list)))))
-(local (defthm coerce-is-not-nil-bracket-char
+(local (defthm implode-is-not-nil-bracket-char
(implies (member #\[ chars)
- (not (equal (coerce chars 'string) "NIL")))
+ (not (equal (implode chars) "NIL")))
:hints(("Goal"
:in-theory (disable member-of-make-character-list)
:use ((:instance member-of-make-character-list
@@ -126,9 +125,9 @@
:hints(("Goal" :in-theory (enable str::natchars)))))
(defthm no-specials-in-natstr
- (and (not (member-equal #\! (coerce (natstr x) 'list)))
- (not (member-equal #\. (coerce (natstr x) 'list)))
- (not (member-equal #\/ (coerce (natstr x) 'list))))
+ (and (not (member-equal #\! (explode (natstr x))))
+ (not (member-equal #\. (explode (natstr x))))
+ (not (member-equal #\/ (explode (natstr x)))))
:hints(("Goal" :in-theory (enable natstr))))))
@@ -405,18 +404,18 @@
;; this in a separate function to minimize expansion from inlining the main
;; function.
(declare (type string x))
- (b* ((chars (coerce x 'list))
+ (b* ((chars (explode x))
(encoded (vl-emodwire-encode-chars chars)))
- (coerce encoded 'string)))
+ (implode encoded)))
(defund vl-emodwire-decode-aux (x)
;; Slow. We don't expect this to ever really be called in practice. We keep
;; this in a separate function to minimize expansion from inlining the main
;; function.
(declare (type string x))
- (b* ((chars (coerce x 'list))
+ (b* ((chars (explode x))
(decoded (vl-emodwire-decode-chars chars)))
- (coerce decoded 'string)))
+ (implode decoded)))
(local (in-theory (enable vl-emodwire-encode-aux
vl-emodwire-decode-aux)))
@@ -565,17 +564,16 @@
(defsection vl-emodwire-encode-nil
- #!ACL2
(local (defthm l0
(implies (force (stringp str))
(equal (equal str "NIL")
- (equal (coerce str 'list)
+ (equal (explode str)
'(#\N #\I #\L))))
:hints(("Goal"
- :in-theory (disable equal-of-coerce-lists)
- :use ((:instance equal-of-coerce-lists
- (x str)
- (y "NIL")))))))
+ :in-theory (disable str::equal-of-explodes)
+ :use ((:instance str::equal-of-explodes
+ (acl2::x str)
+ (acl2::y "NIL")))))))
(defthm vl-emodwire-encode-nil
(implies (stringp x)
@@ -587,7 +585,7 @@
(defthm vl-emodwire-encode-nil-alt
(implies (stringp x)
- (equal (equal (coerce (vl-emodwire-encode x) 'list) '(#\N #\I #\L))
+ (equal (equal (explode (vl-emodwire-encode x)) '(#\N #\I #\L))
(equal x "NIL")))
:hints(("Goal"
:in-theory (enable vl-emodwire-encode
@@ -777,7 +775,7 @@
(vl-emodwire-scan name))
((when (or illegal
(and escape
- (not (vl-emodwire-encoding-valid-p (coerce name 'list))))))
+ (not (vl-emodwire-encoding-valid-p (explode name))))))
;; Improper escaping
nil)
((when (and (not open) (not close)))
@@ -1143,11 +1141,11 @@
:hints(("Goal" :in-theory (enable vl-emodwire-p
vl-emodwire->basename-without-decoding))))
- (local (defthm equal-with-coerce-string
+ (local (defthm equal-with-implode
(implies (and (stringp x)
(character-listp y))
- (equal (equal x (coerce y 'string))
- (equal (coerce x 'list) y)))))
+ (equal (equal x (implode y))
+ (equal (explode x) y)))))
(local (defthm equal-with-append-take-self
(equal (equal x (append (take n x) y))
@@ -1183,7 +1181,7 @@
len
nth)
(acl2::consp-under-iff-when-true-listp
- acl2::coerce-list-under-iff)))))))
+ str::explode-under-iff)))))))
; Reduction 3. Because of the restrictions made in vl-emodwire-p on the name,
; there aren't any special characters except perhaps for { in the basename
@@ -1222,7 +1220,7 @@
(defthm f2
(implies (vl-emodwire-p x)
(vl-emodwire-encoding-valid-p
- (coerce (vl-emodwire->basename-without-decoding x) 'list)))
+ (explode (vl-emodwire->basename-without-decoding x))))
:hints(("Goal" :in-theory (enable vl-emodwire-p
vl-emodwire->basename-without-decoding
subseq subseq-list))))))
@@ -1232,7 +1230,7 @@
(local
(defthm f3
(implies (vl-emodwire-p x)
- (let ((start (coerce (vl-emodwire->basename-without-decoding x) 'list)))
+ (let ((start (explode (vl-emodwire->basename-without-decoding x))))
(and (not (member-equal #\[ start))
(not (member-equal #\] start))
(not (member-equal #\. start))
@@ -1257,8 +1255,8 @@
vl-emodwire-decode-chars-identity
equal-of-vl-emodwire-decode-chars))
:use ((:instance equal-of-vl-emodwire-decode-chars
- (x (coerce (vl-emodwire->basename-without-decoding x) 'list))
- (y (coerce (vl-emodwire->basename-without-decoding y) 'list)))))))))
+ (x (explode (vl-emodwire->basename-without-decoding x)))
+ (y (explode (vl-emodwire->basename-without-decoding y))))))))))
; Chaining it all together we see that emodwires are equal when when their
diff -Nru acl2-6.2/books/centaur/vl/toe/toe-wirealist.lisp acl2-6.3/books/centaur/vl/toe/toe-wirealist.lisp
--- acl2-6.2/books/centaur/vl/toe/toe-wirealist.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/toe/toe-wirealist.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -243,7 +243,7 @@
true and false functions. These wires no longer have a special meaning in
ESIM, but throughout VL our notion of emodwires still assumes that T and F
stand for constant true and false, and, e.g., we still rely on this in @(see
-make-esim). We might eventually get away from this by using a transform
+e-conversion). We might eventually get away from this by using a transform
analagous to @(see weirdint-elim) to introduce T/F wires and eliminate
constants.
@@ -277,11 +277,11 @@
(stringp name))
(equal (equal x name)
(and (stringp x)
- (equal (coerce x 'list) (coerce name 'list)))))
+ (equal (explode x) (explode name)))))
:hints(("Goal"
- :in-theory (disable acl2::coerce-inverse-2)
- :use ((:instance acl2::coerce-inverse-2 (acl2::x x))
- (:instance acl2::coerce-inverse-2 (acl2::x name)))))))
+ :in-theory (disable str::implode-of-explode)
+ :use ((:instance str::implode-of-explode (str::x x))
+ (:instance str::implode-of-explode (str::x name)))))))
(local (defthm open-equal-len
(implies (syntaxp (quotep n))
@@ -304,7 +304,8 @@
(local (in-theory (enable len)))
(definlined vl-plain-wire-name (name)
- (declare (xargs :guard (stringp name)))
+ (declare (xargs :guard (stringp name)
+ :guard-hints(("Goal" :in-theory (disable str::explode-under-iff)))))
(mbe :logic
(cond ((equal name "T")
(make-vl-emodwire :basename "T" :index 0))
@@ -1312,7 +1313,8 @@
(defthm true-listp-of-vl-msb-constint-bitlist-1
(implies (true-listp warnings)
(true-listp (mv-nth 1 (vl-msb-constint-bitlist x warnings))))
- :rule-classes :type-prescription)
+ :rule-classes :type-prescription
+ :hints(("Goal" :in-theory (disable (force)))))
(local (defthm vl-emodwirelist-p-of-make-list-ac
(implies (and (vl-emodwirelist-p ac)
diff -Nru acl2-6.2/books/centaur/vl/top.lisp acl2-6.3/books/centaur/vl/top.lisp
--- acl2-6.2/books/centaur/vl/top.lisp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/top.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -98,7 +98,13 @@
(defxdoc vl
- :short "VL Verilog Toolkit."
+ :parents (hardware-verification)
+ :short "The VL Verilog Toolkit is a large ACL2 library for working with Verilog source code, developed
+by Centaur Technology . It includes a
+Verilog loader and many functions for inspecting and transforming modules, and
+serves as a frontend for many Verilog tools."
+
:long "Note : this documentation is mainly a reference manual.
If you are new to VL, please see @(see getting-started) first.
")
@@ -108,26 +114,26 @@
:long "Introduction
-VL is an ACL2 library for
-working with Verilog source code. It includes:
+VL is an @(see acl2::acl2) library for working with Verilog source code. It
+includes:
A representation for Verilog @(see modules),
A @(see loader) for parsing Verilog source code into this representation,
Utilities for inspecting and analyzing these modules,
- Various transforms that can simplify these modules, and
+ Various @(see transforms) that can simplify these modules, and
Pretty-printing and other report-generation functions.
The original (and still primary) purpose of VL is to translate Verilog
modules into E-language modules for formal verification. E is a comparatively
-simple, hierarchical, register-transfer level hardware description language.
-Because E is still under active development we have not yet released it, but an
-early version is described in the following paper:
+simple, hierarchical, register-transfer level hardware description language;
+see @(see esim). An early version of E is described in:
-Warren A. Hunt, Jr. and Sol Swords. \"Centaur technology media unit
-verification. Case study: Floating point addition.\" in Computer Aided
+
Warren A. Hunt, Jr. and Sol Swords. Centaur technology media
+unit verification. Case study: Floating point addition. in Computer Aided
Verification (CAV '09), June 2009.
Our overall approach to E translation is to apply several Verilog-to-Verilog
@@ -141,21 +147,30 @@
-We have used it to developed linting tools like @(see use-set) and a more
-powerful linter which is available in @('vl/lint') but is not yet
-documented.
+The publicly available VL @(see kit) is a command-line executable built on
+top of ACL2 and VL, which includes commands for @(see lint)ing Verilog designs,
+converting Verilog modules into a JSON format, and other commands.
We have implemented an equivalence checking tool (which is not yet
-released) that has a unit-based timing model and handles transistor-level
+released) that has a tick-based timing model and handles transistor-level
constructs. This tool uses the same parser and most of VL's transforms, but
also has a couple of additional transformation steps.
-We have also used it to implement a web-based \"module browser\" (which
+ We have used it to implement a web-based \"module browser\" (which
will probably not be released since it is very Centaur specific) that lets
users see the original and translated source code for our modules, and has
several nice features (e.g., hyperlinks for navigating between wires and
following wires, and integrated linting and warning/error reporting).
+We have used it to implement VL-Mangle , a web-based refactoring
+tool (which will probably not be released because it is hard to distribute).
+To support this tool we also developed the @(see acl2::bridge). A paper
+describing this tool can be found in: Jared Davis. Embedding
+ACL Models in End-User Applications . In Do-Form
+2013 . April, 2013, Exeter, UK.
+
We imagine that other users of VL may wish to use it:
@@ -176,9 +191,11 @@
Verilog is a huge language, and VL supports only part of it.
-VL is based on our reading of the Verilog-2005 standard, IEEE Std 1364-2005.
-Page and section numbers given throughout the VL documentation are in reference
-to this document. VL does not have any support for SystemVerilog.
+VL is based on our reading of the Verilog-2005
+standard, IEEE Std 1364-2005 . Page and section numbers given throughout
+the VL documentation are in reference to this document. VL does not have any
+support for SystemVerilog.
VL's @(see preprocessor) is somewhat incomplete. It basically just supports
@('`define') and @('`ifdef')-related stuff and can @('`include') files in the
@@ -885,12 +902,14 @@
(defmvtypes vl-simplify-main (true-listp true-listp nil)))
+
(define vl-simplify
((mods "parsed Verilog modules, typically from @(see vl-load)."
(and (vl-modulelist-p mods)
(uniquep (vl-modulelist->names mods))))
(config "various options that govern how to simplify the modules."
vl-simpconfig-p))
+ :guard-debug t
:returns
(mv (mods "modules that we simplified successfully"
:hyp :fguard
@@ -905,7 +924,29 @@
:long "
This is a high-level routine that applies our @(see transforms) in
a suitable order to simplify Verilog modules and to produce E modules.
"
- (vl-simplify-main (vl-annotate-mods mods) config)
+ (mbe :logic
+ (b* (((mv mods failmods use-set-report)
+ (vl-simplify-main (vl-annotate-mods mods) config)))
+ (mv mods failmods use-set-report))
+ :exec
+ (b* (((vl-simpconfig config) config)
+ (mods (vl-annotate-mods mods))
+ (mods (if config.compress-p
+ (cwtime (hons-copy mods)
+ :name compress-annotated-mods)
+ mods))
+ ((mv mods failmods use-set-report)
+ (vl-simplify-main mods config))
+ (mods (if config.compress-p
+ (cwtime (hons-copy mods)
+ :name compress-simplified-mods)
+ mods))
+ (failmods (if config.compress-p
+ (cwtime (hons-copy failmods)
+ :name compress-failed-mods)
+ failmods)))
+ (vl-gc)
+ (mv mods failmods use-set-report)))
///
(defmvtypes vl-simplify (true-listp true-listp nil)))
@@ -923,7 +964,12 @@
(b* (((mv loadresult state)
(cwtime (vl-load loadconfig)))
- ((vl-loadresult loadresult) loadresult)
+ ((vl-loadresult loadresult)
+ (if (vl-simpconfig->compress-p simpconfig)
+ (cwtime (change-vl-loadresult
+ loadresult :mods (hons-copy (vl-loadresult->mods loadresult)))
+ :name compress-original-mods)
+ loadresult))
((mv mods failmods use-set-report)
(cwtime (vl-simplify loadresult.mods simpconfig)))
@@ -949,6 +995,7 @@
(result (make-vl-translation :mods mods
:failmods failmods
+ :origmods loadresult.mods
:filemap loadresult.filemap
:defines loadresult.defines
:loadwarnings loadresult.warnings
@@ -1027,7 +1074,7 @@
:name defmodules-fn)))
(value
`(with-output
- :off (summary)
+ :off (summary event)
(progn (defconst ,name ',translation)
(value-triple ',name))))))))
diff -Nru acl2-6.2/books/centaur/vl/transforms/cn-hooks.lisp acl2-6.3/books/centaur/vl/transforms/cn-hooks.lisp
--- acl2-6.2/books/centaur/vl/transforms/cn-hooks.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/cn-hooks.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -54,47 +54,6 @@
(encapsulate
- (((vl-modulelist-drop-vcovers-hook *) => *
- :formals (x)
- :guard (vl-modulelist-p x)))
-
- (local (defun vl-modulelist-drop-vcovers-hook (x) x))
-
- (defthm vl-modulelist-p-of-vl-modulelist-drop-vcovers-hook
- (implies (force (vl-modulelist-p x))
- (vl-modulelist-p (vl-modulelist-drop-vcovers-hook x))))
-
- (defthm vl-modulelist->names-of-vl-modulelist-drop-vcovers-hook
- (equal (vl-modulelist->names (vl-modulelist-drop-vcovers-hook x))
- (vl-modulelist->names x))))
-
-(defattach vl-modulelist-drop-vcovers-hook identity)
-
-
-
-
-(encapsulate
- (((vl-modulelist-verrors-to-guarantees-hook *) => *
- :formals (x)
- :guard (vl-modulelist-p x)))
-
- (local (defun vl-modulelist-verrors-to-guarantees-hook (x) x))
-
- (defthm vl-modulelist-p-of-vl-modulelist-verrors-to-guarantees-hook
- (implies (force (vl-modulelist-p x))
- (vl-modulelist-p (vl-modulelist-verrors-to-guarantees-hook x))))
-
- (defthm no-duplicatesp-equal-of-vl-modulelist->names-of-vl-modulelist-verrors-to-guarantees-hook
- (implies (force (no-duplicatesp-equal (vl-modulelist->names x)))
- (no-duplicatesp-equal
- (vl-modulelist->names (vl-modulelist-verrors-to-guarantees-hook x))))))
-
-(defattach vl-modulelist-verrors-to-guarantees-hook identity)
-
-
-
-
-(encapsulate
(((vl-modulelist-pre-toe-hook *) => *
:formals (x)
:guard (and (vl-modulelist-p x)
@@ -113,23 +72,3 @@
(defattach vl-modulelist-pre-toe-hook identity)
-
-;; (encapsulate
-;; (((vl-modulelist-esim-trans-hook *) => *
-;; :formals (x)
-;; :guard (vl-modulelist-p x)))
-
-;; (local (defun vl-modulelist-esim-trans-hook (x) x))
-
-;; (defthm vl-modulelist-p-of-vl-modulelist-esim-trans-hook
-;; (implies (force (vl-modulelist-p x))
-;; (vl-modulelist-p (vl-modulelist-esim-trans-hook x))))
-
-;; (defthm vl-modulelist->names-of-vl-modulelist-esim-trans-hook
-;; (equal (vl-modulelist->names (vl-modulelist-esim-trans-hook x))
-;; (vl-modulelist->names x))))
-
-;; (defattach vl-modulelist-esim-trans-hook identity)
-
-
-
diff -Nru acl2-6.2/books/centaur/vl/transforms/occform/add.lisp acl2-6.3/books/centaur/vl/transforms/occform/add.lisp
--- acl2-6.2/books/centaur/vl/transforms/occform/add.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/occform/add.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -105,7 +105,7 @@
})
This is a basic ripple-carry adder formed by chaining together several
-full-adders; see @(see *vl-1-bit-adder-core*) and @(see vl-make-full-adders).
+full-adders; see @(see *vl-1-bit-adder-core*).
This module does NOT correspond to a full addition in Verilog. It computes
something akin to @('assign {cout, sum} = a + b + cin'), but it does not handle
diff -Nru acl2-6.2/books/centaur/vl/transforms/occform/div.lisp acl2-6.3/books/centaur/vl/transforms/occform/div.lisp
--- acl2-6.2/books/centaur/vl/transforms/occform/div.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/occform/div.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -265,7 +265,7 @@
The core modules we produce here do not properly handle zero divides
or detect X/Z values on the dividend and divisor. To see how we correct for
-these cases, see @(see vl-make-n-bit-div).
+these cases, see @(see vl-make-n-bit-div-rem).
Aside from these special cases, the core module does produce the right
answer by chaining together N division steps; for details about these steps and
diff -Nru acl2-6.2/books/centaur/vl/transforms/occform/mul.lisp acl2-6.3/books/centaur/vl/transforms/occform/mul.lisp
--- acl2-6.2/books/centaur/vl/transforms/occform/mul.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/occform/mul.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -128,7 +128,8 @@
(local (defthm l0
(implies (vl-exprlist-p x)
(iff (car (last x))
- (consp x)))))
+ (consp x)))
+ :hints(("Goal" :in-theory (enable last)))))
(def-vl-modgen vl-make-n-bit-mult (n)
:short "Generate an multiplier module."
@@ -156,7 +157,7 @@
:guard (posp n)
:body
(b* (((when (= n 1))
- (list *vl-1-bit-mult*))
+ (list *vl-1-bit-mult* *vl-1-bit-and* *vl-1-bit-xor*))
(name (hons-copy (cat "VL_" (natstr n) "_BIT_MULT")))
((mv o-expr o-port o-portdecl o-netdecl) (vl-occform-mkport "o" :vl-output n))
@@ -206,10 +207,12 @@
:minloc *vl-fakeloc*
:maxloc *vl-fakeloc*)))
- (list* mod (append adder-mods xprop-modules))))
+ (list* mod
+ (cons *vl-1-bit-buf* ;; used in partprod-insts
+ (append adder-mods xprop-modules)))))
#||
(vl-pps-module *vl-1-bit-mult*)
(vl-pps-modulelist (vl-make-n-bit-mult 3))
-||#
\ No newline at end of file
+||#
diff -Nru acl2-6.2/books/centaur/vl/transforms/occform/shl.lisp acl2-6.3/books/centaur/vl/transforms/occform/shl.lisp
--- acl2-6.2/books/centaur/vl/transforms/occform/shl.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/occform/shl.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -202,7 +202,8 @@
(local (defthm l0
(implies (vl-exprlist-p x)
(iff (car (last x))
- (consp x)))))
+ (consp x)))
+ :hints(("Goal" :in-theory (enable last)))))
(local (defthm l1
(implies (vl-exprlist-p x)
diff -Nru acl2-6.2/books/centaur/vl/transforms/occform/shr.lisp acl2-6.3/books/centaur/vl/transforms/occform/shr.lisp
--- acl2-6.2/books/centaur/vl/transforms/occform/shr.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/occform/shr.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -150,7 +150,8 @@
(local (defthm l0
(implies (vl-exprlist-p x)
(iff (car (last x))
- (consp x)))))
+ (consp x)))
+ :hints(("Goal" :in-theory (enable last)))))
(local (defthm l1
(implies (vl-exprlist-p x)
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-argresolve.lisp acl2-6.3/books/centaur/vl/transforms/xf-argresolve.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-argresolve.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-argresolve.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -710,8 +710,8 @@
(verify-guards vl-gateinst-dirassign
:hints(("Goal"
:in-theory (e/d (vl-gatetype-p)
- (vl-gatetype-p-of-vl-gateinst->type))
- :use ((:instance vl-gatetype-p-of-vl-gateinst->type)))))
+ (return-type-of-vl-gateinst->type))
+ :use ((:instance return-type-of-vl-gateinst->type)))))
(defthm vl-warninglist-p-of-vl-gateinst-dirassign
(implies (force (vl-warninglist-p warnings))
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-array-indexing.lisp acl2-6.3/books/centaur/vl/transforms/xf-array-indexing.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-array-indexing.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-array-indexing.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -662,24 +662,27 @@
-(defund vl-module-make-array-indexing (x)
- (declare (xargs :guard (vl-module-p x)))
- (b* (((vl-module x) x)
- ((when (vl-module->hands-offp x))
- x)
- (names (append (vl-regdecllist-collect-array-names x.regdecls)
- (vl-netdecllist-collect-array-names x.netdecls)))
- ((unless names)
- x)
- (fal (make-lookup-alist names))
- (warnings x.warnings)
- ((mv warnings ports) (vl-portlist-make-array-indexing x.ports names fal warnings))
- ((mv warnings assigns) (vl-assignlist-make-array-indexing x.assigns names fal warnings))
- ((mv warnings modinsts) (vl-modinstlist-make-array-indexing x.modinsts names fal warnings))
- ((mv warnings gateinsts) (vl-gateinstlist-make-array-indexing x.gateinsts names fal warnings))
- ((mv warnings alwayses) (vl-alwayslist-make-array-indexing x.alwayses names fal warnings))
- ((mv warnings initials) (vl-initiallist-make-array-indexing x.initials names fal warnings))
- (- (fast-alist-free fal)))
+(defsection vl-module-make-array-indexing
+ :parents (array-indexing)
+
+ (defund vl-module-make-array-indexing (x)
+ (declare (xargs :guard (vl-module-p x)))
+ (b* (((vl-module x) x)
+ ((when (vl-module->hands-offp x))
+ x)
+ (names (append (vl-regdecllist-collect-array-names x.regdecls)
+ (vl-netdecllist-collect-array-names x.netdecls)))
+ ((unless names)
+ x)
+ (fal (make-lookup-alist names))
+ (warnings x.warnings)
+ ((mv warnings ports) (vl-portlist-make-array-indexing x.ports names fal warnings))
+ ((mv warnings assigns) (vl-assignlist-make-array-indexing x.assigns names fal warnings))
+ ((mv warnings modinsts) (vl-modinstlist-make-array-indexing x.modinsts names fal warnings))
+ ((mv warnings gateinsts) (vl-gateinstlist-make-array-indexing x.gateinsts names fal warnings))
+ ((mv warnings alwayses) (vl-alwayslist-make-array-indexing x.alwayses names fal warnings))
+ ((mv warnings initials) (vl-initiallist-make-array-indexing x.initials names fal warnings))
+ (- (fast-alist-free fal)))
(change-vl-module x
:ports ports
@@ -690,16 +693,15 @@
:initials initials
:warnings warnings)))
-(defthm vl-module-p-of-vl-module-make-array-indexing
- (implies (force (vl-module-p x))
- (vl-module-p (vl-module-make-array-indexing x)))
- :hints(("Goal" :in-theory (enable vl-module-make-array-indexing))))
-
-(defthm vl-module->name-of-vl-module-make-array-indexing
- (equal (vl-module->name (vl-module-make-array-indexing x))
- (vl-module->name x))
- :hints(("Goal" :in-theory (enable vl-module-make-array-indexing))))
+ (local (in-theory (enable vl-module-make-array-indexing)))
+ (defthm vl-module-p-of-vl-module-make-array-indexing
+ (implies (force (vl-module-p x))
+ (vl-module-p (vl-module-make-array-indexing x))))
+
+ (defthm vl-module->name-of-vl-module-make-array-indexing
+ (equal (vl-module->name (vl-module-make-array-indexing x))
+ (vl-module->name x))))
(defprojection vl-modulelist-make-array-indexing (x)
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-blankargs.lisp acl2-6.3/books/centaur/vl/transforms/xf-blankargs.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-blankargs.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-blankargs.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -51,9 +51,9 @@
Unlike @(see drop-blankports) which can be applied at any time after @(see
argresolve), the blankargs transformation requires that expression sizes have
-been computed (see @(see selfsize) and @(see ctxsize)) since the new wires need
-to have the appropriate size. We also expect that the @(see replicate) transform
-has been run to ensure that no instances have ranges.
")
+been computed (see @(see expression-sizing)) since the new wires need to have
+the appropriate size. We also expect that the @(see replicate) transform has
+been run to ensure that no instances have ranges.")
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-clean-selects.lisp acl2-6.3/books/centaur/vl/transforms/xf-clean-selects.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-clean-selects.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-clean-selects.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -187,6 +187,7 @@
(defsection vl-stmt-clean-selects
+ :parents (clean-selects)
(mutual-recursion
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-gate-elim.lisp acl2-6.3/books/centaur/vl/transforms/xf-gate-elim.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-gate-elim.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-gate-elim.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -37,7 +37,7 @@
Ordering notes. This transform should typically be run after @(see
gatesplit) and @(see gateredux), and also after other transforms like @(see
-blankargs), @(see expr-sizing), and @(see replicate).
+blankargs), @(see expression-sizing), and @(see replicate).
We only try to deal with non-array instances of gates, with the usual
arities (i.e., 2 arguments to a NOT or BUF, and 3 arguments to AND, OR, ...).
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-gateredux.lisp acl2-6.3/books/centaur/vl/transforms/xf-gateredux.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-gateredux.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-gateredux.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -425,9 +425,9 @@
:off :all
(verify-guards vl-gateinst-gateredux
:hints(("Goal"
- :use ((:instance VL-GATETYPE-P-OF-VL-GATEINST->TYPE))
+ :use ((:instance return-type-OF-VL-GATEINST->TYPE))
:in-theory (e/d (vl-gatetype-p)
- (VL-GATETYPE-P-OF-VL-GATEINST->TYPE))))))
+ (return-type-OF-VL-GATEINST->TYPE))))))
(defthm vl-warninglist-p-of-vl-gateinst-gateredux
(implies (force (vl-warninglist-p warnings))
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-orig.lisp acl2-6.3/books/centaur/vl/transforms/xf-orig.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-orig.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-orig.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -28,7 +28,7 @@
:short "Add @('VL_ORIG_EXPR') annotations to some expressions."
:long "
In this transformation, we annotate many expressions with their
-@('VL_ORIG_EXPR') attribute (see @(see attributes)). The idea is to associate
+@('VL_ORIG_EXPR') attribute (see @(see vl-atts-p)). The idea is to associate
each expression with its \"original version,\" as it was read from the source
file, before any simplification has taken place.
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-propagate-help.lisp acl2-6.3/books/centaur/vl/transforms/xf-propagate-help.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-propagate-help.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-propagate-help.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -0,0 +1,229 @@
+; VL Verilog Toolkit
+; Copyright (C) 2008-2012 Centaur Technology
+;
+; Contact:
+; Centaur Technology Formal Verification Group
+; 7600-C N. Capital of Texas Highway, Suite 300, Austin, TX 78731, USA.
+; http://www.centtech.com/
+;
+; This program is free software; you can redistribute it and/or modify it under
+; the terms of the GNU General Public License as published by the Free Software
+; Foundation; either version 2 of the License, or (at your option) any later
+; version. This program is distributed in the hope that it will be useful but
+; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+; more details. You should have received a copy of the GNU General Public
+; License along with this program; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
+;
+; Original author: Jared Davis
+
+(in-package "VL")
+(include-book "../mlib/find-item")
+(include-book "../mlib/expr-tools")
+(include-book "../mlib/expr-building")
+(include-book "../mlib/expr-slice")
+(local (include-book "../util/arithmetic"))
+
+(defxdoc propagate-help
+ :parents (transforms)
+ :short "Split up assignments to concatenations to assist with @(see propagate)."
+
+ :long "The @(see propagate) transform can get rid of assignments to
+\"intermediate\" wires, but only deals with assignments whose left-hand sides
+are simple identifiers. This limitation means that, in practice, it can fail
+to carry out the desired propagation when there are assignments like this:
+
+@({
+assign {net0413_4, net0413_3, net0413_2, net0413_1, net0413_0} = spb ;
+})
+
+This is a helper transform that is meant to be run before propagate, in order
+to split up assignments like the above into a form that propagate can process. The
+idea is to replace assignments like the above with sequences of assignments, e.g.,
+
+@({
+assign net0413_4 = spb[4];
+assign net0413_3 = spb[3];
+assign net0413_2 = spb[2];
+assign net0413_1 = spb[1];
+assign net0413_0 = spb[0];
+})
+
+After this, propagate can presumably eliminate these intermediate nets.
+
+Prerequisites: expressions need to be sized and ranges resolved. To keep
+things as safe as possible, we only simplify assignments wehre the widths work
+out exactly.
")
+
+(local (in-theory (disable all-equalp)))
+
+(local (defthm nat-listp-when-pos-listp
+ ;; BOZO this is probably fine as a tau system rule, find it a home
+ ;; and make it non-local.
+ (implies (pos-listp x)
+ (nat-listp x))
+ :rule-classes :tau-system
+ :hints(("Goal" :induct (len x)))))
+
+
+(define vl-prophelp-split
+ ((lhs-wires "individual wires from the left-hand side's concatenation"
+ (and (vl-exprlist-p lhs-wires)
+ (vl-idexprlist-p lhs-wires)
+ (pos-listp (vl-exprlist->finalwidths lhs-wires))))
+ (rhs-bits "exploded bits from the right-hand side expression"
+ (and (true-listp rhs-bits)
+ (vl-exprlist-p rhs-bits)
+ (all-equalp 1 (vl-exprlist->finalwidths rhs-bits))))
+ (loc vl-location-p))
+ :guard (equal (sum-nats (vl-exprlist->finalwidths lhs-wires))
+ (len rhs-bits))
+ :returns (assigns vl-assignlist-p :hyp :fguard)
+ :parents (propagate-help)
+ :short "Create an assignment for each individual wire on the left-hand side
+to its associated bits from the right-hand side."
+
+ (b* (((when (atom lhs-wires))
+ nil)
+ (lhs1 (car lhs-wires))
+ (width1 (vl-expr->finalwidth lhs1))
+ (bits1 (take width1 rhs-bits))
+ (rhs1 (make-vl-nonatom :op :vl-concat
+ :args bits1
+ :finaltype :vl-unsigned
+ :finalwidth width1)))
+ (cons (make-vl-assign :lvalue lhs1
+ :expr rhs1
+ :loc loc)
+ (vl-prophelp-split (cdr lhs-wires)
+ (nthcdr width1 rhs-bits)
+ loc)))
+ :prepwork
+ ((local (defthm l0
+ (implies (all-equalp a (vl-exprlist->finalwidths x))
+ (all-equalp a (vl-exprlist->finalwidths (nthcdr n x))))
+ :hints(("Goal" :in-theory (enable nthcdr)))))))
+
+
+
+(define vl-prophelp-assign
+ ((x "assignment to be split up, if it has the right form."
+ vl-assign-p)
+ (mod "module the assignment occurs in, so we can slice up the rhs."
+ vl-module-p)
+ (ialist (equal ialist (vl-moditem-alist mod)))
+ (warnings vl-warninglist-p))
+ :returns (mv (warnings vl-warninglist-p :hyp :fguard)
+ (new-x vl-assignlist-p :hyp :fguard))
+ :parents (propagate-help)
+ :short "Maybe split up an assignment."
+ (b* (((vl-assign x) x)
+
+ ((when (vl-fast-atom-p x.lvalue))
+ ;; Not applicable (assigning to an atom, not a concat)
+ (mv warnings (list x)))
+
+ ((vl-nonatom x.lvalue) x.lvalue)
+ ((unless (and (eq x.lvalue.op :vl-concat)
+ (vl-idexprlist-p x.lvalue.args)
+ (vl-expr-sliceable-p x.expr)))
+ ;; Not applicable (not a concat, or too hard)
+ (mv warnings (list x)))
+
+ (widths (vl-exprlist->finalwidths x.lvalue.args))
+ ((unless (pos-listp widths))
+ ;; Some width isn't computed, so how would we split it up? Give up.
+ (mv (warn :type :vl-prophelp-fail
+ :msg "~a0: not splitting up assignment because the lhs ~
+ width is not determined!"
+ :args (list x))
+ (list x)))
+
+ (lhs-width (sum-nats widths))
+ (rhs-width (vl-expr->finalwidth x.expr))
+ ((unless (eql lhs-width rhs-width))
+ ;; Widths don't agree, so give up; I don't want to think about how to
+ ;; properly do truncations/extensions here.
+ (mv (warn :type :vl-prophelp-fail
+ :msg "~a0: not splitting up assignment because the lhs/rhs ~
+ do not have the same width. Lhs width is ~x1, rhs ~
+ width is ~x2."
+ :args (list x lhs-width rhs-width))
+ (list x)))
+
+ ((unless (and (vl-expr-welltyped-p x.lvalue)
+ (vl-expr-welltyped-p x.expr)))
+ (mv (warn :type :vl-prophelp-fail
+ :msg "~a0: not splitting up assignment because lhs or rhs ~
+ is not well-typed."
+ :args (list x))
+ (list x)))
+
+ ((mv okp warnings rhs-bits)
+ (vl-msb-bitslice-expr x.expr mod ialist warnings))
+ ((unless okp)
+ ;; Somehow failed to split up RHS? Don't do anything.
+ (mv (warn :type :vl-prophelp-fail
+ :msg "~a0: not splitting up assignment because we somehow ~
+ failed to slice its rhs into bits."
+ :args (list x))
+ (list x)))
+
+ ;; Otherwise, this is looking good.
+ (new-assigns (vl-prophelp-split x.lvalue.args rhs-bits x.loc)))
+ (mv warnings new-assigns))
+ ///
+ (defmvtypes vl-prophelp-assign (nil true-listp)))
+
+
+(define vl-prophelp-assignlist
+ ((x vl-assignlist-p)
+ (mod vl-module-p)
+ (ialist (equal ialist (vl-moditem-alist mod)))
+ (warnings vl-warninglist-p))
+ :returns (mv (warnings vl-warninglist-p :hyp :fguard)
+ (new-x vl-assignlist-p :hyp :fguard))
+ :parents (propagate-help)
+ (b* (((when (atom x))
+ (mv warnings nil))
+ ((mv warnings car) (vl-prophelp-assign (car x) mod ialist warnings))
+ ((mv warnings cdr) (vl-prophelp-assignlist (cdr x) mod ialist warnings)))
+ (mv warnings (append car cdr)))
+ ///
+ (defmvtypes vl-prophelp-assign (nil true-listp)))
+
+
+(define vl-prophelp-module ((x vl-module-p))
+ :returns (new-x vl-module-p :hyp :fguard)
+ :parents (propagate-help)
+ (b* (((vl-module x) x)
+ ((when (vl-module->hands-offp x))
+ x)
+ ((unless x.assigns)
+ ;; Optimization: don't even build the moditem alist unless there are
+ ;; assignments. We could do better here, i.e., check for an assignment
+ ;; with a concatenation on the lhs, but this is probably good enough.
+ x)
+ (ialist (vl-moditem-alist x))
+ ((mv warnings assigns)
+ (vl-prophelp-assignlist x.assigns x ialist x.warnings)))
+ (fast-alist-free ialist)
+ (change-vl-module x
+ :assigns assigns
+ :warnings warnings))
+ ///
+ (defthm vl-module->name-of-vl-prophelp-module
+ (equal (vl-module->name (vl-prophelp-module x))
+ (vl-module->name x))))
+
+(defprojection vl-prophelp-modulelist (x)
+ (vl-prophelp-module x)
+ :guard (vl-modulelist-p x)
+ :result-type vl-modulelist-p)
+
+(defthm vl-modulelist->names-of-vl-prophelp-modulelist
+ (equal (vl-modulelist->names (vl-prophelp-modulelist x))
+ (vl-modulelist->names x))
+ :hints(("Goal" :induct (len x))))
+
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-propagate.lisp acl2-6.3/books/centaur/vl/transforms/xf-propagate.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-propagate.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-propagate.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -181,7 +181,7 @@
:hints(("Goal" :induct (len x))))
-(defsection vl-maybe-driven-by-modinsts
+(defsection vl-maybe-driven-by-modinst
:parents (propagate)
:short "Approxpimately the wires driven by a module instance (unsound)."
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-replicate-insts.lisp acl2-6.3/books/centaur/vl/transforms/xf-replicate-insts.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-replicate-insts.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-replicate-insts.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -610,8 +610,8 @@
first.
We might fail with a fatal warning if there is some problem with the actual;
-we expect the actual to be already sized, well-typed , and well-typed , and sliceable ), and its width must be compatible with the
width of the port, as described in @(see argument-partitioning).
"
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-sizing.lisp acl2-6.3/books/centaur/vl/transforms/xf-sizing.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-sizing.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-sizing.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -24,6 +24,7 @@
(include-book "../mlib/context")
(include-book "../mlib/welltyped")
(include-book "../mlib/lvalues")
+(local (include-book "clause-processors/autohide" :dir :system))
(local (include-book "../util/arithmetic"))
@@ -700,9 +701,9 @@
(verify-guards vl-expr-interesting-size-atoms
:hints(("Goal"
- :use ((:instance vl-op-p-of-vl-nonatom->op (x x)))
+ :use ((:instance return-type-of-vl-nonatom->op (x x)))
:in-theory (e/d (vl-op-p vl-op-arity)
- (vl-op-p-of-vl-nonatom->op)))))
+ (return-type-of-vl-nonatom->op)))))
(defthm-vl-flag-expr-interesting-size-atoms
(defthm vl-atomlist-p-of-vl-expr-interesting-size-atoms
@@ -1883,12 +1884,12 @@
(encapsulate
()
- (local (in-theory (disable vl-op-p-of-vl-nonatom->op
+ (local (in-theory (disable return-type-of-vl-nonatom->op
default-car
default-cdr)))
(verify-guards vl-expr-typedecide-aux
:hints(("Goal"
- :use ((:instance vl-op-p-of-vl-nonatom->op)))
+ :use ((:instance return-type-of-vl-nonatom->op)))
(and stable-under-simplificationp
'(:in-theory (enable vl-op-arity vl-op-p)))))))
@@ -4282,8 +4283,8 @@
:hints((and stable-under-simplificationp
'(:in-theory (e/d (vl-op-p vl-maybe-natp
(:ruleset basic-arithmetic-rules))
- (vl-op-p-of-vl-nonatom->op))
- :use ((:instance vl-op-p-of-vl-nonatom->op)))))))
+ (return-type-of-vl-nonatom->op))
+ :use ((:instance return-type-of-vl-nonatom->op)))))))
diff -Nru acl2-6.2/books/centaur/vl/transforms/xf-unparameterize.lisp acl2-6.3/books/centaur/vl/transforms/xf-unparameterize.lisp
--- acl2-6.2/books/centaur/vl/transforms/xf-unparameterize.lisp 2013-06-06 17:11:41.000000000 +0000
+++ acl2-6.3/books/centaur/vl/transforms/xf-unparameterize.lisp 2013-09-30 17:53:07.000000000 +0000
@@ -1625,6 +1625,8 @@
(progn$
(cw "; vl-unparameterize: counter exhausted before fixed point reached.~%")
+ (cw "; modules that still have parameters: ~&0"
+ (vl-modulelist->names withparams))
(vl-handle-unparam-fail mods)))
@@ -1636,6 +1638,8 @@
(progn$
(cw "; vl-unparameterize: fixed point reached with n = ~x0, but ~
there are still modules with parameters: ~%" n)
+ (cw "; modules that still have parameters: ~&0"
+ (vl-modulelist->names withparams))
(vl-handle-unparam-fail mods))
(mv-let (success-rest fail-rest)
diff -Nru acl2-6.2/books/centaur/vl/translation.lisp acl2-6.3/books/centaur/vl/translation.lisp
--- acl2-6.2/books/centaur/vl/translation.lisp 2013-06-06 17:11:43.000000000 +0000
+++ acl2-6.3/books/centaur/vl/translation.lisp 2013-09-30 17:53:10.000000000 +0000
@@ -40,10 +40,15 @@
could not be fully simplified. Typically each module here
will have fatal @(see warnings).")
+ (origmods vl-modulelist-p
+ "The raw list of unsimplified modules that were found
+ immediately after parsing. This can be useful for
+ pretty-printing and understanding modules.")
+
(filemap vl-filemap-p
- "Contains the actual Verilog source code that was
- read. Occasionally this is useful for understanding warnings
- that refer to particular file locations.")
+ "The actual Verilog source code that was read. Occasionally
+ this is useful for understanding warnings that refer to
+ particular file locations.")
(defines vl-defines-p
"Records all of the @('`define') directives that were
@@ -73,7 +78,7 @@
(define vl-translation-has-module ((modname stringp)
(x vl-translation-p))
- :parents (translation-p)
+ :parents (vl-translation-p)
:short "Check whether a module was successfully translated."
:long "The @('modname') should be the desired module's name as a string,
diff -Nru acl2-6.2/books/centaur/vl/util/arithmetic.lisp acl2-6.3/books/centaur/vl/util/arithmetic.lisp
--- acl2-6.2/books/centaur/vl/util/arithmetic.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/arithmetic.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -85,7 +85,7 @@
(include-book "std/alists/top" :dir :system)
(include-book "std/typed-lists/top" :dir :system)
-(include-book "std/misc/explode-atom" :dir :system)
+(include-book "str/explode-atom" :dir :system)
(defun dec-dec-induct (k n)
diff -Nru acl2-6.2/books/centaur/vl/util/bits.lisp acl2-6.3/books/centaur/vl/util/bits.lisp
--- acl2-6.2/books/centaur/vl/util/bits.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/bits.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -82,7 +82,7 @@
:parents (vl-weirdint-p)
:short "Get the string corresponding to a @(see vl-bitlist-p)."
- (coerce (vl-bitlist->charlist x) 'string)
+ (implode (vl-bitlist->charlist x))
///
diff -Nru acl2-6.2/books/centaur/vl/util/character-list-listp.lisp acl2-6.3/books/centaur/vl/util/character-list-listp.lisp
--- acl2-6.2/books/centaur/vl/util/character-list-listp.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/character-list-listp.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -73,27 +73,27 @@
-(define coerce-to-chars-list ((x string-listp))
+(define explode-list ((x string-listp))
:parents (utilities)
:short "Coerce a list of strings into a @(see character-list-listp)."
(if (atom x)
nil
- (cons (coerce (car x) 'list)
- (coerce-to-chars-list (cdr x))))
+ (cons (explode (car x))
+ (explode-list (cdr x))))
:returns (ans character-list-listp)
///
- (defthm coerce-to-chars-list-when-atom
+ (defthm explode-list-when-atom
(implies (atom x)
- (equal (coerce-to-chars-list x)
+ (equal (explode-list x)
nil)))
- (defthm coerce-to-chars-list-of-cons
- (equal (coerce-to-chars-list (cons a x))
- (cons (coerce a 'list)
- (coerce-to-chars-list x)))))
+ (defthm explode-list-of-cons
+ (equal (explode-list (cons a x))
+ (cons (explode a)
+ (explode-list x)))))
diff -Nru acl2-6.2/books/centaur/vl/util/cw-unformatted-raw.lsp acl2-6.3/books/centaur/vl/util/cw-unformatted-raw.lsp
--- acl2-6.2/books/centaur/vl/util/cw-unformatted-raw.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/cw-unformatted-raw.lsp 2013-09-30 17:53:08.000000000 +0000
@@ -0,0 +1,15 @@
+
+(defun cw-unformatted (x)
+ (let ((stream (get-output-stream-from-channel *standard-co*)))
+ (write-string x stream)
+
+; [Jared] We added finish-output to make this work better with file streams
+; that we were wanting to monitor. Unfortunately this turned out to be
+; horribly slow when writing to an NFS-mounted file system. (Which can happen,
+; for instance, if you are running ACL2 and redirecting output to a file from
+; the shell, or using with-stdout, or similar.) It seems that using
+; force-output is much, much faster, and at least tries to accomplish something
+; similar, so now we'll just use it.
+
+ (force-output stream))
+ nil)
diff -Nru acl2-6.2/books/centaur/vl/util/cw-unformatted.lisp acl2-6.3/books/centaur/vl/util/cw-unformatted.lisp
--- acl2-6.2/books/centaur/vl/util/cw-unformatted.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/cw-unformatted.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -20,6 +20,8 @@
(in-package "ACL2")
+(include-book "tools/include-raw" :dir :system)
+
; There doesn't seem to be any mechanism for just printing the contents of a
; string without any formatting using cw. Using ~s mostly works, but it will
; insert its own line breaks. Using ~f fixes that, but puts quotes around the
@@ -33,22 +35,10 @@
(er hard? 'cw-unformatted "Raw lisp definition not installed?"))
(defttag cw-unformatted)
-(progn!
- (set-raw-mode t)
- (defun cw-unformatted (x)
- (let ((stream (get-output-stream-from-channel *standard-co*)))
- (write-string x stream)
-
-; [Jared] We added finish-output to make this work better with file streams
-; that we were wanting to monitor. Unfortunately this turned out to be
-; horribly slow when writing to an NFS-mounted file system. (Which can happen,
-; for instance, if you are running ACL2 and redirecting output to a file from
-; the shell, or using with-stdout, or similar.) It seems that using
-; force-output is much, much faster, and at least tries to accomplish something
-; similar, so now we'll just use it.
- (force-output stream))
- nil))
+; (depends-on "cw-unformatted-raw.lsp")
+(include-raw "cw-unformatted-raw.lsp")
+
(defttag nil)
diff -Nru acl2-6.2/books/centaur/vl/util/defs.lisp acl2-6.3/books/centaur/vl/util/defs.lisp
--- acl2-6.2/books/centaur/vl/util/defs.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/defs.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -64,7 +64,7 @@
:short "A string consisting of a newline character."
(defconst *nls*
- (coerce (list #\Newline) 'string)))
+ (implode (list #\Newline))))
@@ -778,7 +778,7 @@
:long "
Such names are the convention for naming modules in E.
"
(intern-in-package-of-symbol
- (coerce (cons #\* (str::append-chars name (list #\*))) 'string)
+ (implode (cons #\* (str::append-chars name (list #\*))))
'ACL2::foo)
///
diff -Nru acl2-6.2/books/centaur/vl/util/echars.lisp acl2-6.3/books/centaur/vl/util/echars.lisp
--- acl2-6.2/books/centaur/vl/util/echars.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/echars.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -39,20 +39,15 @@
(defaggregate vl-location
- (filename line col)
- :tag :vl-location
- :legiblep nil
- :require ((stringp-of-vl-location->filename
- (stringp filename)
- :rule-classes :type-prescription)
- (posp-of-vl-location->line
- (posp line)
- :rule-classes :type-prescription)
- (natp-of-vl-location->col
- (natp col)
- :rule-classes :type-prescription))
:parents (extended-characters)
:short "Representation of a point in a source file."
+ :tag :vl-location
+ :legiblep nil
+
+ ((filename stringp :rule-classes :type-prescription)
+ (line posp :rule-classes :type-prescription)
+ (col natp :rule-classes :type-prescription))
+
:long "Each vl-location-p represents some location in a source code file.
These locations are attached to characters and module items to provide context
during error reporting.
")
@@ -463,7 +458,7 @@
notably saves a lot of memory when we build @(see vl-filemap-p)s."
:enabled t
- (coerce (vl-echarlist->chars x) 'string)
+ (implode (vl-echarlist->chars x))
///
@@ -707,9 +702,9 @@
(defthm vl-echarlist-from-str-nice-correct
(implies (force (stringp x))
- (equal (vl-echarlist-from-str-nice x n (len (coerce x 'list))
+ (equal (vl-echarlist-from-str-nice x n (len (explode x))
filename line col)
- (vl-echarlist-from-chars-fn (nthcdr n (coerce x 'list))
+ (vl-echarlist-from-chars-fn (nthcdr n (explode x))
filename line col)))
:hints(("Goal" :in-theory (enable vl-echarlist-from-str-nice
vl-echarlist-from-chars-fn))))
@@ -721,8 +716,9 @@
(natp col)))
(type string x filename)
(type integer line col))
- (mbe :logic (vl-echarlist-from-chars-fn (coerce x 'list) filename line col)
- :exec (vl-echarlist-from-str-nice x 0 (length (the string x))
+ (mbe :logic (vl-echarlist-from-chars-fn (explode x) filename line col)
+ :exec (vl-echarlist-from-str-nice x 0
+ (length (the string x))
filename line col)))
(defmacro vl-echarlist-from-str (x &key
diff -Nru acl2-6.2/books/centaur/vl/util/namedb.lisp acl2-6.3/books/centaur/vl/util/namedb.lisp
--- acl2-6.2/books/centaur/vl/util/namedb.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/namedb.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -729,7 +729,8 @@
(declare (xargs :guard (and (stringp name)
(vl-namedb-p db))
:verify-guards nil))
- (b* ((names (vl-namedb->names db))
+ (b* ((name (string-fix name))
+ (names (vl-namedb->names db))
(pset (vl-namedb->pset db))
((when (hons-get name names))
@@ -757,8 +758,7 @@
(verify-guards vl-namedb-plain-name)
(defthm stringp-of-vl-namedb-plain-name
- (implies (force (stringp name))
- (stringp (mv-nth 0 (vl-namedb-plain-name name db))))
+ (stringp (mv-nth 0 (vl-namedb-plain-name name db)))
:hints(("Goal" :in-theory (disable vl-namedb->pset-under-set-equiv)))
:rule-classes :type-prescription)
diff -Nru acl2-6.2/books/centaur/vl/util/position.lisp acl2-6.3/books/centaur/vl/util/position.lisp
--- acl2-6.2/books/centaur/vl/util/position.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/position.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -52,7 +52,7 @@
(defthm position-equal-under-iff-when-stringp
(implies (stringp string)
(iff (position-equal char string)
- (member-equal char (coerce string 'list))))
+ (member-equal char (explode string))))
:hints(("Goal" :in-theory (enable position-equal))))
(encapsulate
@@ -112,22 +112,23 @@
lst)
item))
:hints(("Goal"
- :in-theory (enable position-equal-ac)
+ :in-theory (e/d (position-equal-ac)
+ (acl2::position-equal-ac-is-index-of-aux))
:do-not '(generalize fertilize)
:induct (position-equal-ac item lst acc))))
-(defthm nth-of-position-equal-of-coerce-when-stringp
+(defthm nth-of-position-equal-of-explode-when-stringp
(implies (and (position-equal char string)
(stringp string))
(equal (nth (position-equal char string)
- (coerce string 'list))
+ (explode string))
char))
:hints(("Goal"
:in-theory (e/d (position-equal)
(nth-of-position-equal-ac))
:use ((:instance nth-of-position-equal-ac
(item char)
- (lst (coerce string 'list))
+ (lst (explode string))
(acc 0))))))
(defthm acl2-numberp-of-position-equal
@@ -171,7 +172,8 @@
(<= n (- (position-equal-ac item lst acc) acc)))
(not (member-equal item (take n lst))))
:hints(("Goal"
- :in-theory (enable position-equal-ac)
+ :in-theory (e/d (position-equal-ac)
+ (acl2::position-equal-ac-is-index-of-aux))
:induct (my-induct item n lst acc)))))
(local (defthm l1
@@ -188,29 +190,29 @@
(defthm member-equal-of-subseq-chars-impossible-1
(implies (and (not (position-equal a x))
(<= (nfix end) (length x)))
- (not (member-equal a (coerce (subseq x 0 end) 'list)))))
+ (not (member-equal a (explode (subseq x 0 end))))))
(defthm member-equal-of-subseq-chars-impossible-2
(implies (and (<= end (position-equal a x))
(position-equal a x)
(natp end))
- (not (member-equal a (coerce (subseq x 0 end) 'list))))
+ (not (member-equal a (explode (subseq x 0 end)))))
:hints(("Goal"
:in-theory (disable member-equal-of-subseq-chars-impossible-1 l1)
:use ((:instance member-equal-of-subseq-chars-impossible-1)
- (:instance l1 (item a) (lst (coerce x 'list)) (n end)))))))
+ (:instance l1 (item a) (lst (explode x)) (n end)))))))
-(defthm position-equal-of-coerce-to-string
+(defthm position-equal-of-implode
(implies (character-listp x)
- (equal (position-equal a (coerce x 'string))
+ (equal (position-equal a (implode x))
(position-equal a x)))
:hints(("Goal" :in-theory (enable position-equal))))
-(defthm position-equal-of-coerce-to-list
+(defthm position-equal-of-explode
(implies (stringp x)
- (equal (position-equal a (coerce x 'list))
+ (equal (position-equal a (explode x))
(position-equal a x)))
:hints(("Goal" :in-theory (enable position-equal))))
@@ -252,4 +254,5 @@
0
(and (position-equal a x)
(+ 1 (position-equal a x))))))
- :hints(("Goal" :in-theory (enable position-equal)))))
+ :hints(("Goal" :in-theory (e/d (position-equal)
+ (acl2::position-equal-ac-is-index-of-aux))))))
diff -Nru acl2-6.2/books/centaur/vl/util/print-htmlencode.lisp acl2-6.3/books/centaur/vl/util/print-htmlencode.lisp
--- acl2-6.2/books/centaur/vl/util/print-htmlencode.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/print-htmlencode.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -19,7 +19,7 @@
; Original author: Jared Davis
(in-package "VL")
-(include-book "tools/bstar" :dir :system)
+(include-book "str/cat" :dir :system)
(local (include-book "misc/assert" :dir :system))
(local (include-book "arithmetic"))
@@ -38,12 +38,12 @@
; not be the desired behavior in certain applications, but is very convenient
; for what we are trying to accomplish in VL.
-(defconst *vl-html- * (coerce " " 'list))
-(defconst *vl-html-newline* (append (coerce " " 'list) (list #\Newline)))
-(defconst *vl-html-<* (coerce "<" 'list))
-(defconst *vl-html->* (coerce ">" 'list))
-(defconst *vl-html-&* (coerce "&" 'list))
-(defconst *vl-html-"* (coerce """ 'list))
+(defconst *vl-html- * (explode " "))
+(defconst *vl-html-newline* (append (explode " ") (list #\Newline)))
+(defconst *vl-html-<* (explode "<"))
+(defconst *vl-html->* (explode ">"))
+(defconst *vl-html-&* (explode "&"))
+(defconst *vl-html-"* (explode """))
(defund repeated-revappend (n x y)
@@ -170,8 +170,8 @@
((mv str-col str-ans)
(vl-html-encode-string-aux x 0 (length x) 0 8 nil))
((mv char-col char-ans)
- (vl-html-encode-chars-aux (coerce x 'list) 0 8 nil))
- (- (cw "~s0~%" (coerce (reverse str-ans) 'string))))
+ (vl-html-encode-chars-aux (explode x) 0 8 nil))
+ (- (cw "~s0~%" (str::rchars-to-string str-ans))))
(and (equal str-col char-col)
(equal str-ans char-ans)))))
@@ -213,19 +213,10 @@
(mv-let (col acc)
(vl-html-encode-string-aux x 0 (length x) 0 tabsize nil)
(declare (ignore col))
- (reverse (coerce acc 'string))))
+ (str::rchars-to-string acc)))
(defthm stringp-of-vl-html-encode-string
(stringp (vl-html-encode-string x tabsize))
:rule-classes :type-prescription
:hints(("Goal" :in-theory (enable vl-html-encode-string))))
-(defttag vl-optimize)
-(never-memoize vl-html-encode-string-aux)
-(progn! (set-raw-mode t)
- (defun vl-html-encode-string (x tabsize)
- (mv-let (col acc)
- (vl-html-encode-string-aux x 0 (length x) 0 tabsize nil)
- (declare (ignore col))
- (nreverse (coerce acc 'string)))))
-(defttag nil)
diff -Nru acl2-6.2/books/centaur/vl/util/print-urlencode.lisp acl2-6.3/books/centaur/vl/util/print-urlencode.lisp
--- acl2-6.2/books/centaur/vl/util/print-urlencode.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/print-urlencode.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -19,8 +19,7 @@
; Original author: Jared Davis
(in-package "VL")
-(include-book "xdoc/top" :dir :system)
-(include-book "misc/definline" :dir :system)
+(include-book "str/cat" :dir :system)
(local (include-book "misc/assert" :dir :system))
(local (include-book "arithmetic"))
@@ -60,9 +59,9 @@
(local
(progn
- (assert! (equal (coerce (vl-url-encode-char #\a) 'string) "a"))
- (assert! (equal (coerce (vl-url-encode-char #\Space) 'string) "%20"))
- (assert! (equal (coerce (vl-url-encode-char (code-char 0)) 'string) "%00"))))
+ (assert! (equal (implode (vl-url-encode-char #\a)) "a"))
+ (assert! (equal (implode (vl-url-encode-char #\Space)) "%20"))
+ (assert! (equal (implode (vl-url-encode-char (code-char 0))) "%00"))))
(local (in-theory (enable vl-url-encode-char)))
@@ -201,7 +200,8 @@
(defund vl-url-encode-string (x)
(declare (xargs :guard (stringp x)))
- (reverse (coerce (vl-url-encode-string-aux x 0 (length x) nil) 'string)))
+ (str::rchars-to-string
+ (vl-url-encode-string-aux x 0 (length x) nil)))
(local (in-theory (enable vl-url-encode-string)))
@@ -213,4 +213,4 @@
(local (assert!
(let ((x "foo123$%20 blah !==[]{}7&*^!@&*^&*)($"))
(equal (vl-url-encode-string x)
- (coerce (vl-url-encode-chars (coerce x 'list)) 'string)))))
+ (implode (vl-url-encode-chars (explode x)))))))
diff -Nru acl2-6.2/books/centaur/vl/util/print.lisp acl2-6.3/books/centaur/vl/util/print.lisp
--- acl2-6.2/books/centaur/vl/util/print.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/print.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -170,8 +170,8 @@
:short "Fixed version of ACL2's @(see acl2::print-base-p) function that
returns a Boolean."
:long "ACL2's built-in version of this just calls @(see member) and hence
-can return a non-Boolean. That makes it incompatible with @(see stobj) field
-@('satisfies') types, so we have to introduce our own version.
"
+can return a non-Boolean. That makes it incompatible with @(see acl2::stobj)
+field @('satisfies') types, so we have to introduce our own version."
(if (acl2::print-base-p x)
t
nil))
@@ -736,9 +736,9 @@
:parents (accessing-printed-output)
:short "@('(vl-ps->string)') returns the printed characters as a string in
the proper, non-reversed, printed order."
- :long "This is logically just @('(coerce (vl-ps->chars) 'string)'), but we
+ :long "
This is logically just @('(implode (vl-ps->chars))'), but we
install a more efficient definition under the hood in raw Lisp.
"
- (coerce (vl-ps->chars) 'string)
+ (implode (vl-ps->chars))
///
(defttag vl-optimize)
(progn!
@@ -910,9 +910,10 @@
:parents (basic-printing)
:short "Print to standard-out using @(see ps)"
- :long "@('(vl-cw-ps-seq ...)') expands to @('(cw-unformatted (@(see
-with-local-ps) ...))'). Due to the use of @(see with-local-ps), this macro can
-only be used within functions, and cannot be called from the top level.
"
+ :long "@('(vl-cw-ps-seq ...)') expands to
+@('(cw-unformatted (with-local-ps ...))'). Due to the use of @(see
+with-local-ps), this macro can only be used within functions, and cannot be
+called from the top level.
"
(defmacro vl-cw-ps-seq (&rest args)
`(cw-unformatted (with-local-ps ,@args))))
@@ -1064,7 +1065,7 @@
(<= n xl)
(= xl (length x)))
(equal (vl-col-after-printing-string-aux col x n xl)
- (vl-col-after-printing-chars col (nthcdr n (coerce x 'list)))))
+ (vl-col-after-printing-chars col (nthcdr n (explode x)))))
:hints(("Goal"
:induct (vl-col-after-printing-string-aux col x n xl)
:in-theory (enable vl-col-after-printing-string-aux
@@ -1079,7 +1080,7 @@
:inline t
(declare (type integer col)
(type string string))
- (mbe :logic (vl-col-after-printing-chars col (coerce string 'list))
+ (mbe :logic (vl-col-after-printing-chars col (explode string))
:exec (vl-col-after-printing-string-aux col string 0 (length string))))
(define vl-indent ((n natp) &key (ps 'ps))
@@ -1662,7 +1663,7 @@
(= xl (length x)))
:returns (mv (col-prime natp :rule-classes :type-prescription)
(acc-prime))
- :parents (vl-stupid-ppr1)
+ :parents (vl-basic-fmt)
:short "This is basically like acl2::prin1-with-slashes, but we put the
characters into the accumulator in reverse order instead of printing them."
:measure (nfix (- (nfix xl) (nfix n)))
@@ -1704,6 +1705,7 @@
(defsection vl-ppr-explode-symbol-aux
+ :parents (vl-basic-fmt)
(local (in-theory (disable acl2::may-need-slashes-fn)))
@@ -1745,6 +1747,7 @@
(defsection vl-ppr-explode-symbol
+ :parents (vl-basic-fmt)
(defund vl-ppr-explode-symbol (x pkg col acc)
"Returns (MV COL-PRIME ACC-PRIME)"
@@ -1794,6 +1797,7 @@
(defsection vl-ppr-explode-string
+ :parents (vl-basic-fmt)
(defund vl-ppr-explode-string (x col acc)
"Returns (MV COL-PRIME ACC-PRIME)"
@@ -1827,6 +1831,7 @@
(defsection vl-ppr-explode-atom
+ :parents (vl-basic-fmt)
(defund vl-ppr-explode-atom (x pkg base col acc)
"Returns (MV COL-PRIME ACC-PRIME)"
@@ -1882,6 +1887,7 @@
(defsection vl-stupid-ppr1
+ :parents (vl-basic-fmt)
(defund vl-stupid-ppr1 (x pkg base rmargin in-listp col acc)
"Returns (MV COL-PRIME ACC-PRIME)"
@@ -1958,6 +1964,7 @@
(defsection vl-skip-ws
+ :parents (vl-basic-fmt)
; X is the string we are parsing and XL is its length. N is our current
; position. We return the index of the first non-whitespace character at or
@@ -1998,6 +2005,7 @@
(defsection vl-basic-fmt-parse-tilde
+ :parents (vl-basic-fmt)
(local (in-theory (enable len)))
@@ -2050,7 +2058,7 @@
(prog2$ (er hard? 'vl-basic-fmt-parse-tilde
"The format string ~x0 ends with ~x1, but this directive needs argument."
x
- (coerce (list char1 char2) 'string))
+ (implode (list char1 char2)))
(mv :normal char1 (+ n 1))))
(char3 (char x (+ n 2))))
@@ -2086,6 +2094,7 @@
(true-listp x))))
(define vl-fmt-tilde-x (x &key (ps 'ps))
+ :parents (vl-basic-fmt)
(b* ((rchars (vl-ps->rchars))
(col (vl-ps->col))
(pkg (vl-ps->package))
@@ -2113,12 +2122,14 @@
(vl-ps-update-rchars rchars))))
(define vl-fmt-tilde-s (x &key (ps 'ps))
+ :parents (vl-basic-fmt)
(cond ((stringp x)
(vl-print x))
(t
(vl-fmt-tilde-x x))))
(define vl-fmt-tilde-& (x &key (ps 'ps))
+ :parents (vl-basic-fmt)
(if (atom x)
ps
(vl-ps-seq
@@ -2155,6 +2166,8 @@
(define vl-fmt-print-space (&key (ps 'ps))
+ :parents (vl-basic-fmt)
+
;; Prints spaces encountered in the format string itself, maybe word-wrapping
;; if necessary.
(if (vl-ps->htmlp)
@@ -2176,6 +2189,7 @@
(vl-ps-update-col indent)))))
(define vl-fmt-print-normal ((x :type character) &key (ps 'ps))
+ :parents (vl-basic-fmt)
(cond ((eql x #\-)
(vl-println? x))
((eql x #\Space)
@@ -2184,6 +2198,7 @@
(vl-print x))))
(defsection vl-basic-fmt-aux-fn
+ :parents (vl-basic-fmt)
(defmacro vl-basic-fmt-aux (x n xl alist)
`(vl-basic-fmt-aux-fn ,x ,n ,xl ,alist ps))
diff -Nru acl2-6.2/books/centaur/vl/util/subsetp-equal.lisp acl2-6.3/books/centaur/vl/util/subsetp-equal.lisp
--- acl2-6.2/books/centaur/vl/util/subsetp-equal.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/subsetp-equal.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -26,7 +26,7 @@
(include-book "cutil/defrule" :dir :system)
(include-book "centaur/misc/equal-sets" :dir :system)
-(include-book "finite-set-theory/osets/sets" :dir :system)
+(include-book "std/osets/top" :dir :system)
(include-book "std/lists/list-fix" :dir :system)
(include-book "std/lists/take" :dir :system)
(include-book "defsort/duplicated-members" :dir :system)
diff -Nru acl2-6.2/books/centaur/vl/util/warnings.lisp acl2-6.3/books/centaur/vl/util/warnings.lisp
--- acl2-6.2/books/centaur/vl/util/warnings.lisp 2013-06-06 17:11:42.000000000 +0000
+++ acl2-6.3/books/centaur/vl/util/warnings.lisp 2013-09-30 17:53:08.000000000 +0000
@@ -117,7 +117,11 @@
After carrying out some transformation, we can scan the list of modules for
any fatal warnings, and these modules (and their dependents) can be easily
-thrown out using @(see vl-propagate-errors).
")
+thrown out using @(see vl-propagate-errors).
+
+Printing Warnings
+
+See @(see vl::printer) for information on printing warnings.")
(defaggregate vl-warning
@@ -161,7 +165,7 @@
The @('fatalp') flag indicates whether this error is so severe that the
module ought to be thrown away and not subjected to further translation. See
-the general discussion in @(see warning) for more information on how this is
+the general discussion in @(see warnings) for more information on how this is
used.
The @('fn') is supposed to be the name of the function that caused the
diff -Nru acl2-6.2/books/cert.pl acl2-6.3/books/cert.pl
--- acl2-6.2/books/cert.pl 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/cert.pl 2013-09-30 17:53:32.000000000 +0000
@@ -54,6 +54,10 @@
(do "$RealBin/certlib.pl") or die ("Error loading $RealBin/certlib.pl:\n!: $!\n\@: $@\n");
(do "$RealBin/paths.pl") or die ("Error loading $RealBin/paths.pl:\n!: $!\n\@: $@\n");
+my %reqparams = ("hons-only" => "HONS_ONLY",
+ "uses-glucose" => "USES_GLUCOSE",
+ "uses-quicklisp" => "USES_QUICKLISP",
+ );
# use lib "/usr/lib64/perl5/5.8.8/x86_64-linux-thread-multi/Devel";
# use Devel::DProf;
@@ -83,7 +87,7 @@
my %certlib_opts = ( "debugging" => 0,
"clean_certs" => 0,
"print_deps" => 0,
- "all_deps" => 0,
+ "all_deps" => 1,
"believe_cache" => 0 );
my $cache_file = 0;
my $bin_dir = $ENV{'CERT_PL_BIN_DIR'};
@@ -189,8 +193,10 @@
--all-deps
-d
- Write out dependency information for all targets
- encountered, including ones which don\'t need updating.
+ Toggles writing out dependency information for all targets
+ encountered, including ones which don\'t need updating. This is
+ done by default, so using -d or --all-deps actually means that
+ only targets that need updating are written to the makefile.
--acl2
-a
@@ -237,7 +243,7 @@
--static-makefile
-s
- Equivalent to -d -m -o . Useful for
+ Equivalent to -m -o . Useful for
building a static makefile for your targets, which will
suffice for certifying them as long as the dependencies
between source files don\'t change.
@@ -303,7 +309,7 @@
Run the following command on each source file. The actual
command line is created by replacing the string {} with the
target file in the command string. For example:
- cert.pl top.lisp -n -d --source-cmd "echo {}; wc {}"
+ cert.pl top.lisp -n --source-cmd "echo {}; wc {}"
Any number of --source-cmd directives may be given; the
commands will then be run in the order in which they are given.
@@ -378,7 +384,7 @@
"no-boilerplate" => \$no_boilerplate,
"var-prefix=s" => \$var_prefix,
"o=s" => \$mf_name,
- "all-deps|d" => \$certlib_opts{"all_deps"},
+ "all-deps|d" => sub { $certlib_opts{"all_deps"} = !$certlib_opts{"all_deps"}; },
"static-makefile|s=s" => sub {shift;
$mf_name = shift;
$certlib_opts{"all_deps"} = 1;
@@ -665,18 +671,21 @@
# Write out the list of hons-only certs
# Propagate the hons-only requirement:
- my %visited = ();
- foreach my $cert (@certs) {
- propagate_reqparam($cert, "hons-only", \%visited, \%depmap);
- }
- print $mf "${var_prefix}_HONS_ONLY :=";
- foreach my $cert (@certs) {
- if (cert_get_param($cert, \%depmap, "hons-only")) {
- print $mf " \\\n $cert ";
+ my %visited;
+ foreach my $reqparam (keys %reqparams) {
+ %visited = ();
+ foreach my $cert (@certs) {
+ propagate_reqparam($cert, $reqparam, \%visited, \%depmap);
}
- }
- print $mf "\n\n";
+ print $mf "${var_prefix}_${reqparams{$reqparam}} :=";
+ foreach my $cert (@certs) {
+ if (cert_get_param($cert, \%depmap, $reqparam)) {
+ print $mf " \\\n $cert ";
+ }
+ }
+ print $mf "\n\n";
+ }
# If there are labels, write out the sources and certs for those
foreach my $label (sort(keys %labels)) {
my @topcerts = @{$labels{$label}};
diff -Nru acl2-6.2/books/certlib.pl acl2-6.3/books/certlib.pl
--- acl2-6.2/books/certlib.pl 2013-06-06 17:12:02.000000000 +0000
+++ acl2-6.3/books/certlib.pl 2013-09-30 17:53:32.000000000 +0000
@@ -31,7 +31,7 @@
use Storable qw(nstore retrieve);
use Cwd 'abs_path';
-my $cache_version_code = 3;
+my $cache_version_code = 5;
# Note: for debugging you can enable this use and then print an error message
# using
@@ -84,7 +84,12 @@
sub abs_canonical_path {
my $path = shift;
# print "path: $path\n";
- my $abspath = File::Spec->rel2abs($path);
+ my $abspath;
+ if (File::Spec->file_name_is_absolute($path)) {
+ $abspath = $path;
+ } else {
+ $abspath = File::Spec->rel2abs($path);
+ }
# print "abspath: $abspath\n";
my ($vol, $dir, $file) = File::Spec->splitpath($abspath);
# print "path: $path vol: $vol dir: $dir file: $file\n";
@@ -885,7 +890,7 @@
sub get_cert_param {
my ($base,$the_line,$events) = @_;
- my $regexp = "cert[-_]param:[\\s]*\\(?([^)]*)\\)?";
+ my $regexp = "cert[-_]param:?[\\s]*\\(?([^)]*)\\)?";
my @match = $the_line =~ m/$regexp/;
if (@match) {
debug_print_event($base, "cert_param", \@match);
@@ -918,6 +923,8 @@
return 0;
}
+# (check-hons-enabled (:book
+# cert_param (hons-only)
diff -Nru acl2-6.2/books/cgen/Makefile acl2-6.3/books/cgen/Makefile
--- acl2-6.2/books/cgen/Makefile 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/cgen/Makefile 2013-09-30 17:52:16.000000000 +0000
@@ -0,0 +1,3 @@
+ACL2_COMPILE_FLG := t :ttags :all
+include ../Makefile-generic
+-include Makefile-deps
diff -Nru acl2-6.2/books/cgen/Readme.lsp acl2-6.3/books/cgen/Readme.lsp
--- acl2-6.2/books/cgen/Readme.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/cgen/Readme.lsp 2013-09-30 17:52:16.000000000 +0000
@@ -0,0 +1,196 @@
+((:FILES "
+.:
+acl2-customization.lsp
+acl2s-parameter.lisp
+base.lisp
+basis.lisp
+cert.acl2
+certify-book.sh
+data.lisp
+graph.lisp
+library-support.lisp
+main.lisp
+Makefile
+mv-proof.lisp
+num-list-fns.lisp
+num-list-thms.lisp
+package.lsp
+portcullis.acl2
+portcullis.lisp
+random.lisp
+random-state-basis1.lisp
+random-state.lisp
+Readme.lsp
+rem-and-floor.lisp
+scratchpad.lsp
+simple-graph-array.lisp
+splitnat.lisp
+switchnat.lisp
+testing-regression.lsp
+top.lisp
+type.lisp
+utilities.lisp
+with-timeout.lisp
+with-timeout-raw.lsp
+"
+)
+ (:TITLE "Counterexample Generation")
+ (:AUTHOR/S "Harsh Raju Chamarthi, Peter C. Dillinger") ; With help from Matt Kaufmann and Panagiotis Manolios
+ (:KEYWORDS ; non-empty list of keywords, case-insensitive
+ "book contributions" "contributed books"
+ "testing" "counterexamples" "witnesses" "executable"
+ "models" "random testing" "bounded-exhaustive testing"
+ "theorem-proving" "dpll" "backtracking search"
+ )
+ (:ABSTRACT
+"We provide support for counterexample generation and provide a
+defdata framework which forms the basis for using 'testing' to find
+counterexamples.
+
+We use simple and incremental search strategies in our quest to find
+counterexamples.
+
+At a high-level, the idea of 'simple search' is simple: Given any
+conjecture, infer type information about free variables from the
+hypotheses, generate/sample values of these types (value sampling can
+be random, bounded exhaustive or mixed), instantiate all variables and
+evaluate to get either T or NIL. The value assignment resulting in NIL
+is a counterexample (other cases are witness and vacuous). The type
+information is stored in ACL2 tables and is usually created using
+'defdata' which automatically generates the value enumerator for that
+type. All base types have been lifted to the defdata framework i.e we
+manually defined all enumerators and subtype relationships among the
+ground ACL2 types.
+
+Theorem proving and domain-specific libraries often help in
+substantially shrinking the space of free variables that we need to
+search, improving our chances of finding a counterexample if one
+exists. We do this by using override and backtrack hints to search for
+counterexamples to all checkpoints of a conjecture under
+thm/defthm/test?.
+
+'incremental search' is a DPLL like algorithm that selects an
+appropriate variable, assigns it, propagates this information using
+ACL2 itself to obtain a partially concretized formula, which is then
+tested using 'simple search'. If we ever hit the stopping
+condition (usually 3 counterexamples and witnesses), we abort the
+search. If not, we continue with the select, assign, propagate
+loop. Of course if propagating a value assignment results in a
+contradiction in the hypotheses (i.e inconsistency), we backtrack.
+
+Instructions for usage are in top.lisp.
+
+See the essay in main.lisp for high-level pseudocode of the test driver.
+")
+ (:PERMISSION ; author/s permission for distribution and copying:
+"Copyright (C) 2011 Harsh Raju Chamarthi, Peter C. Dillinger
+ and Northeastern University
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA."))
+#|
+
+
+
+
+These books were developed as part of ACL2s: "The ACL2 Sedan."
+
+To certify books, do the foll at the shell prompt (in the current directory):
+$ export ACL2=
+$ make
+
+Note: You need java to be installed on your machine and in PATH.
+ acl2-lib.jar automatically generates .acl2 files.
+
+Books:
+
+top.lisp
+ top-level entry book with some customizations.
+
+acl2s-parameter.lisp
+ All ACL2s testing/counterexample-generation related configuration parameters
+ are set here. It provides a macro to add a new parameter, producing
+ getters setters and doc items.
+
+base.lisp
+ Builds up the type metadata and type relationship data structures for base
+ ACL2 theory
+
+basis.lisp
+ defines macros for defining functions that ease guard verification
+ (type-checking), and provide facilities for writing concise code. Note that
+ this book is in progress and some features I would like to
+ incorporate in the future are yet unimplemented.
+
+mv-proof.lisp
+rem-and-floor.lisp
+num-list-fns.lisp
+num-list-thms.lisp
+ Support books for defdata
+
+splitnat.lisp
+ Given a natural number seed s and another number n, it provides the
+ function split-nat returns an n-tuple which is bijective to s.
+ It is used to generate enumerators for product types.
+
+switchnat.lisp
+ Given a natural number seed s and another number n, it provides the
+ function switch-nat returns an pair (c,s') which is bijective to s.
+ This is used to generate enumerators for union types.
+
+data.lisp
+ The previous books implement the data definition framework.
+ In particular, it provides the defdata macro which the user can use
+ to introduce
+
+graph.lisp
+ Provides graph utility functions for DFS, SCC and transitive
+ closure. Possibly buggy, will be replaces by simple-graph-array book.
+
+library-support.lisp
+ Some theorems for using misc/records book in our context.
+
+main.lisp
+ The top-level book which implements the main driver functions that
+ orchestrate the testing+theorem-proving synergistic combination.
+ It provides the test? macro and the test-checkpoint function which
+ is used as an override-hint to search for counterexamples at all
+ checkpoints. For more information on implementation look at the
+ essay headed "Main Idea".
+
+random-state-basis1.lisp
+ See below
+random-state.lisp
+ Provides pseudogeometric natural number distribution.
+
+testing-regression.lsp
+ Examples, testcases and in general a book that you can refer to for
+ quick application of counterexample generation.
+
+simple-graph-array.lisp
+ Simple implementation of DFS and SCC (and topological sort)
+
+type.lisp
+ Provides functions to convert ACL2 type set into defdata types and
+ also the meet operation over the subtype (lattice) defdata graph
+
+utilities.lisp
+ Some utility functions used across the books in this directory.
+
+with-timeout.lisp
+ Nested timeouts.
+
+
+|#
diff -Nru acl2-6.2/books/cgen/acl2-customization.lsp acl2-6.3/books/cgen/acl2-customization.lsp
--- acl2-6.2/books/cgen/acl2-customization.lsp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/cgen/acl2-customization.lsp 2013-09-30 17:52:16.000000000 +0000
@@ -0,0 +1 @@
+(ld "package.lsp")
\ No newline at end of file
diff -Nru acl2-6.2/books/cgen/acl2s-parameter.lisp acl2-6.3/books/cgen/acl2s-parameter.lisp
--- acl2-6.2/books/cgen/acl2s-parameter.lisp 1970-01-01 00:00:00.000000000 +0000
+++ acl2-6.3/books/cgen/acl2s-parameter.lisp 2013-09-30 17:52:16.000000000 +0000
@@ -0,0 +1,623 @@
+#|$ACL2s-Preamble$;
+(ld ;; Newline to fool ACL2/cert.pl dependency scanner
+ "portcullis.lsp")
+(acl2::begin-book t :ttags :all);$ACL2s-Preamble$|#
+
+(in-package "ACL2")
+(include-book "utilities")
+
+
+;;; Keep the following defconst synced with all the acl2s parameters
+(defconst *acl2s-parameters* '(num-trials
+ verbosity-level
+ num-counterexamples
+ num-witnesses
+ ;show-top-level-counterexample
+ sampling-method
+ backtrack-limit
+ search-strategy
+ testing-enabled
+ stopping-condition
+ subgoal-timeout
+ ))
+
+;All user-defined parameters are stored here
+(table acl2s-defaults-table)
+
+(defrec acl2s-param-info% (value guard setter) NIL)
+
+(defmacro add-acl2s-parameter (name default
+ &key
+ (setter 'nil)
+ (doc-string 'nil)
+ (guard 't))
+ "Add a new user-defined parameter.
+ Put it in the acl2s-defaults-table as a key,
+ using the value of :default.
+:guard is a term that checks for legal values of the
+ parameter (It uses symbol 'value for variable capture).
+getter and setter specify macro names that will be used by
+the actual getter/setter mechanism to delegate its function.
+Note that setter should be a macro that expands to a state changing
+embedded event form, this this is called from inside an make-event.
+You have to see the code in acl2s-defaults to understand whats going
+on with getter and setter, the situation is assymmetric and I am
+being lazy about documentation.
+:doc-string is a string that is used to specify the defdoc.
+For internal flags dont use a doc-string"
+
+ (b* (((unless (symbolp name))
+ (er hard 'add-acl2s-parameter
+ "Name must be a symbol, but is ~x0." name))
+ ;; ((unless (pseudo-termp guard))
+ ;; (er hard 'add-acl2s-parameter
+ ;; ":guard must be a term, but is ~x0." guard))
+ );*b
+
+ `(progn
+ (table acl2s-defaults-table
+ ',name
+ ',(acl2::make acl2s-param-info%
+ :guard guard ;store guard too
+ :value default
+ :setter setter)
+ :put)
+ ,@(and doc-string
+ `((defdoc ,name ,doc-string))))))
+
+
+
+
+
+(defdoc ACL2::TESTING
+ ":Doc-Section ACL2::TESTING
+
+ A counterexample generation framework for ACL2 ~/
+
+ Test formulas before and during a proof attempt, to find
+ counterexamples and witnesses potentially saving time and
+ effort and providing more intuition into the conjecture under
+ scrutiny. The testing framework is tightly coupled with the
+ data definition (See ~ilc[DATA-DEFINITIONS]) framework.
+
+ ~t[test?] guarantees printing counterexamples in
+ terms of the top goals variables. See ~ilc[test?]
+ for more details and examples.
+
+ The framework can be configured via a bunch of parameters
+ whose documention you will find below. In particular, see
+ ~ilc[num-trials], ~ilc[verbosity-level], ~ilc[testing-enabled].~/
+
+ To understand more about how testing works,
+ please refer to the following paper
+ ~url[http://www.ccs.neu.edu/home/harshrc/ITaITP.pdf]
+ ")
+
+(defdoc ACL2::acl2s-defaults
+ ":Doc-Section ACL2::acl2-sedan
+
+ Getting and setting defaults for various parameters in ACL2 Sedan~/
+
+ ~/
+
+ ")
+
+(add-acl2s-parameter
+ num-trials 1000
+ :doc-string
+ ":Doc-Section ACL2::TESTING
+
+ Max number of tries to find counterexamples~/~/
+
+ Maximum number of tries (attempts) to construct
+ counterexamples and witnesses.
+ By default this parameter is set to 1000. Can be set to
+ any natural number ~t[n]. If set to 0, it has the same
+ effect as setting testing-enabled parameter to ~t[nil].
+ ~bv[]
+ Usage:
+ (acl2s-defaults :set num-trials 1000)
+ (acl2s-defaults :get num-trials)
+ :doc num-trials
+ ~ev[]"
+ :guard (and (natp value)
+ (< value 1000000000)))
+
+(add-acl2s-parameter
+ verbosity-level 1
+ :doc-string
+ ":Doc-Section ACL2::TESTING
+
+ Control verbosity of Testing~/~/
+
+ Control amount of output printed by random-testing
+ Currently 3 verbosity levels are implemented:
+ 0 - All testing output is turned off
+ 1 - Normal verbosity level (default)
+ 2 - More verbose.
+ 3 - For Debug by normal users
+ 4 and above - System level debug by developers
+ ~bv[]
+ Usage:
+ (acl2s-defaults :set verbosity-level 1)
+ (acl2s-defaults :get verbosity-level)
+ :doc verbosity-level
+ ~ev[]"
+ :guard (natp value))
+
+
+(add-acl2s-parameter
+ num-counterexamples 3
+ :doc-string
+ ":Doc-Section ACL2::TESTING
+
+ Number of Counterexamples to be shown~/~/
+
+ Set the number of counterexamples desired to be shown
+ By default this parameter is set to 3. Can be set to
+ any natural number n. Setting this number to 0 implies
+ the user is not interested in seeing counterexamples, and
+ thus none will be printed in the testing output.
+
+ ~bv[]
+ Usage:
+ (acl2s-defaults :set num-counterexamples 3)
+ (acl2s-defaults :get num-counterexamples)
+ :doc num-counterexamples
+ ~ev[]"
+ :guard (natp value))
+
+
+(add-acl2s-parameter
+ num-witnesses 3
+ :doc-string
+ ":Doc-Section ACL2::TESTING
+
+ Number of Witnesses to be shown~/~/
+
+ Set the number of witnesses desired to be shown
+ By default this parameter is set to 3. Can be set to
+ any natural number. Setting this number to 0 implies
+ the user is not interested in seeing witnesses, and
+ thus none will be printed in the testing output.
+
+ ~bv[]
+ Usage:
+ (acl2s-defaults :set num-witnesses 3)
+ (acl2s-defaults :get num-witnesses)
+ :doc num-witnesses
+ ~ev[]"
+ :guard (natp value))
+
+;DEPRECATED
+;; (add-acl2s-parameter
+;; show-top-level-counterexample t
+;; :doc-string ":Doc-Section ACL2::TESTING
+;; Show Counterexamples to the top-level